{"version":3,"sources":["jsdelivr-header.js","/npm/get-own-property-symbols@0.9.6/build/get-own-property-symbols.node.js"],"names":[],"mappings":"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","file":"/npm/get-own-property-symbols@0.9.6/build/get-own-property-symbols.node.js","sourceRoot":"","sourcesContent":["/**\n * Minified by jsDelivr using Terser v5.37.0.\n * Original file: /npm/get-own-property-symbols@0.9.6/build/get-own-property-symbols.node.js\n *\n * Do NOT use SRI with dynamically generated files! More information: https://www.jsdelivr.com/using-sri-with-dynamic-files\n */\n","/*!\nCopyright (C) 2015 by WebReflection\n\nPermission is hereby granted, free of charge, to any person obtaining a copy\nof this software and associated documentation files (the \"Software\"), to deal\nin the Software without restriction, including without limitation the rights\nto use, copy, modify, merge, publish, distribute, sublicense, and/or sell\ncopies of the Software, and to permit persons to whom the Software is\nfurnished to do so, subject to the following conditions:\n\nThe above copyright notice and this permission notice shall be included in\nall copies or substantial portions of the Software.\n\nTHE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\nIMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\nFITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\nAUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\nLIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\nOUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\nTHE SOFTWARE.\n\n*/\n(function (Object, GOPS) {\n  'use strict';\n\n  // (C) Andrea Giammarchi - Mit Style\n\n  if (GOPS in Object) { return; }\n\n  /** @type {(this: ThisParameterType<typeof Object.defineProperty>, ...args: Parameters<typeof Object.defineProperty>) => void} */\n  var setDescriptor;\n  /** @type {global | window} */\n  var G = typeof global === 'undefined' ? window : global;\n  var id = 0;\n  var random = String(Math.random());\n  var prefix = '__\\x01symbol:';\n  var prefixLength = prefix.length;\n  var internalSymbol = '__\\x01symbol@@' + random;\n  var gOPN = Object.getOwnPropertyNames;\n  var gOPD = Object.getOwnPropertyDescriptor;\n  var create = Object.create;\n  var keys = Object.keys;\n  var freeze = Object.freeze || Object;\n  var defineProperty = Object.defineProperty;\n  var $defineProperties = Object.defineProperties;\n  // eslint-disable-next-line no-extra-parens\n  var descriptor = /** @type {PropertyDescriptor} */ (gOPD(Object, 'getOwnPropertyDescriptor'));\n  var ObjectProto = Object.prototype;\n  var hOP = ObjectProto.hasOwnProperty;\n  var pIE = ObjectProto.propertyIsEnumerable;\n  var toString = ObjectProto.toString;\n  /** @type {(o: { [k: string]: Record<`@@${string}`, boolean> }, uid: `@@${string}`, enumerable: boolean) => void} */\n  var addInternalIfNeeded = function (o, uid, enumerable) {\n    if (!hOP.call(o, internalSymbol)) {\n      defineProperty(o, internalSymbol, {\n        enumerable: false,\n        configurable: false,\n        writable: false,\n        value: {}\n      });\n    }\n    o[internalSymbol][/** @type {`@@${string}`} */ ('@@' + uid)] = enumerable; // eslint-disable-line no-param-reassign, no-extra-parens\n  };\n  /** @type {(proto: null | object, descriptors: { [k: string]: Record<`@@${string}`, boolean> }) => object} */\n  var createWithSymbols = function (proto, descriptors) {\n    var self = create(proto);\n    gOPN(descriptors).forEach(function (key) {\n      if (propertyIsEnumerable.call(descriptors, key)) {\n        $defineProperty(self, key, descriptors[key]);\n      }\n    });\n    return self;\n  };\n  /** @type {(descriptor: PropertyDescriptor) => PropertyDescriptor} */\n  var copyAsNonEnumerable = function (descriptor) {\n    var newDescriptor = create(descriptor);\n    newDescriptor.enumerable = false;\n    return newDescriptor;\n  };\n  var get = function get() {};\n  var onlyNonSymbols = /** @type {(name: string | symbolish) => name is string} */ function (name) {\n    // eslint-disable-next-line eqeqeq\n    return name != internalSymbol && !hOP.call(source, name);\n  };\n  var onlySymbols = /** @type {(name: string | symbolish) => name is symbolish} */ function (name) {\n    // eslint-disable-next-line eqeqeq\n    return name != internalSymbol && hOP.call(source, name);\n  };\n  /** @type {(this: { [k: string | symbolish]: Record<`@@${string}`, boolean> }, key: string | symbolish) => boolean} */\n  var propertyIsEnumerable = function propertyIsEnumerable(key) {\n    var uid = String(key);\n    // eslint-disable-next-line no-extra-parens\n    return onlySymbols(uid) ? hOP.call(this, uid) && !!this[internalSymbol] && this[internalSymbol][/** @type {`@@${string}`} */ ('@@' + uid)] : pIE.call(this, key);\n  };\n  /** @type {(uid: `@@${string}`) => Readonly<symbolish>} */\n  var setAndGetSymbol = function (uid) {\n    /** @type {PropertyDescriptor} */\n    var descriptor = {\n      enumerable: false,\n      configurable: true,\n      get: get,\n      set: /** @type {(this: { [k: string]: Record<`@@${string}`, boolean> }, value: unknown) => void} */ function (value) {\n        setDescriptor(this, uid, {\n          enumerable: false,\n          configurable: true,\n          writable: true,\n          value: value\n        });\n        addInternalIfNeeded(this, uid, true);\n      }\n    };\n    defineProperty(ObjectProto, uid, descriptor);\n    source[uid] = defineProperty(\n      Object(uid),\n      'constructor',\n      sourceConstructor\n    );\n    return freeze(source[uid]);\n  };\n    /**\n     * @this {Symbol}\n     * @param {string} description\n     * @returns {Readonly<symbolish>}\n     */\n  var Symbol = function Symbol(description) {\n    if (this instanceof Symbol) {\n      throw new TypeError('Symbol is not a constructor');\n    }\n    // eslint-disable-next-line no-extra-parens\n    return setAndGetSymbol(/** @type {Parameters<typeof setAndGetSymbol>[0]} */ (prefix + (description || '') + random + ++id));\n  };\n  /** @type {Record<`@@${string}`, symbolish>} */\n  var source = create(null);\n  var sourceConstructor = { value: Symbol };\n  /** @type {(uid: `@@${string}`) => symbolish} */\n  var sourceMap = function (uid) {\n    return source[uid];\n  };\n    /** @type {typeof Object.defineProperty} */\n  var $defineProperty = function defineProp(o, key, descriptor) {\n    var uid = String(key);\n    if (onlySymbols(uid)) {\n      setDescriptor(o, uid, descriptor.enumerable ? copyAsNonEnumerable(descriptor) : descriptor);\n      // eslint-disable-next-line no-extra-parens\n      addInternalIfNeeded(/** @type {Parameters<addInternalIfNeeded>[0]} */ (o), uid, !!descriptor.enumerable);\n    } else {\n      defineProperty(o, key, descriptor);\n    }\n    return o;\n  };\n\n  /** @type {typeof Object.getOwnPropertySymbols} */\n  var $getOwnPropertySymbols = function getOwnPropertySymbols(o) {\n    // eslint-disable-next-line no-extra-parens\n    return gOPN(o).filter(onlySymbols).map(/** @type {(uid: string) => symbolish} */ (sourceMap));\n  };\n  descriptor.value = $defineProperty;\n  defineProperty(Object, 'defineProperty', descriptor);\n\n  descriptor.value = $getOwnPropertySymbols;\n  defineProperty(Object, GOPS, descriptor);\n\n  /** @type {typeof Object.getOwnPropertyNames} */\n  descriptor.value = function getOwnPropertyNames(o) {\n    return gOPN(o).filter(onlyNonSymbols);\n  };\n  defineProperty(Object, 'getOwnPropertyDescriptor', descriptor);\n\n  /** @type {typeof Object.defineProperties} */\n  descriptor.value = function defineProperties(o, descriptors) {\n    // eslint-disable-next-line no-extra-parens\n    var symbols = /** @type {symbolish[]} */ ($getOwnPropertySymbols(descriptors));\n    if (symbols.length) {\n      /** @type {(string | symbolish)[]} */\n      var items = [].concat(\n        // @ts-expect-error TS sucks with concat\n        keys(descriptors),\n        symbols\n      );\n      items.forEach(function (uid) {\n        if (propertyIsEnumerable.call(\n          // eslint-disable-next-line no-extra-parens\n          /** @type {ThisParameterType<typeof propertyIsEnumerable>} */ (descriptors),\n          uid\n        )) {\n          $defineProperty(o, uid, descriptors[uid]);\n        }\n      });\n    } else {\n      $defineProperties(o, descriptors);\n    }\n    return o;\n  };\n  defineProperty(Object, 'defineProperties', descriptor);\n\n  descriptor.value = propertyIsEnumerable;\n  defineProperty(ObjectProto, 'propertyIsEnumerable', descriptor);\n\n  descriptor.value = Symbol;\n  defineProperty(G, 'Symbol', descriptor);\n\n  /** @type {(key: string) => Readonly<symbolish>} */\n  // defining `Symbol.for(key)`\n  descriptor.value = function (key) {\n    // eslint-disable-next-line no-extra-parens\n    var uid = /** @type {Parameters<typeof setAndGetSymbol>[0]} */ (prefix + prefix + key + random);\n    return uid in ObjectProto ? source[uid] : setAndGetSymbol(uid);\n  };\n  defineProperty(Symbol, 'for', descriptor);\n\n  /** @type {(symbol: symbolish) => string | undefined} */\n  // defining `Symbol.keyFor(symbol)`\n  descriptor.value = function (symbol) {\n    if (onlyNonSymbols(symbol)) { throw new TypeError(symbol + ' is not a symbol'); }\n    if (!hOP.call(source, symbol)) {\n      return void 0;\n    }\n    var label = symbol.slice(prefixLength);\n    if (label.slice(0, prefixLength) !== prefix) {\n      return void 0;\n    }\n    label = label.slice(prefixLength);\n    if (label === random) {\n      return void 0;\n    }\n    label = label.slice(0, label.length - random.length);\n    return label.length > 0 ? label : void 0;\n  };\n  defineProperty(Symbol, 'keyFor', descriptor);\n\n  /** @type {(o: { [k: string | symbolish]: Record<`@@${string}`, boolean> }, key: string | symbolish) => PropertyDescriptor | undefined} */\n  descriptor.value = function getOwnPropertyDescriptor(o, key) {\n    var descriptor = gOPD(o, key);\n    if (descriptor && onlySymbols(key)) {\n      descriptor.enumerable = propertyIsEnumerable.call(o, key);\n    }\n    return descriptor;\n  };\n  defineProperty(Object, 'getOwnPropertyDescriptor', descriptor);\n\n  // eslint-disable-next-line no-extra-parens\n  descriptor.value = /** @type {typeof Object.create} */ (function (proto, descriptors) {\n    return arguments.length === 1 || typeof descriptors === 'undefined'\n      ? create(proto)\n      // eslint-disable-next-line no-extra-parens\n      : createWithSymbols(proto, /** @type {Parameters<typeof createWithSymbols>[1]} */ (descriptors));\n  });\n  defineProperty(Object, 'create', descriptor);\n\n  /** @type {(this: string | symbolish) => string} */\n  descriptor.value = function () {\n    var str = toString.call(this);\n    return str === '[object String]' && onlySymbols(this) ? '[object Symbol]' : str;\n  };\n  defineProperty(ObjectProto, 'toString', descriptor);\n\n  try { // fails in few pre ES 5.1 engines\n    if (\n      create(defineProperty({}, prefix, {\n        get: function () {\n          return defineProperty(this, prefix, { value: true })[prefix];\n        }\n      }))[prefix] === true\n    ) {\n      setDescriptor = defineProperty;\n    } else {\n      throw 'IE11'; // eslint-disable-line no-throw-literal\n    }\n  } catch (o_O) { // eslint-disable-line camelcase\n    setDescriptor = function (o, key, descriptor) {\n      var protoDescriptor = gOPD(ObjectProto, key);\n      // eslint-disable-next-line no-extra-parens\n      delete ObjectProto[/** @type {keyof typeof Object.prototype} */ (key)];\n      defineProperty(o, key, descriptor);\n      // eslint-disable-next-line no-extra-parens\n      defineProperty(ObjectProto, key, /** @type {NonNullable<typeof protoDescriptor>} */ (protoDescriptor));\n    };\n  }\n\n}(Object, 'getOwnPropertySymbols'));\n\n(function (O, Symbol) {\n  'use strict';\n\n  var dP = O.defineProperty;\n  var ObjectProto = O.prototype;\n  var toString = ObjectProto.toString;\n  [\n    'iterator', // A method returning the default iterator for an object. Used by for...of.\n    'match', // A method that matches against a string, also used to determine if an object may be used as a regular expression. Used by String.prototype.match().\n    'replace', // A method that replaces matched substrings of a string. Used by String.prototype.replace().\n    'search', // A method that returns the index within a string that matches the regular expression. Used by String.prototype.search().\n    'split', // A method that splits a string at the indices that match a regular expression. Used by String.prototype.split().\n    'hasInstance', // A method determining if a constructor object recognizes an object as its instance. Used by instanceof.\n    'isConcatSpreadable', // A Boolean value indicating if an object should be flattened to its array elements. Used by Array.prototype.concat().\n    'unscopables', // An Array of string values that are property values. These are excluded from the with environment bindings of the associated objects.\n    'species', // A constructor function that is used to create derived objects.\n    'toPrimitive', // A method converting an object to a primitive value.\n    'toStringTag' // A string value used for the default description of an object. Used by Object.prototype.toString().\n  ].forEach(function (name) {\n    if (!(name in Symbol)) {\n      dP(Symbol, name, { value: Symbol(name) });\n      if (name === 'toStringTag') {\n        // eslint-disable-next-line no-extra-parens\n        var descriptor = /** @type {PropertyDescriptor} */ (O.getOwnPropertyDescriptor(ObjectProto, 'toString'));\n        descriptor.value = /** @type {(this: null | { [Symbol.toStringTag]?: unknown }) => string} */ function () {\n          var str = toString.call(this);\n          var tst = this == null ? this : this[Symbol.toStringTag];\n          return tst == null ? str : '[object ' + tst + ']';\n        };\n        dP(ObjectProto, 'toString', descriptor);\n      }\n    }\n  });\n}(Object, Symbol));\n\n(/** @type {(Si: symbolish, AP: unknown[] & Record<symbolish, unknown>, SP: String & Record<symbolish, unknown>) => void} */ function (Si, AP, SP) {\n\n  /** @type {<T>(this: T) => T} */\n  function returnThis() { return this; }\n\n  /*\n   * make Arrays usable as iterators\n   * so that other iterables can copy same logic\n   */\n  if (!AP[Si]) {\n    // eslint-disable-next-line no-param-reassign\n    AP[Si] = function () {\n      var i = 0;\n\n      var self = this;\n      /** @type {{ next(): { done: boolean, value?: unknown } } & { [k in symbol]?: unknown }} */\n      var iterator = {\n        next: function next() {\n          var done = self.length <= i;\n          return done ? { done: done } : { done: done, value: self[i++] };\n        }\n      };\n      iterator[Si] = returnThis;\n      return iterator;\n    };\n  }\n\n  /*\n   * make Strings usable as iterators\n   * to simplify Array.from and for/of like loops\n   */\n  if (!SP[Si]) {\n    // eslint-disable-next-line no-param-reassign\n    SP[Si] = function () {\n      var fromCodePoint = String.fromCodePoint;\n      var self = this;\n      var i = 0;\n      var length = self.length;\n      /** @type {{ next(): { done: boolean, value?: string } } & { [k in symbol]?: unknown }} */\n      var iterator = {\n        next: function next() {\n          var done = length <= i;\n          // eslint-disable-next-line no-extra-parens\n          var c = done ? '' : fromCodePoint(/** @type {number} */ (self.codePointAt(i)));\n          i += c.length;\n          return done ? { done: done } : { done: done, value: c };\n        }\n      };\n      iterator[Si] = returnThis;\n      return iterator;\n    };\n  }\n\n}(\n  // eslint-disable-next-line no-extra-parens\n  /** @type {symbolish} */ (Symbol.iterator),\n  // eslint-disable-next-line no-extra-parens\n  /** @type {unknown[] & Record<symbolish, unknown>} */ (Array.prototype),\n  // eslint-disable-next-line no-extra-parens\n  /** @type {String & Record<symbolish, unknown>} */ (String.prototype)\n));\n\n/** @typedef {import('../').symbolish} symbolish */\n\nmodule.exports = Object.getOwnPropertySymbols;"]}