--- /dev/null
+'use strict';
+var $ = require('../internals/export');
+var global = require('../internals/global');
+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 anInstance = require('../internals/an-instance');
+var createPropertyDescriptor = require('../internals/create-property-descriptor');
+var createNonEnumerableProperty = require('../internals/create-non-enumerable-property');
+var toLength = require('../internals/to-length');
+var toIndex = require('../internals/to-index');
+var toOffset = require('../internals/to-offset');
+var toPrimitive = require('../internals/to-primitive');
+var has = require('../internals/has');
+var classof = require('../internals/classof');
+var isObject = require('../internals/is-object');
+var create = require('../internals/object-create');
+var setPrototypeOf = require('../internals/object-set-prototype-of');
+var getOwnPropertyNames = require('../internals/object-get-own-property-names').f;
+var typedArrayFrom = require('../internals/typed-array-from');
+var forEach = require('../internals/array-iteration').forEach;
+var setSpecies = require('../internals/set-species');
+var definePropertyModule = require('../internals/object-define-property');
+var getOwnPropertyDescriptorModule = require('../internals/object-get-own-property-descriptor');
+var InternalStateModule = require('../internals/internal-state');
+var inheritIfRequired = require('../internals/inherit-if-required');
+
+var getInternalState = InternalStateModule.get;
+var setInternalState = InternalStateModule.set;
+var nativeDefineProperty = definePropertyModule.f;
+var nativeGetOwnPropertyDescriptor = getOwnPropertyDescriptorModule.f;
+var round = Math.round;
+var RangeError = global.RangeError;
+var ArrayBuffer = ArrayBufferModule.ArrayBuffer;
+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 aTypedArrayConstructor = ArrayBufferViewCore.aTypedArrayConstructor;
+var isTypedArray = ArrayBufferViewCore.isTypedArray;
+var BYTES_PER_ELEMENT = 'BYTES_PER_ELEMENT';
+var WRONG_LENGTH = 'Wrong length';
+
+var fromList = function (C, list) {
+ var index = 0;
+ var length = list.length;
+ var result = new (aTypedArrayConstructor(C))(length);
+ while (length > index) result[index] = list[index++];
+ return result;
+};
+
+var addGetter = function (it, key) {
+ nativeDefineProperty(it, key, { get: function () {
+ return getInternalState(this)[key];
+ } });
+};
+
+var isArrayBuffer = function (it) {
+ var klass;
+ return it instanceof ArrayBuffer || (klass = classof(it)) == 'ArrayBuffer' || klass == 'SharedArrayBuffer';
+};
+
+var isTypedArrayIndex = function (target, key) {
+ return isTypedArray(target)
+ && typeof key != 'symbol'
+ && key in target
+ && String(+key) == String(key);
+};
+
+var wrappedGetOwnPropertyDescriptor = function getOwnPropertyDescriptor(target, key) {
+ return isTypedArrayIndex(target, key = toPrimitive(key, true))
+ ? createPropertyDescriptor(2, target[key])
+ : nativeGetOwnPropertyDescriptor(target, key);
+};
+
+var wrappedDefineProperty = function defineProperty(target, key, descriptor) {
+ if (isTypedArrayIndex(target, key = toPrimitive(key, true))
+ && isObject(descriptor)
+ && has(descriptor, 'value')
+ && !has(descriptor, 'get')
+ && !has(descriptor, 'set')
+ // TODO: add validation descriptor w/o calling accessors
+ && !descriptor.configurable
+ && (!has(descriptor, 'writable') || descriptor.writable)
+ && (!has(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');
+ }
+
+ $({ 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);
+ if (CLAMPED) value = (value = round(value)) < 0 ? 0 : value > 0xFF ? 0xFF : value & 0xFF;
+ data.view[SETTER](index * BYTES + data.byteOffset, 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
+ });
+ };
+
+ if (!NATIVE_ARRAY_BUFFER_VIEWS) {
+ TypedArrayConstructor = wrapper(function (that, data, offset, $length) {
+ anInstance(that, TypedArrayConstructor, CONSTRUCTOR_NAME);
+ 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 RangeError(WRONG_LENGTH);
+ byteLength = $len - byteOffset;
+ if (byteLength < 0) throw RangeError(WRONG_LENGTH);
+ } else {
+ byteLength = toLength($length) * BYTES;
+ if (byteLength + byteOffset > $len) throw RangeError(WRONG_LENGTH);
+ }
+ length = byteLength / BYTES;
+ } else if (isTypedArray(data)) {
+ return fromList(TypedArrayConstructor, data);
+ } else {
+ return typedArrayFrom.call(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, TypedArrayConstructor, CONSTRUCTOR_NAME);
+ 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 fromList(TypedArrayConstructor, data);
+ return typedArrayFrom.call(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);
+ }
+
+ if (TYPED_ARRAY_TAG) {
+ createNonEnumerableProperty(TypedArrayConstructorPrototype, TYPED_ARRAY_TAG, CONSTRUCTOR_NAME);
+ }
+
+ exported[CONSTRUCTOR_NAME] = TypedArrayConstructor;
+
+ $({
+ global: true, forced: TypedArrayConstructor != NativeTypedArrayConstructor, 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 */ };