System.register(["__unresolved_0", "__unresolved_1", "__unresolved_2", "__unresolved_3", "__unresolved_4", "__unresolved_5", "__unresolved_6", "__unresolved_7"], function (_export, _context) {
  "use strict";

  var _req, _req2, _req3, _req4, _req5, _req6, _req7, _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) {
      _loader = _unresolved_8.default;
    }],
    execute: function () {
      _loader.define(_context.meta.url, function (exports, _require, module, __filename, __dirname) {
        var require = _loader.createRequireWithReqMap({
          "../internals/global": _req,
          "../internals/object-get-own-property-descriptor": _req2,
          "../internals/create-non-enumerable-property": _req3,
          "../internals/redefine": _req4,
          "../internals/set-global": _req5,
          "../internals/copy-constructor-properties": _req6,
          "../internals/is-forced": _req7
        }, _require);

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

          var getOwnPropertyDescriptor = require('../internals/object-get-own-property-descriptor').f;

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

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

          var setGlobal = require('../internals/set-global');

          var copyConstructorProperties = require('../internals/copy-constructor-properties');

          var isForced = require('../internals/is-forced');
          /*
            options.target      - name of the target object
            options.global      - target is the global object
            options.stat        - export as static methods of target
            options.proto       - export as prototype methods of target
            options.real        - real prototype method for the `pure` version
            options.forced      - export even if the native feature is available
            options.bind        - bind methods to the target, required for the `pure` version
            options.wrap        - wrap constructors to preventing global pollution, required for the `pure` version
            options.unsafe      - use the simple assignment of property instead of delete + defineProperty
            options.sham        - add a flag to not completely full polyfills
            options.enumerable  - export as enumerable property
            options.noTargetGet - prevent calling a getter on target
            options.name        - the .name of the function if it does not match the key
          */


          module.exports = function (options, source) {
            var TARGET = options.target;
            var GLOBAL = options.global;
            var STATIC = options.stat;
            var FORCED, target, key, targetProperty, sourceProperty, descriptor;

            if (GLOBAL) {
              target = global;
            } else if (STATIC) {
              target = global[TARGET] || setGlobal(TARGET, {});
            } else {
              target = (global[TARGET] || {}).prototype;
            }

            if (target) for (key in source) {
              sourceProperty = source[key];

              if (options.noTargetGet) {
                descriptor = getOwnPropertyDescriptor(target, key);
                targetProperty = descriptor && descriptor.value;
              } else targetProperty = target[key];

              FORCED = isForced(GLOBAL ? key : TARGET + (STATIC ? '.' : '#') + key, options.forced); // contained in target

              if (!FORCED && targetProperty !== undefined) {
                if (typeof sourceProperty == typeof targetProperty) continue;
                copyConstructorProperties(sourceProperty, targetProperty);
              } // add a flag to not completely full polyfills


              if (options.sham || targetProperty && targetProperty.sham) {
                createNonEnumerableProperty(sourceProperty, 'sham', true);
              } // extend global


              redefine(target, key, sourceProperty, options);
            }
          };
        })();

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

      _export("__cjsMetaURL", __cjsMetaURL = _context.meta.url);
    }
  };
});
//# sourceMappingURL=export.js.map