Modules

node_modules/es-abstract/5/AbstractEqualityComparison.js

@@ -0,0 +1,37 @@
+'use strict';
+
+var ToNumber = require('./ToNumber');
+var ToPrimitive = require('./ToPrimitive');
+var Type = require('./Type');
+
+// https://www.ecma-international.org/ecma-262/5.1/#sec-11.9.3
+
+module.exports = function AbstractEqualityComparison(x, y) {
+	var xType = Type(x);
+	var yType = Type(y);
+	if (xType === yType) {
+		return x === y; // ES6+ specified this shortcut anyways.
+	}
+	if (x == null && y == null) {
+		return true;
+	}
+	if (xType === 'Number' && yType === 'String') {
+		return AbstractEqualityComparison(x, ToNumber(y));
+	}
+	if (xType === 'String' && yType === 'Number') {
+		return AbstractEqualityComparison(ToNumber(x), y);
+	}
+	if (xType === 'Boolean') {
+		return AbstractEqualityComparison(ToNumber(x), y);
+	}
+	if (yType === 'Boolean') {
+		return AbstractEqualityComparison(x, ToNumber(y));
+	}
+	if ((xType === 'String' || xType === 'Number') && yType === 'Object') {
+		return AbstractEqualityComparison(x, ToPrimitive(y));
+	}
+	if (xType === 'Object' && (yType === 'String' || yType === 'Number')) {
+		return AbstractEqualityComparison(ToPrimitive(x), y);
+	}
+	return false;
+};

node_modules/es-abstract/5/AbstractRelationalComparison.js

@@ -0,0 +1,66 @@
+'use strict';
+
+var GetIntrinsic = require('../GetIntrinsic');
+
+var $Number = GetIntrinsic('%Number%');
+var $TypeError = GetIntrinsic('%TypeError%');
+
+var $isNaN = require('../helpers/isNaN');
+var $isFinite = require('../helpers/isFinite');
+var isPrefixOf = require('../helpers/isPrefixOf');
+
+var ToNumber = require('./ToNumber');
+var ToPrimitive = require('./ToPrimitive');
+var Type = require('./Type');
+
+// https://www.ecma-international.org/ecma-262/5.1/#sec-11.8.5
+
+// eslint-disable-next-line max-statements
+module.exports = function AbstractRelationalComparison(x, y, LeftFirst) {
+	if (Type(LeftFirst) !== 'Boolean') {
+		throw new $TypeError('Assertion failed: LeftFirst argument must be a Boolean');
+	}
+	var px;
+	var py;
+	if (LeftFirst) {
+		px = ToPrimitive(x, $Number);
+		py = ToPrimitive(y, $Number);
+	} else {
+		py = ToPrimitive(y, $Number);
+		px = ToPrimitive(x, $Number);
+	}
+	var bothStrings = Type(px) === 'String' && Type(py) === 'String';
+	if (!bothStrings) {
+		var nx = ToNumber(px);
+		var ny = ToNumber(py);
+		if ($isNaN(nx) || $isNaN(ny)) {
+			return undefined;
+		}
+		if ($isFinite(nx) && $isFinite(ny) && nx === ny) {
+			return false;
+		}
+		if (nx === 0 && ny === 0) {
+			return false;
+		}
+		if (nx === Infinity) {
+			return false;
+		}
+		if (ny === Infinity) {
+			return true;
+		}
+		if (ny === -Infinity) {
+			return false;
+		}
+		if (nx === -Infinity) {
+			return true;
+		}
+		return nx < ny; // by now, these are both nonzero, finite, and not equal
+	}
+	if (isPrefixOf(py, px)) {
+		return false;
+	}
+	if (isPrefixOf(px, py)) {
+		return true;
+	}
+	return px < py; // both strings, neither a prefix of the other. shortcut for steps c-f
+};

node_modules/es-abstract/5/CheckObjectCoercible.js

@@ -0,0 +1,14 @@
+'use strict';
+
+var GetIntrinsic = require('../GetIntrinsic');
+
+var $TypeError = GetIntrinsic('%TypeError%');
+
+// http://www.ecma-international.org/ecma-262/5.1/#sec-9.10
+
+module.exports = function CheckObjectCoercible(value, optMessage) {
+	if (value == null) {
+		throw new $TypeError(optMessage || ('Cannot call method on ' + value));
+	}
+	return value;
+};

node_modules/es-abstract/5/DateFromTime.js

@@ -0,0 +1,54 @@
+'use strict';
+
+var GetIntrinsic = require('../GetIntrinsic');
+
+var $EvalError = GetIntrinsic('%EvalError%');
+
+var DayWithinYear = require('./DayWithinYear');
+var InLeapYear = require('./InLeapYear');
+var MonthFromTime = require('./MonthFromTime');
+
+// https://ecma-international.org/ecma-262/5.1/#sec-15.9.1.5
+
+module.exports = function DateFromTime(t) {
+	var m = MonthFromTime(t);
+	var d = DayWithinYear(t);
+	if (m === 0) {
+		return d + 1;
+	}
+	if (m === 1) {
+		return d - 30;
+	}
+	var leap = InLeapYear(t);
+	if (m === 2) {
+		return d - 58 - leap;
+	}
+	if (m === 3) {
+		return d - 89 - leap;
+	}
+	if (m === 4) {
+		return d - 119 - leap;
+	}
+	if (m === 5) {
+		return d - 150 - leap;
+	}
+	if (m === 6) {
+		return d - 180 - leap;
+	}
+	if (m === 7) {
+		return d - 211 - leap;
+	}
+	if (m === 8) {
+		return d - 242 - leap;
+	}
+	if (m === 9) {
+		return d - 272 - leap;
+	}
+	if (m === 10) {
+		return d - 303 - leap;
+	}
+	if (m === 11) {
+		return d - 333 - leap;
+	}
+	throw new $EvalError('Assertion failed: MonthFromTime returned an impossible value: ' + m);
+};

node_modules/es-abstract/5/Day.js

@@ -0,0 +1,13 @@
+'use strict';
+
+var GetIntrinsic = require('../GetIntrinsic');
+
+var $floor = GetIntrinsic('%Math.floor%');
+
+var msPerDay = require('../helpers/timeConstants').msPerDay;
+
+// https://ecma-international.org/ecma-262/5.1/#sec-15.9.1.2
+
+module.exports = function Day(t) {
+	return $floor(t / msPerDay);
+};

node_modules/es-abstract/5/DayFromYear.js

@@ -0,0 +1,12 @@
+'use strict';
+
+var GetIntrinsic = require('../GetIntrinsic');
+
+var $floor = GetIntrinsic('%Math.floor%');
+
+// https://ecma-international.org/ecma-262/5.1/#sec-15.9.1.3
+
+module.exports = function DayFromYear(y) {
+	return (365 * (y - 1970)) + $floor((y - 1969) / 4) - $floor((y - 1901) / 100) + $floor((y - 1601) / 400);
+};
+

node_modules/es-abstract/5/DayWithinYear.js

@@ -0,0 +1,11 @@
+'use strict';
+
+var Day = require('./Day');
+var DayFromYear = require('./DayFromYear');
+var YearFromTime = require('./YearFromTime');
+
+// https://ecma-international.org/ecma-262/5.1/#sec-15.9.1.4
+
+module.exports = function DayWithinYear(t) {
+	return Day(t) - DayFromYear(YearFromTime(t));
+};

node_modules/es-abstract/5/DaysInYear.js

@@ -0,0 +1,18 @@
+'use strict';
+
+var mod = require('../helpers/mod');
+
+// https://ecma-international.org/ecma-262/5.1/#sec-15.9.1.3
+
+module.exports = function DaysInYear(y) {
+	if (mod(y, 4) !== 0) {
+		return 365;
+	}
+	if (mod(y, 100) !== 0) {
+		return 366;
+	}
+	if (mod(y, 400) !== 0) {
+		return 365;
+	}
+	return 366;
+};

node_modules/es-abstract/5/FromPropertyDescriptor.js

@@ -0,0 +1,39 @@
+'use strict';
+
+var GetIntrinsic = require('../GetIntrinsic');
+
+var $TypeError = GetIntrinsic('%TypeError%');
+
+var Type = require('./Type');
+var IsDataDescriptor = require('./IsDataDescriptor');
+var IsAccessorDescriptor = require('./IsAccessorDescriptor');
+
+var assertRecord = require('../helpers/assertRecord');
+
+// https://ecma-international.org/ecma-262/5.1/#sec-8.10.4
+
+module.exports = function FromPropertyDescriptor(Desc) {
+	if (typeof Desc === 'undefined') {
+		return Desc;
+	}
+
+	assertRecord(Type, 'Property Descriptor', 'Desc', Desc);
+
+	if (IsDataDescriptor(Desc)) {
+		return {
+			value: Desc['[[Value]]'],
+			writable: !!Desc['[[Writable]]'],
+			enumerable: !!Desc['[[Enumerable]]'],
+			configurable: !!Desc['[[Configurable]]']
+		};
+	} else if (IsAccessorDescriptor(Desc)) {
+		return {
+			get: Desc['[[Get]]'],
+			set: Desc['[[Set]]'],
+			enumerable: !!Desc['[[Enumerable]]'],
+			configurable: !!Desc['[[Configurable]]']
+		};
+	} else {
+		throw new $TypeError('FromPropertyDescriptor must be called with a fully populated Property Descriptor');
+	}
+};

node_modules/es-abstract/5/HourFromTime.js

@@ -0,0 +1,16 @@
+'use strict';
+
+var GetIntrinsic = require('../GetIntrinsic');
+
+var $floor = GetIntrinsic('%Math.floor%');
+
+var mod = require('../helpers/mod');
+var timeConstants = require('../helpers/timeConstants');
+var msPerHour = timeConstants.msPerHour;
+var HoursPerDay = timeConstants.HoursPerDay;
+
+// https://ecma-international.org/ecma-262/5.1/#sec-15.9.1.10
+
+module.exports = function HourFromTime(t) {
+	return mod($floor(t / msPerHour), HoursPerDay);
+};

node_modules/es-abstract/5/InLeapYear.js

@@ -0,0 +1,21 @@
+'use strict';
+
+var GetIntrinsic = require('../GetIntrinsic');
+
+var $EvalError = GetIntrinsic('%EvalError%');
+
+var DaysInYear = require('./DaysInYear');
+var YearFromTime = require('./YearFromTime');
+
+// https://ecma-international.org/ecma-262/5.1/#sec-15.9.1.3
+
+module.exports = function InLeapYear(t) {
+	var days = DaysInYear(YearFromTime(t));
+	if (days === 365) {
+		return 0;
+	}
+	if (days === 366) {
+		return 1;
+	}
+	throw new $EvalError('Assertion failed: there are not 365 or 366 days in a year, got: ' + days);
+};

node_modules/es-abstract/5/IsAccessorDescriptor.js

@@ -0,0 +1,23 @@
+'use strict';
+
+var has = require('has');
+
+var Type = require('./Type');
+
+var assertRecord = require('../helpers/assertRecord');
+
+// https://ecma-international.org/ecma-262/5.1/#sec-8.10.1
+
+module.exports = function IsAccessorDescriptor(Desc) {
+	if (typeof Desc === 'undefined') {
+		return false;
+	}
+
+	assertRecord(Type, 'Property Descriptor', 'Desc', Desc);
+
+	if (!has(Desc, '[[Get]]') && !has(Desc, '[[Set]]')) {
+		return false;
+	}
+
+	return true;
+};

node_modules/es-abstract/5/IsCallable.js

@@ -0,0 +1,5 @@
+'use strict';
+
+// http://www.ecma-international.org/ecma-262/5.1/#sec-9.11
+
+module.exports = require('is-callable');

node_modules/es-abstract/5/IsDataDescriptor.js

@@ -0,0 +1,23 @@
+'use strict';
+
+var has = require('has');
+
+var Type = require('./Type');
+
+var assertRecord = require('../helpers/assertRecord');
+
+// https://ecma-international.org/ecma-262/5.1/#sec-8.10.2
+
+module.exports = function IsDataDescriptor(Desc) {
+	if (typeof Desc === 'undefined') {
+		return false;
+	}
+
+	assertRecord(Type, 'Property Descriptor', 'Desc', Desc);
+
+	if (!has(Desc, '[[Value]]') && !has(Desc, '[[Writable]]')) {
+		return false;
+	}
+
+	return true;
+};

node_modules/es-abstract/5/IsGenericDescriptor.js

@@ -0,0 +1,23 @@
+'use strict';
+
+var IsAccessorDescriptor = require('./IsAccessorDescriptor');
+var IsDataDescriptor = require('./IsDataDescriptor');
+var Type = require('./Type');
+
+var assertRecord = require('../helpers/assertRecord');
+
+// https://ecma-international.org/ecma-262/5.1/#sec-8.10.3
+
+module.exports = function IsGenericDescriptor(Desc) {
+	if (typeof Desc === 'undefined') {
+		return false;
+	}
+
+	assertRecord(Type, 'Property Descriptor', 'Desc', Desc);
+
+	if (!IsAccessorDescriptor(Desc) && !IsDataDescriptor(Desc)) {
+		return true;
+	}
+
+	return false;
+};

node_modules/es-abstract/5/IsPropertyDescriptor.js

@@ -0,0 +1,17 @@
+'use strict';
+
+var isPropertyDescriptor = require('../helpers/isPropertyDescriptor');
+
+var Type = require('./Type');
+var IsDataDescriptor = require('./IsDataDescriptor');
+var IsAccessorDescriptor = require('./IsAccessorDescriptor');
+
+// https://ecma-international.org/ecma-262/6.0/#sec-property-descriptor-specification-type
+
+module.exports = function IsPropertyDescriptor(Desc) {
+	return isPropertyDescriptor({
+		IsDataDescriptor: IsDataDescriptor,
+		IsAccessorDescriptor: IsAccessorDescriptor,
+		Type: Type
+	}, Desc);
+};

node_modules/es-abstract/5/MakeDate.js

@@ -0,0 +1,13 @@
+'use strict';
+
+var $isFinite = require('../helpers/isFinite');
+var msPerDay = require('../helpers/timeConstants').msPerDay;
+
+// https://ecma-international.org/ecma-262/5.1/#sec-15.9.1.13
+
+module.exports = function MakeDate(day, time) {
+	if (!$isFinite(day) || !$isFinite(time)) {
+		return NaN;
+	}
+	return (day * msPerDay) + time;
+};

node_modules/es-abstract/5/MakeDay.js

@@ -0,0 +1,33 @@
+'use strict';
+
+var GetIntrinsic = require('../GetIntrinsic');
+
+var $floor = GetIntrinsic('%Math.floor%');
+var $DateUTC = GetIntrinsic('%Date.UTC%');
+
+var mod = require('../helpers/mod');
+var $isFinite = require('../helpers/isFinite');
+
+var DateFromTime = require('./DateFromTime');
+var Day = require('./Day');
+var MonthFromTime = require('./MonthFromTime');
+var ToInteger = require('./ToInteger');
+var YearFromTime = require('./YearFromTime');
+
+// https://ecma-international.org/ecma-262/5.1/#sec-15.9.1.12
+
+module.exports = function MakeDay(year, month, date) {
+	if (!$isFinite(year) || !$isFinite(month) || !$isFinite(date)) {
+		return NaN;
+	}
+	var y = ToInteger(year);
+	var m = ToInteger(month);
+	var dt = ToInteger(date);
+	var ym = y + $floor(m / 12);
+	var mn = mod(m, 12);
+	var t = $DateUTC(ym, mn, 1);
+	if (YearFromTime(t) !== ym || MonthFromTime(t) !== mn || DateFromTime(t) !== 1) {
+		return NaN;
+	}
+	return Day(t) + dt - 1;
+};

node_modules/es-abstract/5/MakeTime.js

@@ -0,0 +1,23 @@
+'use strict';
+
+var $isFinite = require('../helpers/isFinite');
+var timeConstants = require('../helpers/timeConstants');
+var msPerSecond = timeConstants.msPerSecond;
+var msPerMinute = timeConstants.msPerMinute;
+var msPerHour = timeConstants.msPerHour;
+
+var ToInteger = require('./ToInteger');
+
+// https://ecma-international.org/ecma-262/5.1/#sec-15.9.1.11
+
+module.exports = function MakeTime(hour, min, sec, ms) {
+	if (!$isFinite(hour) || !$isFinite(min) || !$isFinite(sec) || !$isFinite(ms)) {
+		return NaN;
+	}
+	var h = ToInteger(hour);
+	var m = ToInteger(min);
+	var s = ToInteger(sec);
+	var milli = ToInteger(ms);
+	var t = (h * msPerHour) + (m * msPerMinute) + (s * msPerSecond) + milli;
+	return t;
+};

node_modules/es-abstract/5/MinFromTime.js

@@ -0,0 +1,16 @@
+'use strict';
+
+var GetIntrinsic = require('../GetIntrinsic');
+
+var $floor = GetIntrinsic('%Math.floor%');
+
+var mod = require('../helpers/mod');
+var timeConstants = require('../helpers/timeConstants');
+var msPerMinute = timeConstants.msPerMinute;
+var MinutesPerHour = timeConstants.MinutesPerHour;
+
+// https://ecma-international.org/ecma-262/5.1/#sec-15.9.1.10
+
+module.exports = function MinFromTime(t) {
+	return mod($floor(t / msPerMinute), MinutesPerHour);
+};

node_modules/es-abstract/5/MonthFromTime.js

@@ -0,0 +1,47 @@
+'use strict';
+
+var DayWithinYear = require('./DayWithinYear');
+var InLeapYear = require('./InLeapYear');
+
+// https://ecma-international.org/ecma-262/5.1/#sec-15.9.1.4
+
+module.exports = function MonthFromTime(t) {
+	var day = DayWithinYear(t);
+	if (0 <= day && day < 31) {
+		return 0;
+	}
+	var leap = InLeapYear(t);
+	if (31 <= day && day < (59 + leap)) {
+		return 1;
+	}
+	if ((59 + leap) <= day && day < (90 + leap)) {
+		return 2;
+	}
+	if ((90 + leap) <= day && day < (120 + leap)) {
+		return 3;
+	}
+	if ((120 + leap) <= day && day < (151 + leap)) {
+		return 4;
+	}
+	if ((151 + leap) <= day && day < (181 + leap)) {
+		return 5;
+	}
+	if ((181 + leap) <= day && day < (212 + leap)) {
+		return 6;
+	}
+	if ((212 + leap) <= day && day < (243 + leap)) {
+		return 7;
+	}
+	if ((243 + leap) <= day && day < (273 + leap)) {
+		return 8;
+	}
+	if ((273 + leap) <= day && day < (304 + leap)) {
+		return 9;
+	}
+	if ((304 + leap) <= day && day < (334 + leap)) {
+		return 10;
+	}
+	if ((334 + leap) <= day && day < (365 + leap)) {
+		return 11;
+	}
+};

node_modules/es-abstract/5/SameValue.js

@@ -0,0 +1,13 @@
+'use strict';
+
+var $isNaN = require('../helpers/isNaN');
+
+// http://www.ecma-international.org/ecma-262/5.1/#sec-9.12
+
+module.exports = function SameValue(x, y) {
+	if (x === y) { // 0 === -0, but they are not identical.
+		if (x === 0) { return 1 / x === 1 / y; }
+		return true;
+	}
+	return $isNaN(x) && $isNaN(y);
+};

node_modules/es-abstract/5/SecFromTime.js

@@ -0,0 +1,16 @@
+'use strict';
+
+var GetIntrinsic = require('../GetIntrinsic');
+
+var $floor = GetIntrinsic('%Math.floor%');
+
+var mod = require('../helpers/mod');
+var timeConstants = require('../helpers/timeConstants');
+var msPerSecond = timeConstants.msPerSecond;
+var SecondsPerMinute = timeConstants.SecondsPerMinute;
+
+// https://ecma-international.org/ecma-262/5.1/#sec-15.9.1.10
+
+module.exports = function SecFromTime(t) {
+	return mod($floor(t / msPerSecond), SecondsPerMinute);
+};

node_modules/es-abstract/5/StrictEqualityComparison.js

@@ -0,0 +1,17 @@
+'use strict';
+
+var Type = require('./Type');
+
+// https://www.ecma-international.org/ecma-262/5.1/#sec-11.9.6
+
+module.exports = function StrictEqualityComparison(x, y) {
+	var xType = Type(x);
+	var yType = Type(y);
+	if (xType !== yType) {
+		return false;
+	}
+	if (xType === 'Undefined' || xType === 'Null') {
+		return true;
+	}
+	return x === y; // shortcut for steps 4-7
+};

node_modules/es-abstract/5/TimeClip.js

@@ -0,0 +1,21 @@
+'use strict';
+
+var GetIntrinsic = require('../GetIntrinsic');
+
+var $Date = GetIntrinsic('%Date%');
+var $Number = GetIntrinsic('%Number%');
+var $abs = GetIntrinsic('%Math.abs%');
+
+var $isFinite = require('../helpers/isFinite');
+
+var ToNumber = require('./ToNumber');
+
+// https://ecma-international.org/ecma-262/5.1/#sec-15.9.1.14
+
+module.exports = function TimeClip(time) {
+	if (!$isFinite(time) || $abs(time) > 8.64e15) {
+		return NaN;
+	}
+	return $Number(new $Date(ToNumber(time)));
+};
+

node_modules/es-abstract/5/TimeFromYear.js

@@ -0,0 +1,11 @@
+'use strict';
+
+var msPerDay = require('../helpers/timeConstants').msPerDay;
+
+var DayFromYear = require('./DayFromYear');
+
+// https://ecma-international.org/ecma-262/5.1/#sec-15.9.1.3
+
+module.exports = function TimeFromYear(y) {
+	return msPerDay * DayFromYear(y);
+};

node_modules/es-abstract/5/TimeWithinDay.js

@@ -0,0 +1,11 @@
+'use strict';
+
+var mod = require('../helpers/mod');
+var msPerDay = require('../helpers/timeConstants').msPerDay;
+
+// https://ecma-international.org/ecma-262/5.1/#sec-15.9.1.2
+
+module.exports = function TimeWithinDay(t) {
+	return mod(t, msPerDay);
+};
+

node_modules/es-abstract/5/ToBoolean.js

@@ -0,0 +1,5 @@
+'use strict';
+
+// http://www.ecma-international.org/ecma-262/5.1/#sec-9.2
+
+module.exports = function ToBoolean(value) { return !!value; };

node_modules/es-abstract/5/ToInt32.js

@@ -0,0 +1,9 @@
+'use strict';
+
+var ToNumber = require('./ToNumber');
+
+// http://www.ecma-international.org/ecma-262/5.1/#sec-9.5
+
+module.exports = function ToInt32(x) {
+	return ToNumber(x) >> 0;
+};

node_modules/es-abstract/5/ToInteger.js

@@ -0,0 +1,22 @@
+'use strict';
+
+var GetIntrinsic = require('../GetIntrinsic');
+
+var $Math = GetIntrinsic('%Math%');
+
+var ToNumber = require('./ToNumber');
+var $isNaN = require('../helpers/isNaN');
+var $isFinite = require('../helpers/isFinite');
+var $sign = require('../helpers/sign');
+
+var $floor = $Math.floor;
+var $abs = $Math.abs;
+
+// http://www.ecma-international.org/ecma-262/5.1/#sec-9.4
+
+module.exports = function ToInteger(value) {
+	var number = ToNumber(value);
+	if ($isNaN(number)) { return 0; }
+	if (number === 0 || !$isFinite(number)) { return number; }
+	return $sign(number) * $floor($abs(number));
+};

node_modules/es-abstract/5/ToNumber.js

@@ -0,0 +1,7 @@
+'use strict';
+
+// http://www.ecma-international.org/ecma-262/5.1/#sec-9.3
+
+module.exports = function ToNumber(value) {
+	return +value; // eslint-disable-line no-implicit-coercion
+};

node_modules/es-abstract/5/ToObject.js

@@ -0,0 +1,14 @@
+'use strict';
+
+var GetIntrinsic = require('../GetIntrinsic');
+
+var $Object = GetIntrinsic('%Object%');
+
+var CheckObjectCoercible = require('./CheckObjectCoercible');
+
+// http://www.ecma-international.org/ecma-262/5.1/#sec-9.9
+
+module.exports = function ToObject(value) {
+	CheckObjectCoercible(value);
+	return $Object(value);
+};

node_modules/es-abstract/5/ToPrimitive.js

@@ -0,0 +1,5 @@
+'use strict';
+
+// http://www.ecma-international.org/ecma-262/5.1/#sec-9.1
+
+module.exports = require('es-to-primitive/es5');

node_modules/es-abstract/5/ToPropertyDescriptor.js

@@ -0,0 +1,52 @@
+'use strict';
+
+var has = require('has');
+
+var GetIntrinsic = require('../GetIntrinsic');
+
+var $TypeError = GetIntrinsic('%TypeError%');
+
+var Type = require('./Type');
+var ToBoolean = require('./ToBoolean');
+var IsCallable = require('./IsCallable');
+
+// https://ecma-international.org/ecma-262/5.1/#sec-8.10.5
+
+module.exports = function ToPropertyDescriptor(Obj) {
+	if (Type(Obj) !== 'Object') {
+		throw new $TypeError('ToPropertyDescriptor requires an object');
+	}
+
+	var desc = {};
+	if (has(Obj, 'enumerable')) {
+		desc['[[Enumerable]]'] = ToBoolean(Obj.enumerable);
+	}
+	if (has(Obj, 'configurable')) {
+		desc['[[Configurable]]'] = ToBoolean(Obj.configurable);
+	}
+	if (has(Obj, 'value')) {
+		desc['[[Value]]'] = Obj.value;
+	}
+	if (has(Obj, 'writable')) {
+		desc['[[Writable]]'] = ToBoolean(Obj.writable);
+	}
+	if (has(Obj, 'get')) {
+		var getter = Obj.get;
+		if (typeof getter !== 'undefined' && !IsCallable(getter)) {
+			throw new TypeError('getter must be a function');
+		}
+		desc['[[Get]]'] = getter;
+	}
+	if (has(Obj, 'set')) {
+		var setter = Obj.set;
+		if (typeof setter !== 'undefined' && !IsCallable(setter)) {
+			throw new $TypeError('setter must be a function');
+		}
+		desc['[[Set]]'] = setter;
+	}
+
+	if ((has(desc, '[[Get]]') || has(desc, '[[Set]]')) && (has(desc, '[[Value]]') || has(desc, '[[Writable]]'))) {
+		throw new $TypeError('Invalid property descriptor. Cannot both specify accessors and a value or writable attribute');
+	}
+	return desc;
+};

node_modules/es-abstract/5/ToString.js

@@ -0,0 +1,12 @@
+'use strict';
+
+var GetIntrinsic = require('../GetIntrinsic');
+
+var $String = GetIntrinsic('%String%');
+
+// http://www.ecma-international.org/ecma-262/5.1/#sec-9.8
+
+module.exports = function ToString(value) {
+	return $String(value);
+};
+

node_modules/es-abstract/5/ToUint16.js

@@ -0,0 +1,24 @@
+'use strict';
+
+var GetIntrinsic = require('../GetIntrinsic');
+
+var $Math = GetIntrinsic('%Math%');
+
+var ToNumber = require('./ToNumber');
+
+var $isNaN = require('../helpers/isNaN');
+var $isFinite = require('../helpers/isFinite');
+var $sign = require('../helpers/sign');
+var $mod = require('../helpers/mod');
+
+var $floor = $Math.floor;
+var $abs = $Math.abs;
+
+// http://www.ecma-international.org/ecma-262/5.1/#sec-9.7
+
+module.exports = function ToUint16(value) {
+	var number = ToNumber(value);
+	if ($isNaN(number) || number === 0 || !$isFinite(number)) { return 0; }
+	var posInt = $sign(number) * $floor($abs(number));
+	return $mod(posInt, 0x10000);
+};

node_modules/es-abstract/5/ToUint32.js

@@ -0,0 +1,9 @@
+'use strict';
+
+var ToNumber = require('./ToNumber');
+
+// http://www.ecma-international.org/ecma-262/5.1/#sec-9.6
+
+module.exports = function ToUint32(x) {
+	return ToNumber(x) >>> 0;
+};

node_modules/es-abstract/5/Type.js

@@ -0,0 +1,24 @@
+'use strict';
+
+// https://www.ecma-international.org/ecma-262/5.1/#sec-8
+
+module.exports = function Type(x) {
+	if (x === null) {
+		return 'Null';
+	}
+	if (typeof x === 'undefined') {
+		return 'Undefined';
+	}
+	if (typeof x === 'function' || typeof x === 'object') {
+		return 'Object';
+	}
+	if (typeof x === 'number') {
+		return 'Number';
+	}
+	if (typeof x === 'boolean') {
+		return 'Boolean';
+	}
+	if (typeof x === 'string') {
+		return 'String';
+	}
+};

node_modules/es-abstract/5/WeekDay.js

@@ -0,0 +1,11 @@
+'use strict';
+
+var mod = require('../helpers/mod');
+
+var Day = require('./Day');
+
+// https://ecma-international.org/ecma-262/5.1/#sec-15.9.1.6
+
+module.exports = function WeekDay(t) {
+	return mod(Day(t) + 4, 7);
+};

node_modules/es-abstract/5/YearFromTime.js

@@ -0,0 +1,16 @@
+'use strict';
+
+var GetIntrinsic = require('../GetIntrinsic');
+
+var $Date = GetIntrinsic('%Date%');
+
+var callBound = require('../helpers/callBound');
+
+var $getUTCFullYear = callBound('Date.prototype.getUTCFullYear');
+
+// https://ecma-international.org/ecma-262/5.1/#sec-15.9.1.3
+
+module.exports = function YearFromTime(t) {
+	// largest y such that this.TimeFromYear(y) <= t
+	return $getUTCFullYear(new $Date(t));
+};

node_modules/es-abstract/5/modulo.js

@@ -0,0 +1,9 @@
+'use strict';
+
+var mod = require('../helpers/mod');
+
+// https://ecma-international.org/ecma-262/5.1/#sec-5.2
+
+module.exports = function modulo(x, y) {
+	return mod(x, y);
+};

node_modules/es-abstract/5/msFromTime.js

@@ -0,0 +1,10 @@
+'use strict';
+
+var mod = require('../helpers/mod');
+var msPerSecond = require('../helpers/timeConstants').msPerSecond;
+
+// https://ecma-international.org/ecma-262/5.1/#sec-15.9.1.10
+
+module.exports = function msFromTime(t) {
+	return mod(t, msPerSecond);
+};