| '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-arrays-constructors-requires-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 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, BYTES, wrapper, CLAMPED) { |
| 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); |
| 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); |
| }); |
| |
| 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 */ }; |