polyfill-library 4.7.0 → 4.8.0

package/polyfills/__dist/TypedArray.prototype.keys/raw.js

@@ -3,30 +3,7 @@
 /* global CreateMethodProperty, ArrayIterator */
 // 23.2.3.19 %TypedArray%.prototype.keys ( )
 (function () {
-	// use "Int8Array" as a proxy for support of "TypedArray" subclasses
-
-	function createMethodProperties (fn) {
-		var fnName = 'keys'
-
-		// in IE11, `Int8Array.prototype` inherits directly from `Object.prototype`
-		// in that case, don't define it on the parent; define it directly on the prototype
-		if ('__proto__' in self.Int8Array.prototype && self.Int8Array.prototype.__proto__ !== Object.prototype) {
-			// set this on the underlying "TypedArrayPrototype", which is shared with all "TypedArray" subclasses
-			CreateMethodProperty(self.Int8Array.prototype.__proto__, fnName, fn);
-		} else {
-			CreateMethodProperty(self.Int8Array.prototype, fnName, fn);
-			CreateMethodProperty(self.Uint8Array.prototype, fnName, fn);
-			CreateMethodProperty(self.Uint8ClampedArray.prototype, fnName, fn);
-			CreateMethodProperty(self.Int16Array.prototype, fnName, fn);
-			CreateMethodProperty(self.Uint16Array.prototype, fnName, fn);
-			CreateMethodProperty(self.Int32Array.prototype, fnName, fn);
-			CreateMethodProperty(self.Uint32Array.prototype, fnName, fn);
-			CreateMethodProperty(self.Float32Array.prototype, fnName, fn);
-			CreateMethodProperty(self.Float64Array.prototype, fnName, fn);
-		}
-	}
-
-	createMethodProperties(function keys () {
+	function keys() {
 		// 1. Let O be the this value.
 		var O = this;
 		// 2. Perform ? ValidateTypedArray(O).
@@ -34,5 +11,24 @@
 		// 3. Return CreateArrayIterator(O, key).
 		// TODO: Add CreateArrayIterator
 		return new ArrayIterator(O, 'key');
-	});
+	}
+
+	// use "Int8Array" as a proxy for support of "TypedArray" subclasses
+	var fnName = 'keys'
+	// in IE11, `Int8Array.prototype` inherits directly from `Object.prototype`
+	// in that case, don't define it on the parent; define it directly on the prototype
+	if ('__proto__' in self.Int8Array.prototype && self.Int8Array.prototype.__proto__ !== Object.prototype) {
+		// set this on the underlying "TypedArrayPrototype", which is shared with all "TypedArray" subclasses
+		CreateMethodProperty(self.Int8Array.prototype.__proto__, fnName, keys);
+	} else {
+		CreateMethodProperty(self.Int8Array.prototype, fnName, keys);
+		CreateMethodProperty(self.Uint8Array.prototype, fnName, keys);
+		CreateMethodProperty(self.Uint8ClampedArray.prototype, fnName, keys);
+		CreateMethodProperty(self.Int16Array.prototype, fnName, keys);
+		CreateMethodProperty(self.Uint16Array.prototype, fnName, keys);
+		CreateMethodProperty(self.Int32Array.prototype, fnName, keys);
+		CreateMethodProperty(self.Uint32Array.prototype, fnName, keys);
+		CreateMethodProperty(self.Float32Array.prototype, fnName, keys);
+		CreateMethodProperty(self.Float64Array.prototype, fnName, keys);
+	}
 })();

package/polyfills/__dist/TypedArray.prototype.sort/meta.json

@@ -0,0 +1 @@
+{"dependencies":["_ESAbstract.CreateMethodProperty","_ESAbstract.IsCallable","ArrayBuffer"],"license":"MIT","spec":"https://tc39.es/ecma262/#sec-%typedarray%.prototype.sort","docs":"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/sort","browsers":{"android":"*","bb":"*","chrome":"<45","edge":"<12","edge_mob":"<12","firefox":"<46","firefox_mob":"<46","ie":"*","ie_mob":"*","opera":"<32","op_mob":"<32","op_mini":"*","safari":"<10.0","ios_saf":"<10.0","samsung_mob":"<5.0"},"detectSource":"\"Int8Array\"in self&&\"sort\"in self.Int8Array.prototype\n","baseDir":"TypedArray/prototype/sort","hasTests":true,"isTestable":true,"isPublic":true,"size":1034}

package/polyfills/__dist/TypedArray.prototype.sort/min.js

@@ -0,0 +1 @@
+!function(){function r(r){function t(t,e){return t!==t&&e!==e?0:t!==t?1:e!==e?-1:void 0!==r?r(t,e):t<e?-1:t>e?1:0}if(void 0!==r&&!1===IsCallable(r))throw new TypeError("The comparison function must be either a function or undefined");for(var e=this,o=e.length,p=Array(o),y=0;y<o;y++)p[y]=e[y];p.sort(t);for(var a=0;a<o;)e[a]=p[a],a+=1;return e}"__proto__"in self.Int8Array.prototype&&self.Int8Array.prototype.__proto__!==Object.prototype?CreateMethodProperty(self.Int8Array.prototype.__proto__,"sort",r):(CreateMethodProperty(self.Int8Array.prototype,"sort",r),CreateMethodProperty(self.Uint8Array.prototype,"sort",r),CreateMethodProperty(self.Uint8ClampedArray.prototype,"sort",r),CreateMethodProperty(self.Int16Array.prototype,"sort",r),CreateMethodProperty(self.Uint16Array.prototype,"sort",r),CreateMethodProperty(self.Int32Array.prototype,"sort",r),CreateMethodProperty(self.Uint32Array.prototype,"sort",r),CreateMethodProperty(self.Float32Array.prototype,"sort",r),CreateMethodProperty(self.Float64Array.prototype,"sort",r))}();

package/polyfills/__dist/TypedArray.prototype.sort/raw.js

@@ -0,0 +1,71 @@
+
+// TypedArray.prototype.sort
+/* global CreateMethodProperty, IsCallable */
+// 23.2.3.29 %TypedArray%.prototype.sort ( comparefn )
+(function () {
+	function sort(comparefn) {
+		// 1. If comparefn is not undefined and IsCallable(comparefn) is false, throw a TypeError exception.
+		if (comparefn !== undefined && IsCallable(comparefn) === false) {
+			throw new TypeError(
+				"The comparison function must be either a function or undefined"
+			);
+		}
+		// 2. Let obj be the this value.
+		var obj = this;
+		// 3. Perform ? ValidateTypedArray(obj).
+		// TODO: Add ValidateTypedArray
+		// 4. Let len be obj.[[ArrayLength]].
+		var len = obj.length;
+
+		// Polyfill.io - This is based on https://github.com/inexorabletash/polyfill/blob/716a3f36ca10fad032083014faf1a47c638e2502/typedarray.js#L848-L858
+		// 5. NOTE: The following closure performs a numeric comparison rather than the string comparison used in 23.1.3.30.
+		// 6. Let SortCompare be a new Abstract Closure with parameters (x, y) that captures comparefn and performs the following steps when called:
+		// a. Return ? CompareTypedArrayElements(x, y, comparefn).
+		function sortCompare(x, y) {
+			if (x !== x && y !== y) return +0;
+			if (x !== x) return 1;
+			if (y !== y) return -1;
+			if (comparefn !== undefined) {
+				return comparefn(x, y);
+			}
+			if (x < y) return -1;
+			if (x > y) return 1;
+			return +0;
+		}
+
+		// 7. Let sortedList be ? SortIndexedProperties(obj, len, SortCompare, read-through-holes).
+		var sortedList = Array(len);
+		for (var i = 0; i < len; i++) sortedList[i] = obj[i];
+		sortedList.sort(sortCompare);
+
+		// 8. Let j be 0.
+		var j = 0;
+		// 9. Repeat, while j < len,
+		while (j < len) {
+			// a. Perform ! Set(obj, ! ToString(𝔽(j)), sortedList[j], true).
+			obj[j] = sortedList[j];
+			// b. Set j to j + 1.
+			j = j + 1;
+		}
+
+		// 10. Return obj.
+		return obj;
+	}
+
+	// in IE11, `Int8Array.prototype` inherits directly from `Object.prototype`
+	// in that case, don't define it on the parent; define it directly on the prototype
+	if ('__proto__' in self.Int8Array.prototype && self.Int8Array.prototype.__proto__ !== Object.prototype) {
+		// set this on the underlying "TypedArrayPrototype", which is shared with all "TypedArray" subclasses
+		CreateMethodProperty(self.Int8Array.prototype.__proto__, 'sort', sort);
+	} else {
+		CreateMethodProperty(self.Int8Array.prototype, 'sort', sort);
+		CreateMethodProperty(self.Uint8Array.prototype, 'sort', sort);
+		CreateMethodProperty(self.Uint8ClampedArray.prototype, 'sort', sort);
+		CreateMethodProperty(self.Int16Array.prototype, 'sort', sort);
+		CreateMethodProperty(self.Uint16Array.prototype, 'sort', sort);
+		CreateMethodProperty(self.Int32Array.prototype, 'sort', sort);
+		CreateMethodProperty(self.Uint32Array.prototype, 'sort', sort);
+		CreateMethodProperty(self.Float32Array.prototype, 'sort', sort);
+		CreateMethodProperty(self.Float64Array.prototype, 'sort', sort);
+	}
+})();

package/polyfills/__dist/TypedArray.prototype.toReversed/meta.json

@@ -0,0 +1 @@
+{"aliases":["es2023"],"dependencies":["_ESAbstract.CreateMethodProperty","_ESAbstract.Get","_ESAbstract.ToString","_ESAbstract.TypedArrayCreateSameType","ArrayBuffer"],"license":"MIT","spec":"https://tc39.es/ecma262/#sec-%typedarray%.prototype.toreversed","docs":"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/toReversed","browsers":{"android":"*","bb":"*","chrome":"<110","edge":"*","edge_mob":"*","firefox":"*","firefox_mob":"*","ie":"*","ie_mob":"*","opera":"<96","op_mob":"<74","op_mini":"*","safari":"<16.3","ios_saf":"<16.3","samsung_mob":"*"},"detectSource":"\"Int8Array\"in self&&\"toReversed\"in self.Int8Array.prototype\n","baseDir":"TypedArray/prototype/toReversed","hasTests":true,"isTestable":true,"isPublic":true,"size":913}

package/polyfills/__dist/TypedArray.prototype.toReversed/min.js

@@ -0,0 +1 @@
+!function(){function e(){for(var e=this,t=e.length,r=TypedArrayCreateSameType(e,[t]),o=0;o<t;){var p=ToString(t-o-1),y=ToString(o),a=Get(e,p);r[y]=a,o+=1}return r}"__proto__"in self.Int8Array.prototype&&self.Int8Array.prototype.__proto__!==Object.prototype?CreateMethodProperty(self.Int8Array.prototype.__proto__,"toReversed",e):(CreateMethodProperty(self.Int8Array.prototype,"toReversed",e),CreateMethodProperty(self.Uint8Array.prototype,"toReversed",e),CreateMethodProperty(self.Uint8ClampedArray.prototype,"toReversed",e),CreateMethodProperty(self.Int16Array.prototype,"toReversed",e),CreateMethodProperty(self.Uint16Array.prototype,"toReversed",e),CreateMethodProperty(self.Int32Array.prototype,"toReversed",e),CreateMethodProperty(self.Uint32Array.prototype,"toReversed",e),CreateMethodProperty(self.Float32Array.prototype,"toReversed",e),CreateMethodProperty(self.Float64Array.prototype,"toReversed",e))}();

package/polyfills/__dist/TypedArray.prototype.toReversed/raw.js

@@ -0,0 +1,50 @@
+
+// TypedArray.prototype.toReversed
+/* global CreateMethodProperty, Get, ToString, TypedArrayCreateSameType */
+// 23.2.3.32 %TypedArray%.prototype.toReversed ( )
+(function () {
+	function toReversed() {
+		// 1. Let O be the this value.
+		var O = this;
+		// 2. Perform ? ValidateTypedArray(O).
+		// TODO: Add ValidateTypedArray
+		// 3. Let length be O.[[ArrayLength]].
+		var length = O.length;
+		// 4. Let A be ? TypedArrayCreateSameType(O, « 𝔽(length) »).
+		var A = TypedArrayCreateSameType(O, [ length ]);
+		// 5. Let k be 0.
+		var k = 0;
+		// 6. Repeat, while k < length,
+		while (k < length) {
+			// a. Let from be ! ToString(𝔽(length - k - 1)).
+			var from = ToString(length - k - 1);
+			// b. Let Pk be ! ToString(𝔽(k)).
+			var Pk = ToString(k);
+			// c. Let fromValue be ! Get(O, from).
+			var fromValue = Get(O, from);
+			// d. Perform ! Set(A, Pk, fromValue, true).
+			A[Pk] = fromValue;
+			// e. Set k to k + 1.
+			k = k + 1;
+		}
+		// 7. Return A.
+		return A;
+	}
+
+	// in IE11, `Int8Array.prototype` inherits directly from `Object.prototype`
+	// in that case, don't define it on the parent; define it directly on the prototype
+	if ('__proto__' in self.Int8Array.prototype && self.Int8Array.prototype.__proto__ !== Object.prototype) {
+		// set this on the underlying "TypedArrayPrototype", which is shared with all "TypedArray" subclasses
+		CreateMethodProperty(self.Int8Array.prototype.__proto__, 'toReversed', toReversed);
+	} else {
+		CreateMethodProperty(self.Int8Array.prototype, 'toReversed', toReversed);
+		CreateMethodProperty(self.Uint8Array.prototype, 'toReversed', toReversed);
+		CreateMethodProperty(self.Uint8ClampedArray.prototype, 'toReversed', toReversed);
+		CreateMethodProperty(self.Int16Array.prototype, 'toReversed', toReversed);
+		CreateMethodProperty(self.Uint16Array.prototype, 'toReversed', toReversed);
+		CreateMethodProperty(self.Int32Array.prototype, 'toReversed', toReversed);
+		CreateMethodProperty(self.Uint32Array.prototype, 'toReversed', toReversed);
+		CreateMethodProperty(self.Float32Array.prototype, 'toReversed', toReversed);
+		CreateMethodProperty(self.Float64Array.prototype, 'toReversed', toReversed);
+	}
+})();

package/polyfills/__dist/TypedArray.prototype.toSorted/meta.json

@@ -0,0 +1 @@
+{"aliases":["es2023"],"dependencies":["_ESAbstract.CreateMethodProperty","_ESAbstract.IsCallable","_ESAbstract.ToString","_ESAbstract.TypedArrayCreateSameType","ArrayBuffer","TypedArray.prototype.sort"],"license":"MIT","spec":"https://tc39.es/ecma262/#sec-%typedarray%.prototype.tosorted","docs":"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/toSorted","browsers":{"android":"*","bb":"*","chrome":"<110","edge":"*","edge_mob":"*","firefox":"*","firefox_mob":"*","ie":"*","ie_mob":"*","opera":"<96","op_mob":"<74","op_mini":"*","safari":"<16.3","ios_saf":"<16.3","samsung_mob":"*"},"detectSource":"\"Int8Array\"in self&&\"toSorted\"in self.Int8Array.prototype\n","baseDir":"TypedArray/prototype/toSorted","hasTests":true,"isTestable":true,"isPublic":true,"size":999}

package/polyfills/__dist/TypedArray.prototype.toSorted/min.js

@@ -0,0 +1 @@
+!function(){function t(t){if(void 0!==t&&!1===IsCallable(t))throw new TypeError("The comparison function must be either a function or undefined");for(var r=this,e=r.length,o=TypedArrayCreateSameType(r,[e]),p=0;p<e;)o[p]=r[p],p+=1;return void 0!==t?o.sort(t):o.sort(),o}"__proto__"in self.Int8Array.prototype&&self.Int8Array.prototype.__proto__!==Object.prototype?CreateMethodProperty(self.Int8Array.prototype.__proto__,"toSorted",t):(CreateMethodProperty(self.Int8Array.prototype,"toSorted",t),CreateMethodProperty(self.Uint8Array.prototype,"toSorted",t),CreateMethodProperty(self.Uint8ClampedArray.prototype,"toSorted",t),CreateMethodProperty(self.Int16Array.prototype,"toSorted",t),CreateMethodProperty(self.Uint16Array.prototype,"toSorted",t),CreateMethodProperty(self.Int32Array.prototype,"toSorted",t),CreateMethodProperty(self.Uint32Array.prototype,"toSorted",t),CreateMethodProperty(self.Float32Array.prototype,"toSorted",t),CreateMethodProperty(self.Float64Array.prototype,"toSorted",t))}();

package/polyfills/__dist/TypedArray.prototype.toSorted/raw.js

@@ -0,0 +1,59 @@
+
+// TypedArray.prototype.toSorted
+/* global CreateMethodProperty, IsCallable, TypedArrayCreateSameType */
+// 23.2.3.33 %TypedArray%.prototype.toSorted ( comparefn )
+(function () {
+	function toSorted(comparefn) {
+		// 1. If comparefn is not undefined and IsCallable(comparefn) is false, throw a TypeError exception.
+		if (comparefn !== undefined && IsCallable(comparefn) === false) {
+			throw new TypeError(
+				"The comparison function must be either a function or undefined"
+			);
+		}
+		// 2. Let O be the this value.
+		var O = this;
+		// 3. Perform ? ValidateTypedArray(O).
+		// TODO: Add ValidateTypedArray
+		// 4. Let len be O.[[ArrayLength]].
+		var len = O.length;
+		// 5. Let A be ? TypedArrayCreateSameType(O, « 𝔽(len) »).
+		var A = TypedArrayCreateSameType(O, [ len ]);
+
+		// 9. Let j be 0.
+		var j = 0;
+		// 10. Repeat, while j < len,
+		while (j < len) {
+			// a. Perform ! Set(A, ! ToString(𝔽(j)), sortedList[j], true).
+			A[j] = O[j];
+			// b. Set j to j + 1.
+			j = j + 1;
+		}
+
+		// Polyfill.io - These steps are handled by native `%TypedArray%.prototype.sort`, below
+		// 6. NOTE: The following closure performs a numeric comparison rather than the string comparison used in 23.1.3.34.
+		// 7. Let SortCompare be a new Abstract Closure with parameters (x, y) that captures comparefn and performs the following steps when called:
+		// a. Return ? CompareTypedArrayElements(x, y, comparefn).
+		// 8. Let sortedList be ? SortIndexedProperties(O, len, SortCompare, read-through-holes).
+		comparefn !== undefined ? A.sort(comparefn) : A.sort();
+
+		// 11. Return A.
+		return A;
+	}
+
+	// in IE11, `Int8Array.prototype` inherits directly from `Object.prototype`
+	// in that case, don't define it on the parent; define it directly on the prototype
+	if ('__proto__' in self.Int8Array.prototype && self.Int8Array.prototype.__proto__ !== Object.prototype) {
+		// set this on the underlying "TypedArrayPrototype", which is shared with all "TypedArray" subclasses
+		CreateMethodProperty(self.Int8Array.prototype.__proto__, 'toSorted', toSorted);
+	} else {
+		CreateMethodProperty(self.Int8Array.prototype, 'toSorted', toSorted);
+		CreateMethodProperty(self.Uint8Array.prototype, 'toSorted', toSorted);
+		CreateMethodProperty(self.Uint8ClampedArray.prototype, 'toSorted', toSorted);
+		CreateMethodProperty(self.Int16Array.prototype, 'toSorted', toSorted);
+		CreateMethodProperty(self.Uint16Array.prototype, 'toSorted', toSorted);
+		CreateMethodProperty(self.Int32Array.prototype, 'toSorted', toSorted);
+		CreateMethodProperty(self.Uint32Array.prototype, 'toSorted', toSorted);
+		CreateMethodProperty(self.Float32Array.prototype, 'toSorted', toSorted);
+		CreateMethodProperty(self.Float64Array.prototype, 'toSorted', toSorted);
+	}
+})();

package/polyfills/__dist/TypedArray.prototype.with/meta.json

@@ -0,0 +1 @@
+{"aliases":["es2023"],"dependencies":["_ESAbstract.CreateMethodProperty","_ESAbstract.Get","_ESAbstract.IsValidIntegerIndex","_ESAbstract.ToIntegerOrInfinity","_ESAbstract.ToNumber","_ESAbstract.ToObject","_ESAbstract.ToString","_ESAbstract.TypedArrayCreateSameType","ArrayBuffer","Function.prototype.name"],"license":"MIT","spec":"https://tc39.es/ecma262/#sec-%typedarray%.prototype.with","docs":"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/with","browsers":{"android":"*","bb":"*","chrome":"<110","edge":"*","edge_mob":"*","firefox":"*","firefox_mob":"*","ie":"*","ie_mob":"*","opera":"<96","op_mob":"<74","op_mini":"*","safari":"<16.3","ios_saf":"<16.3","samsung_mob":"*"},"detectSource":"\"Int8Array\"in self&&\"with\"in self.Int8Array.prototype\n","baseDir":"TypedArray/prototype/with","hasTests":true,"isTestable":true,"isPublic":true,"size":1178}

package/polyfills/__dist/TypedArray.prototype.with/min.js

@@ -0,0 +1 @@
+!function(){function t(t,e){var r=this,o=r.length,p=ToIntegerOrInfinity(t),a=p>=0?p:o+p,y=ToNumber(e);if(!1===IsValidIntegerIndex(r,a))throw new RangeError("Invalid index");for(var n=TypedArrayCreateSameType(r,[o]),i=0;i<o;){var h=ToString(i),l=i===a?y:Get(r,h);n[h]=l,i+=1}return n}(function(){var t=function(){};try{return Object.defineProperty(t,"name",{value:"test"}),!0}catch(t){return!1}})()&&Object.defineProperty(t,"name",{value:"with",writable:!1,enumerable:!1,configurable:!0}),"__proto__"in self.Int8Array.prototype&&self.Int8Array.prototype.__proto__!==Object.prototype?CreateMethodProperty(self.Int8Array.prototype.__proto__,"with",t):(CreateMethodProperty(self.Int8Array.prototype,"with",t),CreateMethodProperty(self.Uint8Array.prototype,"with",t),CreateMethodProperty(self.Uint8ClampedArray.prototype,"with",t),CreateMethodProperty(self.Int16Array.prototype,"with",t),CreateMethodProperty(self.Uint16Array.prototype,"with",t),CreateMethodProperty(self.Int32Array.prototype,"with",t),CreateMethodProperty(self.Uint32Array.prototype,"with",t),CreateMethodProperty(self.Float32Array.prototype,"with",t),CreateMethodProperty(self.Float64Array.prototype,"with",t))}();

package/polyfills/__dist/TypedArray.prototype.with/raw.js

@@ -0,0 +1,83 @@
+
+// TypedArray.prototype.with
+/* global CreateMethodProperty, Get, IsValidIntegerIndex, ToIntegerOrInfinity, ToNumber, ToString, TypedArrayCreateSameType */
+// 23.2.3.36 %TypedArray%.prototype.with ( index, value )
+(function () {
+	function With(index, value) {
+		// 1. Let O be the this value.
+		var O = this;
+		// 2. Perform ? ValidateTypedArray(O).
+		// TODO: Add ValidateTypedArray
+		// 3. Let len be O.[[ArrayLength]].
+		var len = O.length;
+		// 4. Let relativeIndex be ? ToIntegerOrInfinity(index).
+		var relativeIndex = ToIntegerOrInfinity(index);
+		// 5. If relativeIndex ≥ 0, let actualIndex be relativeIndex.
+		// 6. Else, let actualIndex be len + relativeIndex.
+		var actualIndex = relativeIndex >= 0 ? relativeIndex : len + relativeIndex;
+		// 7. If O.[[ContentType]] is BigInt, let numericValue be ? ToBigInt(value).
+		// TODO: Add BigInt support
+		// 8. Else, let numericValue be ? ToNumber(value).
+		var numericValue = ToNumber(value);
+		// 9. If IsValidIntegerIndex(O, 𝔽(actualIndex)) is false, throw a RangeError exception.
+		if (IsValidIntegerIndex(O, actualIndex) === false) {
+			throw new RangeError('Invalid index');
+		}
+		// 10. Let A be ? TypedArrayCreateSameType(O, « 𝔽(len) »).
+		var A = TypedArrayCreateSameType(O, [ len ]);
+		// 11. Let k be 0.
+		var k = 0;
+		// 12. Repeat, while k < len,
+		while (k < len) {
+			// a. Let Pk be ! ToString(𝔽(k)).
+			var Pk = ToString(k);
+			// b. If k is actualIndex, let fromValue be numericValue.
+			// c. Else, let fromValue be ! Get(O, Pk).
+			var fromValue = k === actualIndex ? numericValue : Get(O, Pk);
+			// d. Perform ! Set(A, Pk, fromValue, true).
+			A[Pk] = fromValue;
+			// e. Set k to k + 1.
+			k = k + 1;
+		}
+		// 13. Return A.
+		return A;
+	}
+
+	var supportsDefiningFunctionName = (function () {
+		var fn = function () {};
+		try {
+			Object.defineProperty(fn, 'name', {
+				value: 'test'
+			});
+			return true;
+		} catch (ignore) {
+			return false;
+		}
+	})();
+
+	if (supportsDefiningFunctionName) {
+		Object.defineProperty(With, 'name', {
+			value: 'with',
+			writable: false,
+			enumerable: false,
+			configurable: true
+		})
+	}
+
+	// in IE11, `Int8Array.prototype` inherits directly from `Object.prototype`
+	// in that case, don't define it on the parent; define it directly on the prototype
+	if ('__proto__' in self.Int8Array.prototype && self.Int8Array.prototype.__proto__ !== Object.prototype) {
+		// set this on the underlying "TypedArrayPrototype", which is shared with all "TypedArray" subclasses
+		CreateMethodProperty(self.Int8Array.prototype.__proto__, 'with', With);
+	} else {
+		CreateMethodProperty(self.Int8Array.prototype, 'with', With);
+		CreateMethodProperty(self.Uint8Array.prototype, 'with', With);
+		CreateMethodProperty(self.Uint8ClampedArray.prototype, 'with', With);
+		CreateMethodProperty(self.Int16Array.prototype, 'with', With);
+		CreateMethodProperty(self.Uint16Array.prototype, 'with', With);
+		CreateMethodProperty(self.Int32Array.prototype, 'with', With);
+		CreateMethodProperty(self.Uint32Array.prototype, 'with', With);
+		CreateMethodProperty(self.Float32Array.prototype, 'with', With);
+		CreateMethodProperty(self.Float64Array.prototype, 'with', With);
+	}
+})();

package/polyfills/__dist/_ESAbstract.IsValidIntegerIndex/meta.json

@@ -0,0 +1 @@
+{"dependencies":["_ESAbstract.IsInteger"],"spec":"https://tc39.es/ecma262/#sec-isvalidintegerindex","browsers":{"android":"*","bb":"*","chrome":"*","edge":"*","edge_mob":"*","firefox":"*","firefox_mob":"*","ie":"*","ie_mob":"*","opera":"*","op_mob":"*","op_mini":"*","safari":"*","ios_saf":"*","samsung_mob":"*"},"detectSource":"","baseDir":"_ESAbstract/IsValidIntegerIndex","hasTests":false,"isTestable":true,"isPublic":false,"size":92}

package/polyfills/__dist/_ESAbstract.IsValidIntegerIndex/min.js

@@ -0,0 +1 @@
+function IsValidIntegerIndex(e,n){return!1!==IsInteger(n)&&(1/n!=-1/0&&!(n<0||n>=e.length))}

package/polyfills/__dist/_ESAbstract.IsValidIntegerIndex/raw.js

@@ -0,0 +1,16 @@
+
+// _ESAbstract.IsValidIntegerIndex
+/* globals IsInteger */
+// 10.4.5.9 IsValidIntegerIndex ( O, index )
+function IsValidIntegerIndex(O, index) { // eslint-disable-line no-unused-vars
+	// 1. If IsDetachedBuffer(O.[[ViewedArrayBuffer]]) is true, return false.
+	// 2. If IsIntegralNumber(index) is false, return false.
+	if (IsInteger(index) === false) return false;
+	// 3. If index is -0𝔽, return false.
+	// eslint-disable-next-line no-compare-neg-zero
+	if (1 / index === -Infinity) return false;
+	// 4. If ℝ(index) < 0 or ℝ(index) ≥ O.[[ArrayLength]], return false.
+	if (index < 0 || index >= O.length) return false;
+	// 5. Return true.
+	return true;
+}

package/polyfills/__dist/_ESAbstract.TypedArrayCreate/meta.json

@@ -0,0 +1 @@
+{"dependencies":["_ESAbstract.Construct"],"spec":"https://tc39.es/ecma262/#typedarray-create","browsers":{"android":"*","bb":"*","chrome":"*","edge":"*","edge_mob":"*","firefox":"*","firefox_mob":"*","ie":"*","ie_mob":"*","opera":"*","op_mob":"*","op_mini":"*","safari":"*","ios_saf":"*","samsung_mob":"*"},"detectSource":"","baseDir":"_ESAbstract/TypedArrayCreate","hasTests":false,"isTestable":true,"isPublic":false,"size":164}

package/polyfills/__dist/_ESAbstract.TypedArrayCreate/min.js

@@ -0,0 +1 @@
+function TypedArrayCreate(e,r){var t="object"==typeof e?new e(r[0]):Construct(e,r);if(1===r.length&&"number"==typeof r[0]&&t.length<r[0])throw TypeError();return t}

package/polyfills/__dist/_ESAbstract.TypedArrayCreate/raw.js

@@ -0,0 +1,20 @@
+
+// _ESAbstract.TypedArrayCreate
+/* global Construct */
+// 23.2.4.2 TypedArrayCreate ( constructor, argumentList )
+function TypedArrayCreate(constructor, argumentList) { // eslint-disable-line no-unused-vars
+	// 1. Let newTypedArray be ? Construct(constructor, argumentList).
+	var newTypedArray = typeof constructor === 'object'
+		// TODO: Remove this once we drop support for Safari <10, which does not consider `Int8Array` as a constructor (`typeof Int8Array === 'object'`)
+		? new constructor(argumentList[0])
+		: Construct(constructor, argumentList);
+	// 2. Perform ? ValidateTypedArray(newTypedArray).
+	// TODO: Add ValidateTypedArray
+	// 3. If the number of elements in argumentList is 1 and argumentList[0] is a Number, then
+	if (argumentList.length === 1 && typeof argumentList[0] === 'number') {
+		// a. If newTypedArray.[[ArrayLength]] < ℝ(argumentList[0]), throw a TypeError exception.
+		if (newTypedArray.length < argumentList[0]) throw TypeError();
+	}
+	// 4. Return newTypedArray.
+	return newTypedArray;
+}

package/polyfills/__dist/_ESAbstract.TypedArrayCreateSameType/meta.json

@@ -0,0 +1 @@
+{"dependencies":["_ESAbstract.TypedArrayCreate","Function.prototype.name"],"spec":"https://tc39.es/ecma262/#sec-typedarray-create-same-type","browsers":{"android":"*","bb":"*","chrome":"*","edge":"*","edge_mob":"*","firefox":"*","firefox_mob":"*","ie":"*","ie_mob":"*","opera":"*","op_mob":"*","op_mini":"*","safari":"*","ios_saf":"*","samsung_mob":"*"},"detectSource":"","baseDir":"_ESAbstract/TypedArrayCreateSameType","hasTests":false,"isTestable":true,"isPublic":false,"size":689}

package/polyfills/__dist/_ESAbstract.TypedArrayCreateSameType/min.js

@@ -0,0 +1 @@
+function TypedArrayCreateSameType(r,a){var t={Int8Array:self.Int8Array,Uint8Array:self.Uint8Array,Uint8ClampedArray:self.Uint8ClampedArray,Int16Array:self.Int16Array,Uint16Array:self.Uint16Array,Int32Array:self.Int32Array,Uint32Array:self.Uint32Array,Float32Array:self.Float32Array,Float64Array:self.Float64Array}[r&&r.constructor&&r.constructor.name];if(!t){var e=Object.getPrototypeOf(Object(r));t={packI8:self.Int8Array,packU8:self.Uint8Array,packU8Clamped:self.Uint8ClampedArray,packI16:self.Int16Array,packU16:self.Uint16Array,packI32:self.Int32Array,packU32:self.Uint32Array,packF32:self.Float32Array,packF64:self.Float64Array}[e&&e._pack&&e._pack.name]}return TypedArrayCreate(t,a)}

package/polyfills/__dist/_ESAbstract.TypedArrayCreateSameType/raw.js

@@ -0,0 +1,41 @@
+
+// _ESAbstract.TypedArrayCreateSameType
+/* global TypedArrayCreate */
+// 23.2.4.3 TypedArrayCreateSameType ( exemplar, argumentList )
+function TypedArrayCreateSameType(exemplar, argumentList) { // eslint-disable-line no-unused-vars
+	// 1. Let constructor be the intrinsic object associated with the constructor name exemplar.[[TypedArrayName]] in Table 68.
+	var constructor = {
+		Int8Array: self.Int8Array,
+		Uint8Array: self.Uint8Array,
+		Uint8ClampedArray: self.Uint8ClampedArray,
+		Int16Array: self.Int16Array,
+		Uint16Array: self.Uint16Array,
+		Int32Array: self.Int32Array,
+		Uint32Array: self.Uint32Array,
+		Float32Array: self.Float32Array,
+		Float64Array: self.Float64Array
+	}[exemplar && exemplar.constructor && exemplar.constructor.name];
+
+	// Polyfill.io - the `ArrayBuffer` polyfill does not expose a proper `constructor.name`
+	if (!constructor) {
+		var proto = Object.getPrototypeOf(Object(exemplar));
+		constructor = {
+			packI8: self.Int8Array,
+			packU8: self.Uint8Array,
+			packU8Clamped: self.Uint8ClampedArray,
+			packI16: self.Int16Array,
+			packU16: self.Uint16Array,
+			packI32: self.Int32Array,
+			packU32: self.Uint32Array,
+			packF32: self.Float32Array,
+			packF64: self.Float64Array
+		}[proto && proto._pack && proto._pack.name];
+	}
+
+	// 2. Let result be ? TypedArrayCreate(constructor, argumentList).
+	var result = TypedArrayCreate(constructor, argumentList);
+	// 3. Assert: result has [[TypedArrayName]] and [[ContentType]] internal slots.
+	// 4. Assert: result.[[ContentType]] is exemplar.[[ContentType]].
+	// 5. Return result.
+	return result;
+}