'use strict';var wellKnownSymbol=require('./well-known-symbol-08f3111a.js'),normalizeComponent=require('./normalize-component-ebe0c011.js'),arraySpeciesCreate=require('./array-species-create-447f37c0.js'),es_array_includes=require('./es.array.includes-ec502589.js'),objectKeys=require('./object-keys-5cf8040b.js'),setToStringTag=require('./set-to-string-tag-85d5d01f.js'),arrayIteration=require('./array-iteration-7afe833b.js');/* eslint-disable es/no-object-getownpropertynames -- safe */

var $getOwnPropertyNames$1 = wellKnownSymbol.o.f;

var toString = {}.toString;

var windowNames = typeof window == 'object' && window && Object.getOwnPropertyNames
  ? Object.getOwnPropertyNames(window) : [];

var getWindowNames = function (it) {
  try {
    return $getOwnPropertyNames$1(it);
  } catch (error) {
    return windowNames.slice();
  }
};

// fallback for IE11 buggy Object.getOwnPropertyNames with iframe and window
var f$1 = function getOwnPropertyNames(it) {
  return windowNames && toString.call(it) == '[object Window]'
    ? getWindowNames(it)
    : $getOwnPropertyNames$1(wellKnownSymbol.f(it));
};

var objectGetOwnPropertyNamesExternal = {
	f: f$1
};var f = wellKnownSymbol.w;

var wellKnownSymbolWrapped = {
	f: f
};var defineProperty$1 = normalizeComponent.o.f;

var defineWellKnownSymbol = function (NAME) {
  var Symbol = wellKnownSymbol.p.Symbol || (wellKnownSymbol.p.Symbol = {});
  if (!wellKnownSymbol.h(Symbol, NAME)) defineProperty$1(Symbol, NAME, {
    value: wellKnownSymbolWrapped.f(NAME)
  });
};var $forEach = arrayIteration.a.forEach;

var HIDDEN = wellKnownSymbol.s('hidden');
var SYMBOL = 'Symbol';
var PROTOTYPE = 'prototype';
var TO_PRIMITIVE = wellKnownSymbol.w('toPrimitive');
var setInternalState = wellKnownSymbol.m.set;
var getInternalState = wellKnownSymbol.m.getterFor(SYMBOL);
var ObjectPrototype = Object[PROTOTYPE];
var $Symbol = normalizeComponent.g.Symbol;
var $stringify = wellKnownSymbol.g('JSON', 'stringify');
var nativeGetOwnPropertyDescriptor = wellKnownSymbol.q.f;
var nativeDefineProperty = normalizeComponent.o.f;
var nativeGetOwnPropertyNames = objectGetOwnPropertyNamesExternal.f;
var nativePropertyIsEnumerable = wellKnownSymbol.z.f;
var AllSymbols = wellKnownSymbol.j('symbols');
var ObjectPrototypeSymbols = wellKnownSymbol.j('op-symbols');
var StringToSymbolRegistry = wellKnownSymbol.j('string-to-symbol-registry');
var SymbolToStringRegistry = wellKnownSymbol.j('symbol-to-string-registry');
var WellKnownSymbolsStore = wellKnownSymbol.j('wks');
var QObject = normalizeComponent.g.QObject;
// Don't use setters in Qt Script, https://github.com/zloirock/core-js/issues/173
var USE_SETTER = !QObject || !QObject[PROTOTYPE] || !QObject[PROTOTYPE].findChild;

// fallback for old Android, https://code.google.com/p/v8/issues/detail?id=687
var setSymbolDescriptor = normalizeComponent.d && normalizeComponent.f(function () {
  return es_array_includes.o(nativeDefineProperty({}, 'a', {
    get: function () { return nativeDefineProperty(this, 'a', { value: 7 }).a; }
  })).a != 7;
}) ? function (O, P, Attributes) {
  var ObjectPrototypeDescriptor = nativeGetOwnPropertyDescriptor(ObjectPrototype, P);
  if (ObjectPrototypeDescriptor) delete ObjectPrototype[P];
  nativeDefineProperty(O, P, Attributes);
  if (ObjectPrototypeDescriptor && O !== ObjectPrototype) {
    nativeDefineProperty(ObjectPrototype, P, ObjectPrototypeDescriptor);
  }
} : nativeDefineProperty;

var wrap = function (tag, description) {
  var symbol = AllSymbols[tag] = es_array_includes.o($Symbol[PROTOTYPE]);
  setInternalState(symbol, {
    type: SYMBOL,
    tag: tag,
    description: description
  });
  if (!normalizeComponent.d) symbol.description = description;
  return symbol;
};

var isSymbol = wellKnownSymbol.v ? function (it) {
  return typeof it == 'symbol';
} : function (it) {
  return Object(it) instanceof $Symbol;
};

var $defineProperty = function defineProperty(O, P, Attributes) {
  if (O === ObjectPrototype) $defineProperty(ObjectPrototypeSymbols, P, Attributes);
  normalizeComponent.a(O);
  var key = normalizeComponent.t(P, true);
  normalizeComponent.a(Attributes);
  if (wellKnownSymbol.h(AllSymbols, key)) {
    if (!Attributes.enumerable) {
      if (!wellKnownSymbol.h(O, HIDDEN)) nativeDefineProperty(O, HIDDEN, wellKnownSymbol.x(1, {}));
      O[HIDDEN][key] = true;
    } else {
      if (wellKnownSymbol.h(O, HIDDEN) && O[HIDDEN][key]) O[HIDDEN][key] = false;
      Attributes = es_array_includes.o(Attributes, { enumerable: wellKnownSymbol.x(0, false) });
    } return setSymbolDescriptor(O, key, Attributes);
  } return nativeDefineProperty(O, key, Attributes);
};

var $defineProperties = function defineProperties(O, Properties) {
  normalizeComponent.a(O);
  var properties = wellKnownSymbol.f(Properties);
  var keys = objectKeys.o(properties).concat($getOwnPropertySymbols(properties));
  $forEach(keys, function (key) {
    if (!normalizeComponent.d || $propertyIsEnumerable.call(properties, key)) $defineProperty(O, key, properties[key]);
  });
  return O;
};

var $create = function create(O, Properties) {
  return Properties === undefined ? es_array_includes.o(O) : $defineProperties(es_array_includes.o(O), Properties);
};

var $propertyIsEnumerable = function propertyIsEnumerable(V) {
  var P = normalizeComponent.t(V, true);
  var enumerable = nativePropertyIsEnumerable.call(this, P);
  if (this === ObjectPrototype && wellKnownSymbol.h(AllSymbols, P) && !wellKnownSymbol.h(ObjectPrototypeSymbols, P)) return false;
  return enumerable || !wellKnownSymbol.h(this, P) || !wellKnownSymbol.h(AllSymbols, P) || wellKnownSymbol.h(this, HIDDEN) && this[HIDDEN][P] ? enumerable : true;
};

var $getOwnPropertyDescriptor = function getOwnPropertyDescriptor(O, P) {
  var it = wellKnownSymbol.f(O);
  var key = normalizeComponent.t(P, true);
  if (it === ObjectPrototype && wellKnownSymbol.h(AllSymbols, key) && !wellKnownSymbol.h(ObjectPrototypeSymbols, key)) return;
  var descriptor = nativeGetOwnPropertyDescriptor(it, key);
  if (descriptor && wellKnownSymbol.h(AllSymbols, key) && !(wellKnownSymbol.h(it, HIDDEN) && it[HIDDEN][key])) {
    descriptor.enumerable = true;
  }
  return descriptor;
};

var $getOwnPropertyNames = function getOwnPropertyNames(O) {
  var names = nativeGetOwnPropertyNames(wellKnownSymbol.f(O));
  var result = [];
  $forEach(names, function (key) {
    if (!wellKnownSymbol.h(AllSymbols, key) && !wellKnownSymbol.h(wellKnownSymbol.y, key)) result.push(key);
  });
  return result;
};

var $getOwnPropertySymbols = function getOwnPropertySymbols(O) {
  var IS_OBJECT_PROTOTYPE = O === ObjectPrototype;
  var names = nativeGetOwnPropertyNames(IS_OBJECT_PROTOTYPE ? ObjectPrototypeSymbols : wellKnownSymbol.f(O));
  var result = [];
  $forEach(names, function (key) {
    if (wellKnownSymbol.h(AllSymbols, key) && (!IS_OBJECT_PROTOTYPE || wellKnownSymbol.h(ObjectPrototype, key))) {
      result.push(AllSymbols[key]);
    }
  });
  return result;
};

// `Symbol` constructor
// https://tc39.es/ecma262/#sec-symbol-constructor
if (!wellKnownSymbol.n) {
  $Symbol = function Symbol() {
    if (this instanceof $Symbol) throw TypeError('Symbol is not a constructor');
    var description = !arguments.length || arguments[0] === undefined ? undefined : String(arguments[0]);
    var tag = wellKnownSymbol.u(description);
    var setter = function (value) {
      if (this === ObjectPrototype) setter.call(ObjectPrototypeSymbols, value);
      if (wellKnownSymbol.h(this, HIDDEN) && wellKnownSymbol.h(this[HIDDEN], tag)) this[HIDDEN][tag] = false;
      setSymbolDescriptor(this, tag, wellKnownSymbol.x(1, value));
    };
    if (normalizeComponent.d && USE_SETTER) setSymbolDescriptor(ObjectPrototype, tag, { configurable: true, set: setter });
    return wrap(tag, description);
  };

  wellKnownSymbol.b($Symbol[PROTOTYPE], 'toString', function toString() {
    return getInternalState(this).tag;
  });

  wellKnownSymbol.b($Symbol, 'withoutSetter', function (description) {
    return wrap(wellKnownSymbol.u(description), description);
  });

  wellKnownSymbol.z.f = $propertyIsEnumerable;
  normalizeComponent.o.f = $defineProperty;
  wellKnownSymbol.q.f = $getOwnPropertyDescriptor;
  wellKnownSymbol.o.f = objectGetOwnPropertyNamesExternal.f = $getOwnPropertyNames;
  wellKnownSymbol.k.f = $getOwnPropertySymbols;

  wellKnownSymbolWrapped.f = function (name) {
    return wrap(wellKnownSymbol.w(name), name);
  };

  if (normalizeComponent.d) {
    // https://github.com/tc39/proposal-Symbol-description
    nativeDefineProperty($Symbol[PROTOTYPE], 'description', {
      configurable: true,
      get: function description() {
        return getInternalState(this).description;
      }
    });
    {
      wellKnownSymbol.b(ObjectPrototype, 'propertyIsEnumerable', $propertyIsEnumerable, { unsafe: true });
    }
  }
}

wellKnownSymbol._({ global: true, wrap: true, forced: !wellKnownSymbol.n, sham: !wellKnownSymbol.n }, {
  Symbol: $Symbol
});

$forEach(objectKeys.o(WellKnownSymbolsStore), function (name) {
  defineWellKnownSymbol(name);
});

wellKnownSymbol._({ target: SYMBOL, stat: true, forced: !wellKnownSymbol.n }, {
  // `Symbol.for` method
  // https://tc39.es/ecma262/#sec-symbol.for
  'for': function (key) {
    var string = String(key);
    if (wellKnownSymbol.h(StringToSymbolRegistry, string)) return StringToSymbolRegistry[string];
    var symbol = $Symbol(string);
    StringToSymbolRegistry[string] = symbol;
    SymbolToStringRegistry[symbol] = string;
    return symbol;
  },
  // `Symbol.keyFor` method
  // https://tc39.es/ecma262/#sec-symbol.keyfor
  keyFor: function keyFor(sym) {
    if (!isSymbol(sym)) throw TypeError(sym + ' is not a symbol');
    if (wellKnownSymbol.h(SymbolToStringRegistry, sym)) return SymbolToStringRegistry[sym];
  },
  useSetter: function () { USE_SETTER = true; },
  useSimple: function () { USE_SETTER = false; }
});

wellKnownSymbol._({ target: 'Object', stat: true, forced: !wellKnownSymbol.n, sham: !normalizeComponent.d }, {
  // `Object.create` method
  // https://tc39.es/ecma262/#sec-object.create
  create: $create,
  // `Object.defineProperty` method
  // https://tc39.es/ecma262/#sec-object.defineproperty
  defineProperty: $defineProperty,
  // `Object.defineProperties` method
  // https://tc39.es/ecma262/#sec-object.defineproperties
  defineProperties: $defineProperties,
  // `Object.getOwnPropertyDescriptor` method
  // https://tc39.es/ecma262/#sec-object.getownpropertydescriptors
  getOwnPropertyDescriptor: $getOwnPropertyDescriptor
});

wellKnownSymbol._({ target: 'Object', stat: true, forced: !wellKnownSymbol.n }, {
  // `Object.getOwnPropertyNames` method
  // https://tc39.es/ecma262/#sec-object.getownpropertynames
  getOwnPropertyNames: $getOwnPropertyNames,
  // `Object.getOwnPropertySymbols` method
  // https://tc39.es/ecma262/#sec-object.getownpropertysymbols
  getOwnPropertySymbols: $getOwnPropertySymbols
});

// Chrome 38 and 39 `Object.getOwnPropertySymbols` fails on primitives
// https://bugs.chromium.org/p/v8/issues/detail?id=3443
wellKnownSymbol._({ target: 'Object', stat: true, forced: normalizeComponent.f(function () { wellKnownSymbol.k.f(1); }) }, {
  getOwnPropertySymbols: function getOwnPropertySymbols(it) {
    return wellKnownSymbol.k.f(wellKnownSymbol.t(it));
  }
});

// `JSON.stringify` method behavior with symbols
// https://tc39.es/ecma262/#sec-json.stringify
if ($stringify) {
  var FORCED_JSON_STRINGIFY = !wellKnownSymbol.n || normalizeComponent.f(function () {
    var symbol = $Symbol();
    // MS Edge converts symbol values to JSON as {}
    return $stringify([symbol]) != '[null]'
      // WebKit converts symbol values to JSON as null
      || $stringify({ a: symbol }) != '{}'
      // V8 throws on boxed symbols
      || $stringify(Object(symbol)) != '{}';
  });

  wellKnownSymbol._({ target: 'JSON', stat: true, forced: FORCED_JSON_STRINGIFY }, {
    // eslint-disable-next-line no-unused-vars -- required for `.length`
    stringify: function stringify(it, replacer, space) {
      var args = [it];
      var index = 1;
      var $replacer;
      while (arguments.length > index) args.push(arguments[index++]);
      $replacer = replacer;
      if (!normalizeComponent.b(replacer) && it === undefined || isSymbol(it)) return; // IE8 returns string on undefined
      if (!arraySpeciesCreate.i(replacer)) replacer = function (key, value) {
        if (typeof $replacer == 'function') value = $replacer.call(this, key, value);
        if (!isSymbol(value)) return value;
      };
      args[1] = replacer;
      return $stringify.apply(null, args);
    }
  });
}

// `Symbol.prototype[@@toPrimitive]` method
// https://tc39.es/ecma262/#sec-symbol.prototype-@@toprimitive
if (!$Symbol[PROTOTYPE][TO_PRIMITIVE]) {
  wellKnownSymbol.l($Symbol[PROTOTYPE], TO_PRIMITIVE, $Symbol[PROTOTYPE].valueOf);
}
// `Symbol.prototype[@@toStringTag]` property
// https://tc39.es/ecma262/#sec-symbol.prototype-@@tostringtag
setToStringTag.s($Symbol, SYMBOL);

wellKnownSymbol.y[HIDDEN] = true;var defineProperty = normalizeComponent.o.f;


var NativeSymbol = normalizeComponent.g.Symbol;

if (normalizeComponent.d && typeof NativeSymbol == 'function' && (!('description' in NativeSymbol.prototype) ||
  // Safari 12 bug
  NativeSymbol().description !== undefined
)) {
  var EmptyStringDescriptionStore = {};
  // wrap Symbol constructor for correct work with undefined description
  var SymbolWrapper = function Symbol() {
    var description = arguments.length < 1 || arguments[0] === undefined ? undefined : String(arguments[0]);
    var result = this instanceof SymbolWrapper
      ? new NativeSymbol(description)
      // in Edge 13, String(Symbol(undefined)) === 'Symbol(undefined)'
      : description === undefined ? NativeSymbol() : NativeSymbol(description);
    if (description === '') EmptyStringDescriptionStore[result] = true;
    return result;
  };
  wellKnownSymbol.A(SymbolWrapper, NativeSymbol);
  var symbolPrototype = SymbolWrapper.prototype = NativeSymbol.prototype;
  symbolPrototype.constructor = SymbolWrapper;

  var symbolToString = symbolPrototype.toString;
  var native = String(NativeSymbol('test')) == 'Symbol(test)';
  var regexp = /^Symbol\((.*)\)[^)]+$/;
  defineProperty(symbolPrototype, 'description', {
    configurable: true,
    get: function description() {
      var symbol = normalizeComponent.b(this) ? this.valueOf() : this;
      var string = symbolToString.call(symbol);
      if (wellKnownSymbol.h(EmptyStringDescriptionStore, symbol)) return '';
      var desc = native ? string.slice(7, -1) : string.replace(regexp, '$1');
      return desc === '' ? undefined : desc;
    }
  });

  wellKnownSymbol._({ global: true, forced: true }, {
    Symbol: SymbolWrapper
  });
}exports.o=objectGetOwnPropertyNamesExternal;