System.register(["__unresolved_0", "__unresolved_1", "__unresolved_2", "__unresolved_3", "__unresolved_4", "__unresolved_5", "__unresolved_6", "__unresolved_7", "__unresolved_8", "__unresolved_9", "__unresolved_10", "__unresolved_11", "__unresolved_12", "__unresolved_13", "__unresolved_14", "__unresolved_15", "__unresolved_16"], function (_export, _context) {
  "use strict";

  var _req, _req2, _req3, _req4, _req5, _req6, _req7, _req8, _req9, _req10, _req11, _req12, _req13, _req14, _req15, _req16, _loader, _cjsExports, __cjsMetaURL;

  _export("default", void 0);

  return {
    setters: [function (_unresolved_) {
      _req = _unresolved_.__cjsMetaURL;
    }, function (_unresolved_2) {
      _req2 = _unresolved_2.__cjsMetaURL;
    }, function (_unresolved_3) {
      _req3 = _unresolved_3.__cjsMetaURL;
    }, function (_unresolved_4) {
      _req4 = _unresolved_4.__cjsMetaURL;
    }, function (_unresolved_5) {
      _req5 = _unresolved_5.__cjsMetaURL;
    }, function (_unresolved_6) {
      _req6 = _unresolved_6.__cjsMetaURL;
    }, function (_unresolved_7) {
      _req7 = _unresolved_7.__cjsMetaURL;
    }, function (_unresolved_8) {
      _req8 = _unresolved_8.__cjsMetaURL;
    }, function (_unresolved_9) {
      _req9 = _unresolved_9.__cjsMetaURL;
    }, function (_unresolved_10) {
      _req10 = _unresolved_10.__cjsMetaURL;
    }, function (_unresolved_11) {
      _req11 = _unresolved_11.__cjsMetaURL;
    }, function (_unresolved_12) {
      _req12 = _unresolved_12.__cjsMetaURL;
    }, function (_unresolved_13) {
      _req13 = _unresolved_13.__cjsMetaURL;
    }, function (_unresolved_14) {
      _req14 = _unresolved_14.__cjsMetaURL;
    }, function (_unresolved_15) {
      _req15 = _unresolved_15.__cjsMetaURL;
    }, function (_unresolved_16) {
      _req16 = _unresolved_16.__cjsMetaURL;
    }, function (_unresolved_17) {
      _loader = _unresolved_17.default;
    }],
    execute: function () {
      _loader.define(_context.meta.url, function (exports, _require, module, __filename, __dirname) {
        let require = _loader.createRequireWithReqMap({
          "../internals/array-buffer-native": _req,
          "../internals/descriptors": _req2,
          "../internals/global": _req3,
          "../internals/is-callable": _req4,
          "../internals/is-object": _req5,
          "../internals/has-own-property": _req6,
          "../internals/classof": _req7,
          "../internals/try-to-string": _req8,
          "../internals/create-non-enumerable-property": _req9,
          "../internals/redefine": _req10,
          "../internals/object-define-property": _req11,
          "../internals/object-is-prototype-of": _req12,
          "../internals/object-get-prototype-of": _req13,
          "../internals/object-set-prototype-of": _req14,
          "../internals/well-known-symbol": _req15,
          "../internals/uid": _req16
        }, _require);

        (function () {
          var NATIVE_ARRAY_BUFFER = require('../internals/array-buffer-native');

          var DESCRIPTORS = require('../internals/descriptors');

          var global = require('../internals/global');

          var isCallable = require('../internals/is-callable');

          var isObject = require('../internals/is-object');

          var hasOwn = require('../internals/has-own-property');

          var classof = require('../internals/classof');

          var tryToString = require('../internals/try-to-string');

          var createNonEnumerableProperty = require('../internals/create-non-enumerable-property');

          var redefine = require('../internals/redefine');

          var defineProperty = require('../internals/object-define-property').f;

          var isPrototypeOf = require('../internals/object-is-prototype-of');

          var getPrototypeOf = require('../internals/object-get-prototype-of');

          var setPrototypeOf = require('../internals/object-set-prototype-of');

          var wellKnownSymbol = require('../internals/well-known-symbol');

          var uid = require('../internals/uid');

          var Int8Array = global.Int8Array;
          var Int8ArrayPrototype = Int8Array && Int8Array.prototype;
          var Uint8ClampedArray = global.Uint8ClampedArray;
          var Uint8ClampedArrayPrototype = Uint8ClampedArray && Uint8ClampedArray.prototype;
          var TypedArray = Int8Array && getPrototypeOf(Int8Array);
          var TypedArrayPrototype = Int8ArrayPrototype && getPrototypeOf(Int8ArrayPrototype);
          var ObjectPrototype = Object.prototype;
          var TypeError = global.TypeError;
          var TO_STRING_TAG = wellKnownSymbol('toStringTag');
          var TYPED_ARRAY_TAG = uid('TYPED_ARRAY_TAG');
          var TYPED_ARRAY_CONSTRUCTOR = uid('TYPED_ARRAY_CONSTRUCTOR'); // Fixing native typed arrays in Opera Presto crashes the browser, see #595

          var NATIVE_ARRAY_BUFFER_VIEWS = NATIVE_ARRAY_BUFFER && !!setPrototypeOf && classof(global.opera) !== 'Opera';
          var TYPED_ARRAY_TAG_REQUIRED = false;
          var NAME, Constructor, Prototype;
          var TypedArrayConstructorsList = {
            Int8Array: 1,
            Uint8Array: 1,
            Uint8ClampedArray: 1,
            Int16Array: 2,
            Uint16Array: 2,
            Int32Array: 4,
            Uint32Array: 4,
            Float32Array: 4,
            Float64Array: 8
          };
          var BigIntArrayConstructorsList = {
            BigInt64Array: 8,
            BigUint64Array: 8
          };

          var isView = function isView(it) {
            if (!isObject(it)) return false;
            var klass = classof(it);
            return klass === 'DataView' || hasOwn(TypedArrayConstructorsList, klass) || hasOwn(BigIntArrayConstructorsList, klass);
          };

          var isTypedArray = function (it) {
            if (!isObject(it)) return false;
            var klass = classof(it);
            return hasOwn(TypedArrayConstructorsList, klass) || hasOwn(BigIntArrayConstructorsList, klass);
          };

          var aTypedArray = function (it) {
            if (isTypedArray(it)) return it;
            throw TypeError('Target is not a typed array');
          };

          var aTypedArrayConstructor = function (C) {
            if (isCallable(C) && (!setPrototypeOf || isPrototypeOf(TypedArray, C))) return C;
            throw TypeError(tryToString(C) + ' is not a typed array constructor');
          };

          var exportTypedArrayMethod = function (KEY, property, forced, options) {
            if (!DESCRIPTORS) return;
            if (forced) for (var ARRAY in TypedArrayConstructorsList) {
              var TypedArrayConstructor = global[ARRAY];
              if (TypedArrayConstructor && hasOwn(TypedArrayConstructor.prototype, KEY)) try {
                delete TypedArrayConstructor.prototype[KEY];
              } catch (error) {
                // old WebKit bug - some methods are non-configurable
                try {
                  TypedArrayConstructor.prototype[KEY] = property;
                } catch (error2) {
                  /* empty */
                }
              }
            }

            if (!TypedArrayPrototype[KEY] || forced) {
              redefine(TypedArrayPrototype, KEY, forced ? property : NATIVE_ARRAY_BUFFER_VIEWS && Int8ArrayPrototype[KEY] || property, options);
            }
          };

          var exportTypedArrayStaticMethod = function (KEY, property, forced) {
            var ARRAY, TypedArrayConstructor;
            if (!DESCRIPTORS) return;

            if (setPrototypeOf) {
              if (forced) for (ARRAY in TypedArrayConstructorsList) {
                TypedArrayConstructor = global[ARRAY];
                if (TypedArrayConstructor && hasOwn(TypedArrayConstructor, KEY)) try {
                  delete TypedArrayConstructor[KEY];
                } catch (error) {
                  /* empty */
                }
              }

              if (!TypedArray[KEY] || forced) {
                // V8 ~ Chrome 49-50 `%TypedArray%` methods are non-writable non-configurable
                try {
                  return redefine(TypedArray, KEY, forced ? property : NATIVE_ARRAY_BUFFER_VIEWS && TypedArray[KEY] || property);
                } catch (error) {
                  /* empty */
                }
              } else return;
            }

            for (ARRAY in TypedArrayConstructorsList) {
              TypedArrayConstructor = global[ARRAY];

              if (TypedArrayConstructor && (!TypedArrayConstructor[KEY] || forced)) {
                redefine(TypedArrayConstructor, KEY, property);
              }
            }
          };

          for (NAME in TypedArrayConstructorsList) {
            Constructor = global[NAME];
            Prototype = Constructor && Constructor.prototype;
            if (Prototype) createNonEnumerableProperty(Prototype, TYPED_ARRAY_CONSTRUCTOR, Constructor);else NATIVE_ARRAY_BUFFER_VIEWS = false;
          }

          for (NAME in BigIntArrayConstructorsList) {
            Constructor = global[NAME];
            Prototype = Constructor && Constructor.prototype;
            if (Prototype) createNonEnumerableProperty(Prototype, TYPED_ARRAY_CONSTRUCTOR, Constructor);
          } // WebKit bug - typed arrays constructors prototype is Object.prototype


          if (!NATIVE_ARRAY_BUFFER_VIEWS || !isCallable(TypedArray) || TypedArray === Function.prototype) {
            // eslint-disable-next-line no-shadow -- safe
            TypedArray = function TypedArray() {
              throw TypeError('Incorrect invocation');
            };

            if (NATIVE_ARRAY_BUFFER_VIEWS) for (NAME in TypedArrayConstructorsList) {
              if (global[NAME]) setPrototypeOf(global[NAME], TypedArray);
            }
          }

          if (!NATIVE_ARRAY_BUFFER_VIEWS || !TypedArrayPrototype || TypedArrayPrototype === ObjectPrototype) {
            TypedArrayPrototype = TypedArray.prototype;
            if (NATIVE_ARRAY_BUFFER_VIEWS) for (NAME in TypedArrayConstructorsList) {
              if (global[NAME]) setPrototypeOf(global[NAME].prototype, TypedArrayPrototype);
            }
          } // WebKit bug - one more object in Uint8ClampedArray prototype chain


          if (NATIVE_ARRAY_BUFFER_VIEWS && getPrototypeOf(Uint8ClampedArrayPrototype) !== TypedArrayPrototype) {
            setPrototypeOf(Uint8ClampedArrayPrototype, TypedArrayPrototype);
          }

          if (DESCRIPTORS && !hasOwn(TypedArrayPrototype, TO_STRING_TAG)) {
            TYPED_ARRAY_TAG_REQUIRED = true;
            defineProperty(TypedArrayPrototype, TO_STRING_TAG, {
              get: function () {
                return isObject(this) ? this[TYPED_ARRAY_TAG] : undefined;
              }
            });

            for (NAME in TypedArrayConstructorsList) if (global[NAME]) {
              createNonEnumerableProperty(global[NAME], TYPED_ARRAY_TAG, NAME);
            }
          }

          module.exports = {
            NATIVE_ARRAY_BUFFER_VIEWS: NATIVE_ARRAY_BUFFER_VIEWS,
            TYPED_ARRAY_CONSTRUCTOR: TYPED_ARRAY_CONSTRUCTOR,
            TYPED_ARRAY_TAG: TYPED_ARRAY_TAG_REQUIRED && TYPED_ARRAY_TAG,
            aTypedArray: aTypedArray,
            aTypedArrayConstructor: aTypedArrayConstructor,
            exportTypedArrayMethod: exportTypedArrayMethod,
            exportTypedArrayStaticMethod: exportTypedArrayStaticMethod,
            isView: isView,
            isTypedArray: isTypedArray,
            TypedArray: TypedArray,
            TypedArrayPrototype: TypedArrayPrototype
          };
        })();

        _export("default", _cjsExports = module.exports);
      });

      _export("__cjsMetaURL", __cjsMetaURL = _context.meta.url);
    }
  };
});
//# sourceMappingURL=array-buffer-view-core.js.map