core-js 3.35.1 → 4.0.0-alpha.0

package/internals/string-multibyte.js

@@ -4,7 +4,6 @@ var toIntegerOrInfinity = require('../internals/to-integer-or-infinity');
 var toString = require('../internals/to-string');
 var requireObjectCoercible = require('../internals/require-object-coercible');
 
-var charAt = uncurryThis(''.charAt);
 var charCodeAt = uncurryThis(''.charCodeAt);
 var stringSlice = uncurryThis(''.slice);
 
@@ -19,7 +18,7 @@ var createMethod = function (CONVERT_TO_STRING) {
     return first < 0xD800 || first > 0xDBFF || position + 1 === size
       || (second = charCodeAt(S, position + 1)) < 0xDC00 || second > 0xDFFF
         ? CONVERT_TO_STRING
-          ? charAt(S, position)
+          ? S[position]
           : first
         : CONVERT_TO_STRING
           ? stringSlice(S, position, position + 2)
@@ -31,7 +30,5 @@ module.exports = {
   // `String.prototype.codePointAt` method
   // https://tc39.es/ecma262/#sec-string.prototype.codepointat
   codeAt: createMethod(false),
-  // `String.prototype.at` method
-  // https://github.com/mathiasbynens/String.prototype.at
-  charAt: createMethod(true)
+  charAt: createMethod(true),
 };

package/internals/string-pad.js

@@ -1,12 +1,13 @@
 'use strict';
 // https://github.com/tc39/proposal-string-pad-start-end
+var getBuiltInPrototypeMethod = require('../internals/get-built-in-prototype-method');
 var uncurryThis = require('../internals/function-uncurry-this');
 var toLength = require('../internals/to-length');
 var toString = require('../internals/to-string');
-var $repeat = require('../internals/string-repeat');
 var requireObjectCoercible = require('../internals/require-object-coercible');
 
-var repeat = uncurryThis($repeat);
+// dependency: es.string.repeat
+var repeat = uncurryThis(getBuiltInPrototypeMethod('String', 'repeat'));
 var stringSlice = uncurryThis(''.slice);
 var ceil = Math.ceil;
 
@@ -32,5 +33,5 @@ module.exports = {
   start: createMethod(false),
   // `String.prototype.padEnd` method
   // https://tc39.es/ecma262/#sec-string.prototype.padend
-  end: createMethod(true)
+  end: createMethod(true),
 };

package/internals/string-parse.js

@@ -1,10 +1,11 @@
 'use strict';
 // adapted from https://github.com/jridgewell/string-dedent
-var getBuiltIn = require('../internals/get-built-in');
+var getBuiltInStaticMethod = require('../internals/get-built-in-static-method');
 var uncurryThis = require('../internals/function-uncurry-this');
 
 var fromCharCode = String.fromCharCode;
-var fromCodePoint = getBuiltIn('String', 'fromCodePoint');
+// dependency: es.string.from-code-point
+var fromCodePoint = getBuiltInStaticMethod('String', 'fromCodePoint');
 var charAt = uncurryThis(''.charAt);
 var charCodeAt = uncurryThis(''.charCodeAt);
 var stringIndexOf = uncurryThis(''.indexOf);
@@ -76,7 +77,7 @@ module.exports = function (raw) {
       // Escaped line terminators just skip the char.
       case '\r':
         // Treat `\r\n` as a single terminator.
-        if (i < raw.length && charAt(raw, i) === '\n') ++i;
+        if (charAt(raw, i) === '\n') ++i;
       // break omitted
       case '\n':
       case '\u2028':
@@ -97,7 +98,7 @@ module.exports = function (raw) {
       // Unicode escapes contain either 4 chars, or an unlimited number between `{` and `}`.
       // The hex value must not overflow 0x10FFFF.
       case 'u':
-        if (i < raw.length && charAt(raw, i) === '{') {
+        if (charAt(raw, i) === '{') {
           var end = stringIndexOf(raw, '}', ++i);
           if (end === -1) return;
           n = parseHex(raw, i, end);

package/internals/string-punycode-to-ascii.js

@@ -21,7 +21,9 @@ var exec = uncurryThis(regexSeparators.exec);
 var floor = Math.floor;
 var fromCharCode = String.fromCharCode;
 var charCodeAt = uncurryThis(''.charCodeAt);
+var forEach = uncurryThis([].forEach);
 var join = uncurryThis([].join);
+var map = uncurryThis([].map);
 var push = uncurryThis([].push);
 var replace = uncurryThis(''.replace);
 var split = uncurryThis(''.split);
@@ -99,15 +101,13 @@ var encode = function (input) {
   var n = initialN;
   var delta = 0;
   var bias = initialBias;
-  var i, currentValue;
 
   // Handle the basic code points.
-  for (i = 0; i < input.length; i++) {
-    currentValue = input[i];
+  forEach(input, function (currentValue) {
     if (currentValue < 0x80) {
       push(output, fromCharCode(currentValue));
     }
-  }
+  });
 
   var basicLength = output.length; // number of basic code points.
   var handledCPCount = basicLength; // number of code points that have been handled;
@@ -121,12 +121,11 @@ var encode = function (input) {
   while (handledCPCount < inputLength) {
     // All non-basic code points < n have been handled already. Find the next larger one:
     var m = maxInt;
-    for (i = 0; i < input.length; i++) {
-      currentValue = input[i];
+    forEach(input, function (currentValue) {
       if (currentValue >= n && currentValue < m) {
         m = currentValue;
       }
-    }
+    });
 
     // Increase `delta` enough to advance the decoder's <n,i> state to <m,0>, but guard against overflow.
     var handledCPCountPlusOne = handledCPCount + 1;
@@ -137,8 +136,7 @@ var encode = function (input) {
     delta += (m - n) * handledCPCountPlusOne;
     n = m;
 
-    for (i = 0; i < input.length; i++) {
-      currentValue = input[i];
+    forEach(input, function (currentValue) {
       if (currentValue < n && ++delta > maxInt) {
         throw new $RangeError(OVERFLOW_ERROR);
       }
@@ -161,7 +159,7 @@ var encode = function (input) {
         delta = 0;
         handledCPCount++;
       }
-    }
+    });
 
     delta++;
     n++;
@@ -170,12 +168,8 @@ var encode = function (input) {
 };
 
 module.exports = function (input) {
-  var encoded = [];
   var labels = split(replace(toLowerCase(input), regexSeparators, '\u002E'), '.');
-  var i, label;
-  for (i = 0; i < labels.length; i++) {
-    label = labels[i];
-    push(encoded, exec(regexNonASCII, label) ? 'xn--' + encode(label) : label);
-  }
-  return join(encoded, '.');
+  return join(map(labels, function (label) {
+    return exec(regexNonASCII, label) ? 'xn--' + encode(label) : label;
+  }), '.');
 };

package/internals/string-trim.js

@@ -27,5 +27,5 @@ module.exports = {
   end: createMethod(2),
   // `String.prototype.trim` method
   // https://tc39.es/ecma262/#sec-string.prototype.trim
-  trim: createMethod(3)
+  trim: createMethod(3),
 };

package/internals/structured-clone-proper-transfer.js

@@ -1,12 +1,12 @@
 'use strict';
-var global = require('../internals/global');
+var globalThis = require('../internals/global-this');
 var fails = require('../internals/fails');
 var V8 = require('../internals/engine-v8-version');
 var IS_BROWSER = require('../internals/engine-is-browser');
 var IS_DENO = require('../internals/engine-is-deno');
 var IS_NODE = require('../internals/engine-is-node');
 
-var structuredClone = global.structuredClone;
+var structuredClone = globalThis.structuredClone;
 
 module.exports = !!structuredClone && !fails(function () {
   // prevent V8 ArrayBufferDetaching protector cell invalidation and performance degradation

package/internals/symbol-constructor-detection.js

@@ -1,10 +1,8 @@
 'use strict';
 /* eslint-disable es/no-symbol -- required for testing */
-var V8_VERSION = require('../internals/engine-v8-version');
+var globalThis = require('../internals/global-this');
 var fails = require('../internals/fails');
-var global = require('../internals/global');
-
-var $String = global.String;
+var V8_VERSION = require('../internals/engine-v8-version');
 
 // eslint-disable-next-line es/no-object-getownpropertysymbols -- required for testing
 module.exports = !!Object.getOwnPropertySymbols && !fails(function () {
@@ -13,7 +11,7 @@ module.exports = !!Object.getOwnPropertySymbols && !fails(function () {
   // `get-own-property-symbols` polyfill symbols converted to object are not Symbol instances
   // nb: Do not call `String` directly to avoid this being optimized out to `symbol+''` which will,
   // of course, fail.
-  return !$String(symbol) || !(Object(symbol) instanceof Symbol) ||
+  return !globalThis.String(symbol) || !(Object(symbol) instanceof Symbol) ||
     // Chrome 38-40 symbols are not inherited from DOM collections prototypes to instances
     !Symbol.sham && V8_VERSION && V8_VERSION < 41;
 });

package/internals/symbol-registry-detection.js

@@ -2,4 +2,4 @@
 var NATIVE_SYMBOL = require('../internals/symbol-constructor-detection');
 
 /* eslint-disable es/no-symbol -- safe */
-module.exports = NATIVE_SYMBOL && !!Symbol['for'] && !!Symbol.keyFor;
+module.exports = NATIVE_SYMBOL && !!Symbol.for && !!Symbol.keyFor;

package/internals/task.js

@@ -1,62 +1,58 @@
 'use strict';
-var global = require('../internals/global');
+var globalThis = require('../internals/global-this');
 var apply = require('../internals/function-apply');
-var bind = require('../internals/function-bind-context');
 var isCallable = require('../internals/is-callable');
-var hasOwn = require('../internals/has-own-property');
 var fails = require('../internals/fails');
-var html = require('../internals/html');
 var arraySlice = require('../internals/array-slice');
-var createElement = require('../internals/document-create-element');
 var validateArgumentsLength = require('../internals/validate-arguments-length');
 var IS_IOS = require('../internals/engine-is-ios');
 var IS_NODE = require('../internals/engine-is-node');
 
-var set = global.setImmediate;
-var clear = global.clearImmediate;
-var process = global.process;
-var Dispatch = global.Dispatch;
-var Function = global.Function;
-var MessageChannel = global.MessageChannel;
-var String = global.String;
-var counter = 0;
-var queue = {};
-var ONREADYSTATECHANGE = 'onreadystatechange';
-var $location, defer, channel, port;
+var $setImmediate = globalThis.setImmediate;
+var $clearImmediate = globalThis.clearImmediate;
 
-fails(function () {
-  // Deno throws a ReferenceError on `location` access without `--location` flag
-  $location = global.location;
-});
+// Node.js 0.9+, Bun 0.1.7 and IE10+ has setImmediate and clearImmediate, otherwise:
+if (!$setImmediate || !$clearImmediate) {
+  var $setTimeout = globalThis.setTimeout;
+  var process = globalThis.process;
+  var Dispatch = globalThis.Dispatch;
+  var MessageChannel = globalThis.MessageChannel;
+  var $Function = Function;
+  var counter = 0;
+  var queue = Object.create(null);
+  var $location, defer, channel, port;
 
-var run = function (id) {
-  if (hasOwn(queue, id)) {
+  fails(function () {
+    // Deno throws a ReferenceError on `location` access without `--location` flag
+    $location = globalThis.location;
+  });
+
+  var run = function (id) {
     var fn = queue[id];
-    delete queue[id];
-    fn();
-  }
-};
+    if (fn) {
+      delete queue[id];
+      fn();
+    }
+  };
 
-var runner = function (id) {
-  return function () {
-    run(id);
+  var runner = function (id) {
+    return function () {
+      run(id);
+    };
   };
-};
 
-var eventListener = function (event) {
-  run(event.data);
-};
+  var eventListener = function (event) {
+    run(event.data);
+  };
 
-var globalPostMessageDefer = function (id) {
-  // old engines have not location.origin
-  global.postMessage(String(id), $location.protocol + '//' + $location.host);
-};
+  var globalPostMessageDefer = function (id) {
+    // old engines have not location.origin
+    globalThis.postMessage(id + '', $location.protocol + '//' + $location.host);
+  };
 
-// Node.js 0.9+ & IE10+ has setImmediate, otherwise:
-if (!set || !clear) {
-  set = function setImmediate(handler) {
+  $setImmediate = function setImmediate(handler) {
     validateArgumentsLength(arguments.length, 1);
-    var fn = isCallable(handler) ? handler : Function(handler);
+    var fn = isCallable(handler) ? handler : $Function(handler);
     var args = arraySlice(arguments, 1);
     queue[++counter] = function () {
       apply(fn, undefined, args);
@@ -64,7 +60,7 @@ if (!set || !clear) {
     defer(counter);
     return counter;
   };
-  clear = function clearImmediate(id) {
+  $clearImmediate = function clearImmediate(id) {
     delete queue[id];
   };
   // Node.js 0.8-
@@ -83,35 +79,26 @@ if (!set || !clear) {
     channel = new MessageChannel();
     port = channel.port2;
     channel.port1.onmessage = eventListener;
-    defer = bind(port.postMessage, port);
+    defer = port.postMessage.bind(port);
   // Browsers with postMessage, skip WebWorkers
-  // IE8 has postMessage, but it's sync & typeof its postMessage is 'object'
   } else if (
-    global.addEventListener &&
-    isCallable(global.postMessage) &&
-    !global.importScripts &&
+    globalThis.addEventListener &&
+    isCallable(globalThis.postMessage) &&
+    !globalThis.importScripts &&
     $location && $location.protocol !== 'file:' &&
     !fails(globalPostMessageDefer)
   ) {
     defer = globalPostMessageDefer;
-    global.addEventListener('message', eventListener, false);
-  // IE8-
-  } else if (ONREADYSTATECHANGE in createElement('script')) {
-    defer = function (id) {
-      html.appendChild(createElement('script'))[ONREADYSTATECHANGE] = function () {
-        html.removeChild(this);
-        run(id);
-      };
-    };
+    globalThis.addEventListener('message', eventListener, false);
   // Rest old browsers
   } else {
     defer = function (id) {
-      setTimeout(runner(id), 0);
+      $setTimeout(runner(id), 0);
     };
   }
 }
 
 module.exports = {
-  set: set,
-  clear: clear
+  set: $setImmediate,
+  clear: $clearImmediate,
 };

package/internals/typed-array-constructor.js

@@ -1,236 +1,60 @@
 'use strict';
 var $ = require('../internals/export');
-var global = require('../internals/global');
+var globalThis = require('../internals/global-this');
 var call = require('../internals/function-call');
-var DESCRIPTORS = require('../internals/descriptors');
-var TYPED_ARRAYS_CONSTRUCTORS_REQUIRES_WRAPPERS = require('../internals/typed-array-constructors-require-wrappers');
-var ArrayBufferViewCore = require('../internals/array-buffer-view-core');
-var ArrayBufferModule = require('../internals/array-buffer');
+var TYPED_ARRAY_CONSTRUCTORS_REQUIRE_WRAPPERS = require('../internals/typed-array-constructors-require-wrappers');
+var TypedArray = require('../internals/typed-array-core').TypedArray;
 var anInstance = require('../internals/an-instance');
-var createPropertyDescriptor = require('../internals/create-property-descriptor');
-var createNonEnumerableProperty = require('../internals/create-non-enumerable-property');
-var isIntegralNumber = require('../internals/is-integral-number');
-var toLength = require('../internals/to-length');
 var toIndex = require('../internals/to-index');
 var toOffset = require('../internals/to-offset');
-var toUint8Clamped = require('../internals/to-uint8-clamped');
-var toPropertyKey = require('../internals/to-property-key');
-var hasOwn = require('../internals/has-own-property');
 var classof = require('../internals/classof');
 var isObject = require('../internals/is-object');
-var isSymbol = require('../internals/is-symbol');
-var create = require('../internals/object-create');
+var isTypedArray = require('../internals/is-typed-array');
 var isPrototypeOf = require('../internals/object-is-prototype-of');
-var setPrototypeOf = require('../internals/object-set-prototype-of');
-var getOwnPropertyNames = require('../internals/object-get-own-property-names').f;
+var setPrototypeOf = require('../internals/object-set-prototype-of-simple');
 var typedArrayFrom = require('../internals/typed-array-from');
-var forEach = require('../internals/array-iteration').forEach;
-var setSpecies = require('../internals/set-species');
-var defineBuiltInAccessor = require('../internals/define-built-in-accessor');
-var definePropertyModule = require('../internals/object-define-property');
-var getOwnPropertyDescriptorModule = require('../internals/object-get-own-property-descriptor');
 var arrayFromConstructorAndList = require('../internals/array-from-constructor-and-list');
-var InternalStateModule = require('../internals/internal-state');
 var inheritIfRequired = require('../internals/inherit-if-required');
+var copyConstructorProperties = require('../internals/copy-constructor-properties');
 
-var getInternalState = InternalStateModule.get;
-var setInternalState = InternalStateModule.set;
-var enforceInternalState = InternalStateModule.enforce;
-var nativeDefineProperty = definePropertyModule.f;
-var nativeGetOwnPropertyDescriptor = getOwnPropertyDescriptorModule.f;
-var RangeError = global.RangeError;
-var ArrayBuffer = ArrayBufferModule.ArrayBuffer;
 var ArrayBufferPrototype = ArrayBuffer.prototype;
-var DataView = ArrayBufferModule.DataView;
-var NATIVE_ARRAY_BUFFER_VIEWS = ArrayBufferViewCore.NATIVE_ARRAY_BUFFER_VIEWS;
-var TYPED_ARRAY_TAG = ArrayBufferViewCore.TYPED_ARRAY_TAG;
-var TypedArray = ArrayBufferViewCore.TypedArray;
-var TypedArrayPrototype = ArrayBufferViewCore.TypedArrayPrototype;
-var isTypedArray = ArrayBufferViewCore.isTypedArray;
-var BYTES_PER_ELEMENT = 'BYTES_PER_ELEMENT';
-var WRONG_LENGTH = 'Wrong length';
-
-var addGetter = function (it, key) {
-  defineBuiltInAccessor(it, key, {
-    configurable: true,
-    get: function () {
-      return getInternalState(this)[key];
-    }
-  });
-};
 
 var isArrayBuffer = function (it) {
   var klass;
   return isPrototypeOf(ArrayBufferPrototype, it) || (klass = classof(it)) === 'ArrayBuffer' || klass === 'SharedArrayBuffer';
 };
 
-var isTypedArrayIndex = function (target, key) {
-  return isTypedArray(target)
-    && !isSymbol(key)
-    && key in target
-    && isIntegralNumber(+key)
-    && key >= 0;
-};
-
-var wrappedGetOwnPropertyDescriptor = function getOwnPropertyDescriptor(target, key) {
-  key = toPropertyKey(key);
-  return isTypedArrayIndex(target, key)
-    ? createPropertyDescriptor(2, target[key])
-    : nativeGetOwnPropertyDescriptor(target, key);
-};
-
-var wrappedDefineProperty = function defineProperty(target, key, descriptor) {
-  key = toPropertyKey(key);
-  if (isTypedArrayIndex(target, key)
-    && isObject(descriptor)
-    && hasOwn(descriptor, 'value')
-    && !hasOwn(descriptor, 'get')
-    && !hasOwn(descriptor, 'set')
-    // TODO: add validation descriptor w/o calling accessors
-    && !descriptor.configurable
-    && (!hasOwn(descriptor, 'writable') || descriptor.writable)
-    && (!hasOwn(descriptor, 'enumerable') || descriptor.enumerable)
-  ) {
-    target[key] = descriptor.value;
-    return target;
-  } return nativeDefineProperty(target, key, descriptor);
-};
-
-if (DESCRIPTORS) {
-  if (!NATIVE_ARRAY_BUFFER_VIEWS) {
-    getOwnPropertyDescriptorModule.f = wrappedGetOwnPropertyDescriptor;
-    definePropertyModule.f = wrappedDefineProperty;
-    addGetter(TypedArrayPrototype, 'buffer');
-    addGetter(TypedArrayPrototype, 'byteOffset');
-    addGetter(TypedArrayPrototype, 'byteLength');
-    addGetter(TypedArrayPrototype, 'length');
+module.exports = function (TYPE, wrapper, CLAMPED) {
+  var BYTES = TYPE.match(/\d+/)[0] / 8;
+  var CONSTRUCTOR_NAME = TYPE + (CLAMPED ? 'Clamped' : '') + 'Array';
+  var NativeTypedArrayConstructor = globalThis[CONSTRUCTOR_NAME];
+  var TypedArrayConstructor = NativeTypedArrayConstructor;
+  var TypedArrayConstructorPrototype = TypedArrayConstructor && TypedArrayConstructor.prototype;
+  var exported = {};
+
+  if (TYPED_ARRAY_CONSTRUCTORS_REQUIRE_WRAPPERS) {
+    TypedArrayConstructor = wrapper(function (dummy, data, typedArrayOffset, length) {
+      anInstance(dummy, TypedArrayConstructorPrototype);
+      return inheritIfRequired(function () {
+        if (!isObject(data)) return new NativeTypedArrayConstructor(toIndex(data));
+        if (isArrayBuffer(data)) return length !== undefined
+          ? new NativeTypedArrayConstructor(data, toOffset(typedArrayOffset, BYTES), length)
+          : typedArrayOffset !== undefined
+            ? new NativeTypedArrayConstructor(data, toOffset(typedArrayOffset, BYTES))
+            : new NativeTypedArrayConstructor(data);
+        if (isTypedArray(data)) return arrayFromConstructorAndList(TypedArrayConstructor, data);
+        return call(typedArrayFrom, TypedArrayConstructor, data);
+      }(), dummy, TypedArrayConstructorPrototype);
+    });
+
+    TypedArrayConstructor.prototype = TypedArrayConstructorPrototype;
+    TypedArrayConstructorPrototype.constructor = TypedArrayConstructor;
+    // `.from` and `.of` has buggy descriptors in V8 ~ Chrome 50- and anyway can't work with wrappers
+    copyConstructorProperties(TypedArrayConstructor, NativeTypedArrayConstructor, { from: false, of: false });
+    setPrototypeOf(TypedArrayConstructor, TypedArray);
   }
 
-  $({ target: 'Object', stat: true, forced: !NATIVE_ARRAY_BUFFER_VIEWS }, {
-    getOwnPropertyDescriptor: wrappedGetOwnPropertyDescriptor,
-    defineProperty: wrappedDefineProperty
-  });
-
-  module.exports = function (TYPE, wrapper, CLAMPED) {
-    var BYTES = TYPE.match(/\d+/)[0] / 8;
-    var CONSTRUCTOR_NAME = TYPE + (CLAMPED ? 'Clamped' : '') + 'Array';
-    var GETTER = 'get' + TYPE;
-    var SETTER = 'set' + TYPE;
-    var NativeTypedArrayConstructor = global[CONSTRUCTOR_NAME];
-    var TypedArrayConstructor = NativeTypedArrayConstructor;
-    var TypedArrayConstructorPrototype = TypedArrayConstructor && TypedArrayConstructor.prototype;
-    var exported = {};
-
-    var getter = function (that, index) {
-      var data = getInternalState(that);
-      return data.view[GETTER](index * BYTES + data.byteOffset, true);
-    };
-
-    var setter = function (that, index, value) {
-      var data = getInternalState(that);
-      data.view[SETTER](index * BYTES + data.byteOffset, CLAMPED ? toUint8Clamped(value) : value, true);
-    };
-
-    var addElement = function (that, index) {
-      nativeDefineProperty(that, index, {
-        get: function () {
-          return getter(this, index);
-        },
-        set: function (value) {
-          return setter(this, index, value);
-        },
-        enumerable: true
-      });
-    };
+  exported[CONSTRUCTOR_NAME] = TypedArrayConstructor;
 
-    if (!NATIVE_ARRAY_BUFFER_VIEWS) {
-      TypedArrayConstructor = wrapper(function (that, data, offset, $length) {
-        anInstance(that, TypedArrayConstructorPrototype);
-        var index = 0;
-        var byteOffset = 0;
-        var buffer, byteLength, length;
-        if (!isObject(data)) {
-          length = toIndex(data);
-          byteLength = length * BYTES;
-          buffer = new ArrayBuffer(byteLength);
-        } else if (isArrayBuffer(data)) {
-          buffer = data;
-          byteOffset = toOffset(offset, BYTES);
-          var $len = data.byteLength;
-          if ($length === undefined) {
-            if ($len % BYTES) throw new RangeError(WRONG_LENGTH);
-            byteLength = $len - byteOffset;
-            if (byteLength < 0) throw new RangeError(WRONG_LENGTH);
-          } else {
-            byteLength = toLength($length) * BYTES;
-            if (byteLength + byteOffset > $len) throw new RangeError(WRONG_LENGTH);
-          }
-          length = byteLength / BYTES;
-        } else if (isTypedArray(data)) {
-          return arrayFromConstructorAndList(TypedArrayConstructor, data);
-        } else {
-          return call(typedArrayFrom, TypedArrayConstructor, data);
-        }
-        setInternalState(that, {
-          buffer: buffer,
-          byteOffset: byteOffset,
-          byteLength: byteLength,
-          length: length,
-          view: new DataView(buffer)
-        });
-        while (index < length) addElement(that, index++);
-      });
-
-      if (setPrototypeOf) setPrototypeOf(TypedArrayConstructor, TypedArray);
-      TypedArrayConstructorPrototype = TypedArrayConstructor.prototype = create(TypedArrayPrototype);
-    } else if (TYPED_ARRAYS_CONSTRUCTORS_REQUIRES_WRAPPERS) {
-      TypedArrayConstructor = wrapper(function (dummy, data, typedArrayOffset, $length) {
-        anInstance(dummy, TypedArrayConstructorPrototype);
-        return inheritIfRequired(function () {
-          if (!isObject(data)) return new NativeTypedArrayConstructor(toIndex(data));
-          if (isArrayBuffer(data)) return $length !== undefined
-            ? new NativeTypedArrayConstructor(data, toOffset(typedArrayOffset, BYTES), $length)
-            : typedArrayOffset !== undefined
-              ? new NativeTypedArrayConstructor(data, toOffset(typedArrayOffset, BYTES))
-              : new NativeTypedArrayConstructor(data);
-          if (isTypedArray(data)) return arrayFromConstructorAndList(TypedArrayConstructor, data);
-          return call(typedArrayFrom, TypedArrayConstructor, data);
-        }(), dummy, TypedArrayConstructor);
-      });
-
-      if (setPrototypeOf) setPrototypeOf(TypedArrayConstructor, TypedArray);
-      forEach(getOwnPropertyNames(NativeTypedArrayConstructor), function (key) {
-        if (!(key in TypedArrayConstructor)) {
-          createNonEnumerableProperty(TypedArrayConstructor, key, NativeTypedArrayConstructor[key]);
-        }
-      });
-      TypedArrayConstructor.prototype = TypedArrayConstructorPrototype;
-    }
-
-    if (TypedArrayConstructorPrototype.constructor !== TypedArrayConstructor) {
-      createNonEnumerableProperty(TypedArrayConstructorPrototype, 'constructor', TypedArrayConstructor);
-    }
-
-    enforceInternalState(TypedArrayConstructorPrototype).TypedArrayConstructor = TypedArrayConstructor;
-
-    if (TYPED_ARRAY_TAG) {
-      createNonEnumerableProperty(TypedArrayConstructorPrototype, TYPED_ARRAY_TAG, CONSTRUCTOR_NAME);
-    }
-
-    var FORCED = TypedArrayConstructor !== NativeTypedArrayConstructor;
-
-    exported[CONSTRUCTOR_NAME] = TypedArrayConstructor;
-
-    $({ global: true, constructor: true, forced: FORCED, sham: !NATIVE_ARRAY_BUFFER_VIEWS }, exported);
-
-    if (!(BYTES_PER_ELEMENT in TypedArrayConstructor)) {
-      createNonEnumerableProperty(TypedArrayConstructor, BYTES_PER_ELEMENT, BYTES);
-    }
-
-    if (!(BYTES_PER_ELEMENT in TypedArrayConstructorPrototype)) {
-      createNonEnumerableProperty(TypedArrayConstructorPrototype, BYTES_PER_ELEMENT, BYTES);
-    }
-
-    setSpecies(CONSTRUCTOR_NAME);
-  };
-} else module.exports = function () { /* empty */ };
+  $({ global: true, constructor: true, forced: TYPED_ARRAY_CONSTRUCTORS_REQUIRE_WRAPPERS }, exported);
+};