test-filesystem 1.0.0

package/browser/test-fs.js

@@ -0,0 +1,2856 @@
+(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'
+
+    Object.defineProperty(exports, '__esModule', {
+      value: true
+    })
+    exports.default = exports.circularObject = void 0
+    /**
+ * Multilayered node tree-like structure with parent references
+ * @memberOf module:test-fs
+ * @type {Object.<string, string|Object|Array>}
+ */
+    const circularObject = exports.circularObject = {
+      name: 'root',
+      parent: null,
+      body: null,
+      head: null,
+      children: []
+    }
+    circularObject.children = [{
+      name: 'body',
+      parent: null,
+      children: []
+    }, {
+      name: 'head',
+      parent: null,
+      children: []
+    }]
+    circularObject.body = circularObject.children[0]
+    circularObject.head = circularObject.children[1]
+    circularObject.body.parent = circularObject
+    circularObject.head.parent = circularObject
+    circularObject.body.children = [{
+      name: 'body child one',
+      parent: null,
+      children: []
+    }, {
+      name: 'body child two',
+      parent: null,
+      children: []
+    }]
+    circularObject.body.children[0].parent = circularObject.body
+    circularObject.body.children[1].parent = circularObject.body
+    circularObject.head.children = [{
+      name: 'head child one',
+      parent: null,
+      children: []
+    }, {
+      name: 'head child two',
+      parent: null,
+      children: []
+    }]
+    circularObject.head.children[0].parent = circularObject.head
+    circularObject.head.children[1].parent = circularObject.head
+    var _default = exports.default = circularObject
+  }, {}],
+  2: [function (require, module, exports) {
+    'use strict'
+
+    Object.defineProperty(exports, '__esModule', {
+      value: true
+    })
+    exports.default = exports.countMatches = void 0
+    /**
+ * Simple way to count string occurrences for testing.
+ * @function
+ * @memberOf module:test-fs
+ * @param {string} content
+ * @param {string} search
+ * @returns {number}
+ */
+    const countMatches = (content, search) => content.split(search).length - 1
+    exports.countMatches = countMatches
+    var _default = exports.default = countMatches
+  }, {}],
+  3: [function (require, module, exports) {
+    'use strict'
+
+    Object.defineProperty(exports, '__esModule', {
+      value: true
+    })
+    exports.default = exports.deepReferenceObject = void 0
+    /**
+ * Sample object with deep references.
+ * @memberOf module:test-fs
+ * @type {Object.<string, string|number|Object>}
+ */
+    const deepReferenceObject = exports.deepReferenceObject = {
+      object1: {
+        name: 'someName',
+        object2: {
+          age: 12,
+          array1: ['someString', 'anotherString']
+        },
+        array2: [89, 32]
+      },
+      title: 'Some Title',
+      item: 45
+    }
+    var _default = exports.default = deepReferenceObject
+  }, {}],
+  4: [function (require, module, exports) {
+    'use strict'
+
+    Object.defineProperty(exports, '__esModule', {
+      value: true
+    })
+    exports.domItem = exports.default = void 0
+    /**
+ * Sample of domItem child with nested child and optional details
+ * @memberOf module:test-fs
+ * @type {Object.<string, string|number|Array|Object>}
+ */
+    const domItem = exports.domItem = [{
+      attributes: {
+        className: 'row',
+        style: {}
+      },
+      axis: 'y',
+      children: [{
+        attributes: {
+          style: {}
+        },
+        axis: 'x',
+        children: [],
+        element: {},
+        eventListeners: {},
+        hasShip: false,
+        isHit: false,
+        parentItem: {},
+        point: {},
+        tagName: 'div'
+      }],
+      element: null,
+      eventListeners: {},
+      parentItem: {},
+      tagName: 'div'
+    }]
+    var _default = exports.default = domItem
+  }, {}],
+  5: [function (require, module, exports) {
+    'use strict'
+
+    Object.defineProperty(exports, '__esModule', {
+      value: true
+    })
+    exports.jsonDom = exports.default = void 0
+    /**
+ * Sample of jsonDom object containing an empty nested array and objects
+ * @memberOf module:test-fs
+ * @type {Object.<string, string|number|Array|Object>}
+ */
+    const jsonDom = exports.jsonDom = {
+      tagName: 'div',
+      attributes: {
+        style: {},
+        className: 'column'
+      },
+      element: null,
+      eventListeners: {},
+      parentItem: {},
+      children: [],
+      axis: 'x'
+    }
+    var _default = exports.default = jsonDom
+  }, {}],
+  6: [function (require, module, exports) {
+    'use strict'
+
+    Object.defineProperty(exports, '__esModule', {
+      value: true
+    })
+    exports.linkedList = exports.default = void 0
+    /**
+ * Sample LinkedList for testing circular references.
+ * @memberOf module:test-fs
+ * @type {Object.<string, string|Object>}
+ */
+    const linkedList = exports.linkedList = {
+      name: 'one',
+      prev: null,
+      next: null
+    }
+    linkedList.next = {
+      name: 'two',
+      prev: linkedList,
+      next: null
+    }
+    linkedList.next.next = {
+      name: 'three',
+      prev: linkedList.next,
+      next: null
+    }
+    var _default = exports.default = linkedList
+  }, {}],
+  7: [function (require, module, exports) {
+    'use strict'
+
+    Object.defineProperty(exports, '__esModule', {
+      value: true
+    })
+    exports.logObject = exports.default = void 0
+    /**
+ * Log out an object in a nicely formatted way.
+ * @function
+ * @memberOf module:test-fs
+ * @param {Object} object
+ * @param {string} [label=logging]
+ * @param {string} [outputType=log]
+ * @returns {string|undefined}
+ */
+    const logObject = (object, label = 'logging', outputType = 'log') => {
+      const logger = outputType === 'string' ? (label, object) => `'${label}' | ` + JSON.stringify(object) : console[outputType]
+      if (typeof require === 'undefined' || outputType === 'string') {
+        return logger(label, object)
+      }
+      return logger(label, require('util').inspect(object, false, null, true))
+    }
+    exports.logObject = logObject
+    var _default = exports.default = logObject
+  }, { util: 38 }],
+  8: [function (require, module, exports) {
+    'use strict'
+
+    Object.defineProperty(exports, '__esModule', {
+      value: true
+    })
+    exports.multiReferenceObject = exports.default = void 0
+    /**
+ * Sample of an object containing multiple references.
+ * @memberOf module:test-fs
+ * @type {Object.<string, string|number|Object>}
+ */
+    const multiReferenceObject = exports.multiReferenceObject = {
+      object1: {
+        name: 'someName'
+      },
+      object2: {
+        age: 12
+      },
+      array1: ['someString', 'anotherString'],
+      array2: [89, 32],
+      title: 'Some Title',
+      item: 45
+    }
+    var _default = exports.default = multiReferenceObject
+  }, {}],
+  9: [function (require, module, exports) {
+    'use strict'
+
+    Object.defineProperty(exports, '__esModule', {
+      value: true
+    })
+    exports.nodeTree = exports.default = void 0
+    /**
+ * Sample NodeTree for testing circular references and arrays.
+ * @memberOf module:test-fs
+ * @type {Object.<string, string|Object|Array>}
+ */
+    const nodeTree = exports.nodeTree = {
+      name: 'one',
+      parent: null,
+      children: []
+    }
+    nodeTree.children[0] = {
+      name: 'child one',
+      parent: nodeTree,
+      children: []
+    }
+    nodeTree.children[1] = {
+      name: 'child two',
+      parent: nodeTree,
+      children: []
+    }
+    nodeTree.children[0].children[0] = {
+      name: 'grandchild one',
+      parent: nodeTree.children[0],
+      children: []
+    }
+    var _default = exports.default = nodeTree
+  }, {}],
+  10: [function (require, module, exports) {
+    'use strict'
+
+    Object.defineProperty(exports, '__esModule', {
+      value: true
+    })
+    exports.removeDirectory = exports.default = void 0
+    var _fs = require('fs')
+    /**
+ * Return a promise to be completed once the specified directory is deleted.
+ * @function
+ * @memberOf module:test-fs
+ * @param {string} dirPath
+ * @returns {Promise<*>}
+ */
+    const removeDirectory = dirPath => new Promise((resolve, reject) => (0, _fs.access)(dirPath, _fs.constants.F_OK, removed => removed ? resolve(dirPath) : (0, _fs.rm)(dirPath, {
+      recursive: true
+    }, error => error ? reject(error) : resolve(dirPath))))
+    exports.removeDirectory = removeDirectory
+    var _default = exports.default = removeDirectory
+  }, { fs: 14 }],
+  11: [function (require, module, exports) {
+    'use strict'
+
+    Object.defineProperty(exports, '__esModule', {
+      value: true
+    })
+    exports.setUp = exports.setDefaults = exports.default = exports.createTempDir = exports.beforeEach = exports.afterEach = void 0
+    var _fs = require('fs')
+    var _removeDirectory = _interopRequireDefault(require('./removeDirectory'))
+    function _interopRequireDefault (obj) { return obj && obj.__esModule ? obj : { default: obj } }
+    var __awaiter = void 0 && (void 0).__awaiter || function (thisArg, _arguments, P, generator) {
+      function adopt (value) {
+        return value instanceof P ? value : new P(function (resolve) {
+          resolve(value)
+        })
+      }
+      return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled (value) {
+          try {
+            step(generator.next(value))
+          } catch (e) {
+            reject(e)
+          }
+        }
+        function rejected (value) {
+          try {
+            step(generator.throw(value))
+          } catch (e) {
+            reject(e)
+          }
+        }
+        function step (result) {
+          result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected)
+        }
+        step((generator = generator.apply(thisArg, _arguments || [])).next())
+      })
+    }
+
+    // Import the configurations and override some of them to direct to the temp directory.
+
+    let tempDir = 'test-temp/'
+    let srcPath = `${tempDir}src`
+    /**
+ * In the Jest.afterEach function call this one to clean up and remove the temp directory.
+ * @function
+ * @memberOf module:test-fs
+ * @returns {Promise<*>}
+ */
+    const afterEach = () => (0, _removeDirectory.default)(tempDir)
+    /**
+ * Ensure that the del has completed, recursively attempt to delete and recreate
+ * @function
+ * @memberOf module:test-fs
+ * @param {boolean} [exists=true]
+ * @returns {Promise<*|void>}
+ */
+    exports.afterEach = afterEach
+    const createTempDir = (exists = true) => __awaiter(void 0, void 0, void 0, function * () {
+      if (exists) {
+        return (0, _removeDirectory.default)(tempDir).then(removedDir => createTempDir((0, _fs.existsSync)(removedDir))).catch(error => console.error('Error: ', error))
+      }
+      return (0, _fs.mkdirSync)(srcPath, {
+        recursive: true
+      })
+    })
+    /**
+ * In the Jest.beforeEach function call this one to set up the temp directory.
+ * @function
+ * @memberOf module:test-fs
+ * @returns {Promise<*|void>}
+ */
+    exports.createTempDir = createTempDir
+    const beforeEach = () => createTempDir()
+    exports.beforeEach = beforeEach
+    const setDefaults = (dirPath = null) => {
+      if (dirPath) {
+        tempDir = dirPath
+        srcPath = `${tempDir}src`
+      }
+    }
+    exports.setDefaults = setDefaults
+    const setUp = exports.setUp = {
+      afterEach,
+      beforeEach,
+      createTempDir,
+      setDefaults
+    }
+    var _default = exports.default = setUp
+  }, { './removeDirectory': 10, fs: 14 }],
+  12: [function (require, module, exports) {
+    'use strict'
+
+    Object.defineProperty(exports, '__esModule', {
+      value: 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 } }
+    /**
+ * An assortment of objects that can be used in tests and some functions to help debug and write tests.
+ * @file
+ * @author Joshua Heagle <joshuaheagle@gmail.com>
+ * @version 1.0.0
+ * @module test-fs
+ */
+
+    const testFs = exports.testFs = {
+      circularObject: _circularObject.default,
+      countMatches: _countMatches.default,
+      deepReferenceObject: _deepReferenceObject.default,
+      domItem: _domItem.default,
+      jsonDom: _jsonDom.default,
+      linkedList: _linkedList.default,
+      logObject: _logObject.default,
+      multiReferenceObject: _multiReferenceObject.default,
+      nodeTree: _nodeTree.default,
+      removeDirectory: _removeDirectory.default,
+      setUp: _setUp.default
+    }
+    var _default = exports.default = testFs
+    const testFsBrowser = exports.testFsBrowser = {
+      circularObject: _circularObject.default,
+      countMatches: _countMatches.default,
+      deepReferenceObject: _deepReferenceObject.default,
+      domItem: _domItem.default,
+      jsonDom: _jsonDom.default,
+      linkedList: _linkedList.default,
+      logObject: _logObject.default,
+      multiReferenceObject: _multiReferenceObject.default,
+      nodeTree: _nodeTree.default
+    }
+    if (void 0) {
+      // @ts-ignore
+      (void 0).testFs = testFsBrowser
+    } else if (typeof window !== 'undefined') {
+      // @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) {
+    (function (global) {
+      (function () {
+        'use strict'
+
+        var possibleNames = [
+          'BigInt64Array',
+          'BigUint64Array',
+          'Float32Array',
+          'Float64Array',
+          'Int16Array',
+          'Int32Array',
+          'Int8Array',
+          'Uint16Array',
+          'Uint32Array',
+          'Uint8Array',
+          'Uint8ClampedArray'
+        ]
+
+        var g = typeof globalThis === 'undefined' ? global : globalThis
+
+        module.exports = function availableTypedArrays () {
+          var out = []
+          for (var i = 0; i < possibleNames.length; i++) {
+            if (typeof g[possibleNames[i]] === 'function') {
+              out[out.length] = possibleNames[i]
+            }
+          }
+          return out
+        }
+      }).call(this)
+    }).call(this, typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : typeof window !== 'undefined' ? window : {})
+  }, {}],
+  14: [function (require, module, exports) {
+
+  }, {}],
+  15: [function (require, module, exports) {
+    'use strict'
+
+    var GetIntrinsic = require('get-intrinsic')
+
+    var callBind = require('./')
+
+    var $indexOf = callBind(GetIntrinsic('String.prototype.indexOf'))
+
+    module.exports = function callBoundIntrinsic (name, allowMissing) {
+      var intrinsic = GetIntrinsic(name, !!allowMissing)
+      if (typeof intrinsic === 'function' && $indexOf(name, '.prototype.') > -1) {
+        return callBind(intrinsic)
+      }
+      return intrinsic
+    }
+  }, { './': 16, 'get-intrinsic': 21 }],
+  16: [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 $apply = GetIntrinsic('%Function.prototype.apply%')
+    var $call = GetIntrinsic('%Function.prototype.call%')
+    var $reflectApply = GetIntrinsic('%Reflect.apply%', true) || bind.call($call, $apply)
+
+    var $defineProperty = GetIntrinsic('%Object.defineProperty%', true)
+    var $max = GetIntrinsic('%Math.max%')
+
+    if ($defineProperty) {
+      try {
+        $defineProperty({}, 'a', { value: 1 })
+      } catch (e) {
+      // IE 8 has a broken defineProperty
+        $defineProperty = null
+      }
+    }
+
+    module.exports = function callBind (originalFunction) {
+      if (typeof originalFunction !== 'function') {
+        throw new $TypeError('a function is required')
+      }
+      var func = $reflectApply(bind, $call, arguments)
+      return setFunctionLength(
+        func,
+        1 + $max(0, originalFunction.length - (arguments.length - 1)),
+        true
+      )
+    }
+
+    var applyBind = function applyBind () {
+      return $reflectApply(bind, $apply, arguments)
+    }
+
+    if ($defineProperty) {
+      $defineProperty(module.exports, 'apply', { value: applyBind })
+    } else {
+      module.exports.apply = applyBind
+    }
+  }, { 'function-bind': 20, 'get-intrinsic': 21, 'set-function-length': 35 }],
+  17: [function (require, module, exports) {
+    'use strict'
+
+    var hasPropertyDescriptors = require('has-property-descriptors')()
+
+    var GetIntrinsic = require('get-intrinsic')
+
+    var $defineProperty = hasPropertyDescriptors && GetIntrinsic('%Object.defineProperty%', true)
+    if ($defineProperty) {
+      try {
+        $defineProperty({}, 'a', { value: 1 })
+      } catch (e) {
+      // IE 8 has a broken defineProperty
+        $defineProperty = false
+      }
+    }
+
+    var $SyntaxError = GetIntrinsic('%SyntaxError%')
+    var $TypeError = GetIntrinsic('%TypeError%')
+
+    var gopd = require('gopd')
+
+    /** @type {(obj: Record<PropertyKey, unknown>, property: PropertyKey, value: unknown, nonEnumerable?: boolean | null, nonWritable?: boolean | null, nonConfigurable?: boolean | null, loose?: boolean) => void} */
+    module.exports = function defineDataProperty (
+      obj,
+      property,
+      value
+    ) {
+      if (!obj || (typeof obj !== 'object' && typeof obj !== 'function')) {
+        throw new $TypeError('`obj` must be an object or a function`')
+      }
+      if (typeof property !== 'string' && typeof property !== 'symbol') {
+        throw new $TypeError('`property` must be a string or a symbol`')
+      }
+      if (arguments.length > 3 && typeof arguments[3] !== 'boolean' && arguments[3] !== null) {
+        throw new $TypeError('`nonEnumerable`, if provided, must be a boolean or null')
+      }
+      if (arguments.length > 4 && typeof arguments[4] !== 'boolean' && arguments[4] !== null) {
+        throw new $TypeError('`nonWritable`, if provided, must be a boolean or null')
+      }
+      if (arguments.length > 5 && typeof arguments[5] !== 'boolean' && arguments[5] !== null) {
+        throw new $TypeError('`nonConfigurable`, if provided, must be a boolean or null')
+      }
+      if (arguments.length > 6 && typeof arguments[6] !== 'boolean') {
+        throw new $TypeError('`loose`, if provided, must be a boolean')
+      }
+
+      var nonEnumerable = arguments.length > 3 ? arguments[3] : null
+      var nonWritable = arguments.length > 4 ? arguments[4] : null
+      var nonConfigurable = arguments.length > 5 ? arguments[5] : null
+      var loose = arguments.length > 6 ? arguments[6] : false
+
+      /* @type {false | TypedPropertyDescriptor<unknown>} */
+      var desc = !!gopd && gopd(obj, property)
+
+      if ($defineProperty) {
+        $defineProperty(obj, property, {
+          configurable: nonConfigurable === null && desc ? desc.configurable : !nonConfigurable,
+          enumerable: nonEnumerable === null && desc ? desc.enumerable : !nonEnumerable,
+          value: value,
+          writable: nonWritable === null && desc ? desc.writable : !nonWritable
+        })
+      } else if (loose || (!nonEnumerable && !nonWritable && !nonConfigurable)) {
+      // must fall back to [[Set]], and was not explicitly asked to make non-enumerable, non-writable, or non-configurable
+        obj[property] = value // eslint-disable-line no-param-reassign
+      } else {
+        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) {
+    'use strict'
+
+    var isCallable = require('is-callable')
+
+    var toStr = Object.prototype.toString
+    var hasOwnProperty = Object.prototype.hasOwnProperty
+
+    var forEachArray = function forEachArray (array, iterator, receiver) {
+      for (var i = 0, len = array.length; i < len; i++) {
+        if (hasOwnProperty.call(array, i)) {
+          if (receiver == null) {
+            iterator(array[i], i, array)
+          } else {
+            iterator.call(receiver, array[i], i, array)
+          }
+        }
+      }
+    }
+
+    var forEachString = function forEachString (string, iterator, receiver) {
+      for (var i = 0, len = string.length; i < len; i++) {
+      // no such thing as a sparse string.
+        if (receiver == null) {
+          iterator(string.charAt(i), i, string)
+        } else {
+          iterator.call(receiver, string.charAt(i), i, string)
+        }
+      }
+    }
+
+    var forEachObject = function forEachObject (object, iterator, receiver) {
+      for (var k in object) {
+        if (hasOwnProperty.call(object, k)) {
+          if (receiver == null) {
+            iterator(object[k], k, object)
+          } else {
+            iterator.call(receiver, object[k], k, object)
+          }
+        }
+      }
+    }
+
+    var forEach = function forEach (list, iterator, thisArg) {
+      if (!isCallable(iterator)) {
+        throw new TypeError('iterator must be a function')
+      }
+
+      var receiver
+      if (arguments.length >= 3) {
+        receiver = thisArg
+      }
+
+      if (toStr.call(list) === '[object Array]') {
+        forEachArray(list, iterator, receiver)
+      } else if (typeof list === 'string') {
+        forEachString(list, iterator, receiver)
+      } else {
+        forEachObject(list, iterator, receiver)
+      }
+    }
+
+    module.exports = forEach
+  }, { 'is-callable': 31 }],
+  19: [function (require, module, exports) {
+    'use strict'
+
+    /* eslint no-invalid-this: 1 */
+
+    var ERROR_MESSAGE = 'Function.prototype.bind called on incompatible '
+    var toStr = Object.prototype.toString
+    var max = Math.max
+    var funcType = '[object Function]'
+
+    var concatty = function concatty (a, b) {
+      var arr = []
+
+      for (var i = 0; i < a.length; i += 1) {
+        arr[i] = a[i]
+      }
+      for (var j = 0; j < b.length; j += 1) {
+        arr[j + a.length] = b[j]
+      }
+
+      return arr
+    }
+
+    var slicy = function slicy (arrLike, offset) {
+      var arr = []
+      for (var i = offset || 0, j = 0; i < arrLike.length; i += 1, j += 1) {
+        arr[j] = arrLike[i]
+      }
+      return arr
+    }
+
+    var joiny = function (arr, joiner) {
+      var str = ''
+      for (var i = 0; i < arr.length; i += 1) {
+        str += arr[i]
+        if (i + 1 < arr.length) {
+          str += joiner
+        }
+      }
+      return str
+    }
+
+    module.exports = function bind (that) {
+      var target = this
+      if (typeof target !== 'function' || toStr.apply(target) !== funcType) {
+        throw new TypeError(ERROR_MESSAGE + target)
+      }
+      var args = slicy(arguments, 1)
+
+      var bound
+      var binder = function () {
+        if (this instanceof bound) {
+          var result = target.apply(
+            this,
+            concatty(args, arguments)
+          )
+          if (Object(result) === result) {
+            return result
+          }
+          return this
+        }
+        return target.apply(
+          that,
+          concatty(args, arguments)
+        )
+      }
+
+      var boundLength = max(0, target.length - args.length)
+      var boundArgs = []
+      for (var i = 0; i < boundLength; i++) {
+        boundArgs[i] = '$' + i
+      }
+
+      bound = Function('binder', 'return function (' + joiny(boundArgs, ',') + '){ return binder.apply(this,arguments); }')(binder)
+
+      if (target.prototype) {
+        var Empty = function Empty () {}
+        Empty.prototype = target.prototype
+        bound.prototype = new Empty()
+        Empty.prototype = null
+      }
+
+      return bound
+    }
+  }, {}],
+  20: [function (require, module, exports) {
+    'use strict'
+
+    var implementation = require('./implementation')
+
+    module.exports = Function.prototype.bind || implementation
+  }, { './implementation': 19 }],
+  21: [function (require, module, exports) {
+    'use strict'
+
+    var undefined
+
+    var $SyntaxError = SyntaxError
+    var $Function = Function
+    var $TypeError = TypeError
+
+    // eslint-disable-next-line consistent-return
+    var getEvalledConstructor = function (expressionSyntax) {
+      try {
+        return $Function('"use strict"; return (' + expressionSyntax + ').constructor;')()
+      } catch (e) {}
+    }
+
+    var $gOPD = Object.getOwnPropertyDescriptor
+    if ($gOPD) {
+      try {
+        $gOPD({}, '')
+      } catch (e) {
+        $gOPD = null // this is IE 8, which has a broken gOPD
+      }
+    }
+
+    var throwTypeError = function () {
+      throw new $TypeError()
+    }
+    var ThrowTypeError = $gOPD
+      ? (function () {
+        try {
+        // eslint-disable-next-line no-unused-expressions, no-caller, no-restricted-properties
+          arguments.callee // IE 8 does not throw here
+          return throwTypeError
+        } catch (calleeThrows) {
+          try {
+          // IE 8 throws on Object.getOwnPropertyDescriptor(arguments, '')
+            return $gOPD(arguments, 'callee').get
+          } catch (gOPDthrows) {
+            return throwTypeError
+          }
+        }
+      }())
+      : throwTypeError
+
+    var hasSymbols = require('has-symbols')()
+    var hasProto = require('has-proto')()
+
+    var getProto = Object.getPrototypeOf || (
+      hasProto
+        ? function (x) { return x.__proto__ } // eslint-disable-line no-proto
+        : null
+    )
+
+    var needsEval = {}
+
+    var TypedArray = typeof Uint8Array === 'undefined' || !getProto ? undefined : getProto(Uint8Array)
+
+    var INTRINSICS = {
+      '%AggregateError%': typeof AggregateError === 'undefined' ? undefined : AggregateError,
+      '%Array%': Array,
+      '%ArrayBuffer%': typeof ArrayBuffer === 'undefined' ? undefined : ArrayBuffer,
+      '%ArrayIteratorPrototype%': hasSymbols && getProto ? getProto([][Symbol.iterator]()) : undefined,
+      '%AsyncFromSyncIteratorPrototype%': undefined,
+      '%AsyncFunction%': needsEval,
+      '%AsyncGenerator%': needsEval,
+      '%AsyncGeneratorFunction%': needsEval,
+      '%AsyncIteratorPrototype%': needsEval,
+      '%Atomics%': typeof Atomics === 'undefined' ? undefined : Atomics,
+      '%BigInt%': typeof BigInt === 'undefined' ? undefined : BigInt,
+      '%BigInt64Array%': typeof BigInt64Array === 'undefined' ? undefined : BigInt64Array,
+      '%BigUint64Array%': typeof BigUint64Array === 'undefined' ? undefined : BigUint64Array,
+      '%Boolean%': Boolean,
+      '%DataView%': typeof DataView === 'undefined' ? undefined : DataView,
+      '%Date%': Date,
+      '%decodeURI%': decodeURI,
+      '%decodeURIComponent%': decodeURIComponent,
+      '%encodeURI%': encodeURI,
+      '%encodeURIComponent%': encodeURIComponent,
+      '%Error%': Error,
+      '%eval%': eval, // eslint-disable-line no-eval
+      '%EvalError%': EvalError,
+      '%Float32Array%': typeof Float32Array === 'undefined' ? undefined : Float32Array,
+      '%Float64Array%': typeof Float64Array === 'undefined' ? undefined : Float64Array,
+      '%FinalizationRegistry%': typeof FinalizationRegistry === 'undefined' ? undefined : FinalizationRegistry,
+      '%Function%': $Function,
+      '%GeneratorFunction%': needsEval,
+      '%Int8Array%': typeof Int8Array === 'undefined' ? undefined : Int8Array,
+      '%Int16Array%': typeof Int16Array === 'undefined' ? undefined : Int16Array,
+      '%Int32Array%': typeof Int32Array === 'undefined' ? undefined : Int32Array,
+      '%isFinite%': isFinite,
+      '%isNaN%': isNaN,
+      '%IteratorPrototype%': hasSymbols && getProto ? getProto(getProto([][Symbol.iterator]())) : undefined,
+      '%JSON%': typeof JSON === 'object' ? JSON : undefined,
+      '%Map%': typeof Map === 'undefined' ? undefined : Map,
+      '%MapIteratorPrototype%': typeof Map === 'undefined' || !hasSymbols || !getProto ? undefined : getProto(new Map()[Symbol.iterator]()),
+      '%Math%': Math,
+      '%Number%': Number,
+      '%Object%': Object,
+      '%parseFloat%': parseFloat,
+      '%parseInt%': parseInt,
+      '%Promise%': typeof Promise === 'undefined' ? undefined : Promise,
+      '%Proxy%': typeof Proxy === 'undefined' ? undefined : Proxy,
+      '%RangeError%': RangeError,
+      '%ReferenceError%': ReferenceError,
+      '%Reflect%': typeof Reflect === 'undefined' ? undefined : Reflect,
+      '%RegExp%': RegExp,
+      '%Set%': typeof Set === 'undefined' ? undefined : Set,
+      '%SetIteratorPrototype%': typeof Set === 'undefined' || !hasSymbols || !getProto ? undefined : getProto(new Set()[Symbol.iterator]()),
+      '%SharedArrayBuffer%': typeof SharedArrayBuffer === 'undefined' ? undefined : SharedArrayBuffer,
+      '%String%': String,
+      '%StringIteratorPrototype%': hasSymbols && getProto ? getProto(''[Symbol.iterator]()) : undefined,
+      '%Symbol%': hasSymbols ? Symbol : undefined,
+      '%SyntaxError%': $SyntaxError,
+      '%ThrowTypeError%': ThrowTypeError,
+      '%TypedArray%': TypedArray,
+      '%TypeError%': $TypeError,
+      '%Uint8Array%': typeof Uint8Array === 'undefined' ? undefined : Uint8Array,
+      '%Uint8ClampedArray%': typeof Uint8ClampedArray === 'undefined' ? undefined : Uint8ClampedArray,
+      '%Uint16Array%': typeof Uint16Array === 'undefined' ? undefined : Uint16Array,
+      '%Uint32Array%': typeof Uint32Array === 'undefined' ? undefined : Uint32Array,
+      '%URIError%': URIError,
+      '%WeakMap%': typeof WeakMap === 'undefined' ? undefined : WeakMap,
+      '%WeakRef%': typeof WeakRef === 'undefined' ? undefined : WeakRef,
+      '%WeakSet%': typeof WeakSet === 'undefined' ? undefined : WeakSet
+    }
+
+    if (getProto) {
+      try {
+        null.error // eslint-disable-line no-unused-expressions
+      } catch (e) {
+      // https://github.com/tc39/proposal-shadowrealm/pull/384#issuecomment-1364264229
+        var errorProto = getProto(getProto(e))
+        INTRINSICS['%Error.prototype%'] = errorProto
+      }
+    }
+
+    var doEval = function doEval (name) {
+      var value
+      if (name === '%AsyncFunction%') {
+        value = getEvalledConstructor('async function () {}')
+      } else if (name === '%GeneratorFunction%') {
+        value = getEvalledConstructor('function* () {}')
+      } else if (name === '%AsyncGeneratorFunction%') {
+        value = getEvalledConstructor('async function* () {}')
+      } else if (name === '%AsyncGenerator%') {
+        var fn = doEval('%AsyncGeneratorFunction%')
+        if (fn) {
+          value = fn.prototype
+        }
+      } else if (name === '%AsyncIteratorPrototype%') {
+        var gen = doEval('%AsyncGenerator%')
+        if (gen && getProto) {
+          value = getProto(gen.prototype)
+        }
+      }
+
+      INTRINSICS[name] = value
+
+      return value
+    }
+
+    var LEGACY_ALIASES = {
+      '%ArrayBufferPrototype%': ['ArrayBuffer', 'prototype'],
+      '%ArrayPrototype%': ['Array', 'prototype'],
+      '%ArrayProto_entries%': ['Array', 'prototype', 'entries'],
+      '%ArrayProto_forEach%': ['Array', 'prototype', 'forEach'],
+      '%ArrayProto_keys%': ['Array', 'prototype', 'keys'],
+      '%ArrayProto_values%': ['Array', 'prototype', 'values'],
+      '%AsyncFunctionPrototype%': ['AsyncFunction', 'prototype'],
+      '%AsyncGenerator%': ['AsyncGeneratorFunction', 'prototype'],
+      '%AsyncGeneratorPrototype%': ['AsyncGeneratorFunction', 'prototype', 'prototype'],
+      '%BooleanPrototype%': ['Boolean', 'prototype'],
+      '%DataViewPrototype%': ['DataView', 'prototype'],
+      '%DatePrototype%': ['Date', 'prototype'],
+      '%ErrorPrototype%': ['Error', 'prototype'],
+      '%EvalErrorPrototype%': ['EvalError', 'prototype'],
+      '%Float32ArrayPrototype%': ['Float32Array', 'prototype'],
+      '%Float64ArrayPrototype%': ['Float64Array', 'prototype'],
+      '%FunctionPrototype%': ['Function', 'prototype'],
+      '%Generator%': ['GeneratorFunction', 'prototype'],
+      '%GeneratorPrototype%': ['GeneratorFunction', 'prototype', 'prototype'],
+      '%Int8ArrayPrototype%': ['Int8Array', 'prototype'],
+      '%Int16ArrayPrototype%': ['Int16Array', 'prototype'],
+      '%Int32ArrayPrototype%': ['Int32Array', 'prototype'],
+      '%JSONParse%': ['JSON', 'parse'],
+      '%JSONStringify%': ['JSON', 'stringify'],
+      '%MapPrototype%': ['Map', 'prototype'],
+      '%NumberPrototype%': ['Number', 'prototype'],
+      '%ObjectPrototype%': ['Object', 'prototype'],
+      '%ObjProto_toString%': ['Object', 'prototype', 'toString'],
+      '%ObjProto_valueOf%': ['Object', 'prototype', 'valueOf'],
+      '%PromisePrototype%': ['Promise', 'prototype'],
+      '%PromiseProto_then%': ['Promise', 'prototype', 'then'],
+      '%Promise_all%': ['Promise', 'all'],
+      '%Promise_reject%': ['Promise', 'reject'],
+      '%Promise_resolve%': ['Promise', 'resolve'],
+      '%RangeErrorPrototype%': ['RangeError', 'prototype'],
+      '%ReferenceErrorPrototype%': ['ReferenceError', 'prototype'],
+      '%RegExpPrototype%': ['RegExp', 'prototype'],
+      '%SetPrototype%': ['Set', 'prototype'],
+      '%SharedArrayBufferPrototype%': ['SharedArrayBuffer', 'prototype'],
+      '%StringPrototype%': ['String', 'prototype'],
+      '%SymbolPrototype%': ['Symbol', 'prototype'],
+      '%SyntaxErrorPrototype%': ['SyntaxError', 'prototype'],
+      '%TypedArrayPrototype%': ['TypedArray', 'prototype'],
+      '%TypeErrorPrototype%': ['TypeError', 'prototype'],
+      '%Uint8ArrayPrototype%': ['Uint8Array', 'prototype'],
+      '%Uint8ClampedArrayPrototype%': ['Uint8ClampedArray', 'prototype'],
+      '%Uint16ArrayPrototype%': ['Uint16Array', 'prototype'],
+      '%Uint32ArrayPrototype%': ['Uint32Array', 'prototype'],
+      '%URIErrorPrototype%': ['URIError', 'prototype'],
+      '%WeakMapPrototype%': ['WeakMap', 'prototype'],
+      '%WeakSetPrototype%': ['WeakSet', 'prototype']
+    }
+
+    var bind = require('function-bind')
+    var hasOwn = require('hasown')
+    var $concat = bind.call(Function.call, Array.prototype.concat)
+    var $spliceApply = bind.call(Function.apply, Array.prototype.splice)
+    var $replace = bind.call(Function.call, String.prototype.replace)
+    var $strSlice = bind.call(Function.call, String.prototype.slice)
+    var $exec = bind.call(Function.call, RegExp.prototype.exec)
+
+    /* adapted from https://github.com/lodash/lodash/blob/4.17.15/dist/lodash.js#L6735-L6744 */
+    var rePropName = /[^%.[\]]+|\[(?:(-?\d+(?:\.\d+)?)|(["'])((?:(?!\2)[^\\]|\\.)*?)\2)\]|(?=(?:\.|\[\])(?:\.|\[\]|%$))/g
+    var reEscapeChar = /\\(\\)?/g /** Used to match backslashes in property paths. */
+    var stringToPath = function stringToPath (string) {
+      var first = $strSlice(string, 0, 1)
+      var last = $strSlice(string, -1)
+      if (first === '%' && last !== '%') {
+        throw new $SyntaxError('invalid intrinsic syntax, expected closing `%`')
+      } else if (last === '%' && first !== '%') {
+        throw new $SyntaxError('invalid intrinsic syntax, expected opening `%`')
+      }
+      var result = []
+      $replace(string, rePropName, function (match, number, quote, subString) {
+        result[result.length] = quote ? $replace(subString, reEscapeChar, '$1') : number || match
+      })
+      return result
+    }
+    /* end adaptation */
+
+    var getBaseIntrinsic = function getBaseIntrinsic (name, allowMissing) {
+      var intrinsicName = name
+      var alias
+      if (hasOwn(LEGACY_ALIASES, intrinsicName)) {
+        alias = LEGACY_ALIASES[intrinsicName]
+        intrinsicName = '%' + alias[0] + '%'
+      }
+
+      if (hasOwn(INTRINSICS, intrinsicName)) {
+        var value = INTRINSICS[intrinsicName]
+        if (value === needsEval) {
+          value = doEval(intrinsicName)
+        }
+        if (typeof value === 'undefined' && !allowMissing) {
+          throw new $TypeError('intrinsic ' + name + ' exists, but is not available. Please file an issue!')
+        }
+
+        return {
+          alias: alias,
+          name: intrinsicName,
+          value: value
+        }
+      }
+
+      throw new $SyntaxError('intrinsic ' + name + ' does not exist!')
+    }
+
+    module.exports = function GetIntrinsic (name, allowMissing) {
+      if (typeof name !== 'string' || name.length === 0) {
+        throw new $TypeError('intrinsic name must be a non-empty string')
+      }
+      if (arguments.length > 1 && typeof allowMissing !== 'boolean') {
+        throw new $TypeError('"allowMissing" argument must be a boolean')
+      }
+
+      if ($exec(/^%?[^%]*%?$/, name) === null) {
+        throw new $SyntaxError('`%` may not be present anywhere but at the beginning and end of the intrinsic name')
+      }
+      var parts = stringToPath(name)
+      var intrinsicBaseName = parts.length > 0 ? parts[0] : ''
+
+      var intrinsic = getBaseIntrinsic('%' + intrinsicBaseName + '%', allowMissing)
+      var intrinsicRealName = intrinsic.name
+      var value = intrinsic.value
+      var skipFurtherCaching = false
+
+      var alias = intrinsic.alias
+      if (alias) {
+        intrinsicBaseName = alias[0]
+        $spliceApply(parts, $concat([0, 1], alias))
+      }
+
+      for (var i = 1, isOwn = true; i < parts.length; i += 1) {
+        var part = parts[i]
+        var first = $strSlice(part, 0, 1)
+        var last = $strSlice(part, -1)
+        if (
+          (
+            (first === '"' || first === "'" || first === '`') ||
+				(last === '"' || last === "'" || last === '`')
+          ) &&
+			first !== last
+        ) {
+          throw new $SyntaxError('property names with quotes must have matching quotes')
+        }
+        if (part === 'constructor' || !isOwn) {
+          skipFurtherCaching = true
+        }
+
+        intrinsicBaseName += '.' + part
+        intrinsicRealName = '%' + intrinsicBaseName + '%'
+
+        if (hasOwn(INTRINSICS, intrinsicRealName)) {
+          value = INTRINSICS[intrinsicRealName]
+        } else if (value != null) {
+          if (!(part in value)) {
+            if (!allowMissing) {
+              throw new $TypeError('base intrinsic for ' + name + ' exists, but the property is not available.')
+            }
+            return void undefined
+          }
+          if ($gOPD && (i + 1) >= parts.length) {
+            var desc = $gOPD(value, part)
+            isOwn = !!desc
+
+            // By convention, when a data property is converted to an accessor
+            // property to emulate a data property that does not suffer from
+            // the override mistake, that accessor's getter is marked with
+            // an `originalValue` property. Here, when we detect this, we
+            // uphold the illusion by pretending to see that original data
+            // property, i.e., returning the value rather than the getter
+            // itself.
+            if (isOwn && 'get' in desc && !('originalValue' in desc.get)) {
+              value = desc.get
+            } else {
+              value = value[part]
+            }
+          } else {
+            isOwn = hasOwn(value, part)
+            value = value[part]
+          }
+
+          if (isOwn && !skipFurtherCaching) {
+            INTRINSICS[intrinsicRealName] = value
+          }
+        }
+      }
+      return value
+    }
+  }, { 'function-bind': 20, 'has-proto': 24, 'has-symbols': 25, hasown: 28 }],
+  22: [function (require, module, exports) {
+    'use strict'
+
+    var GetIntrinsic = require('get-intrinsic')
+
+    var $gOPD = GetIntrinsic('%Object.getOwnPropertyDescriptor%', true)
+
+    if ($gOPD) {
+      try {
+        $gOPD([], 'length')
+      } catch (e) {
+      // IE 8 has a broken gOPD
+        $gOPD = null
+      }
+    }
+
+    module.exports = $gOPD
+  }, { 'get-intrinsic': 21 }],
+  23: [function (require, module, exports) {
+    'use strict'
+
+    var GetIntrinsic = require('get-intrinsic')
+
+    var $defineProperty = GetIntrinsic('%Object.defineProperty%', true)
+
+    var hasPropertyDescriptors = function hasPropertyDescriptors () {
+      if ($defineProperty) {
+        try {
+          $defineProperty({}, 'a', { value: 1 })
+          return true
+        } catch (e) {
+        // IE 8 has a broken defineProperty
+          return false
+        }
+      }
+      return false
+    }
+
+    hasPropertyDescriptors.hasArrayLengthDefineBug = function hasArrayLengthDefineBug () {
+    // node v0.6 has a bug where array lengths can be Set but not Defined
+      if (!hasPropertyDescriptors()) {
+        return null
+      }
+      try {
+        return $defineProperty([], 'length', { value: 1 }).length !== 1
+      } catch (e) {
+      // In Firefox 4-22, defining length on an array throws an exception.
+        return true
+      }
+    }
+
+    module.exports = hasPropertyDescriptors
+  }, { 'get-intrinsic': 21 }],
+  24: [function (require, module, exports) {
+    'use strict'
+
+    var test = {
+      foo: {}
+    }
+
+    var $Object = Object
+
+    module.exports = function hasProto () {
+      return { __proto__: test }.foo === test.foo && !({ __proto__: null } instanceof $Object)
+    }
+  }, {}],
+  25: [function (require, module, exports) {
+    'use strict'
+
+    var origSymbol = typeof Symbol !== 'undefined' && Symbol
+    var hasSymbolSham = require('./shams')
+
+    module.exports = function hasNativeSymbols () {
+      if (typeof origSymbol !== 'function') { return false }
+      if (typeof Symbol !== 'function') { return false }
+      if (typeof origSymbol('foo') !== 'symbol') { return false }
+      if (typeof Symbol('bar') !== 'symbol') { return false }
+
+      return hasSymbolSham()
+    }
+  }, { './shams': 26 }],
+  26: [function (require, module, exports) {
+    'use strict'
+
+    /* eslint complexity: [2, 18], max-statements: [2, 33] */
+    module.exports = function hasSymbols () {
+      if (typeof Symbol !== 'function' || typeof Object.getOwnPropertySymbols !== 'function') { return false }
+      if (typeof Symbol.iterator === 'symbol') { return true }
+
+      var obj = {}
+      var sym = Symbol('test')
+      var symObj = Object(sym)
+      if (typeof sym === 'string') { return false }
+
+      if (Object.prototype.toString.call(sym) !== '[object Symbol]') { return false }
+      if (Object.prototype.toString.call(symObj) !== '[object Symbol]') { return false }
+
+      // temp disabled per https://github.com/ljharb/object.assign/issues/17
+      // if (sym instanceof Symbol) { return false; }
+      // temp disabled per https://github.com/WebReflection/get-own-property-symbols/issues/4
+      // if (!(symObj instanceof Symbol)) { return false; }
+
+      // if (typeof Symbol.prototype.toString !== 'function') { return false; }
+      // if (String(sym) !== Symbol.prototype.toString.call(sym)) { return false; }
+
+      var symVal = 42
+      obj[sym] = symVal
+      for (sym in obj) { return false } // eslint-disable-line no-restricted-syntax, no-unreachable-loop
+      if (typeof Object.keys === 'function' && Object.keys(obj).length !== 0) { return false }
+
+      if (typeof Object.getOwnPropertyNames === 'function' && Object.getOwnPropertyNames(obj).length !== 0) { return false }
+
+      var syms = Object.getOwnPropertySymbols(obj)
+      if (syms.length !== 1 || syms[0] !== sym) { return false }
+
+      if (!Object.prototype.propertyIsEnumerable.call(obj, sym)) { return false }
+
+      if (typeof Object.getOwnPropertyDescriptor === 'function') {
+        var descriptor = Object.getOwnPropertyDescriptor(obj, sym)
+        if (descriptor.value !== symVal || descriptor.enumerable !== true) { return false }
+      }
+
+      return true
+    }
+  }, {}],
+  27: [function (require, module, exports) {
+    'use strict'
+
+    var hasSymbols = require('has-symbols/shams')
+
+    module.exports = function hasToStringTagShams () {
+      return hasSymbols() && !!Symbol.toStringTag
+    }
+  }, { 'has-symbols/shams': 26 }],
+  28: [function (require, module, exports) {
+    'use strict'
+
+    var call = Function.prototype.call
+    var $hasOwn = Object.prototype.hasOwnProperty
+    var bind = require('function-bind')
+
+    /** @type {(o: {}, p: PropertyKey) => p is keyof o} */
+    module.exports = bind.call(call, $hasOwn)
+  }, { 'function-bind': 20 }],
+  29: [function (require, module, exports) {
+    if (typeof Object.create === 'function') {
+      // implementation from standard node.js 'util' module
+      module.exports = function inherits (ctor, superCtor) {
+        if (superCtor) {
+          ctor.super_ = superCtor
+          ctor.prototype = Object.create(superCtor.prototype, {
+            constructor: {
+              value: ctor,
+              enumerable: false,
+              writable: true,
+              configurable: true
+            }
+          })
+        }
+      }
+    } else {
+      // old school shim for old browsers
+      module.exports = function inherits (ctor, superCtor) {
+        if (superCtor) {
+          ctor.super_ = superCtor
+          var TempCtor = function () {}
+          TempCtor.prototype = superCtor.prototype
+          ctor.prototype = new TempCtor()
+          ctor.prototype.constructor = ctor
+        }
+      }
+    }
+  }, {}],
+  30: [function (require, module, exports) {
+    'use strict'
+
+    var hasToStringTag = require('has-tostringtag/shams')()
+    var callBound = require('call-bind/callBound')
+
+    var $toString = callBound('Object.prototype.toString')
+
+    var isStandardArguments = function isArguments (value) {
+      if (hasToStringTag && value && typeof value === 'object' && Symbol.toStringTag in value) {
+        return false
+      }
+      return $toString(value) === '[object Arguments]'
+    }
+
+    var isLegacyArguments = function isArguments (value) {
+      if (isStandardArguments(value)) {
+        return true
+      }
+      return value !== null &&
+		typeof value === 'object' &&
+		typeof value.length === 'number' &&
+		value.length >= 0 &&
+		$toString(value) !== '[object Array]' &&
+		$toString(value.callee) === '[object Function]'
+    }
+
+    var supportsStandardArguments = (function () {
+      return isStandardArguments(arguments)
+    }())
+
+    isStandardArguments.isLegacyArguments = isLegacyArguments // for tests
+
+    module.exports = supportsStandardArguments ? isStandardArguments : isLegacyArguments
+  }, { 'call-bind/callBound': 15, 'has-tostringtag/shams': 27 }],
+  31: [function (require, module, exports) {
+    'use strict'
+
+    var fnToStr = Function.prototype.toString
+    var reflectApply = typeof Reflect === 'object' && Reflect !== null && Reflect.apply
+    var badArrayLike
+    var isCallableMarker
+    if (typeof reflectApply === 'function' && typeof Object.defineProperty === 'function') {
+      try {
+        badArrayLike = Object.defineProperty({}, 'length', {
+          get: function () {
+            throw isCallableMarker
+          }
+        })
+        isCallableMarker = {}
+        // eslint-disable-next-line no-throw-literal
+        reflectApply(function () { throw 42 }, null, badArrayLike)
+      } catch (_) {
+        if (_ !== isCallableMarker) {
+          reflectApply = null
+        }
+      }
+    } else {
+      reflectApply = null
+    }
+
+    var constructorRegex = /^\s*class\b/
+    var isES6ClassFn = function isES6ClassFunction (value) {
+      try {
+        var fnStr = fnToStr.call(value)
+        return constructorRegex.test(fnStr)
+      } catch (e) {
+        return false // not a function
+      }
+    }
+
+    var tryFunctionObject = function tryFunctionToStr (value) {
+      try {
+        if (isES6ClassFn(value)) { return false }
+        fnToStr.call(value)
+        return true
+      } catch (e) {
+        return false
+      }
+    }
+    var toStr = Object.prototype.toString
+    var objectClass = '[object Object]'
+    var fnClass = '[object Function]'
+    var genClass = '[object GeneratorFunction]'
+    var ddaClass = '[object HTMLAllCollection]' // IE 11
+    var ddaClass2 = '[object HTML document.all class]'
+    var ddaClass3 = '[object HTMLCollection]' // IE 9-10
+    var hasToStringTag = typeof Symbol === 'function' && !!Symbol.toStringTag // better: use `has-tostringtag`
+
+    var isIE68 = !(0 in [,]) // eslint-disable-line no-sparse-arrays, comma-spacing
+
+    var isDDA = function isDocumentDotAll () { return false }
+    if (typeof document === 'object') {
+    // Firefox 3 canonicalizes DDA to undefined when it's not accessed directly
+      var all = document.all
+      if (toStr.call(all) === toStr.call(document.all)) {
+        isDDA = function isDocumentDotAll (value) {
+        /* globals document: false */
+        // in IE 6-8, typeof document.all is "object" and it's truthy
+          if ((isIE68 || !value) && (typeof value === 'undefined' || typeof value === 'object')) {
+            try {
+              var str = toStr.call(value)
+              return (
+                str === ddaClass ||
+						str === ddaClass2 ||
+						str === ddaClass3 || // opera 12.16
+						str === objectClass // IE 6-8
+              ) && value('') == null // eslint-disable-line eqeqeq
+            } catch (e) { /**/ }
+          }
+          return false
+        }
+      }
+    }
+
+    module.exports = reflectApply
+      ? function isCallable (value) {
+        if (isDDA(value)) { return true }
+        if (!value) { return false }
+        if (typeof value !== 'function' && typeof value !== 'object') { return false }
+        try {
+          reflectApply(value, null, badArrayLike)
+        } catch (e) {
+          if (e !== isCallableMarker) { return false }
+        }
+        return !isES6ClassFn(value) && tryFunctionObject(value)
+      }
+      : function isCallable (value) {
+        if (isDDA(value)) { return true }
+        if (!value) { return false }
+        if (typeof value !== 'function' && typeof value !== 'object') { return false }
+        if (hasToStringTag) { return tryFunctionObject(value) }
+        if (isES6ClassFn(value)) { return false }
+        var strClass = toStr.call(value)
+        if (strClass !== fnClass && strClass !== genClass && !(/^\[object HTML/).test(strClass)) { return false }
+        return tryFunctionObject(value)
+      }
+  }, {}],
+  32: [function (require, module, exports) {
+    'use strict'
+
+    var toStr = Object.prototype.toString
+    var fnToStr = Function.prototype.toString
+    var isFnRegex = /^\s*(?:function)?\*/
+    var hasToStringTag = require('has-tostringtag/shams')()
+    var getProto = Object.getPrototypeOf
+    var getGeneratorFunc = function () { // eslint-disable-line consistent-return
+      if (!hasToStringTag) {
+        return false
+      }
+      try {
+        return Function('return function*() {}')()
+      } catch (e) {
+      }
+    }
+    var GeneratorFunction
+
+    module.exports = function isGeneratorFunction (fn) {
+      if (typeof fn !== 'function') {
+        return false
+      }
+      if (isFnRegex.test(fnToStr.call(fn))) {
+        return true
+      }
+      if (!hasToStringTag) {
+        var str = toStr.call(fn)
+        return str === '[object GeneratorFunction]'
+      }
+      if (!getProto) {
+        return false
+      }
+      if (typeof GeneratorFunction === 'undefined') {
+        var generatorFunc = getGeneratorFunc()
+        GeneratorFunction = generatorFunc ? getProto(generatorFunc) : false
+      }
+      return getProto(fn) === GeneratorFunction
+    }
+  }, { 'has-tostringtag/shams': 27 }],
+  33: [function (require, module, exports) {
+    'use strict'
+
+    var whichTypedArray = require('which-typed-array')
+
+    module.exports = function isTypedArray (value) {
+      return !!whichTypedArray(value)
+    }
+  }, { 'which-typed-array': 39 }],
+  34: [function (require, module, exports) {
+    // shim for using process in browser
+    var process = module.exports = {}
+
+    // cached from whatever global is present so that test runners that stub it
+    // don't break things.  But we need to wrap it in a try catch in case it is
+    // wrapped in strict mode code which doesn't define any globals.  It's inside a
+    // function because try/catches deoptimize in certain engines.
+
+    var cachedSetTimeout
+    var cachedClearTimeout
+
+    function defaultSetTimout () {
+      throw new Error('setTimeout has not been defined')
+    }
+    function defaultClearTimeout () {
+      throw new Error('clearTimeout has not been defined')
+    }
+    (function () {
+      try {
+        if (typeof setTimeout === 'function') {
+          cachedSetTimeout = setTimeout
+        } else {
+          cachedSetTimeout = defaultSetTimout
+        }
+      } catch (e) {
+        cachedSetTimeout = defaultSetTimout
+      }
+      try {
+        if (typeof clearTimeout === 'function') {
+          cachedClearTimeout = clearTimeout
+        } else {
+          cachedClearTimeout = defaultClearTimeout
+        }
+      } catch (e) {
+        cachedClearTimeout = defaultClearTimeout
+      }
+    }())
+    function runTimeout (fun) {
+      if (cachedSetTimeout === setTimeout) {
+      // normal enviroments in sane situations
+        return setTimeout(fun, 0)
+      }
+      // if setTimeout wasn't available but was latter defined
+      if ((cachedSetTimeout === defaultSetTimout || !cachedSetTimeout) && setTimeout) {
+        cachedSetTimeout = setTimeout
+        return setTimeout(fun, 0)
+      }
+      try {
+      // when when somebody has screwed with setTimeout but no I.E. maddness
+        return cachedSetTimeout(fun, 0)
+      } catch (e) {
+        try {
+        // When we are in I.E. but the script has been evaled so I.E. doesn't trust the global object when called normally
+          return cachedSetTimeout.call(null, fun, 0)
+        } catch (e) {
+        // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error
+          return cachedSetTimeout.call(this, fun, 0)
+        }
+      }
+    }
+    function runClearTimeout (marker) {
+      if (cachedClearTimeout === clearTimeout) {
+      // normal enviroments in sane situations
+        return clearTimeout(marker)
+      }
+      // if clearTimeout wasn't available but was latter defined
+      if ((cachedClearTimeout === defaultClearTimeout || !cachedClearTimeout) && clearTimeout) {
+        cachedClearTimeout = clearTimeout
+        return clearTimeout(marker)
+      }
+      try {
+      // when when somebody has screwed with setTimeout but no I.E. maddness
+        return cachedClearTimeout(marker)
+      } catch (e) {
+        try {
+        // When we are in I.E. but the script has been evaled so I.E. doesn't  trust the global object when called normally
+          return cachedClearTimeout.call(null, marker)
+        } catch (e) {
+        // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error.
+        // Some versions of I.E. have different rules for clearTimeout vs setTimeout
+          return cachedClearTimeout.call(this, marker)
+        }
+      }
+    }
+    var queue = []
+    var draining = false
+    var currentQueue
+    var queueIndex = -1
+
+    function cleanUpNextTick () {
+      if (!draining || !currentQueue) {
+        return
+      }
+      draining = false
+      if (currentQueue.length) {
+        queue = currentQueue.concat(queue)
+      } else {
+        queueIndex = -1
+      }
+      if (queue.length) {
+        drainQueue()
+      }
+    }
+
+    function drainQueue () {
+      if (draining) {
+        return
+      }
+      var timeout = runTimeout(cleanUpNextTick)
+      draining = true
+
+      var len = queue.length
+      while (len) {
+        currentQueue = queue
+        queue = []
+        while (++queueIndex < len) {
+          if (currentQueue) {
+            currentQueue[queueIndex].run()
+          }
+        }
+        queueIndex = -1
+        len = queue.length
+      }
+      currentQueue = null
+      draining = false
+      runClearTimeout(timeout)
+    }
+
+    process.nextTick = function (fun) {
+      var args = new Array(arguments.length - 1)
+      if (arguments.length > 1) {
+        for (var i = 1; i < arguments.length; i++) {
+          args[i - 1] = arguments[i]
+        }
+      }
+      queue.push(new Item(fun, args))
+      if (queue.length === 1 && !draining) {
+        runTimeout(drainQueue)
+      }
+    }
+
+    // v8 likes predictible objects
+    function Item (fun, array) {
+      this.fun = fun
+      this.array = array
+    }
+    Item.prototype.run = function () {
+      this.fun.apply(null, this.array)
+    }
+    process.title = 'browser'
+    process.browser = true
+    process.env = {}
+    process.argv = []
+    process.version = '' // empty string to avoid regexp issues
+    process.versions = {}
+
+    function noop () {}
+
+    process.on = noop
+    process.addListener = noop
+    process.once = noop
+    process.off = noop
+    process.removeListener = noop
+    process.removeAllListeners = noop
+    process.emit = noop
+    process.prependListener = noop
+    process.prependOnceListener = noop
+
+    process.listeners = function (name) { return [] }
+
+    process.binding = function (name) {
+      throw new Error('process.binding is not supported')
+    }
+
+    process.cwd = function () { return '/' }
+    process.chdir = function (dir) {
+      throw new Error('process.chdir is not supported')
+    }
+    process.umask = function () { return 0 }
+  }, {}],
+  35: [function (require, module, exports) {
+    'use strict'
+
+    var GetIntrinsic = require('get-intrinsic')
+    var define = require('define-data-property')
+    var hasDescriptors = require('has-property-descriptors')()
+    var gOPD = require('gopd')
+
+    var $TypeError = GetIntrinsic('%TypeError%')
+    var $floor = GetIntrinsic('%Math.floor%')
+
+    module.exports = function setFunctionLength (fn, length) {
+      if (typeof fn !== 'function') {
+        throw new $TypeError('`fn` is not a function')
+      }
+      if (typeof length !== 'number' || length < 0 || length > 0xFFFFFFFF || $floor(length) !== length) {
+        throw new $TypeError('`length` must be a positive 32-bit integer')
+      }
+
+      var loose = arguments.length > 2 && !!arguments[2]
+
+      var functionLengthIsConfigurable = true
+      var functionLengthIsWritable = true
+      if ('length' in fn && gOPD) {
+        var desc = gOPD(fn, 'length')
+        if (desc && !desc.configurable) {
+          functionLengthIsConfigurable = false
+        }
+        if (desc && !desc.writable) {
+          functionLengthIsWritable = false
+        }
+      }
+
+      if (functionLengthIsConfigurable || functionLengthIsWritable || !loose) {
+        if (hasDescriptors) {
+          define(fn, 'length', length, true, true)
+        } else {
+          define(fn, 'length', length)
+        }
+      }
+      return fn
+    }
+  }, { 'define-data-property': 17, 'get-intrinsic': 21, gopd: 22, 'has-property-descriptors': 23 }],
+  36: [function (require, module, exports) {
+    module.exports = function isBuffer (arg) {
+      return arg && typeof arg === 'object' &&
+    typeof arg.copy === 'function' &&
+    typeof arg.fill === 'function' &&
+    typeof arg.readUInt8 === 'function'
+    }
+  }, {}],
+  37: [function (require, module, exports) {
+    // Currently in sync with Node.js lib/internal/util/types.js
+    // https://github.com/nodejs/node/commit/112cc7c27551254aa2b17098fb774867f05ed0d9
+
+    'use strict'
+
+    var isArgumentsObject = require('is-arguments')
+    var isGeneratorFunction = require('is-generator-function')
+    var whichTypedArray = require('which-typed-array')
+    var isTypedArray = require('is-typed-array')
+
+    function uncurryThis (f) {
+      return f.call.bind(f)
+    }
+
+    var BigIntSupported = typeof BigInt !== 'undefined'
+    var SymbolSupported = typeof Symbol !== 'undefined'
+
+    var ObjectToString = uncurryThis(Object.prototype.toString)
+
+    var numberValue = uncurryThis(Number.prototype.valueOf)
+    var stringValue = uncurryThis(String.prototype.valueOf)
+    var booleanValue = uncurryThis(Boolean.prototype.valueOf)
+
+    if (BigIntSupported) {
+      var bigIntValue = uncurryThis(BigInt.prototype.valueOf)
+    }
+
+    if (SymbolSupported) {
+      var symbolValue = uncurryThis(Symbol.prototype.valueOf)
+    }
+
+    function checkBoxedPrimitive (value, prototypeValueOf) {
+      if (typeof value !== 'object') {
+        return false
+      }
+      try {
+        prototypeValueOf(value)
+        return true
+      } catch (e) {
+        return false
+      }
+    }
+
+    exports.isArgumentsObject = isArgumentsObject
+    exports.isGeneratorFunction = isGeneratorFunction
+    exports.isTypedArray = isTypedArray
+
+    // Taken from here and modified for better browser support
+    // https://github.com/sindresorhus/p-is-promise/blob/cda35a513bda03f977ad5cde3a079d237e82d7ef/index.js
+    function isPromise (input) {
+      return (
+        (
+          typeof Promise !== 'undefined' &&
+			input instanceof Promise
+        ) ||
+		(
+		  input !== null &&
+			typeof input === 'object' &&
+			typeof input.then === 'function' &&
+			typeof input.catch === 'function'
+		)
+      )
+    }
+    exports.isPromise = isPromise
+
+    function isArrayBufferView (value) {
+      if (typeof ArrayBuffer !== 'undefined' && ArrayBuffer.isView) {
+        return ArrayBuffer.isView(value)
+      }
+
+      return (
+        isTypedArray(value) ||
+    isDataView(value)
+      )
+    }
+    exports.isArrayBufferView = isArrayBufferView
+
+    function isUint8Array (value) {
+      return whichTypedArray(value) === 'Uint8Array'
+    }
+    exports.isUint8Array = isUint8Array
+
+    function isUint8ClampedArray (value) {
+      return whichTypedArray(value) === 'Uint8ClampedArray'
+    }
+    exports.isUint8ClampedArray = isUint8ClampedArray
+
+    function isUint16Array (value) {
+      return whichTypedArray(value) === 'Uint16Array'
+    }
+    exports.isUint16Array = isUint16Array
+
+    function isUint32Array (value) {
+      return whichTypedArray(value) === 'Uint32Array'
+    }
+    exports.isUint32Array = isUint32Array
+
+    function isInt8Array (value) {
+      return whichTypedArray(value) === 'Int8Array'
+    }
+    exports.isInt8Array = isInt8Array
+
+    function isInt16Array (value) {
+      return whichTypedArray(value) === 'Int16Array'
+    }
+    exports.isInt16Array = isInt16Array
+
+    function isInt32Array (value) {
+      return whichTypedArray(value) === 'Int32Array'
+    }
+    exports.isInt32Array = isInt32Array
+
+    function isFloat32Array (value) {
+      return whichTypedArray(value) === 'Float32Array'
+    }
+    exports.isFloat32Array = isFloat32Array
+
+    function isFloat64Array (value) {
+      return whichTypedArray(value) === 'Float64Array'
+    }
+    exports.isFloat64Array = isFloat64Array
+
+    function isBigInt64Array (value) {
+      return whichTypedArray(value) === 'BigInt64Array'
+    }
+    exports.isBigInt64Array = isBigInt64Array
+
+    function isBigUint64Array (value) {
+      return whichTypedArray(value) === 'BigUint64Array'
+    }
+    exports.isBigUint64Array = isBigUint64Array
+
+    function isMapToString (value) {
+      return ObjectToString(value) === '[object Map]'
+    }
+    isMapToString.working = (
+      typeof Map !== 'undefined' &&
+  isMapToString(new Map())
+    )
+
+    function isMap (value) {
+      if (typeof Map === 'undefined') {
+        return false
+      }
+
+      return isMapToString.working
+        ? isMapToString(value)
+        : value instanceof Map
+    }
+    exports.isMap = isMap
+
+    function isSetToString (value) {
+      return ObjectToString(value) === '[object Set]'
+    }
+    isSetToString.working = (
+      typeof Set !== 'undefined' &&
+  isSetToString(new Set())
+    )
+    function isSet (value) {
+      if (typeof Set === 'undefined') {
+        return false
+      }
+
+      return isSetToString.working
+        ? isSetToString(value)
+        : value instanceof Set
+    }
+    exports.isSet = isSet
+
+    function isWeakMapToString (value) {
+      return ObjectToString(value) === '[object WeakMap]'
+    }
+    isWeakMapToString.working = (
+      typeof WeakMap !== 'undefined' &&
+  isWeakMapToString(new WeakMap())
+    )
+    function isWeakMap (value) {
+      if (typeof WeakMap === 'undefined') {
+        return false
+      }
+
+      return isWeakMapToString.working
+        ? isWeakMapToString(value)
+        : value instanceof WeakMap
+    }
+    exports.isWeakMap = isWeakMap
+
+    function isWeakSetToString (value) {
+      return ObjectToString(value) === '[object WeakSet]'
+    }
+    isWeakSetToString.working = (
+      typeof WeakSet !== 'undefined' &&
+  isWeakSetToString(new WeakSet())
+    )
+    function isWeakSet (value) {
+      return isWeakSetToString(value)
+    }
+    exports.isWeakSet = isWeakSet
+
+    function isArrayBufferToString (value) {
+      return ObjectToString(value) === '[object ArrayBuffer]'
+    }
+    isArrayBufferToString.working = (
+      typeof ArrayBuffer !== 'undefined' &&
+  isArrayBufferToString(new ArrayBuffer())
+    )
+    function isArrayBuffer (value) {
+      if (typeof ArrayBuffer === 'undefined') {
+        return false
+      }
+
+      return isArrayBufferToString.working
+        ? isArrayBufferToString(value)
+        : value instanceof ArrayBuffer
+    }
+    exports.isArrayBuffer = isArrayBuffer
+
+    function isDataViewToString (value) {
+      return ObjectToString(value) === '[object DataView]'
+    }
+    isDataViewToString.working = (
+      typeof ArrayBuffer !== 'undefined' &&
+  typeof DataView !== 'undefined' &&
+  isDataViewToString(new DataView(new ArrayBuffer(1), 0, 1))
+    )
+    function isDataView (value) {
+      if (typeof DataView === 'undefined') {
+        return false
+      }
+
+      return isDataViewToString.working
+        ? isDataViewToString(value)
+        : value instanceof DataView
+    }
+    exports.isDataView = isDataView
+
+    // Store a copy of SharedArrayBuffer in case it's deleted elsewhere
+    var SharedArrayBufferCopy = typeof SharedArrayBuffer !== 'undefined' ? SharedArrayBuffer : undefined
+    function isSharedArrayBufferToString (value) {
+      return ObjectToString(value) === '[object SharedArrayBuffer]'
+    }
+    function isSharedArrayBuffer (value) {
+      if (typeof SharedArrayBufferCopy === 'undefined') {
+        return false
+      }
+
+      if (typeof isSharedArrayBufferToString.working === 'undefined') {
+        isSharedArrayBufferToString.working = isSharedArrayBufferToString(new SharedArrayBufferCopy())
+      }
+
+      return isSharedArrayBufferToString.working
+        ? isSharedArrayBufferToString(value)
+        : value instanceof SharedArrayBufferCopy
+    }
+    exports.isSharedArrayBuffer = isSharedArrayBuffer
+
+    function isAsyncFunction (value) {
+      return ObjectToString(value) === '[object AsyncFunction]'
+    }
+    exports.isAsyncFunction = isAsyncFunction
+
+    function isMapIterator (value) {
+      return ObjectToString(value) === '[object Map Iterator]'
+    }
+    exports.isMapIterator = isMapIterator
+
+    function isSetIterator (value) {
+      return ObjectToString(value) === '[object Set Iterator]'
+    }
+    exports.isSetIterator = isSetIterator
+
+    function isGeneratorObject (value) {
+      return ObjectToString(value) === '[object Generator]'
+    }
+    exports.isGeneratorObject = isGeneratorObject
+
+    function isWebAssemblyCompiledModule (value) {
+      return ObjectToString(value) === '[object WebAssembly.Module]'
+    }
+    exports.isWebAssemblyCompiledModule = isWebAssemblyCompiledModule
+
+    function isNumberObject (value) {
+      return checkBoxedPrimitive(value, numberValue)
+    }
+    exports.isNumberObject = isNumberObject
+
+    function isStringObject (value) {
+      return checkBoxedPrimitive(value, stringValue)
+    }
+    exports.isStringObject = isStringObject
+
+    function isBooleanObject (value) {
+      return checkBoxedPrimitive(value, booleanValue)
+    }
+    exports.isBooleanObject = isBooleanObject
+
+    function isBigIntObject (value) {
+      return BigIntSupported && checkBoxedPrimitive(value, bigIntValue)
+    }
+    exports.isBigIntObject = isBigIntObject
+
+    function isSymbolObject (value) {
+      return SymbolSupported && checkBoxedPrimitive(value, symbolValue)
+    }
+    exports.isSymbolObject = isSymbolObject
+
+    function isBoxedPrimitive (value) {
+      return (
+        isNumberObject(value) ||
+    isStringObject(value) ||
+    isBooleanObject(value) ||
+    isBigIntObject(value) ||
+    isSymbolObject(value)
+      )
+    }
+    exports.isBoxedPrimitive = isBoxedPrimitive
+
+    function isAnyArrayBuffer (value) {
+      return typeof Uint8Array !== 'undefined' && (
+        isArrayBuffer(value) ||
+    isSharedArrayBuffer(value)
+      )
+    }
+    exports.isAnyArrayBuffer = isAnyArrayBuffer;
+
+    ['isProxy', 'isExternal', 'isModuleNamespaceObject'].forEach(function (method) {
+      Object.defineProperty(exports, method, {
+        enumerable: false,
+        value: function () {
+          throw new Error(method + ' is not supported in userland')
+        }
+      })
+    })
+  }, { 'is-arguments': 30, 'is-generator-function': 32, 'is-typed-array': 33, 'which-typed-array': 39 }],
+  38: [function (require, module, exports) {
+    (function (process) {
+      (function () {
+        // Copyright Joyent, Inc. and other Node contributors.
+        //
+        // Permission is hereby granted, free of charge, to any person obtaining a
+        // copy of this software and associated documentation files (the
+        // "Software"), to deal in the Software without restriction, including
+        // without limitation the rights to use, copy, modify, merge, publish,
+        // distribute, sublicense, and/or sell copies of the Software, and to permit
+        // persons to whom the Software is furnished to do so, subject to the
+        // following conditions:
+        //
+        // The above copyright notice and this permission notice shall be included
+        // in all copies or substantial portions of the Software.
+        //
+        // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+        // OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+        // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+        // NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+        // DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+        // OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+        // USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+        var getOwnPropertyDescriptors = Object.getOwnPropertyDescriptors ||
+  function getOwnPropertyDescriptors (obj) {
+    var keys = Object.keys(obj)
+    var descriptors = {}
+    for (var i = 0; i < keys.length; i++) {
+      descriptors[keys[i]] = Object.getOwnPropertyDescriptor(obj, keys[i])
+    }
+    return descriptors
+  }
+
+        var formatRegExp = /%[sdj%]/g
+        exports.format = function (f) {
+          if (!isString(f)) {
+            var objects = []
+            for (var i = 0; i < arguments.length; i++) {
+              objects.push(inspect(arguments[i]))
+            }
+            return objects.join(' ')
+          }
+
+          var i = 1
+          var args = arguments
+          var len = args.length
+          var str = String(f).replace(formatRegExp, function (x) {
+            if (x === '%%') return '%'
+            if (i >= len) return x
+            switch (x) {
+              case '%s': return String(args[i++])
+              case '%d': return Number(args[i++])
+              case '%j':
+                try {
+                  return JSON.stringify(args[i++])
+                } catch (_) {
+                  return '[Circular]'
+                }
+              default:
+                return x
+            }
+          })
+          for (var x = args[i]; i < len; x = args[++i]) {
+            if (isNull(x) || !isObject(x)) {
+              str += ' ' + x
+            } else {
+              str += ' ' + inspect(x)
+            }
+          }
+          return str
+        }
+
+        // Mark that a method should not be used.
+        // Returns a modified function which warns once by default.
+        // If --no-deprecation is set, then it is a no-op.
+        exports.deprecate = function (fn, msg) {
+          if (typeof process !== 'undefined' && process.noDeprecation === true) {
+            return fn
+          }
+
+          // Allow for deprecating things in the process of starting up.
+          if (typeof process === 'undefined') {
+            return function () {
+              return exports.deprecate(fn, msg).apply(this, arguments)
+            }
+          }
+
+          var warned = false
+          function deprecated () {
+            if (!warned) {
+              if (process.throwDeprecation) {
+                throw new Error(msg)
+              } else if (process.traceDeprecation) {
+                console.trace(msg)
+              } else {
+                console.error(msg)
+              }
+              warned = true
+            }
+            return fn.apply(this, arguments)
+          }
+
+          return deprecated
+        }
+
+        var debugs = {}
+        var debugEnvRegex = /^$/
+
+        if (process.env.NODE_DEBUG) {
+          var debugEnv = process.env.NODE_DEBUG
+          debugEnv = debugEnv.replace(/[|\\{}()[\]^$+?.]/g, '\\$&')
+            .replace(/\*/g, '.*')
+            .replace(/,/g, '$|^')
+            .toUpperCase()
+          debugEnvRegex = new RegExp('^' + debugEnv + '$', 'i')
+        }
+        exports.debuglog = function (set) {
+          set = set.toUpperCase()
+          if (!debugs[set]) {
+            if (debugEnvRegex.test(set)) {
+              var pid = process.pid
+              debugs[set] = function () {
+                var msg = exports.format.apply(exports, arguments)
+                console.error('%s %d: %s', set, pid, msg)
+              }
+            } else {
+              debugs[set] = function () {}
+            }
+          }
+          return debugs[set]
+        }
+
+        /**
+ * Echos the value of a value. Trys to print the value out
+ * in the best way possible given the different types.
+ *
+ * @param {Object} obj The object to print out.
+ * @param {Object} opts Optional options object that alters the output.
+ */
+        /* legacy: obj, showHidden, depth, colors */
+        function inspect (obj, opts) {
+          // default options
+          var ctx = {
+            seen: [],
+            stylize: stylizeNoColor
+          }
+          // legacy...
+          if (arguments.length >= 3) ctx.depth = arguments[2]
+          if (arguments.length >= 4) ctx.colors = arguments[3]
+          if (isBoolean(opts)) {
+            // legacy...
+            ctx.showHidden = opts
+          } else if (opts) {
+            // got an "options" object
+            exports._extend(ctx, opts)
+          }
+          // set default options
+          if (isUndefined(ctx.showHidden)) ctx.showHidden = false
+          if (isUndefined(ctx.depth)) ctx.depth = 2
+          if (isUndefined(ctx.colors)) ctx.colors = false
+          if (isUndefined(ctx.customInspect)) ctx.customInspect = true
+          if (ctx.colors) ctx.stylize = stylizeWithColor
+          return formatValue(ctx, obj, ctx.depth)
+        }
+        exports.inspect = inspect
+
+        // http://en.wikipedia.org/wiki/ANSI_escape_code#graphics
+        inspect.colors = {
+          bold: [1, 22],
+          italic: [3, 23],
+          underline: [4, 24],
+          inverse: [7, 27],
+          white: [37, 39],
+          grey: [90, 39],
+          black: [30, 39],
+          blue: [34, 39],
+          cyan: [36, 39],
+          green: [32, 39],
+          magenta: [35, 39],
+          red: [31, 39],
+          yellow: [33, 39]
+        }
+
+        // Don't use 'blue' not visible on cmd.exe
+        inspect.styles = {
+          special: 'cyan',
+          number: 'yellow',
+          boolean: 'yellow',
+          undefined: 'grey',
+          null: 'bold',
+          string: 'green',
+          date: 'magenta',
+          // "name": intentionally not styling
+          regexp: 'red'
+        }
+
+        function stylizeWithColor (str, styleType) {
+          var style = inspect.styles[styleType]
+
+          if (style) {
+            return '\u001b[' + inspect.colors[style][0] + 'm' + str +
+           '\u001b[' + inspect.colors[style][1] + 'm'
+          } else {
+            return str
+          }
+        }
+
+        function stylizeNoColor (str, styleType) {
+          return str
+        }
+
+        function arrayToHash (array) {
+          var hash = {}
+
+          array.forEach(function (val, idx) {
+            hash[val] = true
+          })
+
+          return hash
+        }
+
+        function formatValue (ctx, value, recurseTimes) {
+          // Provide a hook for user-specified inspect functions.
+          // Check that value is an object with an inspect function on it
+          if (ctx.customInspect &&
+      value &&
+      isFunction(value.inspect) &&
+      // Filter out the util module, it's inspect function is special
+      value.inspect !== exports.inspect &&
+      // Also filter out any prototype objects using the circular check.
+      !(value.constructor && value.constructor.prototype === value)) {
+            var ret = value.inspect(recurseTimes, ctx)
+            if (!isString(ret)) {
+              ret = formatValue(ctx, ret, recurseTimes)
+            }
+            return ret
+          }
+
+          // Primitive types cannot have properties
+          var primitive = formatPrimitive(ctx, value)
+          if (primitive) {
+            return primitive
+          }
+
+          // Look up the keys of the object.
+          var keys = Object.keys(value)
+          var visibleKeys = arrayToHash(keys)
+
+          if (ctx.showHidden) {
+            keys = Object.getOwnPropertyNames(value)
+          }
+
+          // IE doesn't make error fields non-enumerable
+          // http://msdn.microsoft.com/en-us/library/ie/dww52sbt(v=vs.94).aspx
+          if (isError(value) &&
+      (keys.indexOf('message') >= 0 || keys.indexOf('description') >= 0)) {
+            return formatError(value)
+          }
+
+          // Some type of object without properties can be shortcutted.
+          if (keys.length === 0) {
+            if (isFunction(value)) {
+              var name = value.name ? ': ' + value.name : ''
+              return ctx.stylize('[Function' + name + ']', 'special')
+            }
+            if (isRegExp(value)) {
+              return ctx.stylize(RegExp.prototype.toString.call(value), 'regexp')
+            }
+            if (isDate(value)) {
+              return ctx.stylize(Date.prototype.toString.call(value), 'date')
+            }
+            if (isError(value)) {
+              return formatError(value)
+            }
+          }
+
+          var base = ''; var array = false; var braces = ['{', '}']
+
+          // Make Array say that they are Array
+          if (isArray(value)) {
+            array = true
+            braces = ['[', ']']
+          }
+
+          // Make functions say that they are functions
+          if (isFunction(value)) {
+            var n = value.name ? ': ' + value.name : ''
+            base = ' [Function' + n + ']'
+          }
+
+          // Make RegExps say that they are RegExps
+          if (isRegExp(value)) {
+            base = ' ' + RegExp.prototype.toString.call(value)
+          }
+
+          // Make dates with properties first say the date
+          if (isDate(value)) {
+            base = ' ' + Date.prototype.toUTCString.call(value)
+          }
+
+          // Make error with message first say the error
+          if (isError(value)) {
+            base = ' ' + formatError(value)
+          }
+
+          if (keys.length === 0 && (!array || value.length == 0)) {
+            return braces[0] + base + braces[1]
+          }
+
+          if (recurseTimes < 0) {
+            if (isRegExp(value)) {
+              return ctx.stylize(RegExp.prototype.toString.call(value), 'regexp')
+            } else {
+              return ctx.stylize('[Object]', 'special')
+            }
+          }
+
+          ctx.seen.push(value)
+
+          var output
+          if (array) {
+            output = formatArray(ctx, value, recurseTimes, visibleKeys, keys)
+          } else {
+            output = keys.map(function (key) {
+              return formatProperty(ctx, value, recurseTimes, visibleKeys, key, array)
+            })
+          }
+
+          ctx.seen.pop()
+
+          return reduceToSingleString(output, base, braces)
+        }
+
+        function formatPrimitive (ctx, value) {
+          if (isUndefined(value)) { return ctx.stylize('undefined', 'undefined') }
+          if (isString(value)) {
+            var simple = '\'' + JSON.stringify(value).replace(/^"|"$/g, '')
+              .replace(/'/g, "\\'")
+              .replace(/\\"/g, '"') + '\''
+            return ctx.stylize(simple, 'string')
+          }
+          if (isNumber(value)) { return ctx.stylize('' + value, 'number') }
+          if (isBoolean(value)) { return ctx.stylize('' + value, 'boolean') }
+          // For some reason typeof null is "object", so special case here.
+          if (isNull(value)) { return ctx.stylize('null', 'null') }
+        }
+
+        function formatError (value) {
+          return '[' + Error.prototype.toString.call(value) + ']'
+        }
+
+        function formatArray (ctx, value, recurseTimes, visibleKeys, keys) {
+          var output = []
+          for (var i = 0, l = value.length; i < l; ++i) {
+            if (hasOwnProperty(value, String(i))) {
+              output.push(formatProperty(ctx, value, recurseTimes, visibleKeys,
+                String(i), true))
+            } else {
+              output.push('')
+            }
+          }
+          keys.forEach(function (key) {
+            if (!key.match(/^\d+$/)) {
+              output.push(formatProperty(ctx, value, recurseTimes, visibleKeys,
+                key, true))
+            }
+          })
+          return output
+        }
+
+        function formatProperty (ctx, value, recurseTimes, visibleKeys, key, array) {
+          var name, str, desc
+          desc = Object.getOwnPropertyDescriptor(value, key) || { value: value[key] }
+          if (desc.get) {
+            if (desc.set) {
+              str = ctx.stylize('[Getter/Setter]', 'special')
+            } else {
+              str = ctx.stylize('[Getter]', 'special')
+            }
+          } else {
+            if (desc.set) {
+              str = ctx.stylize('[Setter]', 'special')
+            }
+          }
+          if (!hasOwnProperty(visibleKeys, key)) {
+            name = '[' + key + ']'
+          }
+          if (!str) {
+            if (ctx.seen.indexOf(desc.value) < 0) {
+              if (isNull(recurseTimes)) {
+                str = formatValue(ctx, desc.value, null)
+              } else {
+                str = formatValue(ctx, desc.value, recurseTimes - 1)
+              }
+              if (str.indexOf('\n') > -1) {
+                if (array) {
+                  str = str.split('\n').map(function (line) {
+                    return '  ' + line
+                  }).join('\n').slice(2)
+                } else {
+                  str = '\n' + str.split('\n').map(function (line) {
+                    return '   ' + line
+                  }).join('\n')
+                }
+              }
+            } else {
+              str = ctx.stylize('[Circular]', 'special')
+            }
+          }
+          if (isUndefined(name)) {
+            if (array && key.match(/^\d+$/)) {
+              return str
+            }
+            name = JSON.stringify('' + key)
+            if (name.match(/^"([a-zA-Z_][a-zA-Z_0-9]*)"$/)) {
+              name = name.slice(1, -1)
+              name = ctx.stylize(name, 'name')
+            } else {
+              name = name.replace(/'/g, "\\'")
+                .replace(/\\"/g, '"')
+                .replace(/(^"|"$)/g, "'")
+              name = ctx.stylize(name, 'string')
+            }
+          }
+
+          return name + ': ' + str
+        }
+
+        function reduceToSingleString (output, base, braces) {
+          var numLinesEst = 0
+          var length = output.reduce(function (prev, cur) {
+            numLinesEst++
+            if (cur.indexOf('\n') >= 0) numLinesEst++
+            return prev + cur.replace(/\u001b\[\d\d?m/g, '').length + 1
+          }, 0)
+
+          if (length > 60) {
+            return braces[0] +
+           (base === '' ? '' : base + '\n ') +
+           ' ' +
+           output.join(',\n  ') +
+           ' ' +
+           braces[1]
+          }
+
+          return braces[0] + base + ' ' + output.join(', ') + ' ' + braces[1]
+        }
+
+        // NOTE: These type checking functions intentionally don't use `instanceof`
+        // because it is fragile and can be easily faked with `Object.create()`.
+        exports.types = require('./support/types')
+
+        function isArray (ar) {
+          return Array.isArray(ar)
+        }
+        exports.isArray = isArray
+
+        function isBoolean (arg) {
+          return typeof arg === 'boolean'
+        }
+        exports.isBoolean = isBoolean
+
+        function isNull (arg) {
+          return arg === null
+        }
+        exports.isNull = isNull
+
+        function isNullOrUndefined (arg) {
+          return arg == null
+        }
+        exports.isNullOrUndefined = isNullOrUndefined
+
+        function isNumber (arg) {
+          return typeof arg === 'number'
+        }
+        exports.isNumber = isNumber
+
+        function isString (arg) {
+          return typeof arg === 'string'
+        }
+        exports.isString = isString
+
+        function isSymbol (arg) {
+          return typeof arg === 'symbol'
+        }
+        exports.isSymbol = isSymbol
+
+        function isUndefined (arg) {
+          return arg === void 0
+        }
+        exports.isUndefined = isUndefined
+
+        function isRegExp (re) {
+          return isObject(re) && objectToString(re) === '[object RegExp]'
+        }
+        exports.isRegExp = isRegExp
+        exports.types.isRegExp = isRegExp
+
+        function isObject (arg) {
+          return typeof arg === 'object' && arg !== null
+        }
+        exports.isObject = isObject
+
+        function isDate (d) {
+          return isObject(d) && objectToString(d) === '[object Date]'
+        }
+        exports.isDate = isDate
+        exports.types.isDate = isDate
+
+        function isError (e) {
+          return isObject(e) &&
+      (objectToString(e) === '[object Error]' || e instanceof Error)
+        }
+        exports.isError = isError
+        exports.types.isNativeError = isError
+
+        function isFunction (arg) {
+          return typeof arg === 'function'
+        }
+        exports.isFunction = isFunction
+
+        function isPrimitive (arg) {
+          return arg === null ||
+         typeof arg === 'boolean' ||
+         typeof arg === 'number' ||
+         typeof arg === 'string' ||
+         typeof arg === 'symbol' || // ES6 symbol
+         typeof arg === 'undefined'
+        }
+        exports.isPrimitive = isPrimitive
+
+        exports.isBuffer = require('./support/isBuffer')
+
+        function objectToString (o) {
+          return Object.prototype.toString.call(o)
+        }
+
+        function pad (n) {
+          return n < 10 ? '0' + n.toString(10) : n.toString(10)
+        }
+
+        var months = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep',
+          'Oct', 'Nov', 'Dec']
+
+        // 26 Feb 16:19:34
+        function timestamp () {
+          var d = new Date()
+          var time = [pad(d.getHours()),
+            pad(d.getMinutes()),
+            pad(d.getSeconds())].join(':')
+          return [d.getDate(), months[d.getMonth()], time].join(' ')
+        }
+
+        // log is just a thin wrapper to console.log that prepends a timestamp
+        exports.log = function () {
+          console.log('%s - %s', timestamp(), exports.format.apply(exports, arguments))
+        }
+
+        /**
+ * Inherit the prototype methods from one constructor into another.
+ *
+ * The Function.prototype.inherits from lang.js rewritten as a standalone
+ * function (not on Function.prototype). NOTE: If this file is to be loaded
+ * during bootstrapping this function needs to be rewritten using some native
+ * functions as prototype setup using normal JavaScript does not work as
+ * expected during bootstrapping (see mirror.js in r114903).
+ *
+ * @param {function} ctor Constructor function which needs to inherit the
+ *     prototype.
+ * @param {function} superCtor Constructor function to inherit prototype from.
+ */
+        exports.inherits = require('inherits')
+
+        exports._extend = function (origin, add) {
+          // Don't do anything if add isn't an object
+          if (!add || !isObject(add)) return origin
+
+          var keys = Object.keys(add)
+          var i = keys.length
+          while (i--) {
+            origin[keys[i]] = add[keys[i]]
+          }
+          return origin
+        }
+
+        function hasOwnProperty (obj, prop) {
+          return Object.prototype.hasOwnProperty.call(obj, prop)
+        }
+
+        var kCustomPromisifiedSymbol = typeof Symbol !== 'undefined' ? Symbol('util.promisify.custom') : undefined
+
+        exports.promisify = function promisify (original) {
+          if (typeof original !== 'function') { throw new TypeError('The "original" argument must be of type Function') }
+
+          if (kCustomPromisifiedSymbol && original[kCustomPromisifiedSymbol]) {
+            var fn = original[kCustomPromisifiedSymbol]
+            if (typeof fn !== 'function') {
+              throw new TypeError('The "util.promisify.custom" argument must be of type Function')
+            }
+            Object.defineProperty(fn, kCustomPromisifiedSymbol, {
+              value: fn, enumerable: false, writable: false, configurable: true
+            })
+            return fn
+          }
+
+          function fn () {
+            var promiseResolve, promiseReject
+            var promise = new Promise(function (resolve, reject) {
+              promiseResolve = resolve
+              promiseReject = reject
+            })
+
+            var args = []
+            for (var i = 0; i < arguments.length; i++) {
+              args.push(arguments[i])
+            }
+            args.push(function (err, value) {
+              if (err) {
+                promiseReject(err)
+              } else {
+                promiseResolve(value)
+              }
+            })
+
+            try {
+              original.apply(this, args)
+            } catch (err) {
+              promiseReject(err)
+            }
+
+            return promise
+          }
+
+          Object.setPrototypeOf(fn, Object.getPrototypeOf(original))
+
+          if (kCustomPromisifiedSymbol) {
+            Object.defineProperty(fn, kCustomPromisifiedSymbol, {
+              value: fn, enumerable: false, writable: false, configurable: true
+            })
+          }
+          return Object.defineProperties(
+            fn,
+            getOwnPropertyDescriptors(original)
+          )
+        }
+
+        exports.promisify.custom = kCustomPromisifiedSymbol
+
+        function callbackifyOnRejected (reason, cb) {
+          // `!reason` guard inspired by bluebird (Ref: https://goo.gl/t5IS6M).
+          // Because `null` is a special error value in callbacks which means "no error
+          // occurred", we error-wrap so the callback consumer can distinguish between
+          // "the promise rejected with null" or "the promise fulfilled with undefined".
+          if (!reason) {
+            var newReason = new Error('Promise was rejected with a falsy value')
+            newReason.reason = reason
+            reason = newReason
+          }
+          return cb(reason)
+        }
+
+        function callbackify (original) {
+          if (typeof original !== 'function') {
+            throw new TypeError('The "original" argument must be of type Function')
+          }
+
+          // We DO NOT return the promise as it gives the user a false sense that
+          // the promise is actually somehow related to the callback's execution
+          // and that the callback throwing will reject the promise.
+          function callbackified () {
+            var args = []
+            for (var i = 0; i < arguments.length; i++) {
+              args.push(arguments[i])
+            }
+
+            var maybeCb = args.pop()
+            if (typeof maybeCb !== 'function') {
+              throw new TypeError('The last argument must be of type Function')
+            }
+            var self = this
+            var cb = function () {
+              return maybeCb.apply(self, arguments)
+            }
+            // In true node style we process the callback on `nextTick` with all the
+            // implications (stack, `uncaughtException`, `async_hooks`)
+            original.apply(this, args)
+              .then(function (ret) { process.nextTick(cb.bind(null, null, ret)) },
+                function (rej) { process.nextTick(callbackifyOnRejected.bind(null, rej, cb)) })
+          }
+
+          Object.setPrototypeOf(callbackified, Object.getPrototypeOf(original))
+          Object.defineProperties(callbackified,
+            getOwnPropertyDescriptors(original))
+          return callbackified
+        }
+        exports.callbackify = callbackify
+      }).call(this)
+    }).call(this, require('_process'))
+  }, { './support/isBuffer': 36, './support/types': 37, _process: 34, inherits: 29 }],
+  39: [function (require, module, exports) {
+    (function (global) {
+      (function () {
+        'use strict'
+
+        var forEach = require('for-each')
+        var availableTypedArrays = require('available-typed-arrays')
+        var callBind = require('call-bind')
+        var callBound = require('call-bind/callBound')
+        var gOPD = require('gopd')
+
+        var $toString = callBound('Object.prototype.toString')
+        var hasToStringTag = require('has-tostringtag/shams')()
+
+        var g = typeof globalThis === 'undefined' ? global : globalThis
+        var typedArrays = availableTypedArrays()
+
+        var $slice = callBound('String.prototype.slice')
+        var getPrototypeOf = Object.getPrototypeOf // require('getprototypeof');
+
+        var $indexOf = callBound('Array.prototype.indexOf', true) || function indexOf (array, value) {
+          for (var i = 0; i < array.length; i += 1) {
+            if (array[i] === value) {
+              return i
+            }
+          }
+          return -1
+        }
+        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)
+              var descriptor = gOPD(proto, Symbol.toStringTag)
+              if (!descriptor) {
+                var superProto = getPrototypeOf(proto)
+                descriptor = gOPD(superProto, Symbol.toStringTag)
+              }
+              cache['$' + typedArray] = callBind(descriptor.get)
+            }
+          })
+        } else {
+          forEach(typedArrays, function (typedArray) {
+            var arr = new g[typedArray]()
+            var fn = arr.slice || arr.set
+            if (fn) {
+              cache['$' + typedArray] = callBind(fn)
+            }
+          })
+        }
+
+        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) { /**/ }
+            }
+          })
+          return found
+        }
+
+        var trySlices = function tryAllSlices (value) {
+          var found = false
+          forEach(cache, function (getter, name) {
+            if (!found) {
+              try {
+                getter(value)
+                found = $slice(name, 1)
+              } catch (e) { /**/ }
+            }
+          })
+          return found
+        }
+
+        module.exports = function whichTypedArray (value) {
+          if (!value || typeof value !== 'object') { return false }
+          if (!hasToStringTag) {
+            var tag = $slice($toString(value), 8, -1)
+            if ($indexOf(typedArrays, tag) > -1) {
+              return tag
+            }
+            if (tag !== 'Object') {
+              return false
+            }
+            // node < 0.6 hits here on real Typed Arrays
+            return trySlices(value)
+          }
+          if (!gOPD) { return null } // unknown engine
+          return tryTypedArrays(value)
+        }
+      }).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])