test-filesystem 1.1.0 → 1.1.2

package/browser/test-fs.js

@@ -1,6 +1,1883 @@
 (function () { function r (e, n, t) { function o (i, f) { if (!n[i]) { if (!e[i]) { var c = typeof require === 'function' && require; if (!f && c) return c(i, !0); if (u) return u(i, !0); var a = new Error("Cannot find module '" + i + "'"); throw a.code = 'MODULE_NOT_FOUND', a } var p = n[i] = { exports: {} }; e[i][0].call(p.exports, function (r) { var n = e[i][1][r]; return o(n || r) }, p, p.exports, r, e, n, t) } return n[i].exports } for (var u = typeof require === 'function' && require, i = 0; i < t.length; i++)o(t[i]); return o } return r })()({
   1: [function (require, module, exports) {
     'use strict'
+    var isCallable = require('../internals/is-callable')
+    var tryToString = require('../internals/try-to-string')
+
+    var $TypeError = TypeError
+
+    // `Assert: IsCallable(argument) is true`
+    module.exports = function (argument) {
+      if (isCallable(argument)) return argument
+      throw new $TypeError(tryToString(argument) + ' is not a function')
+    }
+  }, { '../internals/is-callable': 46, '../internals/try-to-string': 85 }],
+  2: [function (require, module, exports) {
+    'use strict'
+    var has = require('../internals/weak-map-helpers').has
+
+    // Perform ? RequireInternalSlot(M, [[WeakMapData]])
+    module.exports = function (it) {
+      has(it)
+      return it
+    }
+  }, { '../internals/weak-map-helpers': 90 }],
+  3: [function (require, module, exports) {
+    'use strict'
+    var isPrototypeOf = require('../internals/object-is-prototype-of')
+
+    var $TypeError = TypeError
+
+    module.exports = function (it, Prototype) {
+      if (isPrototypeOf(Prototype, it)) return it
+      throw new $TypeError('Incorrect invocation')
+    }
+  }, { '../internals/object-is-prototype-of': 66 }],
+  4: [function (require, module, exports) {
+    'use strict'
+    var isObject = require('../internals/is-object')
+
+    var $String = String
+    var $TypeError = TypeError
+
+    // `Assert: Type(argument) is Object`
+    module.exports = function (argument) {
+      if (isObject(argument)) return argument
+      throw new $TypeError($String(argument) + ' is not an object')
+    }
+  }, { '../internals/is-object': 49 }],
+  5: [function (require, module, exports) {
+    'use strict'
+    var toIndexedObject = require('../internals/to-indexed-object')
+    var toAbsoluteIndex = require('../internals/to-absolute-index')
+    var lengthOfArrayLike = require('../internals/length-of-array-like')
+
+    // `Array.prototype.{ indexOf, includes }` methods implementation
+    var createMethod = function (IS_INCLUDES) {
+      return function ($this, el, fromIndex) {
+        var O = toIndexedObject($this)
+        var length = lengthOfArrayLike(O)
+        var index = toAbsoluteIndex(fromIndex, length)
+        var value
+        // Array#includes uses SameValueZero equality algorithm
+        // eslint-disable-next-line no-self-compare -- NaN check
+        if (IS_INCLUDES && el !== el) {
+          while (length > index) {
+            value = O[index++]
+            // eslint-disable-next-line no-self-compare -- NaN check
+            if (value !== value) return true
+          // Array#indexOf ignores holes, Array#includes - not
+          }
+        } else {
+          for (;length > index; index++) {
+            if ((IS_INCLUDES || index in O) && O[index] === el) return IS_INCLUDES || index || 0
+          }
+        } return !IS_INCLUDES && -1
+      }
+    }
+
+    module.exports = {
+      // `Array.prototype.includes` method
+      // https://tc39.es/ecma262/#sec-array.prototype.includes
+      includes: createMethod(true),
+      // `Array.prototype.indexOf` method
+      // https://tc39.es/ecma262/#sec-array.prototype.indexof
+      indexOf: createMethod(false)
+    }
+  }, { '../internals/length-of-array-like': 56, '../internals/to-absolute-index': 77, '../internals/to-indexed-object': 78 }],
+  6: [function (require, module, exports) {
+    'use strict'
+    var call = require('../internals/function-call')
+    var getBuiltIn = require('../internals/get-built-in')
+    var getMethod = require('../internals/get-method')
+
+    module.exports = function (iterator, method, argument, reject) {
+      try {
+        var returnMethod = getMethod(iterator, 'return')
+        if (returnMethod) {
+          return getBuiltIn('Promise').resolve(call(returnMethod, iterator)).then(function () {
+            method(argument)
+          }, function (error) {
+            reject(error)
+          })
+        }
+      } catch (error2) {
+        return reject(error2)
+      } method(argument)
+    }
+  }, { '../internals/function-call': 28, '../internals/get-built-in': 32, '../internals/get-method': 36 }],
+  7: [function (require, module, exports) {
+    'use strict'
+    // https://github.com/tc39/proposal-iterator-helpers
+    // https://github.com/tc39/proposal-array-from-async
+    var call = require('../internals/function-call')
+    var aCallable = require('../internals/a-callable')
+    var anObject = require('../internals/an-object')
+    var isObject = require('../internals/is-object')
+    var doesNotExceedSafeInteger = require('../internals/does-not-exceed-safe-integer')
+    var getBuiltIn = require('../internals/get-built-in')
+    var getIteratorDirect = require('../internals/get-iterator-direct')
+    var closeAsyncIteration = require('../internals/async-iterator-close')
+
+    var createMethod = function (TYPE) {
+      var IS_TO_ARRAY = TYPE === 0
+      var IS_FOR_EACH = TYPE === 1
+      var IS_EVERY = TYPE === 2
+      var IS_SOME = TYPE === 3
+      return function (object, fn, target) {
+        anObject(object)
+        var MAPPING = fn !== undefined
+        if (MAPPING || !IS_TO_ARRAY) aCallable(fn)
+        var record = getIteratorDirect(object)
+        var Promise = getBuiltIn('Promise')
+        var iterator = record.iterator
+        var next = record.next
+        var counter = 0
+
+        return new Promise(function (resolve, reject) {
+          var ifAbruptCloseAsyncIterator = function (error) {
+            closeAsyncIteration(iterator, reject, error, reject)
+          }
+
+          var loop = function () {
+            try {
+              if (MAPPING) {
+                try {
+                  doesNotExceedSafeInteger(counter)
+                } catch (error5) { ifAbruptCloseAsyncIterator(error5) }
+              }
+              Promise.resolve(anObject(call(next, iterator))).then(function (step) {
+                try {
+                  if (anObject(step).done) {
+                    if (IS_TO_ARRAY) {
+                      target.length = counter
+                      resolve(target)
+                    } else resolve(IS_SOME ? false : IS_EVERY || undefined)
+                  } else {
+                    var value = step.value
+                    try {
+                      if (MAPPING) {
+                        var result = fn(value, counter)
+
+                        var handler = function ($result) {
+                          if (IS_FOR_EACH) {
+                            loop()
+                          } else if (IS_EVERY) {
+                            $result ? loop() : closeAsyncIteration(iterator, resolve, false, reject)
+                          } else if (IS_TO_ARRAY) {
+                            try {
+                              target[counter++] = $result
+                              loop()
+                            } catch (error4) { ifAbruptCloseAsyncIterator(error4) }
+                          } else {
+                            $result ? closeAsyncIteration(iterator, resolve, IS_SOME || value, reject) : loop()
+                          }
+                        }
+
+                        if (isObject(result)) Promise.resolve(result).then(handler, ifAbruptCloseAsyncIterator)
+                        else handler(result)
+                      } else {
+                        target[counter++] = value
+                        loop()
+                      }
+                    } catch (error3) { ifAbruptCloseAsyncIterator(error3) }
+                  }
+                } catch (error2) { reject(error2) }
+              }, reject)
+            } catch (error) { reject(error) }
+          }
+
+          loop()
+        })
+      }
+    }
+
+    module.exports = {
+      toArray: createMethod(0),
+      forEach: createMethod(1),
+      every: createMethod(2),
+      some: createMethod(3),
+      find: createMethod(4)
+    }
+  }, { '../internals/a-callable': 1, '../internals/an-object': 4, '../internals/async-iterator-close': 6, '../internals/does-not-exceed-safe-integer': 20, '../internals/function-call': 28, '../internals/get-built-in': 32, '../internals/get-iterator-direct': 33, '../internals/is-object': 49 }],
+  8: [function (require, module, exports) {
+    'use strict'
+    var uncurryThis = require('../internals/function-uncurry-this')
+
+    var toString = uncurryThis({}.toString)
+    var stringSlice = uncurryThis(''.slice)
+
+    module.exports = function (it) {
+      return stringSlice(toString(it), 8, -1)
+    }
+  }, { '../internals/function-uncurry-this': 31 }],
+  9: [function (require, module, exports) {
+    'use strict'
+    var TO_STRING_TAG_SUPPORT = require('../internals/to-string-tag-support')
+    var isCallable = require('../internals/is-callable')
+    var classofRaw = require('../internals/classof-raw')
+    var wellKnownSymbol = require('../internals/well-known-symbol')
+
+    var TO_STRING_TAG = wellKnownSymbol('toStringTag')
+    var $Object = Object
+
+    // ES3 wrong here
+    var CORRECT_ARGUMENTS = classofRaw(function () { return arguments }()) === 'Arguments'
+
+    // fallback for IE11 Script Access Denied error
+    var tryGet = function (it, key) {
+      try {
+        return it[key]
+      } catch (error) { /* empty */ }
+    }
+
+    // getting tag from ES6+ `Object.prototype.toString`
+    module.exports = TO_STRING_TAG_SUPPORT ? classofRaw : function (it) {
+      var O, tag, result
+      return it === undefined ? 'Undefined' : it === null ? 'Null'
+      // @@toStringTag case
+        : typeof (tag = tryGet(O = $Object(it), TO_STRING_TAG)) === 'string' ? tag
+        // builtinTag case
+          : CORRECT_ARGUMENTS ? classofRaw(O)
+          // ES3 arguments fallback
+            : (result = classofRaw(O)) === 'Object' && isCallable(O.callee) ? 'Arguments' : result
+    }
+  }, { '../internals/classof-raw': 8, '../internals/is-callable': 46, '../internals/to-string-tag-support': 84, '../internals/well-known-symbol': 91 }],
+  10: [function (require, module, exports) {
+    'use strict'
+    var hasOwn = require('../internals/has-own-property')
+    var ownKeys = require('../internals/own-keys')
+    var getOwnPropertyDescriptorModule = require('../internals/object-get-own-property-descriptor')
+    var definePropertyModule = require('../internals/object-define-property')
+
+    module.exports = function (target, source, exceptions) {
+      var keys = ownKeys(source)
+      var defineProperty = definePropertyModule.f
+      var getOwnPropertyDescriptor = getOwnPropertyDescriptorModule.f
+      for (var i = 0; i < keys.length; i++) {
+        var key = keys[i]
+        if (!hasOwn(target, key) && !(exceptions && hasOwn(exceptions, key))) {
+          defineProperty(target, key, getOwnPropertyDescriptor(source, key))
+        }
+      }
+    }
+  }, { '../internals/has-own-property': 38, '../internals/object-define-property': 61, '../internals/object-get-own-property-descriptor': 62, '../internals/own-keys': 71 }],
+  11: [function (require, module, exports) {
+    'use strict'
+    var fails = require('../internals/fails')
+
+    module.exports = !fails(function () {
+      function F () { /* empty */ }
+      F.prototype.constructor = null
+      // eslint-disable-next-line es/no-object-getprototypeof -- required for testing
+      return Object.getPrototypeOf(new F()) !== F.prototype
+    })
+  }, { '../internals/fails': 25 }],
+  12: [function (require, module, exports) {
+    'use strict'
+    var DESCRIPTORS = require('../internals/descriptors')
+    var definePropertyModule = require('../internals/object-define-property')
+    var createPropertyDescriptor = require('../internals/create-property-descriptor')
+
+    module.exports = DESCRIPTORS ? function (object, key, value) {
+      return definePropertyModule.f(object, key, createPropertyDescriptor(1, value))
+    } : function (object, key, value) {
+      object[key] = value
+      return object
+    }
+  }, { '../internals/create-property-descriptor': 13, '../internals/descriptors': 18, '../internals/object-define-property': 61 }],
+  13: [function (require, module, exports) {
+    'use strict'
+    module.exports = function (bitmap, value) {
+      return {
+        enumerable: !(bitmap & 1),
+        configurable: !(bitmap & 2),
+        writable: !(bitmap & 4),
+        value: value
+      }
+    }
+  }, {}],
+  14: [function (require, module, exports) {
+    'use strict'
+    var toPropertyKey = require('../internals/to-property-key')
+    var definePropertyModule = require('../internals/object-define-property')
+    var createPropertyDescriptor = require('../internals/create-property-descriptor')
+
+    module.exports = function (object, key, value) {
+      var propertyKey = toPropertyKey(key)
+      if (propertyKey in object) definePropertyModule.f(object, propertyKey, createPropertyDescriptor(0, value))
+      else object[propertyKey] = value
+    }
+  }, { '../internals/create-property-descriptor': 13, '../internals/object-define-property': 61, '../internals/to-property-key': 83 }],
+  15: [function (require, module, exports) {
+    'use strict'
+    var makeBuiltIn = require('../internals/make-built-in')
+    var defineProperty = require('../internals/object-define-property')
+
+    module.exports = function (target, name, descriptor) {
+      if (descriptor.get) makeBuiltIn(descriptor.get, name, { getter: true })
+      if (descriptor.set) makeBuiltIn(descriptor.set, name, { setter: true })
+      return defineProperty.f(target, name, descriptor)
+    }
+  }, { '../internals/make-built-in': 57, '../internals/object-define-property': 61 }],
+  16: [function (require, module, exports) {
+    'use strict'
+    var isCallable = require('../internals/is-callable')
+    var definePropertyModule = require('../internals/object-define-property')
+    var makeBuiltIn = require('../internals/make-built-in')
+    var defineGlobalProperty = require('../internals/define-global-property')
+
+    module.exports = function (O, key, value, options) {
+      if (!options) options = {}
+      var simple = options.enumerable
+      var name = options.name !== undefined ? options.name : key
+      if (isCallable(value)) makeBuiltIn(value, name, options)
+      if (options.global) {
+        if (simple) O[key] = value
+        else defineGlobalProperty(key, value)
+      } else {
+        try {
+          if (!options.unsafe) delete O[key]
+          else if (O[key]) simple = true
+        } catch (error) { /* empty */ }
+        if (simple) O[key] = value
+        else {
+          definePropertyModule.f(O, key, {
+            value: value,
+            enumerable: false,
+            configurable: !options.nonConfigurable,
+            writable: !options.nonWritable
+          })
+        }
+      } return O
+    }
+  }, { '../internals/define-global-property': 17, '../internals/is-callable': 46, '../internals/make-built-in': 57, '../internals/object-define-property': 61 }],
+  17: [function (require, module, exports) {
+    'use strict'
+    var global = require('../internals/global')
+
+    // eslint-disable-next-line es/no-object-defineproperty -- safe
+    var defineProperty = Object.defineProperty
+
+    module.exports = function (key, value) {
+      try {
+        defineProperty(global, key, { value: value, configurable: true, writable: true })
+      } catch (error) {
+        global[key] = value
+      } return value
+    }
+  }, { '../internals/global': 37 }],
+  18: [function (require, module, exports) {
+    'use strict'
+    var fails = require('../internals/fails')
+
+    // Detect IE8's incomplete defineProperty implementation
+    module.exports = !fails(function () {
+      // eslint-disable-next-line es/no-object-defineproperty -- required for testing
+      return Object.defineProperty({}, 1, { get: function () { return 7 } })[1] !== 7
+    })
+  }, { '../internals/fails': 25 }],
+  19: [function (require, module, exports) {
+    'use strict'
+    var global = require('../internals/global')
+    var isObject = require('../internals/is-object')
+
+    var document = global.document
+    // typeof document.createElement is 'object' in old IE
+    var EXISTS = isObject(document) && isObject(document.createElement)
+
+    module.exports = function (it) {
+      return EXISTS ? document.createElement(it) : {}
+    }
+  }, { '../internals/global': 37, '../internals/is-object': 49 }],
+  20: [function (require, module, exports) {
+    'use strict'
+    var $TypeError = TypeError
+    var MAX_SAFE_INTEGER = 0x1FFFFFFFFFFFFF // 2 ** 53 - 1 == 9007199254740991
+
+    module.exports = function (it) {
+      if (it > MAX_SAFE_INTEGER) throw $TypeError('Maximum allowed index exceeded')
+      return it
+    }
+  }, {}],
+  21: [function (require, module, exports) {
+    'use strict'
+    module.exports = typeof navigator !== 'undefined' && String(navigator.userAgent) || ''
+  }, {}],
+  22: [function (require, module, exports) {
+    'use strict'
+    var global = require('../internals/global')
+    var userAgent = require('../internals/engine-user-agent')
+
+    var process = global.process
+    var Deno = global.Deno
+    var versions = process && process.versions || Deno && Deno.version
+    var v8 = versions && versions.v8
+    var match, version
+
+    if (v8) {
+      match = v8.split('.')
+      // in old Chrome, versions of V8 isn't V8 = Chrome / 10
+      // but their correct versions are not interesting for us
+      version = match[0] > 0 && match[0] < 4 ? 1 : +(match[0] + match[1])
+    }
+
+    // BrowserFS NodeJS `process` polyfill incorrectly set `.v8` to `0.0`
+    // so check `userAgent` even if `.v8` exists, but 0
+    if (!version && userAgent) {
+      match = userAgent.match(/Edge\/(\d+)/)
+      if (!match || match[1] >= 74) {
+        match = userAgent.match(/Chrome\/(\d+)/)
+        if (match) version = +match[1]
+      }
+    }
+
+    module.exports = version
+  }, { '../internals/engine-user-agent': 21, '../internals/global': 37 }],
+  23: [function (require, module, exports) {
+    'use strict'
+    // IE8- don't enum bug keys
+    module.exports = [
+      'constructor',
+      'hasOwnProperty',
+      'isPrototypeOf',
+      'propertyIsEnumerable',
+      'toLocaleString',
+      'toString',
+      'valueOf'
+    ]
+  }, {}],
+  24: [function (require, module, exports) {
+    'use strict'
+    var global = require('../internals/global')
+    var getOwnPropertyDescriptor = require('../internals/object-get-own-property-descriptor').f
+    var createNonEnumerableProperty = require('../internals/create-non-enumerable-property')
+    var defineBuiltIn = require('../internals/define-built-in')
+    var defineGlobalProperty = require('../internals/define-global-property')
+    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.dontCallGetSet - 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] || defineGlobalProperty(TARGET, {})
+      } else {
+        target = (global[TARGET] || {}).prototype
+      }
+      if (target) {
+        for (key in source) {
+          sourceProperty = source[key]
+          if (options.dontCallGetSet) {
+            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)
+          }
+          defineBuiltIn(target, key, sourceProperty, options)
+        }
+      }
+    }
+  }, { '../internals/copy-constructor-properties': 10, '../internals/create-non-enumerable-property': 12, '../internals/define-built-in': 16, '../internals/define-global-property': 17, '../internals/global': 37, '../internals/is-forced': 47, '../internals/object-get-own-property-descriptor': 62 }],
+  25: [function (require, module, exports) {
+    'use strict'
+    module.exports = function (exec) {
+      try {
+        return !!exec()
+      } catch (error) {
+        return true
+      }
+    }
+  }, {}],
+  26: [function (require, module, exports) {
+    'use strict'
+    var uncurryThis = require('../internals/function-uncurry-this-clause')
+    var aCallable = require('../internals/a-callable')
+    var NATIVE_BIND = require('../internals/function-bind-native')
+
+    var bind = uncurryThis(uncurryThis.bind)
+
+    // optional / simple context binding
+    module.exports = function (fn, that) {
+      aCallable(fn)
+      return that === undefined ? fn : NATIVE_BIND ? bind(fn, that) : function (/* ...args */) {
+        return fn.apply(that, arguments)
+      }
+    }
+  }, { '../internals/a-callable': 1, '../internals/function-bind-native': 27, '../internals/function-uncurry-this-clause': 30 }],
+  27: [function (require, module, exports) {
+    'use strict'
+    var fails = require('../internals/fails')
+
+    module.exports = !fails(function () {
+      // eslint-disable-next-line es/no-function-prototype-bind -- safe
+      var test = function () { /* empty */ }.bind()
+      // eslint-disable-next-line no-prototype-builtins -- safe
+      return typeof test !== 'function' || test.hasOwnProperty('prototype')
+    })
+  }, { '../internals/fails': 25 }],
+  28: [function (require, module, exports) {
+    'use strict'
+    var NATIVE_BIND = require('../internals/function-bind-native')
+
+    var call = Function.prototype.call
+
+    module.exports = NATIVE_BIND ? call.bind(call) : function () {
+      return call.apply(call, arguments)
+    }
+  }, { '../internals/function-bind-native': 27 }],
+  29: [function (require, module, exports) {
+    'use strict'
+    var DESCRIPTORS = require('../internals/descriptors')
+    var hasOwn = require('../internals/has-own-property')
+
+    var FunctionPrototype = Function.prototype
+    // eslint-disable-next-line es/no-object-getownpropertydescriptor -- safe
+    var getDescriptor = DESCRIPTORS && Object.getOwnPropertyDescriptor
+
+    var EXISTS = hasOwn(FunctionPrototype, 'name')
+    // additional protection from minified / mangled / dropped function names
+    var PROPER = EXISTS && function something () { /* empty */ }.name === 'something'
+    var CONFIGURABLE = EXISTS && (!DESCRIPTORS || (DESCRIPTORS && getDescriptor(FunctionPrototype, 'name').configurable))
+
+    module.exports = {
+      EXISTS: EXISTS,
+      PROPER: PROPER,
+      CONFIGURABLE: CONFIGURABLE
+    }
+  }, { '../internals/descriptors': 18, '../internals/has-own-property': 38 }],
+  30: [function (require, module, exports) {
+    'use strict'
+    var classofRaw = require('../internals/classof-raw')
+    var uncurryThis = require('../internals/function-uncurry-this')
+
+    module.exports = function (fn) {
+      // Nashorn bug:
+      //   https://github.com/zloirock/core-js/issues/1128
+      //   https://github.com/zloirock/core-js/issues/1130
+      if (classofRaw(fn) === 'Function') return uncurryThis(fn)
+    }
+  }, { '../internals/classof-raw': 8, '../internals/function-uncurry-this': 31 }],
+  31: [function (require, module, exports) {
+    'use strict'
+    var NATIVE_BIND = require('../internals/function-bind-native')
+
+    var FunctionPrototype = Function.prototype
+    var call = FunctionPrototype.call
+    var uncurryThisWithBind = NATIVE_BIND && FunctionPrototype.bind.bind(call, call)
+
+    module.exports = NATIVE_BIND ? uncurryThisWithBind : function (fn) {
+      return function () {
+        return call.apply(fn, arguments)
+      }
+    }
+  }, { '../internals/function-bind-native': 27 }],
+  32: [function (require, module, exports) {
+    'use strict'
+    var global = require('../internals/global')
+    var isCallable = require('../internals/is-callable')
+
+    var aFunction = function (argument) {
+      return isCallable(argument) ? argument : undefined
+    }
+
+    module.exports = function (namespace, method) {
+      return arguments.length < 2 ? aFunction(global[namespace]) : global[namespace] && global[namespace][method]
+    }
+  }, { '../internals/global': 37, '../internals/is-callable': 46 }],
+  33: [function (require, module, exports) {
+    'use strict'
+    // `GetIteratorDirect(obj)` abstract operation
+    // https://tc39.es/proposal-iterator-helpers/#sec-getiteratordirect
+    module.exports = function (obj) {
+      return {
+        iterator: obj,
+        next: obj.next,
+        done: false
+      }
+    }
+  }, {}],
+  34: [function (require, module, exports) {
+    'use strict'
+    var classof = require('../internals/classof')
+    var getMethod = require('../internals/get-method')
+    var isNullOrUndefined = require('../internals/is-null-or-undefined')
+    var Iterators = require('../internals/iterators')
+    var wellKnownSymbol = require('../internals/well-known-symbol')
+
+    var ITERATOR = wellKnownSymbol('iterator')
+
+    module.exports = function (it) {
+      if (!isNullOrUndefined(it)) {
+        return getMethod(it, ITERATOR) ||
+    getMethod(it, '@@iterator') ||
+    Iterators[classof(it)]
+      }
+    }
+  }, { '../internals/classof': 9, '../internals/get-method': 36, '../internals/is-null-or-undefined': 48, '../internals/iterators': 55, '../internals/well-known-symbol': 91 }],
+  35: [function (require, module, exports) {
+    'use strict'
+    var call = require('../internals/function-call')
+    var aCallable = require('../internals/a-callable')
+    var anObject = require('../internals/an-object')
+    var tryToString = require('../internals/try-to-string')
+    var getIteratorMethod = require('../internals/get-iterator-method')
+
+    var $TypeError = TypeError
+
+    module.exports = function (argument, usingIterator) {
+      var iteratorMethod = arguments.length < 2 ? getIteratorMethod(argument) : usingIterator
+      if (aCallable(iteratorMethod)) return anObject(call(iteratorMethod, argument))
+      throw new $TypeError(tryToString(argument) + ' is not iterable')
+    }
+  }, { '../internals/a-callable': 1, '../internals/an-object': 4, '../internals/function-call': 28, '../internals/get-iterator-method': 34, '../internals/try-to-string': 85 }],
+  36: [function (require, module, exports) {
+    'use strict'
+    var aCallable = require('../internals/a-callable')
+    var isNullOrUndefined = require('../internals/is-null-or-undefined')
+
+    // `GetMethod` abstract operation
+    // https://tc39.es/ecma262/#sec-getmethod
+    module.exports = function (V, P) {
+      var func = V[P]
+      return isNullOrUndefined(func) ? undefined : aCallable(func)
+    }
+  }, { '../internals/a-callable': 1, '../internals/is-null-or-undefined': 48 }],
+  37: [function (require, module, exports) {
+    (function (global) {
+      (function () {
+        'use strict'
+        var check = function (it) {
+          return it && it.Math === Math && it
+        }
+
+        // https://github.com/zloirock/core-js/issues/86#issuecomment-115759028
+        module.exports =
+  // eslint-disable-next-line es/no-global-this -- safe
+  check(typeof globalThis === 'object' && globalThis) ||
+  check(typeof window === 'object' && window) ||
+  // eslint-disable-next-line no-restricted-globals -- safe
+  check(typeof self === 'object' && self) ||
+  check(typeof global === 'object' && global) ||
+  check(typeof this === 'object' && this) ||
+  // eslint-disable-next-line no-new-func -- fallback
+  (function () { return this })() || Function('return this')()
+      }).call(this)
+    }).call(this, typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : typeof window !== 'undefined' ? window : {})
+  }, {}],
+  38: [function (require, module, exports) {
+    'use strict'
+    var uncurryThis = require('../internals/function-uncurry-this')
+    var toObject = require('../internals/to-object')
+
+    var hasOwnProperty = uncurryThis({}.hasOwnProperty)
+
+    // `HasOwnProperty` abstract operation
+    // https://tc39.es/ecma262/#sec-hasownproperty
+    // eslint-disable-next-line es/no-object-hasown -- safe
+    module.exports = Object.hasOwn || function hasOwn (it, key) {
+      return hasOwnProperty(toObject(it), key)
+    }
+  }, { '../internals/function-uncurry-this': 31, '../internals/to-object': 81 }],
+  39: [function (require, module, exports) {
+    'use strict'
+    module.exports = {}
+  }, {}],
+  40: [function (require, module, exports) {
+    'use strict'
+    var getBuiltIn = require('../internals/get-built-in')
+
+    module.exports = getBuiltIn('document', 'documentElement')
+  }, { '../internals/get-built-in': 32 }],
+  41: [function (require, module, exports) {
+    'use strict'
+    var DESCRIPTORS = require('../internals/descriptors')
+    var fails = require('../internals/fails')
+    var createElement = require('../internals/document-create-element')
+
+    // Thanks to IE8 for its funny defineProperty
+    module.exports = !DESCRIPTORS && !fails(function () {
+      // eslint-disable-next-line es/no-object-defineproperty -- required for testing
+      return Object.defineProperty(createElement('div'), 'a', {
+        get: function () { return 7 }
+      }).a !== 7
+    })
+  }, { '../internals/descriptors': 18, '../internals/document-create-element': 19, '../internals/fails': 25 }],
+  42: [function (require, module, exports) {
+    'use strict'
+    var uncurryThis = require('../internals/function-uncurry-this')
+    var fails = require('../internals/fails')
+    var classof = require('../internals/classof-raw')
+
+    var $Object = Object
+    var split = uncurryThis(''.split)
+
+    // fallback for non-array-like ES3 and non-enumerable old V8 strings
+    module.exports = fails(function () {
+      // throws an error in rhino, see https://github.com/mozilla/rhino/issues/346
+      // eslint-disable-next-line no-prototype-builtins -- safe
+      return !$Object('z').propertyIsEnumerable(0)
+    }) ? function (it) {
+        return classof(it) === 'String' ? split(it, '') : $Object(it)
+      } : $Object
+  }, { '../internals/classof-raw': 8, '../internals/fails': 25, '../internals/function-uncurry-this': 31 }],
+  43: [function (require, module, exports) {
+    'use strict'
+    var uncurryThis = require('../internals/function-uncurry-this')
+    var isCallable = require('../internals/is-callable')
+    var store = require('../internals/shared-store')
+
+    var functionToString = uncurryThis(Function.toString)
+
+    // this helper broken in `core-js@3.4.1-3.4.4`, so we can't use `shared` helper
+    if (!isCallable(store.inspectSource)) {
+      store.inspectSource = function (it) {
+        return functionToString(it)
+      }
+    }
+
+    module.exports = store.inspectSource
+  }, { '../internals/function-uncurry-this': 31, '../internals/is-callable': 46, '../internals/shared-store': 74 }],
+  44: [function (require, module, exports) {
+    'use strict'
+    var NATIVE_WEAK_MAP = require('../internals/weak-map-basic-detection')
+    var global = require('../internals/global')
+    var isObject = require('../internals/is-object')
+    var createNonEnumerableProperty = require('../internals/create-non-enumerable-property')
+    var hasOwn = require('../internals/has-own-property')
+    var shared = require('../internals/shared-store')
+    var sharedKey = require('../internals/shared-key')
+    var hiddenKeys = require('../internals/hidden-keys')
+
+    var OBJECT_ALREADY_INITIALIZED = 'Object already initialized'
+    var TypeError = global.TypeError
+    var WeakMap = global.WeakMap
+    var set, get, has
+
+    var enforce = function (it) {
+      return has(it) ? get(it) : set(it, {})
+    }
+
+    var getterFor = function (TYPE) {
+      return function (it) {
+        var state
+        if (!isObject(it) || (state = get(it)).type !== TYPE) {
+          throw new TypeError('Incompatible receiver, ' + TYPE + ' required')
+        } return state
+      }
+    }
+
+    if (NATIVE_WEAK_MAP || shared.state) {
+      var store = shared.state || (shared.state = new WeakMap())
+      /* eslint-disable no-self-assign -- prototype methods protection */
+      store.get = store.get
+      store.has = store.has
+      store.set = store.set
+      /* eslint-enable no-self-assign -- prototype methods protection */
+      set = function (it, metadata) {
+        if (store.has(it)) throw new TypeError(OBJECT_ALREADY_INITIALIZED)
+        metadata.facade = it
+        store.set(it, metadata)
+        return metadata
+      }
+      get = function (it) {
+        return store.get(it) || {}
+      }
+      has = function (it) {
+        return store.has(it)
+      }
+    } else {
+      var STATE = sharedKey('state')
+      hiddenKeys[STATE] = true
+      set = function (it, metadata) {
+        if (hasOwn(it, STATE)) throw new TypeError(OBJECT_ALREADY_INITIALIZED)
+        metadata.facade = it
+        createNonEnumerableProperty(it, STATE, metadata)
+        return metadata
+      }
+      get = function (it) {
+        return hasOwn(it, STATE) ? it[STATE] : {}
+      }
+      has = function (it) {
+        return hasOwn(it, STATE)
+      }
+    }
+
+    module.exports = {
+      set: set,
+      get: get,
+      has: has,
+      enforce: enforce,
+      getterFor: getterFor
+    }
+  }, { '../internals/create-non-enumerable-property': 12, '../internals/global': 37, '../internals/has-own-property': 38, '../internals/hidden-keys': 39, '../internals/is-object': 49, '../internals/shared-key': 73, '../internals/shared-store': 74, '../internals/weak-map-basic-detection': 89 }],
+  45: [function (require, module, exports) {
+    'use strict'
+    var wellKnownSymbol = require('../internals/well-known-symbol')
+    var Iterators = require('../internals/iterators')
+
+    var ITERATOR = wellKnownSymbol('iterator')
+    var ArrayPrototype = Array.prototype
+
+    // check on default Array iterator
+    module.exports = function (it) {
+      return it !== undefined && (Iterators.Array === it || ArrayPrototype[ITERATOR] === it)
+    }
+  }, { '../internals/iterators': 55, '../internals/well-known-symbol': 91 }],
+  46: [function (require, module, exports) {
+    'use strict'
+    // https://tc39.es/ecma262/#sec-IsHTMLDDA-internal-slot
+    var documentAll = typeof document === 'object' && document.all
+
+    // `IsCallable` abstract operation
+    // https://tc39.es/ecma262/#sec-iscallable
+    // eslint-disable-next-line unicorn/no-typeof-undefined -- required for testing
+    module.exports = typeof documentAll === 'undefined' && documentAll !== undefined ? function (argument) {
+      return typeof argument === 'function' || argument === documentAll
+    } : function (argument) {
+      return typeof argument === 'function'
+    }
+  }, {}],
+  47: [function (require, module, exports) {
+    'use strict'
+    var fails = require('../internals/fails')
+    var isCallable = require('../internals/is-callable')
+
+    var replacement = /#|\.prototype\./
+
+    var isForced = function (feature, detection) {
+      var value = data[normalize(feature)]
+      return value === POLYFILL ? true
+        : value === NATIVE ? false
+          : isCallable(detection) ? fails(detection)
+            : !!detection
+    }
+
+    var normalize = isForced.normalize = function (string) {
+      return String(string).replace(replacement, '.').toLowerCase()
+    }
+
+    var data = isForced.data = {}
+    var NATIVE = isForced.NATIVE = 'N'
+    var POLYFILL = isForced.POLYFILL = 'P'
+
+    module.exports = isForced
+  }, { '../internals/fails': 25, '../internals/is-callable': 46 }],
+  48: [function (require, module, exports) {
+    'use strict'
+    // we can't use just `it == null` since of `document.all` special case
+    // https://tc39.es/ecma262/#sec-IsHTMLDDA-internal-slot-aec
+    module.exports = function (it) {
+      return it === null || it === undefined
+    }
+  }, {}],
+  49: [function (require, module, exports) {
+    'use strict'
+    var isCallable = require('../internals/is-callable')
+
+    module.exports = function (it) {
+      return typeof it === 'object' ? it !== null : isCallable(it)
+    }
+  }, { '../internals/is-callable': 46 }],
+  50: [function (require, module, exports) {
+    'use strict'
+    module.exports = false
+  }, {}],
+  51: [function (require, module, exports) {
+    'use strict'
+    var getBuiltIn = require('../internals/get-built-in')
+    var isCallable = require('../internals/is-callable')
+    var isPrototypeOf = require('../internals/object-is-prototype-of')
+    var USE_SYMBOL_AS_UID = require('../internals/use-symbol-as-uid')
+
+    var $Object = Object
+
+    module.exports = USE_SYMBOL_AS_UID ? function (it) {
+      return typeof it === 'symbol'
+    } : function (it) {
+      var $Symbol = getBuiltIn('Symbol')
+      return isCallable($Symbol) && isPrototypeOf($Symbol.prototype, $Object(it))
+    }
+  }, { '../internals/get-built-in': 32, '../internals/is-callable': 46, '../internals/object-is-prototype-of': 66, '../internals/use-symbol-as-uid': 87 }],
+  52: [function (require, module, exports) {
+    'use strict'
+    var bind = require('../internals/function-bind-context')
+    var call = require('../internals/function-call')
+    var anObject = require('../internals/an-object')
+    var tryToString = require('../internals/try-to-string')
+    var isArrayIteratorMethod = require('../internals/is-array-iterator-method')
+    var lengthOfArrayLike = require('../internals/length-of-array-like')
+    var isPrototypeOf = require('../internals/object-is-prototype-of')
+    var getIterator = require('../internals/get-iterator')
+    var getIteratorMethod = require('../internals/get-iterator-method')
+    var iteratorClose = require('../internals/iterator-close')
+
+    var $TypeError = TypeError
+
+    var Result = function (stopped, result) {
+      this.stopped = stopped
+      this.result = result
+    }
+
+    var ResultPrototype = Result.prototype
+
+    module.exports = function (iterable, unboundFunction, options) {
+      var that = options && options.that
+      var AS_ENTRIES = !!(options && options.AS_ENTRIES)
+      var IS_RECORD = !!(options && options.IS_RECORD)
+      var IS_ITERATOR = !!(options && options.IS_ITERATOR)
+      var INTERRUPTED = !!(options && options.INTERRUPTED)
+      var fn = bind(unboundFunction, that)
+      var iterator, iterFn, index, length, result, next, step
+
+      var stop = function (condition) {
+        if (iterator) iteratorClose(iterator, 'normal', condition)
+        return new Result(true, condition)
+      }
+
+      var callFn = function (value) {
+        if (AS_ENTRIES) {
+          anObject(value)
+          return INTERRUPTED ? fn(value[0], value[1], stop) : fn(value[0], value[1])
+        } return INTERRUPTED ? fn(value, stop) : fn(value)
+      }
+
+      if (IS_RECORD) {
+        iterator = iterable.iterator
+      } else if (IS_ITERATOR) {
+        iterator = iterable
+      } else {
+        iterFn = getIteratorMethod(iterable)
+        if (!iterFn) throw new $TypeError(tryToString(iterable) + ' is not iterable')
+        // optimisation for array iterators
+        if (isArrayIteratorMethod(iterFn)) {
+          for (index = 0, length = lengthOfArrayLike(iterable); length > index; index++) {
+            result = callFn(iterable[index])
+            if (result && isPrototypeOf(ResultPrototype, result)) return result
+          } return new Result(false)
+        }
+        iterator = getIterator(iterable, iterFn)
+      }
+
+      next = IS_RECORD ? iterable.next : iterator.next
+      while (!(step = call(next, iterator)).done) {
+        try {
+          result = callFn(step.value)
+        } catch (error) {
+          iteratorClose(iterator, 'throw', error)
+        }
+        if (typeof result === 'object' && result && isPrototypeOf(ResultPrototype, result)) return result
+      } return new Result(false)
+    }
+  }, { '../internals/an-object': 4, '../internals/function-bind-context': 26, '../internals/function-call': 28, '../internals/get-iterator': 35, '../internals/get-iterator-method': 34, '../internals/is-array-iterator-method': 45, '../internals/iterator-close': 53, '../internals/length-of-array-like': 56, '../internals/object-is-prototype-of': 66, '../internals/try-to-string': 85 }],
+  53: [function (require, module, exports) {
+    'use strict'
+    var call = require('../internals/function-call')
+    var anObject = require('../internals/an-object')
+    var getMethod = require('../internals/get-method')
+
+    module.exports = function (iterator, kind, value) {
+      var innerResult, innerError
+      anObject(iterator)
+      try {
+        innerResult = getMethod(iterator, 'return')
+        if (!innerResult) {
+          if (kind === 'throw') throw value
+          return value
+        }
+        innerResult = call(innerResult, iterator)
+      } catch (error) {
+        innerError = true
+        innerResult = error
+      }
+      if (kind === 'throw') throw value
+      if (innerError) throw innerResult
+      anObject(innerResult)
+      return value
+    }
+  }, { '../internals/an-object': 4, '../internals/function-call': 28, '../internals/get-method': 36 }],
+  54: [function (require, module, exports) {
+    'use strict'
+    var fails = require('../internals/fails')
+    var isCallable = require('../internals/is-callable')
+    var isObject = require('../internals/is-object')
+    var create = require('../internals/object-create')
+    var getPrototypeOf = require('../internals/object-get-prototype-of')
+    var defineBuiltIn = require('../internals/define-built-in')
+    var wellKnownSymbol = require('../internals/well-known-symbol')
+    var IS_PURE = require('../internals/is-pure')
+
+    var ITERATOR = wellKnownSymbol('iterator')
+    var BUGGY_SAFARI_ITERATORS = false
+
+    // `%IteratorPrototype%` object
+    // https://tc39.es/ecma262/#sec-%iteratorprototype%-object
+    var IteratorPrototype, PrototypeOfArrayIteratorPrototype, arrayIterator
+
+    /* eslint-disable es/no-array-prototype-keys -- safe */
+    if ([].keys) {
+      arrayIterator = [].keys()
+      // Safari 8 has buggy iterators w/o `next`
+      if (!('next' in arrayIterator)) BUGGY_SAFARI_ITERATORS = true
+      else {
+        PrototypeOfArrayIteratorPrototype = getPrototypeOf(getPrototypeOf(arrayIterator))
+        if (PrototypeOfArrayIteratorPrototype !== Object.prototype) IteratorPrototype = PrototypeOfArrayIteratorPrototype
+      }
+    }
+
+    var NEW_ITERATOR_PROTOTYPE = !isObject(IteratorPrototype) || fails(function () {
+      var test = {}
+      // FF44- legacy iterators case
+      return IteratorPrototype[ITERATOR].call(test) !== test
+    })
+
+    if (NEW_ITERATOR_PROTOTYPE) IteratorPrototype = {}
+    else if (IS_PURE) IteratorPrototype = create(IteratorPrototype)
+
+    // `%IteratorPrototype%[@@iterator]()` method
+    // https://tc39.es/ecma262/#sec-%iteratorprototype%-@@iterator
+    if (!isCallable(IteratorPrototype[ITERATOR])) {
+      defineBuiltIn(IteratorPrototype, ITERATOR, function () {
+        return this
+      })
+    }
+
+    module.exports = {
+      IteratorPrototype: IteratorPrototype,
+      BUGGY_SAFARI_ITERATORS: BUGGY_SAFARI_ITERATORS
+    }
+  }, { '../internals/define-built-in': 16, '../internals/fails': 25, '../internals/is-callable': 46, '../internals/is-object': 49, '../internals/is-pure': 50, '../internals/object-create': 59, '../internals/object-get-prototype-of': 65, '../internals/well-known-symbol': 91 }],
+  55: [function (require, module, exports) {
+    arguments[4][39][0].apply(exports, arguments)
+  }, { dup: 39 }],
+  56: [function (require, module, exports) {
+    'use strict'
+    var toLength = require('../internals/to-length')
+
+    // `LengthOfArrayLike` abstract operation
+    // https://tc39.es/ecma262/#sec-lengthofarraylike
+    module.exports = function (obj) {
+      return toLength(obj.length)
+    }
+  }, { '../internals/to-length': 80 }],
+  57: [function (require, module, exports) {
+    'use strict'
+    var uncurryThis = require('../internals/function-uncurry-this')
+    var fails = require('../internals/fails')
+    var isCallable = require('../internals/is-callable')
+    var hasOwn = require('../internals/has-own-property')
+    var DESCRIPTORS = require('../internals/descriptors')
+    var CONFIGURABLE_FUNCTION_NAME = require('../internals/function-name').CONFIGURABLE
+    var inspectSource = require('../internals/inspect-source')
+    var InternalStateModule = require('../internals/internal-state')
+
+    var enforceInternalState = InternalStateModule.enforce
+    var getInternalState = InternalStateModule.get
+    var $String = String
+    // eslint-disable-next-line es/no-object-defineproperty -- safe
+    var defineProperty = Object.defineProperty
+    var stringSlice = uncurryThis(''.slice)
+    var replace = uncurryThis(''.replace)
+    var join = uncurryThis([].join)
+
+    var CONFIGURABLE_LENGTH = DESCRIPTORS && !fails(function () {
+      return defineProperty(function () { /* empty */ }, 'length', { value: 8 }).length !== 8
+    })
+
+    var TEMPLATE = String(String).split('String')
+
+    var makeBuiltIn = module.exports = function (value, name, options) {
+      if (stringSlice($String(name), 0, 7) === 'Symbol(') {
+        name = '[' + replace($String(name), /^Symbol\(([^)]*)\)/, '$1') + ']'
+      }
+      if (options && options.getter) name = 'get ' + name
+      if (options && options.setter) name = 'set ' + name
+      if (!hasOwn(value, 'name') || (CONFIGURABLE_FUNCTION_NAME && value.name !== name)) {
+        if (DESCRIPTORS) defineProperty(value, 'name', { value: name, configurable: true })
+        else value.name = name
+      }
+      if (CONFIGURABLE_LENGTH && options && hasOwn(options, 'arity') && value.length !== options.arity) {
+        defineProperty(value, 'length', { value: options.arity })
+      }
+      try {
+        if (options && hasOwn(options, 'constructor') && options.constructor) {
+          if (DESCRIPTORS) defineProperty(value, 'prototype', { writable: false })
+          // in V8 ~ Chrome 53, prototypes of some methods, like `Array.prototype.values`, are non-writable
+        } else if (value.prototype) value.prototype = undefined
+      } catch (error) { /* empty */ }
+      var state = enforceInternalState(value)
+      if (!hasOwn(state, 'source')) {
+        state.source = join(TEMPLATE, typeof name === 'string' ? name : '')
+      } return value
+    }
+
+    // add fake Function#toString for correct work wrapped methods / constructors with methods like LoDash isNative
+    // eslint-disable-next-line no-extend-native -- required
+    Function.prototype.toString = makeBuiltIn(function toString () {
+      return isCallable(this) && getInternalState(this).source || inspectSource(this)
+    }, 'toString')
+  }, { '../internals/descriptors': 18, '../internals/fails': 25, '../internals/function-name': 29, '../internals/function-uncurry-this': 31, '../internals/has-own-property': 38, '../internals/inspect-source': 43, '../internals/internal-state': 44, '../internals/is-callable': 46 }],
+  58: [function (require, module, exports) {
+    'use strict'
+    var ceil = Math.ceil
+    var floor = Math.floor
+
+    // `Math.trunc` method
+    // https://tc39.es/ecma262/#sec-math.trunc
+    // eslint-disable-next-line es/no-math-trunc -- safe
+    module.exports = Math.trunc || function trunc (x) {
+      var n = +x
+      return (n > 0 ? floor : ceil)(n)
+    }
+  }, {}],
+  59: [function (require, module, exports) {
+    'use strict'
+    /* global ActiveXObject -- old IE, WSH */
+    var anObject = require('../internals/an-object')
+    var definePropertiesModule = require('../internals/object-define-properties')
+    var enumBugKeys = require('../internals/enum-bug-keys')
+    var hiddenKeys = require('../internals/hidden-keys')
+    var html = require('../internals/html')
+    var documentCreateElement = require('../internals/document-create-element')
+    var sharedKey = require('../internals/shared-key')
+
+    var GT = '>'
+    var LT = '<'
+    var PROTOTYPE = 'prototype'
+    var SCRIPT = 'script'
+    var IE_PROTO = sharedKey('IE_PROTO')
+
+    var EmptyConstructor = function () { /* empty */ }
+
+    var scriptTag = function (content) {
+      return LT + SCRIPT + GT + content + LT + '/' + SCRIPT + GT
+    }
+
+    // Create object with fake `null` prototype: use ActiveX Object with cleared prototype
+    var NullProtoObjectViaActiveX = function (activeXDocument) {
+      activeXDocument.write(scriptTag(''))
+      activeXDocument.close()
+      var temp = activeXDocument.parentWindow.Object
+      activeXDocument = null // avoid memory leak
+      return temp
+    }
+
+    // Create object with fake `null` prototype: use iframe Object with cleared prototype
+    var NullProtoObjectViaIFrame = function () {
+      // Thrash, waste and sodomy: IE GC bug
+      var iframe = documentCreateElement('iframe')
+      var JS = 'java' + SCRIPT + ':'
+      var iframeDocument
+      iframe.style.display = 'none'
+      html.appendChild(iframe)
+      // https://github.com/zloirock/core-js/issues/475
+      iframe.src = String(JS)
+      iframeDocument = iframe.contentWindow.document
+      iframeDocument.open()
+      iframeDocument.write(scriptTag('document.F=Object'))
+      iframeDocument.close()
+      return iframeDocument.F
+    }
+
+    // Check for document.domain and active x support
+    // No need to use active x approach when document.domain is not set
+    // see https://github.com/es-shims/es5-shim/issues/150
+    // variation of https://github.com/kitcambridge/es5-shim/commit/4f738ac066346
+    // avoid IE GC bug
+    var activeXDocument
+    var NullProtoObject = function () {
+      try {
+        activeXDocument = new ActiveXObject('htmlfile')
+      } catch (error) { /* ignore */ }
+      NullProtoObject = typeof document !== 'undefined'
+        ? document.domain && activeXDocument
+          ? NullProtoObjectViaActiveX(activeXDocument) // old IE
+          : NullProtoObjectViaIFrame()
+        : NullProtoObjectViaActiveX(activeXDocument) // WSH
+      var length = enumBugKeys.length
+      while (length--) delete NullProtoObject[PROTOTYPE][enumBugKeys[length]]
+      return NullProtoObject()
+    }
+
+    hiddenKeys[IE_PROTO] = true
+
+    // `Object.create` method
+    // https://tc39.es/ecma262/#sec-object.create
+    // eslint-disable-next-line es/no-object-create -- safe
+    module.exports = Object.create || function create (O, Properties) {
+      var result
+      if (O !== null) {
+        EmptyConstructor[PROTOTYPE] = anObject(O)
+        result = new EmptyConstructor()
+        EmptyConstructor[PROTOTYPE] = null
+        // add "__proto__" for Object.getPrototypeOf polyfill
+        result[IE_PROTO] = O
+      } else result = NullProtoObject()
+      return Properties === undefined ? result : definePropertiesModule.f(result, Properties)
+    }
+  }, { '../internals/an-object': 4, '../internals/document-create-element': 19, '../internals/enum-bug-keys': 23, '../internals/hidden-keys': 39, '../internals/html': 40, '../internals/object-define-properties': 60, '../internals/shared-key': 73 }],
+  60: [function (require, module, exports) {
+    'use strict'
+    var DESCRIPTORS = require('../internals/descriptors')
+    var V8_PROTOTYPE_DEFINE_BUG = require('../internals/v8-prototype-define-bug')
+    var definePropertyModule = require('../internals/object-define-property')
+    var anObject = require('../internals/an-object')
+    var toIndexedObject = require('../internals/to-indexed-object')
+    var objectKeys = require('../internals/object-keys')
+
+    // `Object.defineProperties` method
+    // https://tc39.es/ecma262/#sec-object.defineproperties
+    // eslint-disable-next-line es/no-object-defineproperties -- safe
+    exports.f = DESCRIPTORS && !V8_PROTOTYPE_DEFINE_BUG ? Object.defineProperties : function defineProperties (O, Properties) {
+      anObject(O)
+      var props = toIndexedObject(Properties)
+      var keys = objectKeys(Properties)
+      var length = keys.length
+      var index = 0
+      var key
+      while (length > index) definePropertyModule.f(O, key = keys[index++], props[key])
+      return O
+    }
+  }, { '../internals/an-object': 4, '../internals/descriptors': 18, '../internals/object-define-property': 61, '../internals/object-keys': 68, '../internals/to-indexed-object': 78, '../internals/v8-prototype-define-bug': 88 }],
+  61: [function (require, module, exports) {
+    'use strict'
+    var DESCRIPTORS = require('../internals/descriptors')
+    var IE8_DOM_DEFINE = require('../internals/ie8-dom-define')
+    var V8_PROTOTYPE_DEFINE_BUG = require('../internals/v8-prototype-define-bug')
+    var anObject = require('../internals/an-object')
+    var toPropertyKey = require('../internals/to-property-key')
+
+    var $TypeError = TypeError
+    // eslint-disable-next-line es/no-object-defineproperty -- safe
+    var $defineProperty = Object.defineProperty
+    // eslint-disable-next-line es/no-object-getownpropertydescriptor -- safe
+    var $getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor
+    var ENUMERABLE = 'enumerable'
+    var CONFIGURABLE = 'configurable'
+    var WRITABLE = 'writable'
+
+    // `Object.defineProperty` method
+    // https://tc39.es/ecma262/#sec-object.defineproperty
+    exports.f = DESCRIPTORS ? V8_PROTOTYPE_DEFINE_BUG ? function defineProperty (O, P, Attributes) {
+      anObject(O)
+      P = toPropertyKey(P)
+      anObject(Attributes)
+      if (typeof O === 'function' && P === 'prototype' && 'value' in Attributes && WRITABLE in Attributes && !Attributes[WRITABLE]) {
+        var current = $getOwnPropertyDescriptor(O, P)
+        if (current && current[WRITABLE]) {
+          O[P] = Attributes.value
+          Attributes = {
+            configurable: CONFIGURABLE in Attributes ? Attributes[CONFIGURABLE] : current[CONFIGURABLE],
+            enumerable: ENUMERABLE in Attributes ? Attributes[ENUMERABLE] : current[ENUMERABLE],
+            writable: false
+          }
+        }
+      } return $defineProperty(O, P, Attributes)
+    } : $defineProperty : function defineProperty (O, P, Attributes) {
+      anObject(O)
+      P = toPropertyKey(P)
+      anObject(Attributes)
+      if (IE8_DOM_DEFINE) {
+        try {
+          return $defineProperty(O, P, Attributes)
+        } catch (error) { /* empty */ }
+      }
+      if ('get' in Attributes || 'set' in Attributes) throw new $TypeError('Accessors not supported')
+      if ('value' in Attributes) O[P] = Attributes.value
+      return O
+    }
+  }, { '../internals/an-object': 4, '../internals/descriptors': 18, '../internals/ie8-dom-define': 41, '../internals/to-property-key': 83, '../internals/v8-prototype-define-bug': 88 }],
+  62: [function (require, module, exports) {
+    'use strict'
+    var DESCRIPTORS = require('../internals/descriptors')
+    var call = require('../internals/function-call')
+    var propertyIsEnumerableModule = require('../internals/object-property-is-enumerable')
+    var createPropertyDescriptor = require('../internals/create-property-descriptor')
+    var toIndexedObject = require('../internals/to-indexed-object')
+    var toPropertyKey = require('../internals/to-property-key')
+    var hasOwn = require('../internals/has-own-property')
+    var IE8_DOM_DEFINE = require('../internals/ie8-dom-define')
+
+    // eslint-disable-next-line es/no-object-getownpropertydescriptor -- safe
+    var $getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor
+
+    // `Object.getOwnPropertyDescriptor` method
+    // https://tc39.es/ecma262/#sec-object.getownpropertydescriptor
+    exports.f = DESCRIPTORS ? $getOwnPropertyDescriptor : function getOwnPropertyDescriptor (O, P) {
+      O = toIndexedObject(O)
+      P = toPropertyKey(P)
+      if (IE8_DOM_DEFINE) {
+        try {
+          return $getOwnPropertyDescriptor(O, P)
+        } catch (error) { /* empty */ }
+      }
+      if (hasOwn(O, P)) return createPropertyDescriptor(!call(propertyIsEnumerableModule.f, O, P), O[P])
+    }
+  }, { '../internals/create-property-descriptor': 13, '../internals/descriptors': 18, '../internals/function-call': 28, '../internals/has-own-property': 38, '../internals/ie8-dom-define': 41, '../internals/object-property-is-enumerable': 69, '../internals/to-indexed-object': 78, '../internals/to-property-key': 83 }],
+  63: [function (require, module, exports) {
+    'use strict'
+    var internalObjectKeys = require('../internals/object-keys-internal')
+    var enumBugKeys = require('../internals/enum-bug-keys')
+
+    var hiddenKeys = enumBugKeys.concat('length', 'prototype')
+
+    // `Object.getOwnPropertyNames` method
+    // https://tc39.es/ecma262/#sec-object.getownpropertynames
+    // eslint-disable-next-line es/no-object-getownpropertynames -- safe
+    exports.f = Object.getOwnPropertyNames || function getOwnPropertyNames (O) {
+      return internalObjectKeys(O, hiddenKeys)
+    }
+  }, { '../internals/enum-bug-keys': 23, '../internals/object-keys-internal': 67 }],
+  64: [function (require, module, exports) {
+    'use strict'
+    // eslint-disable-next-line es/no-object-getownpropertysymbols -- safe
+    exports.f = Object.getOwnPropertySymbols
+  }, {}],
+  65: [function (require, module, exports) {
+    'use strict'
+    var hasOwn = require('../internals/has-own-property')
+    var isCallable = require('../internals/is-callable')
+    var toObject = require('../internals/to-object')
+    var sharedKey = require('../internals/shared-key')
+    var CORRECT_PROTOTYPE_GETTER = require('../internals/correct-prototype-getter')
+
+    var IE_PROTO = sharedKey('IE_PROTO')
+    var $Object = Object
+    var ObjectPrototype = $Object.prototype
+
+    // `Object.getPrototypeOf` method
+    // https://tc39.es/ecma262/#sec-object.getprototypeof
+    // eslint-disable-next-line es/no-object-getprototypeof -- safe
+    module.exports = CORRECT_PROTOTYPE_GETTER ? $Object.getPrototypeOf : function (O) {
+      var object = toObject(O)
+      if (hasOwn(object, IE_PROTO)) return object[IE_PROTO]
+      var constructor = object.constructor
+      if (isCallable(constructor) && object instanceof constructor) {
+        return constructor.prototype
+      } return object instanceof $Object ? ObjectPrototype : null
+    }
+  }, { '../internals/correct-prototype-getter': 11, '../internals/has-own-property': 38, '../internals/is-callable': 46, '../internals/shared-key': 73, '../internals/to-object': 81 }],
+  66: [function (require, module, exports) {
+    'use strict'
+    var uncurryThis = require('../internals/function-uncurry-this')
+
+    module.exports = uncurryThis({}.isPrototypeOf)
+  }, { '../internals/function-uncurry-this': 31 }],
+  67: [function (require, module, exports) {
+    'use strict'
+    var uncurryThis = require('../internals/function-uncurry-this')
+    var hasOwn = require('../internals/has-own-property')
+    var toIndexedObject = require('../internals/to-indexed-object')
+    var indexOf = require('../internals/array-includes').indexOf
+    var hiddenKeys = require('../internals/hidden-keys')
+
+    var push = uncurryThis([].push)
+
+    module.exports = function (object, names) {
+      var O = toIndexedObject(object)
+      var i = 0
+      var result = []
+      var key
+      for (key in O) !hasOwn(hiddenKeys, key) && hasOwn(O, key) && push(result, key)
+      // Don't enum bug & hidden keys
+      while (names.length > i) {
+        if (hasOwn(O, key = names[i++])) {
+          ~indexOf(result, key) || push(result, key)
+        }
+      }
+      return result
+    }
+  }, { '../internals/array-includes': 5, '../internals/function-uncurry-this': 31, '../internals/has-own-property': 38, '../internals/hidden-keys': 39, '../internals/to-indexed-object': 78 }],
+  68: [function (require, module, exports) {
+    'use strict'
+    var internalObjectKeys = require('../internals/object-keys-internal')
+    var enumBugKeys = require('../internals/enum-bug-keys')
+
+    // `Object.keys` method
+    // https://tc39.es/ecma262/#sec-object.keys
+    // eslint-disable-next-line es/no-object-keys -- safe
+    module.exports = Object.keys || function keys (O) {
+      return internalObjectKeys(O, enumBugKeys)
+    }
+  }, { '../internals/enum-bug-keys': 23, '../internals/object-keys-internal': 67 }],
+  69: [function (require, module, exports) {
+    'use strict'
+    var $propertyIsEnumerable = {}.propertyIsEnumerable
+    // eslint-disable-next-line es/no-object-getownpropertydescriptor -- safe
+    var getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor
+
+    // Nashorn ~ JDK8 bug
+    var NASHORN_BUG = getOwnPropertyDescriptor && !$propertyIsEnumerable.call({ 1: 2 }, 1)
+
+    // `Object.prototype.propertyIsEnumerable` method implementation
+    // https://tc39.es/ecma262/#sec-object.prototype.propertyisenumerable
+    exports.f = NASHORN_BUG ? function propertyIsEnumerable (V) {
+      var descriptor = getOwnPropertyDescriptor(this, V)
+      return !!descriptor && descriptor.enumerable
+    } : $propertyIsEnumerable
+  }, {}],
+  70: [function (require, module, exports) {
+    'use strict'
+    var call = require('../internals/function-call')
+    var isCallable = require('../internals/is-callable')
+    var isObject = require('../internals/is-object')
+
+    var $TypeError = TypeError
+
+    // `OrdinaryToPrimitive` abstract operation
+    // https://tc39.es/ecma262/#sec-ordinarytoprimitive
+    module.exports = function (input, pref) {
+      var fn, val
+      if (pref === 'string' && isCallable(fn = input.toString) && !isObject(val = call(fn, input))) return val
+      if (isCallable(fn = input.valueOf) && !isObject(val = call(fn, input))) return val
+      if (pref !== 'string' && isCallable(fn = input.toString) && !isObject(val = call(fn, input))) return val
+      throw new $TypeError("Can't convert object to primitive value")
+    }
+  }, { '../internals/function-call': 28, '../internals/is-callable': 46, '../internals/is-object': 49 }],
+  71: [function (require, module, exports) {
+    'use strict'
+    var getBuiltIn = require('../internals/get-built-in')
+    var uncurryThis = require('../internals/function-uncurry-this')
+    var getOwnPropertyNamesModule = require('../internals/object-get-own-property-names')
+    var getOwnPropertySymbolsModule = require('../internals/object-get-own-property-symbols')
+    var anObject = require('../internals/an-object')
+
+    var concat = uncurryThis([].concat)
+
+    // all object keys, includes non-enumerable and symbols
+    module.exports = getBuiltIn('Reflect', 'ownKeys') || function ownKeys (it) {
+      var keys = getOwnPropertyNamesModule.f(anObject(it))
+      var getOwnPropertySymbols = getOwnPropertySymbolsModule.f
+      return getOwnPropertySymbols ? concat(keys, getOwnPropertySymbols(it)) : keys
+    }
+  }, { '../internals/an-object': 4, '../internals/function-uncurry-this': 31, '../internals/get-built-in': 32, '../internals/object-get-own-property-names': 63, '../internals/object-get-own-property-symbols': 64 }],
+  72: [function (require, module, exports) {
+    'use strict'
+    var isNullOrUndefined = require('../internals/is-null-or-undefined')
+
+    var $TypeError = TypeError
+
+    // `RequireObjectCoercible` abstract operation
+    // https://tc39.es/ecma262/#sec-requireobjectcoercible
+    module.exports = function (it) {
+      if (isNullOrUndefined(it)) throw new $TypeError("Can't call method on " + it)
+      return it
+    }
+  }, { '../internals/is-null-or-undefined': 48 }],
+  73: [function (require, module, exports) {
+    'use strict'
+    var shared = require('../internals/shared')
+    var uid = require('../internals/uid')
+
+    var keys = shared('keys')
+
+    module.exports = function (key) {
+      return keys[key] || (keys[key] = uid(key))
+    }
+  }, { '../internals/shared': 75, '../internals/uid': 86 }],
+  74: [function (require, module, exports) {
+    'use strict'
+    var global = require('../internals/global')
+    var defineGlobalProperty = require('../internals/define-global-property')
+
+    var SHARED = '__core-js_shared__'
+    var store = global[SHARED] || defineGlobalProperty(SHARED, {})
+
+    module.exports = store
+  }, { '../internals/define-global-property': 17, '../internals/global': 37 }],
+  75: [function (require, module, exports) {
+    'use strict'
+    var IS_PURE = require('../internals/is-pure')
+    var store = require('../internals/shared-store');
+
+    (module.exports = function (key, value) {
+      return store[key] || (store[key] = value !== undefined ? value : {})
+    })('versions', []).push({
+      version: '3.35.0',
+      mode: IS_PURE ? 'pure' : 'global',
+      copyright: '© 2014-2023 Denis Pushkarev (zloirock.ru)',
+      license: 'https://github.com/zloirock/core-js/blob/v3.35.0/LICENSE',
+      source: 'https://github.com/zloirock/core-js'
+    })
+  }, { '../internals/is-pure': 50, '../internals/shared-store': 74 }],
+  76: [function (require, module, exports) {
+    'use strict'
+    /* eslint-disable es/no-symbol -- required for testing */
+    var V8_VERSION = require('../internals/engine-v8-version')
+    var fails = require('../internals/fails')
+    var global = require('../internals/global')
+
+    var $String = global.String
+
+    // eslint-disable-next-line es/no-object-getownpropertysymbols -- required for testing
+    module.exports = !!Object.getOwnPropertySymbols && !fails(function () {
+      var symbol = Symbol('symbol detection')
+      // Chrome 38 Symbol has incorrect toString conversion
+      // `get-own-property-symbols` polyfill symbols converted to object are not Symbol instances
+      // nb: Do not call `String` directly to avoid this being optimized out to `symbol+''` which will,
+      // of course, fail.
+      return !$String(symbol) || !(Object(symbol) instanceof Symbol) ||
+    // Chrome 38-40 symbols are not inherited from DOM collections prototypes to instances
+    !Symbol.sham && V8_VERSION && V8_VERSION < 41
+    })
+  }, { '../internals/engine-v8-version': 22, '../internals/fails': 25, '../internals/global': 37 }],
+  77: [function (require, module, exports) {
+    'use strict'
+    var toIntegerOrInfinity = require('../internals/to-integer-or-infinity')
+
+    var max = Math.max
+    var min = Math.min
+
+    // Helper for a popular repeating case of the spec:
+    // Let integer be ? ToInteger(index).
+    // If integer < 0, let result be max((length + integer), 0); else let result be min(integer, length).
+    module.exports = function (index, length) {
+      var integer = toIntegerOrInfinity(index)
+      return integer < 0 ? max(integer + length, 0) : min(integer, length)
+    }
+  }, { '../internals/to-integer-or-infinity': 79 }],
+  78: [function (require, module, exports) {
+    'use strict'
+    // toObject with fallback for non-array-like ES3 strings
+    var IndexedObject = require('../internals/indexed-object')
+    var requireObjectCoercible = require('../internals/require-object-coercible')
+
+    module.exports = function (it) {
+      return IndexedObject(requireObjectCoercible(it))
+    }
+  }, { '../internals/indexed-object': 42, '../internals/require-object-coercible': 72 }],
+  79: [function (require, module, exports) {
+    'use strict'
+    var trunc = require('../internals/math-trunc')
+
+    // `ToIntegerOrInfinity` abstract operation
+    // https://tc39.es/ecma262/#sec-tointegerorinfinity
+    module.exports = function (argument) {
+      var number = +argument
+      // eslint-disable-next-line no-self-compare -- NaN check
+      return number !== number || number === 0 ? 0 : trunc(number)
+    }
+  }, { '../internals/math-trunc': 58 }],
+  80: [function (require, module, exports) {
+    'use strict'
+    var toIntegerOrInfinity = require('../internals/to-integer-or-infinity')
+
+    var min = Math.min
+
+    // `ToLength` abstract operation
+    // https://tc39.es/ecma262/#sec-tolength
+    module.exports = function (argument) {
+      return argument > 0 ? min(toIntegerOrInfinity(argument), 0x1FFFFFFFFFFFFF) : 0 // 2 ** 53 - 1 == 9007199254740991
+    }
+  }, { '../internals/to-integer-or-infinity': 79 }],
+  81: [function (require, module, exports) {
+    'use strict'
+    var requireObjectCoercible = require('../internals/require-object-coercible')
+
+    var $Object = Object
+
+    // `ToObject` abstract operation
+    // https://tc39.es/ecma262/#sec-toobject
+    module.exports = function (argument) {
+      return $Object(requireObjectCoercible(argument))
+    }
+  }, { '../internals/require-object-coercible': 72 }],
+  82: [function (require, module, exports) {
+    'use strict'
+    var call = require('../internals/function-call')
+    var isObject = require('../internals/is-object')
+    var isSymbol = require('../internals/is-symbol')
+    var getMethod = require('../internals/get-method')
+    var ordinaryToPrimitive = require('../internals/ordinary-to-primitive')
+    var wellKnownSymbol = require('../internals/well-known-symbol')
+
+    var $TypeError = TypeError
+    var TO_PRIMITIVE = wellKnownSymbol('toPrimitive')
+
+    // `ToPrimitive` abstract operation
+    // https://tc39.es/ecma262/#sec-toprimitive
+    module.exports = function (input, pref) {
+      if (!isObject(input) || isSymbol(input)) return input
+      var exoticToPrim = getMethod(input, TO_PRIMITIVE)
+      var result
+      if (exoticToPrim) {
+        if (pref === undefined) pref = 'default'
+        result = call(exoticToPrim, input, pref)
+        if (!isObject(result) || isSymbol(result)) return result
+        throw new $TypeError("Can't convert object to primitive value")
+      }
+      if (pref === undefined) pref = 'number'
+      return ordinaryToPrimitive(input, pref)
+    }
+  }, { '../internals/function-call': 28, '../internals/get-method': 36, '../internals/is-object': 49, '../internals/is-symbol': 51, '../internals/ordinary-to-primitive': 70, '../internals/well-known-symbol': 91 }],
+  83: [function (require, module, exports) {
+    'use strict'
+    var toPrimitive = require('../internals/to-primitive')
+    var isSymbol = require('../internals/is-symbol')
+
+    // `ToPropertyKey` abstract operation
+    // https://tc39.es/ecma262/#sec-topropertykey
+    module.exports = function (argument) {
+      var key = toPrimitive(argument, 'string')
+      return isSymbol(key) ? key : key + ''
+    }
+  }, { '../internals/is-symbol': 51, '../internals/to-primitive': 82 }],
+  84: [function (require, module, exports) {
+    'use strict'
+    var wellKnownSymbol = require('../internals/well-known-symbol')
+
+    var TO_STRING_TAG = wellKnownSymbol('toStringTag')
+    var test = {}
+
+    test[TO_STRING_TAG] = 'z'
+
+    module.exports = String(test) === '[object z]'
+  }, { '../internals/well-known-symbol': 91 }],
+  85: [function (require, module, exports) {
+    'use strict'
+    var $String = String
+
+    module.exports = function (argument) {
+      try {
+        return $String(argument)
+      } catch (error) {
+        return 'Object'
+      }
+    }
+  }, {}],
+  86: [function (require, module, exports) {
+    'use strict'
+    var uncurryThis = require('../internals/function-uncurry-this')
+
+    var id = 0
+    var postfix = Math.random()
+    var toString = uncurryThis(1.0.toString)
+
+    module.exports = function (key) {
+      return 'Symbol(' + (key === undefined ? '' : key) + ')_' + toString(++id + postfix, 36)
+    }
+  }, { '../internals/function-uncurry-this': 31 }],
+  87: [function (require, module, exports) {
+    'use strict'
+    /* eslint-disable es/no-symbol -- required for testing */
+    var NATIVE_SYMBOL = require('../internals/symbol-constructor-detection')
+
+    module.exports = NATIVE_SYMBOL &&
+  !Symbol.sham &&
+  typeof Symbol.iterator === 'symbol'
+  }, { '../internals/symbol-constructor-detection': 76 }],
+  88: [function (require, module, exports) {
+    'use strict'
+    var DESCRIPTORS = require('../internals/descriptors')
+    var fails = require('../internals/fails')
+
+    // V8 ~ Chrome 36-
+    // https://bugs.chromium.org/p/v8/issues/detail?id=3334
+    module.exports = DESCRIPTORS && fails(function () {
+      // eslint-disable-next-line es/no-object-defineproperty -- required for testing
+      return Object.defineProperty(function () { /* empty */ }, 'prototype', {
+        value: 42,
+        writable: false
+      }).prototype !== 42
+    })
+  }, { '../internals/descriptors': 18, '../internals/fails': 25 }],
+  89: [function (require, module, exports) {
+    'use strict'
+    var global = require('../internals/global')
+    var isCallable = require('../internals/is-callable')
+
+    var WeakMap = global.WeakMap
+
+    module.exports = isCallable(WeakMap) && /native code/.test(String(WeakMap))
+  }, { '../internals/global': 37, '../internals/is-callable': 46 }],
+  90: [function (require, module, exports) {
+    'use strict'
+    var uncurryThis = require('../internals/function-uncurry-this')
+
+    // eslint-disable-next-line es/no-weak-map -- safe
+    var WeakMapPrototype = WeakMap.prototype
+
+    module.exports = {
+      // eslint-disable-next-line es/no-weak-map -- safe
+      WeakMap: WeakMap,
+      set: uncurryThis(WeakMapPrototype.set),
+      get: uncurryThis(WeakMapPrototype.get),
+      has: uncurryThis(WeakMapPrototype.has),
+      remove: uncurryThis(WeakMapPrototype.delete)
+    }
+  }, { '../internals/function-uncurry-this': 31 }],
+  91: [function (require, module, exports) {
+    'use strict'
+    var global = require('../internals/global')
+    var shared = require('../internals/shared')
+    var hasOwn = require('../internals/has-own-property')
+    var uid = require('../internals/uid')
+    var NATIVE_SYMBOL = require('../internals/symbol-constructor-detection')
+    var USE_SYMBOL_AS_UID = require('../internals/use-symbol-as-uid')
+
+    var Symbol = global.Symbol
+    var WellKnownSymbolsStore = shared('wks')
+    var createWellKnownSymbol = USE_SYMBOL_AS_UID ? Symbol.for || Symbol : Symbol && Symbol.withoutSetter || uid
+
+    module.exports = function (name) {
+      if (!hasOwn(WellKnownSymbolsStore, name)) {
+        WellKnownSymbolsStore[name] = NATIVE_SYMBOL && hasOwn(Symbol, name)
+          ? Symbol[name]
+          : createWellKnownSymbol('Symbol.' + name)
+      } return WellKnownSymbolsStore[name]
+    }
+  }, { '../internals/global': 37, '../internals/has-own-property': 38, '../internals/shared': 75, '../internals/symbol-constructor-detection': 76, '../internals/uid': 86, '../internals/use-symbol-as-uid': 87 }],
+  92: [function (require, module, exports) {
+    'use strict'
+    var $ = require('../internals/export')
+    var $forEach = require('../internals/async-iterator-iteration').forEach
+
+    // `AsyncIterator.prototype.forEach` method
+    // https://github.com/tc39/proposal-async-iterator-helpers
+    $({ target: 'AsyncIterator', proto: true, real: true }, {
+      forEach: function forEach (fn) {
+        return $forEach(this, fn)
+      }
+    })
+  }, { '../internals/async-iterator-iteration': 7, '../internals/export': 24 }],
+  93: [function (require, module, exports) {
+    'use strict'
+    var $ = require('../internals/export')
+    var global = require('../internals/global')
+    var anInstance = require('../internals/an-instance')
+    var anObject = require('../internals/an-object')
+    var isCallable = require('../internals/is-callable')
+    var getPrototypeOf = require('../internals/object-get-prototype-of')
+    var defineBuiltInAccessor = require('../internals/define-built-in-accessor')
+    var createProperty = require('../internals/create-property')
+    var fails = require('../internals/fails')
+    var hasOwn = require('../internals/has-own-property')
+    var wellKnownSymbol = require('../internals/well-known-symbol')
+    var IteratorPrototype = require('../internals/iterators-core').IteratorPrototype
+    var DESCRIPTORS = require('../internals/descriptors')
+    var IS_PURE = require('../internals/is-pure')
+
+    var CONSTRUCTOR = 'constructor'
+    var ITERATOR = 'Iterator'
+    var TO_STRING_TAG = wellKnownSymbol('toStringTag')
+
+    var $TypeError = TypeError
+    var NativeIterator = global[ITERATOR]
+
+    // FF56- have non-standard global helper `Iterator`
+    var FORCED = IS_PURE ||
+  !isCallable(NativeIterator) ||
+  NativeIterator.prototype !== IteratorPrototype ||
+  // FF44- non-standard `Iterator` passes previous tests
+  !fails(function () { NativeIterator({}) })
+
+    var IteratorConstructor = function Iterator () {
+      anInstance(this, IteratorPrototype)
+      if (getPrototypeOf(this) === IteratorPrototype) throw new $TypeError('Abstract class Iterator not directly constructable')
+    }
+
+    var defineIteratorPrototypeAccessor = function (key, value) {
+      if (DESCRIPTORS) {
+        defineBuiltInAccessor(IteratorPrototype, key, {
+          configurable: true,
+          get: function () {
+            return value
+          },
+          set: function (replacement) {
+            anObject(this)
+            if (this === IteratorPrototype) throw new $TypeError("You can't redefine this property")
+            if (hasOwn(this, key)) this[key] = replacement
+            else createProperty(this, key, replacement)
+          }
+        })
+      } else IteratorPrototype[key] = value
+    }
+
+    if (!hasOwn(IteratorPrototype, TO_STRING_TAG)) defineIteratorPrototypeAccessor(TO_STRING_TAG, ITERATOR)
+
+    if (FORCED || !hasOwn(IteratorPrototype, CONSTRUCTOR) || IteratorPrototype[CONSTRUCTOR] === Object) {
+      defineIteratorPrototypeAccessor(CONSTRUCTOR, IteratorConstructor)
+    }
+
+    IteratorConstructor.prototype = IteratorPrototype
+
+    // `Iterator` constructor
+    // https://github.com/tc39/proposal-iterator-helpers
+    $({ global: true, constructor: true, forced: FORCED }, {
+      Iterator: IteratorConstructor
+    })
+  }, { '../internals/an-instance': 3, '../internals/an-object': 4, '../internals/create-property': 14, '../internals/define-built-in-accessor': 15, '../internals/descriptors': 18, '../internals/export': 24, '../internals/fails': 25, '../internals/global': 37, '../internals/has-own-property': 38, '../internals/is-callable': 46, '../internals/is-pure': 50, '../internals/iterators-core': 54, '../internals/object-get-prototype-of': 65, '../internals/well-known-symbol': 91 }],
+  94: [function (require, module, exports) {
+    'use strict'
+    var $ = require('../internals/export')
+    var iterate = require('../internals/iterate')
+    var aCallable = require('../internals/a-callable')
+    var anObject = require('../internals/an-object')
+    var getIteratorDirect = require('../internals/get-iterator-direct')
+
+    // `Iterator.prototype.forEach` method
+    // https://github.com/tc39/proposal-iterator-helpers
+    $({ target: 'Iterator', proto: true, real: true }, {
+      forEach: function forEach (fn) {
+        anObject(this)
+        aCallable(fn)
+        var record = getIteratorDirect(this)
+        var counter = 0
+        iterate(record, function (value) {
+          fn(value, counter++)
+        }, { IS_RECORD: true })
+      }
+    })
+  }, { '../internals/a-callable': 1, '../internals/an-object': 4, '../internals/export': 24, '../internals/get-iterator-direct': 33, '../internals/iterate': 52 }],
+  95: [function (require, module, exports) {
+    'use strict'
+    var $ = require('../internals/export')
+    var aWeakMap = require('../internals/a-weak-map')
+    var remove = require('../internals/weak-map-helpers').remove
+
+    // `WeakMap.prototype.deleteAll` method
+    // https://github.com/tc39/proposal-collection-methods
+    $({ target: 'WeakMap', proto: true, real: true, forced: true }, {
+      deleteAll: function deleteAll (/* ...elements */) {
+        var collection = aWeakMap(this)
+        var allDeleted = true
+        var wasDeleted
+        for (var k = 0, len = arguments.length; k < len; k++) {
+          wasDeleted = remove(collection, arguments[k])
+          allDeleted = allDeleted && wasDeleted
+        } return !!allDeleted
+      }
+    })
+  }, { '../internals/a-weak-map': 2, '../internals/export': 24, '../internals/weak-map-helpers': 90 }],
+  96: [function (require, module, exports) {
+    'use strict'
 
     Object.defineProperty(exports, '__esModule', {
       value: true
@@ -55,7 +1932,7 @@
     circularObject.head.children[1].parent = circularObject.head
     var _default = exports.default = circularObject
   }, {}],
-  2: [function (require, module, exports) {
+  97: [function (require, module, exports) {
     'use strict'
 
     Object.defineProperty(exports, '__esModule', {
@@ -74,7 +1951,7 @@
     exports.countMatches = countMatches
     var _default = exports.default = countMatches
   }, {}],
-  3: [function (require, module, exports) {
+  98: [function (require, module, exports) {
     'use strict'
 
     Object.defineProperty(exports, '__esModule', {
@@ -100,7 +1977,7 @@
     }
     var _default = exports.default = deepReferenceObject
   }, {}],
-  4: [function (require, module, exports) {
+  99: [function (require, module, exports) {
     'use strict'
 
     Object.defineProperty(exports, '__esModule', {
@@ -139,7 +2016,7 @@
     }]
     var _default = exports.default = domItem
   }, {}],
-  5: [function (require, module, exports) {
+  100: [function (require, module, exports) {
     'use strict'
 
     Object.defineProperty(exports, '__esModule', {
@@ -165,7 +2042,7 @@
     }
     var _default = exports.default = jsonDom
   }, {}],
-  6: [function (require, module, exports) {
+  101: [function (require, module, exports) {
     'use strict'
 
     Object.defineProperty(exports, '__esModule', {
@@ -194,7 +2071,7 @@
     }
     var _default = exports.default = linkedList
   }, {}],
-  7: [function (require, module, exports) {
+  102: [function (require, module, exports) {
     'use strict'
 
     Object.defineProperty(exports, '__esModule', {
@@ -219,8 +2096,8 @@
     }
     exports.logObject = logObject
     var _default = exports.default = logObject
-  }, { util: 38 }],
-  8: [function (require, module, exports) {
+  }, { util: 140 }],
+  103: [function (require, module, exports) {
     'use strict'
 
     Object.defineProperty(exports, '__esModule', {
@@ -246,7 +2123,7 @@
     }
     var _default = exports.default = multiReferenceObject
   }, {}],
-  9: [function (require, module, exports) {
+  104: [function (require, module, exports) {
     'use strict'
 
     Object.defineProperty(exports, '__esModule', {
@@ -280,7 +2157,7 @@
     }
     var _default = exports.default = nodeTree
   }, {}],
-  10: [function (require, module, exports) {
+  105: [function (require, module, exports) {
     'use strict'
 
     Object.defineProperty(exports, '__esModule', {
@@ -300,8 +2177,8 @@
     }, error => error ? reject(error) : resolve(dirPath))))
     exports.removeDirectory = removeDirectory
     var _default = exports.default = removeDirectory
-  }, { fs: 14 }],
-  11: [function (require, module, exports) {
+  }, { fs: 109 }],
+  106: [function (require, module, exports) {
     'use strict'
 
     Object.defineProperty(exports, '__esModule', {
@@ -389,26 +2266,156 @@
       setDefaults
     }
     var _default = exports.default = setUp
-  }, { './removeDirectory': 10, fs: 14 }],
-  12: [function (require, module, exports) {
+  }, { './removeDirectory': 105, fs: 109 }],
+  107: [function (require, module, exports) {
     'use strict'
 
+    require('core-js/modules/esnext.weak-map.delete-all.js')
+    require('core-js/modules/esnext.async-iterator.for-each.js')
+    require('core-js/modules/esnext.iterator.constructor.js')
+    require('core-js/modules/esnext.iterator.for-each.js')
     Object.defineProperty(exports, '__esModule', {
       value: true
     })
+    var _exportNames = {
+      testFs: true,
+      testFsBrowser: true
+    }
     exports.testFsBrowser = exports.testFs = exports.default = void 0
-    var _circularObject = _interopRequireDefault(require('./functions/circularObject'))
-    var _countMatches = _interopRequireDefault(require('./functions/countMatches'))
-    var _deepReferenceObject = _interopRequireDefault(require('./functions/deepReferenceObject'))
-    var _domItem = _interopRequireDefault(require('./functions/domItem'))
-    var _jsonDom = _interopRequireDefault(require('./functions/jsonDom'))
-    var _linkedList = _interopRequireDefault(require('./functions/linkedList'))
-    var _logObject = _interopRequireDefault(require('./functions/logObject'))
-    var _multiReferenceObject = _interopRequireDefault(require('./functions/multiReferenceObject'))
-    var _nodeTree = _interopRequireDefault(require('./functions/nodeTree'))
-    var _removeDirectory = _interopRequireDefault(require('./functions/removeDirectory'))
-    var _setUp = _interopRequireDefault(require('./functions/setUp'))
-    function _interopRequireDefault (obj) { return obj && obj.__esModule ? obj : { default: obj } }
+    var _circularObject = _interopRequireWildcard(require('./functions/circularObject'))
+    Object.keys(_circularObject).forEach(function (key) {
+      if (key === 'default' || key === '__esModule') return
+      if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return
+      if (key in exports && exports[key] === _circularObject[key]) return
+      Object.defineProperty(exports, key, {
+        enumerable: true,
+        get: function () {
+          return _circularObject[key]
+        }
+      })
+    })
+    var _countMatches = _interopRequireWildcard(require('./functions/countMatches'))
+    Object.keys(_countMatches).forEach(function (key) {
+      if (key === 'default' || key === '__esModule') return
+      if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return
+      if (key in exports && exports[key] === _countMatches[key]) return
+      Object.defineProperty(exports, key, {
+        enumerable: true,
+        get: function () {
+          return _countMatches[key]
+        }
+      })
+    })
+    var _deepReferenceObject = _interopRequireWildcard(require('./functions/deepReferenceObject'))
+    Object.keys(_deepReferenceObject).forEach(function (key) {
+      if (key === 'default' || key === '__esModule') return
+      if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return
+      if (key in exports && exports[key] === _deepReferenceObject[key]) return
+      Object.defineProperty(exports, key, {
+        enumerable: true,
+        get: function () {
+          return _deepReferenceObject[key]
+        }
+      })
+    })
+    var _domItem = _interopRequireWildcard(require('./functions/domItem'))
+    Object.keys(_domItem).forEach(function (key) {
+      if (key === 'default' || key === '__esModule') return
+      if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return
+      if (key in exports && exports[key] === _domItem[key]) return
+      Object.defineProperty(exports, key, {
+        enumerable: true,
+        get: function () {
+          return _domItem[key]
+        }
+      })
+    })
+    var _jsonDom = _interopRequireWildcard(require('./functions/jsonDom'))
+    Object.keys(_jsonDom).forEach(function (key) {
+      if (key === 'default' || key === '__esModule') return
+      if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return
+      if (key in exports && exports[key] === _jsonDom[key]) return
+      Object.defineProperty(exports, key, {
+        enumerable: true,
+        get: function () {
+          return _jsonDom[key]
+        }
+      })
+    })
+    var _linkedList = _interopRequireWildcard(require('./functions/linkedList'))
+    Object.keys(_linkedList).forEach(function (key) {
+      if (key === 'default' || key === '__esModule') return
+      if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return
+      if (key in exports && exports[key] === _linkedList[key]) return
+      Object.defineProperty(exports, key, {
+        enumerable: true,
+        get: function () {
+          return _linkedList[key]
+        }
+      })
+    })
+    var _logObject = _interopRequireWildcard(require('./functions/logObject'))
+    Object.keys(_logObject).forEach(function (key) {
+      if (key === 'default' || key === '__esModule') return
+      if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return
+      if (key in exports && exports[key] === _logObject[key]) return
+      Object.defineProperty(exports, key, {
+        enumerable: true,
+        get: function () {
+          return _logObject[key]
+        }
+      })
+    })
+    var _multiReferenceObject = _interopRequireWildcard(require('./functions/multiReferenceObject'))
+    Object.keys(_multiReferenceObject).forEach(function (key) {
+      if (key === 'default' || key === '__esModule') return
+      if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return
+      if (key in exports && exports[key] === _multiReferenceObject[key]) return
+      Object.defineProperty(exports, key, {
+        enumerable: true,
+        get: function () {
+          return _multiReferenceObject[key]
+        }
+      })
+    })
+    var _nodeTree = _interopRequireWildcard(require('./functions/nodeTree'))
+    Object.keys(_nodeTree).forEach(function (key) {
+      if (key === 'default' || key === '__esModule') return
+      if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return
+      if (key in exports && exports[key] === _nodeTree[key]) return
+      Object.defineProperty(exports, key, {
+        enumerable: true,
+        get: function () {
+          return _nodeTree[key]
+        }
+      })
+    })
+    var _removeDirectory = _interopRequireWildcard(require('./functions/removeDirectory'))
+    Object.keys(_removeDirectory).forEach(function (key) {
+      if (key === 'default' || key === '__esModule') return
+      if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return
+      if (key in exports && exports[key] === _removeDirectory[key]) return
+      Object.defineProperty(exports, key, {
+        enumerable: true,
+        get: function () {
+          return _removeDirectory[key]
+        }
+      })
+    })
+    var _setUp = _interopRequireWildcard(require('./functions/setUp'))
+    Object.keys(_setUp).forEach(function (key) {
+      if (key === 'default' || key === '__esModule') return
+      if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return
+      if (key in exports && exports[key] === _setUp[key]) return
+      Object.defineProperty(exports, key, {
+        enumerable: true,
+        get: function () {
+          return _setUp[key]
+        }
+      })
+    })
+    function _getRequireWildcardCache (e) { if (typeof WeakMap !== 'function') return null; var r = new WeakMap(); var t = new WeakMap(); return (_getRequireWildcardCache = function (e) { return e ? t : r })(e) }
+    function _interopRequireWildcard (e, r) { if (!r && e && e.__esModule) return e; if (e === null || typeof e !== 'object' && typeof e !== 'function') return { default: e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }; var a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if (u !== 'default' && Object.prototype.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u] } return n.default = e, t && t.set(e, n), n }
     /**
  * An assortment of objects that can be used in tests and some functions to help debug and write tests.
  * @file
@@ -449,13 +2456,13 @@
       // @ts-ignore
       window.testFs = testFsBrowser
     }
-  }, { './functions/circularObject': 1, './functions/countMatches': 2, './functions/deepReferenceObject': 3, './functions/domItem': 4, './functions/jsonDom': 5, './functions/linkedList': 6, './functions/logObject': 7, './functions/multiReferenceObject': 8, './functions/nodeTree': 9, './functions/removeDirectory': 10, './functions/setUp': 11 }],
-  13: [function (require, module, exports) {
+  }, { './functions/circularObject': 96, './functions/countMatches': 97, './functions/deepReferenceObject': 98, './functions/domItem': 99, './functions/jsonDom': 100, './functions/linkedList': 101, './functions/logObject': 102, './functions/multiReferenceObject': 103, './functions/nodeTree': 104, './functions/removeDirectory': 105, './functions/setUp': 106, 'core-js/modules/esnext.async-iterator.for-each.js': 92, 'core-js/modules/esnext.iterator.constructor.js': 93, 'core-js/modules/esnext.iterator.for-each.js': 94, 'core-js/modules/esnext.weak-map.delete-all.js': 95 }],
+  108: [function (require, module, exports) {
     (function (global) {
       (function () {
         'use strict'
 
-        var possibleNames = [
+        var /** @type {ReturnType<import('.')>} */ possibleNames = [
           'BigInt64Array',
           'BigUint64Array',
           'Float32Array',
@@ -471,10 +2478,12 @@
 
         var g = typeof globalThis === 'undefined' ? global : globalThis
 
+        /** @type {import('.')} */
         module.exports = function availableTypedArrays () {
-          var out = []
+          var /** @type {ReturnType<typeof availableTypedArrays>} */ out = []
           for (var i = 0; i < possibleNames.length; i++) {
             if (typeof g[possibleNames[i]] === 'function') {
+              // @ts-expect-error
               out[out.length] = possibleNames[i]
             }
           }
@@ -483,10 +2492,10 @@
       }).call(this)
     }).call(this, typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : typeof window !== 'undefined' ? window : {})
   }, {}],
-  14: [function (require, module, exports) {
+  109: [function (require, module, exports) {
 
   }, {}],
-  15: [function (require, module, exports) {
+  110: [function (require, module, exports) {
     'use strict'
 
     var GetIntrinsic = require('get-intrinsic')
@@ -502,15 +2511,15 @@
       }
       return intrinsic
     }
-  }, { './': 16, 'get-intrinsic': 21 }],
-  16: [function (require, module, exports) {
+  }, { './': 111, 'get-intrinsic': 123 }],
+  111: [function (require, module, exports) {
     'use strict'
 
     var bind = require('function-bind')
     var GetIntrinsic = require('get-intrinsic')
     var setFunctionLength = require('set-function-length')
 
-    var $TypeError = GetIntrinsic('%TypeError%')
+    var $TypeError = require('es-errors/type')
     var $apply = GetIntrinsic('%Function.prototype.apply%')
     var $call = GetIntrinsic('%Function.prototype.call%')
     var $reflectApply = GetIntrinsic('%Reflect.apply%', true) || bind.call($call, $apply)
@@ -548,8 +2557,8 @@
     } else {
       module.exports.apply = applyBind
     }
-  }, { 'function-bind': 20, 'get-intrinsic': 21, 'set-function-length': 35 }],
-  17: [function (require, module, exports) {
+  }, { 'es-errors/type': 118, 'function-bind': 122, 'get-intrinsic': 123, 'set-function-length': 137 }],
+  112: [function (require, module, exports) {
     'use strict'
 
     var hasPropertyDescriptors = require('has-property-descriptors')()
@@ -566,8 +2575,8 @@
       }
     }
 
-    var $SyntaxError = GetIntrinsic('%SyntaxError%')
-    var $TypeError = GetIntrinsic('%TypeError%')
+    var $SyntaxError = require('es-errors/syntax')
+    var $TypeError = require('es-errors/type')
 
     var gopd = require('gopd')
 
@@ -618,8 +2627,50 @@
         throw new $SyntaxError('This environment does not support defining a property as non-configurable, non-writable, or non-enumerable.')
       }
     }
-  }, { 'get-intrinsic': 21, gopd: 22, 'has-property-descriptors': 23 }],
-  18: [function (require, module, exports) {
+  }, { 'es-errors/syntax': 117, 'es-errors/type': 118, 'get-intrinsic': 123, gopd: 124, 'has-property-descriptors': 125 }],
+  113: [function (require, module, exports) {
+    'use strict'
+
+    /** @type {import('./eval')} */
+    module.exports = EvalError
+  }, {}],
+  114: [function (require, module, exports) {
+    'use strict'
+
+    /** @type {import('.')} */
+    module.exports = Error
+  }, {}],
+  115: [function (require, module, exports) {
+    'use strict'
+
+    /** @type {import('./range')} */
+    module.exports = RangeError
+  }, {}],
+  116: [function (require, module, exports) {
+    'use strict'
+
+    /** @type {import('./ref')} */
+    module.exports = ReferenceError
+  }, {}],
+  117: [function (require, module, exports) {
+    'use strict'
+
+    /** @type {import('./syntax')} */
+    module.exports = SyntaxError
+  }, {}],
+  118: [function (require, module, exports) {
+    'use strict'
+
+    /** @type {import('./type')} */
+    module.exports = TypeError
+  }, {}],
+  119: [function (require, module, exports) {
+    'use strict'
+
+    /** @type {import('./uri')} */
+    module.exports = URIError
+  }, {}],
+  120: [function (require, module, exports) {
     'use strict'
 
     var isCallable = require('is-callable')
@@ -682,8 +2733,8 @@
     }
 
     module.exports = forEach
-  }, { 'is-callable': 31 }],
-  19: [function (require, module, exports) {
+  }, { 'is-callable': 133 }],
+  121: [function (require, module, exports) {
     'use strict'
 
     /* eslint no-invalid-this: 1 */
@@ -768,21 +2819,27 @@
       return bound
     }
   }, {}],
-  20: [function (require, module, exports) {
+  122: [function (require, module, exports) {
     'use strict'
 
     var implementation = require('./implementation')
 
     module.exports = Function.prototype.bind || implementation
-  }, { './implementation': 19 }],
-  21: [function (require, module, exports) {
+  }, { './implementation': 121 }],
+  123: [function (require, module, exports) {
     'use strict'
 
     var undefined
 
-    var $SyntaxError = SyntaxError
+    var $Error = require('es-errors')
+    var $EvalError = require('es-errors/eval')
+    var $RangeError = require('es-errors/range')
+    var $ReferenceError = require('es-errors/ref')
+    var $SyntaxError = require('es-errors/syntax')
+    var $TypeError = require('es-errors/type')
+    var $URIError = require('es-errors/uri')
+
     var $Function = Function
-    var $TypeError = TypeError
 
     // eslint-disable-next-line consistent-return
     var getEvalledConstructor = function (expressionSyntax) {
@@ -834,6 +2891,7 @@
     var TypedArray = typeof Uint8Array === 'undefined' || !getProto ? undefined : getProto(Uint8Array)
 
     var INTRINSICS = {
+      __proto__: null,
       '%AggregateError%': typeof AggregateError === 'undefined' ? undefined : AggregateError,
       '%Array%': Array,
       '%ArrayBuffer%': typeof ArrayBuffer === 'undefined' ? undefined : ArrayBuffer,
@@ -854,9 +2912,9 @@
       '%decodeURIComponent%': decodeURIComponent,
       '%encodeURI%': encodeURI,
       '%encodeURIComponent%': encodeURIComponent,
-      '%Error%': Error,
+      '%Error%': $Error,
       '%eval%': eval, // eslint-disable-line no-eval
-      '%EvalError%': EvalError,
+      '%EvalError%': $EvalError,
       '%Float32Array%': typeof Float32Array === 'undefined' ? undefined : Float32Array,
       '%Float64Array%': typeof Float64Array === 'undefined' ? undefined : Float64Array,
       '%FinalizationRegistry%': typeof FinalizationRegistry === 'undefined' ? undefined : FinalizationRegistry,
@@ -878,8 +2936,8 @@
       '%parseInt%': parseInt,
       '%Promise%': typeof Promise === 'undefined' ? undefined : Promise,
       '%Proxy%': typeof Proxy === 'undefined' ? undefined : Proxy,
-      '%RangeError%': RangeError,
-      '%ReferenceError%': ReferenceError,
+      '%RangeError%': $RangeError,
+      '%ReferenceError%': $ReferenceError,
       '%Reflect%': typeof Reflect === 'undefined' ? undefined : Reflect,
       '%RegExp%': RegExp,
       '%Set%': typeof Set === 'undefined' ? undefined : Set,
@@ -896,7 +2954,7 @@
       '%Uint8ClampedArray%': typeof Uint8ClampedArray === 'undefined' ? undefined : Uint8ClampedArray,
       '%Uint16Array%': typeof Uint16Array === 'undefined' ? undefined : Uint16Array,
       '%Uint32Array%': typeof Uint32Array === 'undefined' ? undefined : Uint32Array,
-      '%URIError%': URIError,
+      '%URIError%': $URIError,
       '%WeakMap%': typeof WeakMap === 'undefined' ? undefined : WeakMap,
       '%WeakRef%': typeof WeakRef === 'undefined' ? undefined : WeakRef,
       '%WeakSet%': typeof WeakSet === 'undefined' ? undefined : WeakSet
@@ -938,6 +2996,7 @@
     }
 
     var LEGACY_ALIASES = {
+      __proto__: null,
       '%ArrayBufferPrototype%': ['ArrayBuffer', 'prototype'],
       '%ArrayPrototype%': ['Array', 'prototype'],
       '%ArrayProto_entries%': ['Array', 'prototype', 'entries'],
@@ -1127,8 +3186,8 @@
       }
       return value
     }
-  }, { 'function-bind': 20, 'has-proto': 24, 'has-symbols': 25, hasown: 28 }],
-  22: [function (require, module, exports) {
+  }, { 'es-errors': 114, 'es-errors/eval': 113, 'es-errors/range': 115, 'es-errors/ref': 116, 'es-errors/syntax': 117, 'es-errors/type': 118, 'es-errors/uri': 119, 'function-bind': 122, 'has-proto': 126, 'has-symbols': 127, hasown: 130 }],
+  124: [function (require, module, exports) {
     'use strict'
 
     var GetIntrinsic = require('get-intrinsic')
@@ -1145,8 +3204,8 @@
     }
 
     module.exports = $gOPD
-  }, { 'get-intrinsic': 21 }],
-  23: [function (require, module, exports) {
+  }, { 'get-intrinsic': 123 }],
+  125: [function (require, module, exports) {
     'use strict'
 
     var GetIntrinsic = require('get-intrinsic')
@@ -1180,8 +3239,8 @@
     }
 
     module.exports = hasPropertyDescriptors
-  }, { 'get-intrinsic': 21 }],
-  24: [function (require, module, exports) {
+  }, { 'get-intrinsic': 123 }],
+  126: [function (require, module, exports) {
     'use strict'
 
     var test = {
@@ -1194,7 +3253,7 @@
       return { __proto__: test }.foo === test.foo && !({ __proto__: null } instanceof $Object)
     }
   }, {}],
-  25: [function (require, module, exports) {
+  127: [function (require, module, exports) {
     'use strict'
 
     var origSymbol = typeof Symbol !== 'undefined' && Symbol
@@ -1208,8 +3267,8 @@
 
       return hasSymbolSham()
     }
-  }, { './shams': 26 }],
-  26: [function (require, module, exports) {
+  }, { './shams': 128 }],
+  128: [function (require, module, exports) {
     'use strict'
 
     /* eslint complexity: [2, 18], max-statements: [2, 33] */
@@ -1253,16 +3312,17 @@
       return true
     }
   }, {}],
-  27: [function (require, module, exports) {
+  129: [function (require, module, exports) {
     'use strict'
 
     var hasSymbols = require('has-symbols/shams')
 
+    /** @type {import('.')} */
     module.exports = function hasToStringTagShams () {
       return hasSymbols() && !!Symbol.toStringTag
     }
-  }, { 'has-symbols/shams': 26 }],
-  28: [function (require, module, exports) {
+  }, { 'has-symbols/shams': 128 }],
+  130: [function (require, module, exports) {
     'use strict'
 
     var call = Function.prototype.call
@@ -1271,8 +3331,8 @@
 
     /** @type {(o: {}, p: PropertyKey) => p is keyof o} */
     module.exports = bind.call(call, $hasOwn)
-  }, { 'function-bind': 20 }],
-  29: [function (require, module, exports) {
+  }, { 'function-bind': 122 }],
+  131: [function (require, module, exports) {
     if (typeof Object.create === 'function') {
       // implementation from standard node.js 'util' module
       module.exports = function inherits (ctor, superCtor) {
@@ -1301,7 +3361,7 @@
       }
     }
   }, {}],
-  30: [function (require, module, exports) {
+  132: [function (require, module, exports) {
     'use strict'
 
     var hasToStringTag = require('has-tostringtag/shams')()
@@ -1335,8 +3395,8 @@
     isStandardArguments.isLegacyArguments = isLegacyArguments // for tests
 
     module.exports = supportsStandardArguments ? isStandardArguments : isLegacyArguments
-  }, { 'call-bind/callBound': 15, 'has-tostringtag/shams': 27 }],
-  31: [function (require, module, exports) {
+  }, { 'call-bind/callBound': 110, 'has-tostringtag/shams': 129 }],
+  133: [function (require, module, exports) {
     'use strict'
 
     var fnToStr = Function.prototype.toString
@@ -1439,7 +3499,7 @@
         return tryFunctionObject(value)
       }
   }, {}],
-  32: [function (require, module, exports) {
+  134: [function (require, module, exports) {
     'use strict'
 
     var toStr = Object.prototype.toString
@@ -1478,17 +3538,18 @@
       }
       return getProto(fn) === GeneratorFunction
     }
-  }, { 'has-tostringtag/shams': 27 }],
-  33: [function (require, module, exports) {
+  }, { 'has-tostringtag/shams': 129 }],
+  135: [function (require, module, exports) {
     'use strict'
 
     var whichTypedArray = require('which-typed-array')
 
+    /** @type {import('.')} */
     module.exports = function isTypedArray (value) {
       return !!whichTypedArray(value)
     }
-  }, { 'which-typed-array': 39 }],
-  34: [function (require, module, exports) {
+  }, { 'which-typed-array': 141 }],
+  136: [function (require, module, exports) {
     // shim for using process in browser
     var process = module.exports = {}
 
@@ -1669,7 +3730,7 @@
     }
     process.umask = function () { return 0 }
   }, {}],
-  35: [function (require, module, exports) {
+  137: [function (require, module, exports) {
     'use strict'
 
     var GetIntrinsic = require('get-intrinsic')
@@ -1677,9 +3738,12 @@
     var hasDescriptors = require('has-property-descriptors')()
     var gOPD = require('gopd')
 
-    var $TypeError = GetIntrinsic('%TypeError%')
+    var $TypeError = require('es-errors/type')
     var $floor = GetIntrinsic('%Math.floor%')
 
+    /** @typedef {(...args: unknown[]) => unknown} Func */
+
+    /** @type {<T extends Func = Func>(fn: T, length: number, loose?: boolean) => T} */
     module.exports = function setFunctionLength (fn, length) {
       if (typeof fn !== 'function') {
         throw new $TypeError('`fn` is not a function')
@@ -1704,15 +3768,15 @@
 
       if (functionLengthIsConfigurable || functionLengthIsWritable || !loose) {
         if (hasDescriptors) {
-          define(fn, 'length', length, true, true)
+          define(/** @type {Parameters<define>[0]} */ (fn), 'length', length, true, true)
         } else {
-          define(fn, 'length', length)
+          define(/** @type {Parameters<define>[0]} */ (fn), 'length', length)
         }
       }
       return fn
     }
-  }, { 'define-data-property': 17, 'get-intrinsic': 21, gopd: 22, 'has-property-descriptors': 23 }],
-  36: [function (require, module, exports) {
+  }, { 'define-data-property': 112, 'es-errors/type': 118, 'get-intrinsic': 123, gopd: 124, 'has-property-descriptors': 125 }],
+  138: [function (require, module, exports) {
     module.exports = function isBuffer (arg) {
       return arg && typeof arg === 'object' &&
     typeof arg.copy === 'function' &&
@@ -1720,7 +3784,7 @@
     typeof arg.readUInt8 === 'function'
     }
   }, {}],
-  37: [function (require, module, exports) {
+  139: [function (require, module, exports) {
     // Currently in sync with Node.js lib/internal/util/types.js
     // https://github.com/nodejs/node/commit/112cc7c27551254aa2b17098fb774867f05ed0d9
 
@@ -2054,8 +4118,8 @@
         }
       })
     })
-  }, { 'is-arguments': 30, 'is-generator-function': 32, 'is-typed-array': 33, 'which-typed-array': 39 }],
-  38: [function (require, module, exports) {
+  }, { 'is-arguments': 132, 'is-generator-function': 134, 'is-typed-array': 135, 'which-typed-array': 141 }],
+  140: [function (require, module, exports) {
     (function (process) {
       (function () {
         // Copyright Joyent, Inc. and other Node contributors.
@@ -2754,8 +4818,8 @@
         exports.callbackify = callbackify
       }).call(this)
     }).call(this, require('_process'))
-  }, { './support/isBuffer': 36, './support/types': 37, _process: 34, inherits: 29 }],
-  39: [function (require, module, exports) {
+  }, { './support/isBuffer': 138, './support/types': 139, _process: 136, inherits: 131 }],
+  141: [function (require, module, exports) {
     (function (global) {
       (function () {
         'use strict'
@@ -2775,7 +4839,7 @@
         var $slice = callBound('String.prototype.slice')
         var getPrototypeOf = Object.getPrototypeOf // require('getprototypeof');
 
-        var $indexOf = callBound('Array.prototype.indexOf', true) || function indexOf (array, value) {
+        var $indexOf = callBound('Array.prototype.indexOf', true) || /** @type {(array: readonly unknown[], value: unknown) => keyof array} */ function indexOf (array, value) {
           for (var i = 0; i < array.length; i += 1) {
             if (array[i] === value) {
               return i
@@ -2783,17 +4847,24 @@
           }
           return -1
         }
+
+        /** @typedef {Int8Array | Uint8Array | Uint8ClampedArray | Int16Array | Uint16Array | Int32Array | Uint32Array | Float32Array | Float64Array | BigInt64Array | BigUint64Array} TypedArray */
+        /** @typedef {'Int8Array' | 'Uint8Array' | 'Uint8ClampedArray' | 'Int16Array' | 'Uint16Array' | 'Int32Array' | 'Uint32Array' | 'Float32Array' | 'Float64Array' | 'BigInt64Array' | 'BigUint64Array'} TypedArrayName */
+        /** @type {{ [k in `\$${TypedArrayName}`]?: (receiver: TypedArray) => string | typeof Uint8Array.prototype.slice.call | typeof Uint8Array.prototype.set.call } & { __proto__: null }} */
         var cache = { __proto__: null }
         if (hasToStringTag && gOPD && getPrototypeOf) {
           forEach(typedArrays, function (typedArray) {
             var arr = new g[typedArray]()
             if (Symbol.toStringTag in arr) {
               var proto = getPrototypeOf(arr)
+              // @ts-expect-error TS won't narrow inside a closure
               var descriptor = gOPD(proto, Symbol.toStringTag)
               if (!descriptor) {
                 var superProto = getPrototypeOf(proto)
+                // @ts-expect-error TS won't narrow inside a closure
                 descriptor = gOPD(superProto, Symbol.toStringTag)
               }
+              // @ts-expect-error TODO: fix
               cache['$' + typedArray] = callBind(descriptor.get)
             }
           })
@@ -2802,38 +4873,52 @@
             var arr = new g[typedArray]()
             var fn = arr.slice || arr.set
             if (fn) {
+              // @ts-expect-error TODO: fix
               cache['$' + typedArray] = callBind(fn)
             }
           })
         }
 
+        /** @type {import('.')} */
         var tryTypedArrays = function tryAllTypedArrays (value) {
-          var found = false
-          forEach(cache, function (getter, typedArray) {
-            if (!found) {
-              try {
-                if ('$' + getter(value) === typedArray) {
-                  found = $slice(typedArray, 1)
-                }
-              } catch (e) { /**/ }
+          /** @type {ReturnType<tryAllTypedArrays>} */ var found = false
+          forEach(
+            // eslint-disable-next-line no-extra-parens
+            /** @type {Record<`\$${TypedArrayName}`, typeof cache>} */ /** @type {any} */ (cache),
+            /** @type {(getter: typeof cache, name: `\$${TypedArrayName}`) => void} */ function (getter, typedArray) {
+              if (!found) {
+                try {
+                  // @ts-expect-error TODO: fix
+                  if ('$' + getter(value) === typedArray) {
+                    found = $slice(typedArray, 1)
+                  }
+                } catch (e) { /**/ }
+              }
             }
-          })
+          )
           return found
         }
 
+        /** @type {import('.')} */
         var trySlices = function tryAllSlices (value) {
-          var found = false
-          forEach(cache, function (getter, name) {
-            if (!found) {
-              try {
-                getter(value)
-                found = $slice(name, 1)
-              } catch (e) { /**/ }
+          /** @type {ReturnType<tryAllSlices>} */ var found = false
+          forEach(
+            // eslint-disable-next-line no-extra-parens
+            /** @type {any} */ (cache),
+            /** @type {(getter: typeof cache, name: `\$${TypedArrayName}`) => void} */ function (getter, name) {
+              if (!found) {
+                try {
+                  // @ts-expect-error TODO: fix
+                  getter(value)
+                  found = $slice(name, 1)
+                } catch (e) { /**/ }
+              }
             }
-          })
+          )
           return found
         }
 
+        /** @type {import('.')} */
         module.exports = function whichTypedArray (value) {
           if (!value || typeof value !== 'object') { return false }
           if (!hasToStringTag) {
@@ -2852,5 +4937,5 @@
         }
       }).call(this)
     }).call(this, typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : typeof window !== 'undefined' ? window : {})
-  }, { 'available-typed-arrays': 13, 'call-bind': 16, 'call-bind/callBound': 15, 'for-each': 18, gopd: 22, 'has-tostringtag/shams': 27 }]
-}, {}, [12])
+  }, { 'available-typed-arrays': 108, 'call-bind': 111, 'call-bind/callBound': 110, 'for-each': 120, gopd: 124, 'has-tostringtag/shams': 129 }]
+}, {}, [107])