{"version":3,"sources":["jsdelivr-header.js","/npm/sinon@21.0.2/pkg/node_modules/@sinonjs/commons/lib/global.js","/npm/sinon@21.0.2/pkg/node_modules/@sinonjs/commons/lib/prototypes/throws-on-proto.js","/npm/sinon@21.0.2/pkg/node_modules/@sinonjs/commons/lib/prototypes/copy-prototype-methods.js","/npm/sinon@21.0.2/pkg/node_modules/@sinonjs/commons/lib/prototypes/array.js","/npm/sinon@21.0.2/pkg/node_modules/@sinonjs/commons/lib/called-in-order.js","/npm/sinon@21.0.2/pkg/node_modules/@sinonjs/commons/lib/class-name.js","/npm/sinon@21.0.2/pkg/node_modules/@sinonjs/commons/lib/deprecated.js","/npm/sinon@21.0.2/pkg/node_modules/@sinonjs/commons/lib/every.js","/npm/sinon@21.0.2/pkg/node_modules/@sinonjs/commons/lib/function-name.js","/npm/sinon@21.0.2/pkg/node_modules/@sinonjs/commons/lib/order-by-first-call.js","/npm/sinon@21.0.2/pkg/node_modules/@sinonjs/commons/lib/prototypes/function.js","/npm/sinon@21.0.2/pkg/node_modules/@sinonjs/commons/lib/prototypes/map.js","/npm/sinon@21.0.2/pkg/node_modules/@sinonjs/commons/lib/prototypes/object.js","/npm/sinon@21.0.2/pkg/node_modules/@sinonjs/commons/lib/prototypes/set.js","/npm/sinon@21.0.2/pkg/node_modules/@sinonjs/commons/lib/prototypes/string.js","/npm/sinon@21.0.2/pkg/node_modules/@sinonjs/commons/lib/prototypes/index.js","/npm/sinon@21.0.2/pkg/node_modules/type-detect/type-detect.js","/npm/sinon@21.0.2/pkg/node_modules/@sinonjs/commons/lib/type-of.js","/npm/sinon@21.0.2/pkg/node_modules/@sinonjs/commons/lib/value-to-string.js","/npm/sinon@21.0.2/pkg/node_modules/@sinonjs/commons/lib/index.js","/npm/sinon@21.0.2/pkg/lib/sinon/util/core/extend.js","/npm/sinon@21.0.2/pkg/lib/sinon/util/core/get-next-tick.js","/npm/sinon@21.0.2/pkg/lib/sinon/util/core/next-tick.js","/npm/sinon@21.0.2/pkg/lib/sinon/util/core/export-async-behaviors.js","/npm/sinon@21.0.2/pkg/lib/sinon/behavior.js","/npm/sinon@21.0.2/pkg/lib/sinon/util/core/walk.js","/npm/sinon@21.0.2/pkg/lib/sinon/util/core/get-property-descriptor.js","/npm/sinon@21.0.2/pkg/lib/sinon/collect-own-methods.js","/npm/sinon@21.0.2/pkg/lib/sinon/util/core/is-property-configurable.js","/npm/sinon@21.0.2/pkg/node_modules/@sinonjs/samsam/lib/is-nan.js","/npm/sinon@21.0.2/pkg/node_modules/@sinonjs/samsam/lib/is-neg-zero.js","/npm/sinon@21.0.2/pkg/node_modules/@sinonjs/samsam/lib/identical.js","/npm/sinon@21.0.2/pkg/node_modules/@sinonjs/samsam/lib/get-class.js","/npm/sinon@21.0.2/pkg/node_modules/@sinonjs/samsam/lib/is-arguments.js","/npm/sinon@21.0.2/pkg/node_modules/@sinonjs/samsam/lib/is-element.js","/npm/sinon@21.0.2/pkg/node_modules/@sinonjs/samsam/lib/is-set.js","/npm/sinon@21.0.2/pkg/node_modules/@sinonjs/samsam/lib/is-map.js","/npm/sinon@21.0.2/pkg/node_modules/@sinonjs/samsam/node_modules/type-detect/type-detect.js","/npm/sinon@21.0.2/pkg/node_modules/@sinonjs/samsam/lib/array-types.js","/npm/sinon@21.0.2/pkg/node_modules/@sinonjs/samsam/lib/is-array-type.js","/npm/sinon@21.0.2/pkg/node_modules/@sinonjs/samsam/lib/is-date.js","/npm/sinon@21.0.2/pkg/node_modules/@sinonjs/samsam/lib/is-iterable.js","/npm/sinon@21.0.2/pkg/node_modules/@sinonjs/samsam/lib/is-object.js","/npm/sinon@21.0.2/pkg/node_modules/@sinonjs/samsam/lib/is-subset.js","/npm/sinon@21.0.2/pkg/node_modules/@sinonjs/samsam/lib/deep-equal.js","/npm/sinon@21.0.2/pkg/node_modules/@sinonjs/samsam/lib/iterable-to-string.js","/npm/sinon@21.0.2/pkg/node_modules/@sinonjs/samsam/lib/create-matcher/matcher-prototype.js","/npm/sinon@21.0.2/pkg/node_modules/@sinonjs/samsam/lib/create-matcher/is-matcher.js","/npm/sinon@21.0.2/pkg/node_modules/@sinonjs/samsam/lib/create-matcher/assert-matcher.js","/npm/sinon@21.0.2/pkg/node_modules/@sinonjs/samsam/lib/create-matcher/assert-method-exists.js","/npm/sinon@21.0.2/pkg/node_modules/@sinonjs/samsam/lib/create-matcher/assert-type.js","/npm/sinon@21.0.2/pkg/node_modules/@sinonjs/samsam/lib/create-matcher/is-iterable.js","/npm/sinon@21.0.2/pkg/node_modules/@sinonjs/samsam/lib/create-matcher/match-object.js","/npm/sinon@21.0.2/pkg/node_modules/@sinonjs/samsam/lib/create-matcher/type-map.js","/npm/sinon@21.0.2/pkg/node_modules/@sinonjs/samsam/lib/create-matcher.js","/npm/sinon@21.0.2/pkg/node_modules/@sinonjs/samsam/lib/match.js","/npm/sinon@21.0.2/pkg/node_modules/@sinonjs/samsam/lib/samsam.js","/npm/sinon@21.0.2/pkg/lib/sinon/util/core/times-in-words.js","/npm/sinon@21.0.2/pkg/node_modules/has-symbols/shams.js","/npm/sinon@21.0.2/pkg/node_modules/has-tostringtag/shams.js","/npm/sinon@21.0.2/pkg/node_modules/es-errors/index.js","/npm/sinon@21.0.2/pkg/node_modules/es-errors/eval.js","/npm/sinon@21.0.2/pkg/node_modules/es-errors/range.js","/npm/sinon@21.0.2/pkg/node_modules/es-errors/ref.js","/npm/sinon@21.0.2/pkg/node_modules/es-errors/syntax.js","/npm/sinon@21.0.2/pkg/node_modules/es-errors/type.js","/npm/sinon@21.0.2/pkg/node_modules/es-errors/uri.js","/npm/sinon@21.0.2/pkg/node_modules/has-symbols/index.js","/npm/sinon@21.0.2/pkg/node_modules/has-proto/index.js","/npm/sinon@21.0.2/pkg/node_modules/function-bind/implementation.js","/npm/sinon@21.0.2/pkg/node_modules/function-bind/index.js","/npm/sinon@21.0.2/pkg/node_modules/hasown/index.js","/npm/sinon@21.0.2/pkg/node_modules/get-intrinsic/index.js","/npm/sinon@21.0.2/pkg/node_modules/es-define-property/index.js","/npm/sinon@21.0.2/pkg/node_modules/gopd/index.js","/npm/sinon@21.0.2/pkg/node_modules/define-data-property/index.js","/npm/sinon@21.0.2/pkg/node_modules/has-property-descriptors/index.js","/npm/sinon@21.0.2/pkg/node_modules/set-function-length/index.js","/npm/sinon@21.0.2/pkg/node_modules/call-bind/index.js","/npm/sinon@21.0.2/pkg/node_modules/call-bind/callBound.js","/npm/sinon@21.0.2/pkg/node_modules/is-arguments/index.js","/npm/sinon@21.0.2/pkg/node_modules/is-generator-function/index.js","/npm/sinon@21.0.2/pkg/node_modules/is-callable/index.js","/npm/sinon@21.0.2/pkg/node_modules/for-each/index.js","/npm/sinon@21.0.2/pkg/node_modules/possible-typed-array-names/index.js","/npm/sinon@21.0.2/pkg/node_modules/available-typed-arrays/index.js","/npm/sinon@21.0.2/pkg/node_modules/which-typed-array/index.js","/npm/sinon@21.0.2/pkg/node_modules/is-typed-array/index.js","/npm/sinon@21.0.2/pkg/node_modules/util/support/types.js","/npm/sinon@21.0.2/pkg/node_modules/util/support/isBufferBrowser.js","/npm/sinon@21.0.2/pkg/node_modules/inherits/inherits_browser.js","/npm/sinon@21.0.2/pkg/node_modules/util/util.js","/npm/sinon@21.0.2/pkg/lib/sinon/assert.js","/npm/sinon@21.0.2/pkg/node_modules/@sinonjs/fake-timers/src/fake-timers-src.js","/npm/sinon@21.0.2/pkg/lib/sinon/util/fake-timers.js","/npm/sinon@21.0.2/pkg/lib/sinon/proxy-call-util.js","/npm/sinon@21.0.2/pkg/lib/sinon/proxy-invoke.js","/npm/sinon@21.0.2/pkg/lib/sinon/proxy-call.js","/npm/sinon@21.0.2/pkg/lib/sinon/default-behaviors.js","/npm/sinon@21.0.2/pkg/lib/sinon/util/core/function-to-string.js","/npm/sinon@21.0.2/pkg/node_modules/supports-color/browser.js","/npm/sinon@21.0.2/pkg/lib/sinon/colorizer.js","/npm/sinon@21.0.2/pkg/node_modules/diff/libcjs/diff/base.js","/npm/sinon@21.0.2/pkg/node_modules/diff/libcjs/diff/character.js","/npm/sinon@21.0.2/pkg/node_modules/diff/libcjs/util/string.js","/npm/sinon@21.0.2/pkg/node_modules/diff/libcjs/diff/word.js","/npm/sinon@21.0.2/pkg/node_modules/diff/libcjs/util/params.js","/npm/sinon@21.0.2/pkg/node_modules/diff/libcjs/diff/line.js","/npm/sinon@21.0.2/pkg/node_modules/diff/libcjs/diff/sentence.js","/npm/sinon@21.0.2/pkg/node_modules/diff/libcjs/diff/css.js","/npm/sinon@21.0.2/pkg/node_modules/diff/libcjs/diff/json.js","/npm/sinon@21.0.2/pkg/node_modules/diff/libcjs/diff/array.js","/npm/sinon@21.0.2/pkg/node_modules/diff/libcjs/patch/line-endings.js","/npm/sinon@21.0.2/pkg/node_modules/diff/libcjs/patch/parse.js","/npm/sinon@21.0.2/pkg/node_modules/diff/libcjs/util/distance-iterator.js","/npm/sinon@21.0.2/pkg/node_modules/diff/libcjs/patch/apply.js","/npm/sinon@21.0.2/pkg/node_modules/diff/libcjs/patch/reverse.js","/npm/sinon@21.0.2/pkg/node_modules/diff/libcjs/patch/create.js","/npm/sinon@21.0.2/pkg/node_modules/diff/libcjs/convert/dmp.js","/npm/sinon@21.0.2/pkg/node_modules/diff/libcjs/convert/xml.js","/npm/sinon@21.0.2/pkg/node_modules/diff/libcjs/index.js","/npm/sinon@21.0.2/pkg/lib/sinon/spy-formatters.js","/npm/sinon@21.0.2/pkg/lib/sinon/proxy.js","/npm/sinon@21.0.2/pkg/lib/sinon/util/core/is-non-existent-property.js","/npm/sinon@21.0.2/pkg/lib/sinon/util/core/is-es-module.js","/npm/sinon@21.0.2/pkg/lib/sinon/util/core/walk-object.js","/npm/sinon@21.0.2/pkg/lib/sinon/util/core/sinon-type.js","/npm/sinon@21.0.2/pkg/lib/sinon/util/core/wrap-method.js","/npm/sinon@21.0.2/pkg/lib/sinon/spy.js","/npm/sinon@21.0.2/pkg/lib/sinon/throw-on-falsy-object.js","/npm/sinon@21.0.2/pkg/lib/sinon/stub.js","/npm/sinon@21.0.2/pkg/lib/sinon/mock-expectation.js","/npm/sinon@21.0.2/pkg/lib/sinon/mock.js","/npm/sinon@21.0.2/pkg/lib/sinon/create-stub-instance.js","/npm/sinon@21.0.2/pkg/lib/sinon/fake.js","/npm/sinon@21.0.2/pkg/lib/sinon/sandbox.js","/npm/sinon@21.0.2/pkg/lib/sinon/create-sandbox.js","/npm/sinon@21.0.2/pkg/lib/sinon/util/core/is-restorable.js","/npm/sinon@21.0.2/pkg/lib/sinon/promise.js","/npm/sinon@21.0.2/pkg/lib/sinon/restore-object.js","/npm/sinon@21.0.2/pkg/lib/sinon.js","/npm/sinon@21.0.2/pkg/lib/create-sinon-api.js"],"names":[],"mappings":"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","file":"/npm/sinon@21.0.2/pkg/sinon.js","sourceRoot":"","sourcesContent":["/**\n * Minified by jsDelivr using Terser v5.39.0.\n * Original file: /npm/sinon@21.0.2/pkg/sinon.js\n *\n * Do NOT use SRI with dynamically generated files! More information: https://www.jsdelivr.com/using-sri-with-dynamic-files\n */\n","\"use strict\";\n\n/**\n * A reference to the global object\n * @type {object} globalObject\n */\nvar globalObject;\n\n/* istanbul ignore else */\nif (typeof global !== \"undefined\") {\n    // Node\n    globalObject = global;\n} else if (typeof window !== \"undefined\") {\n    // Browser\n    globalObject = window;\n} else {\n    // WebWorker\n    globalObject = self;\n}\n\nmodule.exports = globalObject;\n","\"use strict\";\n\n/**\n * Is true when the environment causes an error to be thrown for accessing the\n * __proto__ property.\n * This is necessary in order to support `node --disable-proto=throw`.\n *\n * See https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/proto\n * @type {boolean}\n */\nlet throwsOnProto;\ntry {\n    const object = {};\n    // eslint-disable-next-line no-proto, no-unused-expressions\n    object.__proto__;\n    throwsOnProto = false;\n} catch (_) {\n    // This branch is covered when tests are run with `--disable-proto=throw`,\n    // however we can test both branches at the same time, so this is ignored\n    /* istanbul ignore next */\n    throwsOnProto = true;\n}\n\nmodule.exports = throwsOnProto;\n","\"use strict\";\n\nvar call = Function.call;\nvar throwsOnProto = require(\"./throws-on-proto\");\n\nvar disallowedProperties = [\n    // ignore size because it throws from Map\n    \"size\",\n    \"caller\",\n    \"callee\",\n    \"arguments\",\n];\n\n// This branch is covered when tests are run with `--disable-proto=throw`,\n// however we can test both branches at the same time, so this is ignored\n/* istanbul ignore next */\nif (throwsOnProto) {\n    disallowedProperties.push(\"__proto__\");\n}\n\nmodule.exports = function copyPrototypeMethods(prototype) {\n    // eslint-disable-next-line @sinonjs/no-prototype-methods/no-prototype-methods\n    return Object.getOwnPropertyNames(prototype).reduce(function (\n        result,\n        name\n    ) {\n        if (disallowedProperties.includes(name)) {\n            return result;\n        }\n\n        if (typeof prototype[name] !== \"function\") {\n            return result;\n        }\n\n        result[name] = call.bind(prototype[name]);\n\n        return result;\n    },\n    Object.create(null));\n};\n","\"use strict\";\n\nvar copyPrototype = require(\"./copy-prototype-methods\");\n\nmodule.exports = copyPrototype(Array.prototype);\n","\"use strict\";\n\nvar every = require(\"./prototypes/array\").every;\n\n/**\n * @private\n */\nfunction hasCallsLeft(callMap, spy) {\n    if (callMap[spy.id] === undefined) {\n        callMap[spy.id] = 0;\n    }\n\n    return callMap[spy.id] < spy.callCount;\n}\n\n/**\n * @private\n */\nfunction checkAdjacentCalls(callMap, spy, index, spies) {\n    var calledBeforeNext = true;\n\n    if (index !== spies.length - 1) {\n        calledBeforeNext = spy.calledBefore(spies[index + 1]);\n    }\n\n    if (hasCallsLeft(callMap, spy) && calledBeforeNext) {\n        callMap[spy.id] += 1;\n        return true;\n    }\n\n    return false;\n}\n\n/**\n * A Sinon proxy object (fake, spy, stub)\n * @typedef {object} SinonProxy\n * @property {Function} calledBefore - A method that determines if this proxy was called before another one\n * @property {string} id - Some id\n * @property {number} callCount - Number of times this proxy has been called\n */\n\n/**\n * Returns true when the spies have been called in the order they were supplied in\n * @param  {SinonProxy[] | SinonProxy} spies An array of proxies, or several proxies as arguments\n * @returns {boolean} true when spies are called in order, false otherwise\n */\nfunction calledInOrder(spies) {\n    var callMap = {};\n    // eslint-disable-next-line no-underscore-dangle\n    var _spies = arguments.length > 1 ? arguments : spies;\n\n    return every(_spies, checkAdjacentCalls.bind(null, callMap));\n}\n\nmodule.exports = calledInOrder;\n","\"use strict\";\n\n/**\n * Returns a display name for a value from a constructor\n * @param  {object} value A value to examine\n * @returns {(string|null)} A string or null\n */\nfunction className(value) {\n    const name = value.constructor && value.constructor.name;\n    return name || null;\n}\n\nmodule.exports = className;\n","/* eslint-disable no-console */\n\"use strict\";\n\n/**\n * Returns a function that will invoke the supplied function and print a\n * deprecation warning to the console each time it is called.\n * @param  {Function} func\n * @param  {string} msg\n * @returns {Function}\n */\nexports.wrap = function (func, msg) {\n    var wrapped = function () {\n        exports.printWarning(msg);\n        return func.apply(this, arguments);\n    };\n    if (func.prototype) {\n        wrapped.prototype = func.prototype;\n    }\n    return wrapped;\n};\n\n/**\n * Returns a string which can be supplied to `wrap()` to notify the user that a\n * particular part of the sinon API has been deprecated.\n * @param  {string} packageName\n * @param  {string} funcName\n * @returns {string}\n */\nexports.defaultMsg = function (packageName, funcName) {\n    return `${packageName}.${funcName} is deprecated and will be removed from the public API in a future version of ${packageName}.`;\n};\n\n/**\n * Prints a warning on the console, when it exists\n * @param  {string} msg\n * @returns {undefined}\n */\nexports.printWarning = function (msg) {\n    /* istanbul ignore next */\n    if (typeof process === \"object\" && process.emitWarning) {\n        // Emit Warnings in Node\n        process.emitWarning(msg);\n    } else if (console.info) {\n        console.info(msg);\n    } else {\n        console.log(msg);\n    }\n};\n","\"use strict\";\n\n/**\n * Returns true when fn returns true for all members of obj.\n * This is an every implementation that works for all iterables\n * @param  {object}   obj\n * @param  {Function} fn\n * @returns {boolean}\n */\nmodule.exports = function every(obj, fn) {\n    var pass = true;\n\n    try {\n        // eslint-disable-next-line @sinonjs/no-prototype-methods/no-prototype-methods\n        obj.forEach(function () {\n            if (!fn.apply(this, arguments)) {\n                // Throwing an error is the only way to break `forEach`\n                throw new Error();\n            }\n        });\n    } catch (e) {\n        pass = false;\n    }\n\n    return pass;\n};\n","\"use strict\";\n\n/**\n * Returns a display name for a function\n * @param  {Function} func\n * @returns {string}\n */\nmodule.exports = function functionName(func) {\n    if (!func) {\n        return \"\";\n    }\n\n    try {\n        return (\n            func.displayName ||\n            func.name ||\n            // Use function decomposition as a last resort to get function\n            // name. Does not rely on function decomposition to work - if it\n            // doesn't debugging will be slightly less informative\n            // (i.e. toString will say 'spy' rather than 'myFunc').\n            (String(func).match(/function ([^\\s(]+)/) || [])[1]\n        );\n    } catch (e) {\n        // Stringify may fail and we might get an exception, as a last-last\n        // resort fall back to empty string.\n        return \"\";\n    }\n};\n","\"use strict\";\n\nvar sort = require(\"./prototypes/array\").sort;\nvar slice = require(\"./prototypes/array\").slice;\n\n/**\n * @private\n */\nfunction comparator(a, b) {\n    // uuid, won't ever be equal\n    var aCall = a.getCall(0);\n    var bCall = b.getCall(0);\n    var aId = (aCall && aCall.callId) || -1;\n    var bId = (bCall && bCall.callId) || -1;\n\n    return aId < bId ? -1 : 1;\n}\n\n/**\n * A Sinon proxy object (fake, spy, stub)\n * @typedef {object} SinonProxy\n * @property {Function} getCall - A method that can return the first call\n */\n\n/**\n * Sorts an array of SinonProxy instances (fake, spy, stub) by their first call\n * @param  {SinonProxy[] | SinonProxy} spies\n * @returns {SinonProxy[]}\n */\nfunction orderByFirstCall(spies) {\n    return sort(slice(spies), comparator);\n}\n\nmodule.exports = orderByFirstCall;\n","\"use strict\";\n\nvar copyPrototype = require(\"./copy-prototype-methods\");\n\nmodule.exports = copyPrototype(Function.prototype);\n","\"use strict\";\n\nvar copyPrototype = require(\"./copy-prototype-methods\");\n\nmodule.exports = copyPrototype(Map.prototype);\n","\"use strict\";\n\nvar copyPrototype = require(\"./copy-prototype-methods\");\n\nmodule.exports = copyPrototype(Object.prototype);\n","\"use strict\";\n\nvar copyPrototype = require(\"./copy-prototype-methods\");\n\nmodule.exports = copyPrototype(Set.prototype);\n","\"use strict\";\n\nvar copyPrototype = require(\"./copy-prototype-methods\");\n\nmodule.exports = copyPrototype(String.prototype);\n","\"use strict\";\n\nmodule.exports = {\n    array: require(\"./array\"),\n    function: require(\"./function\"),\n    map: require(\"./map\"),\n    object: require(\"./object\"),\n    set: require(\"./set\"),\n    string: require(\"./string\"),\n};\n","(function (global, factory) {\n\ttypeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory() :\n\ttypeof define === 'function' && define.amd ? define(factory) :\n\t(global.typeDetect = factory());\n}(this, (function () { 'use strict';\n\n/* !\n * type-detect\n * Copyright(c) 2013 jake luer <jake@alogicalparadox.com>\n * MIT Licensed\n */\nvar promiseExists = typeof Promise === 'function';\n\n/* eslint-disable no-undef */\nvar globalObject = typeof self === 'object' ? self : global; // eslint-disable-line id-blacklist\n\nvar symbolExists = typeof Symbol !== 'undefined';\nvar mapExists = typeof Map !== 'undefined';\nvar setExists = typeof Set !== 'undefined';\nvar weakMapExists = typeof WeakMap !== 'undefined';\nvar weakSetExists = typeof WeakSet !== 'undefined';\nvar dataViewExists = typeof DataView !== 'undefined';\nvar symbolIteratorExists = symbolExists && typeof Symbol.iterator !== 'undefined';\nvar symbolToStringTagExists = symbolExists && typeof Symbol.toStringTag !== 'undefined';\nvar setEntriesExists = setExists && typeof Set.prototype.entries === 'function';\nvar mapEntriesExists = mapExists && typeof Map.prototype.entries === 'function';\nvar setIteratorPrototype = setEntriesExists && Object.getPrototypeOf(new Set().entries());\nvar mapIteratorPrototype = mapEntriesExists && Object.getPrototypeOf(new Map().entries());\nvar arrayIteratorExists = symbolIteratorExists && typeof Array.prototype[Symbol.iterator] === 'function';\nvar arrayIteratorPrototype = arrayIteratorExists && Object.getPrototypeOf([][Symbol.iterator]());\nvar stringIteratorExists = symbolIteratorExists && typeof String.prototype[Symbol.iterator] === 'function';\nvar stringIteratorPrototype = stringIteratorExists && Object.getPrototypeOf(''[Symbol.iterator]());\nvar toStringLeftSliceLength = 8;\nvar toStringRightSliceLength = -1;\n/**\n * ### typeOf (obj)\n *\n * Uses `Object.prototype.toString` to determine the type of an object,\n * normalising behaviour across engine versions & well optimised.\n *\n * @param {Mixed} object\n * @return {String} object type\n * @api public\n */\nfunction typeDetect(obj) {\n  /* ! Speed optimisation\n   * Pre:\n   *   string literal     x 3,039,035 ops/sec ±1.62% (78 runs sampled)\n   *   boolean literal    x 1,424,138 ops/sec ±4.54% (75 runs sampled)\n   *   number literal     x 1,653,153 ops/sec ±1.91% (82 runs sampled)\n   *   undefined          x 9,978,660 ops/sec ±1.92% (75 runs sampled)\n   *   function           x 2,556,769 ops/sec ±1.73% (77 runs sampled)\n   * Post:\n   *   string literal     x 38,564,796 ops/sec ±1.15% (79 runs sampled)\n   *   boolean literal    x 31,148,940 ops/sec ±1.10% (79 runs sampled)\n   *   number literal     x 32,679,330 ops/sec ±1.90% (78 runs sampled)\n   *   undefined          x 32,363,368 ops/sec ±1.07% (82 runs sampled)\n   *   function           x 31,296,870 ops/sec ±0.96% (83 runs sampled)\n   */\n  var typeofObj = typeof obj;\n  if (typeofObj !== 'object') {\n    return typeofObj;\n  }\n\n  /* ! Speed optimisation\n   * Pre:\n   *   null               x 28,645,765 ops/sec ±1.17% (82 runs sampled)\n   * Post:\n   *   null               x 36,428,962 ops/sec ±1.37% (84 runs sampled)\n   */\n  if (obj === null) {\n    return 'null';\n  }\n\n  /* ! Spec Conformance\n   * Test: `Object.prototype.toString.call(window)``\n   *  - Node === \"[object global]\"\n   *  - Chrome === \"[object global]\"\n   *  - Firefox === \"[object Window]\"\n   *  - PhantomJS === \"[object Window]\"\n   *  - Safari === \"[object Window]\"\n   *  - IE 11 === \"[object Window]\"\n   *  - IE Edge === \"[object Window]\"\n   * Test: `Object.prototype.toString.call(this)``\n   *  - Chrome Worker === \"[object global]\"\n   *  - Firefox Worker === \"[object DedicatedWorkerGlobalScope]\"\n   *  - Safari Worker === \"[object DedicatedWorkerGlobalScope]\"\n   *  - IE 11 Worker === \"[object WorkerGlobalScope]\"\n   *  - IE Edge Worker === \"[object WorkerGlobalScope]\"\n   */\n  if (obj === globalObject) {\n    return 'global';\n  }\n\n  /* ! Speed optimisation\n   * Pre:\n   *   array literal      x 2,888,352 ops/sec ±0.67% (82 runs sampled)\n   * Post:\n   *   array literal      x 22,479,650 ops/sec ±0.96% (81 runs sampled)\n   */\n  if (\n    Array.isArray(obj) &&\n    (symbolToStringTagExists === false || !(Symbol.toStringTag in obj))\n  ) {\n    return 'Array';\n  }\n\n  // Not caching existence of `window` and related properties due to potential\n  // for `window` to be unset before tests in quasi-browser environments.\n  if (typeof window === 'object' && window !== null) {\n    /* ! Spec Conformance\n     * (https://html.spec.whatwg.org/multipage/browsers.html#location)\n     * WhatWG HTML$7.7.3 - The `Location` interface\n     * Test: `Object.prototype.toString.call(window.location)``\n     *  - IE <=11 === \"[object Object]\"\n     *  - IE Edge <=13 === \"[object Object]\"\n     */\n    if (typeof window.location === 'object' && obj === window.location) {\n      return 'Location';\n    }\n\n    /* ! Spec Conformance\n     * (https://html.spec.whatwg.org/#document)\n     * WhatWG HTML$3.1.1 - The `Document` object\n     * Note: Most browsers currently adher to the W3C DOM Level 2 spec\n     *       (https://www.w3.org/TR/DOM-Level-2-HTML/html.html#ID-26809268)\n     *       which suggests that browsers should use HTMLTableCellElement for\n     *       both TD and TH elements. WhatWG separates these.\n     *       WhatWG HTML states:\n     *         > For historical reasons, Window objects must also have a\n     *         > writable, configurable, non-enumerable property named\n     *         > HTMLDocument whose value is the Document interface object.\n     * Test: `Object.prototype.toString.call(document)``\n     *  - Chrome === \"[object HTMLDocument]\"\n     *  - Firefox === \"[object HTMLDocument]\"\n     *  - Safari === \"[object HTMLDocument]\"\n     *  - IE <=10 === \"[object Document]\"\n     *  - IE 11 === \"[object HTMLDocument]\"\n     *  - IE Edge <=13 === \"[object HTMLDocument]\"\n     */\n    if (typeof window.document === 'object' && obj === window.document) {\n      return 'Document';\n    }\n\n    if (typeof window.navigator === 'object') {\n      /* ! Spec Conformance\n       * (https://html.spec.whatwg.org/multipage/webappapis.html#mimetypearray)\n       * WhatWG HTML$8.6.1.5 - Plugins - Interface MimeTypeArray\n       * Test: `Object.prototype.toString.call(navigator.mimeTypes)``\n       *  - IE <=10 === \"[object MSMimeTypesCollection]\"\n       */\n      if (typeof window.navigator.mimeTypes === 'object' &&\n          obj === window.navigator.mimeTypes) {\n        return 'MimeTypeArray';\n      }\n\n      /* ! Spec Conformance\n       * (https://html.spec.whatwg.org/multipage/webappapis.html#pluginarray)\n       * WhatWG HTML$8.6.1.5 - Plugins - Interface PluginArray\n       * Test: `Object.prototype.toString.call(navigator.plugins)``\n       *  - IE <=10 === \"[object MSPluginsCollection]\"\n       */\n      if (typeof window.navigator.plugins === 'object' &&\n          obj === window.navigator.plugins) {\n        return 'PluginArray';\n      }\n    }\n\n    if ((typeof window.HTMLElement === 'function' ||\n        typeof window.HTMLElement === 'object') &&\n        obj instanceof window.HTMLElement) {\n      /* ! Spec Conformance\n      * (https://html.spec.whatwg.org/multipage/webappapis.html#pluginarray)\n      * WhatWG HTML$4.4.4 - The `blockquote` element - Interface `HTMLQuoteElement`\n      * Test: `Object.prototype.toString.call(document.createElement('blockquote'))``\n      *  - IE <=10 === \"[object HTMLBlockElement]\"\n      */\n      if (obj.tagName === 'BLOCKQUOTE') {\n        return 'HTMLQuoteElement';\n      }\n\n      /* ! Spec Conformance\n       * (https://html.spec.whatwg.org/#htmltabledatacellelement)\n       * WhatWG HTML$4.9.9 - The `td` element - Interface `HTMLTableDataCellElement`\n       * Note: Most browsers currently adher to the W3C DOM Level 2 spec\n       *       (https://www.w3.org/TR/DOM-Level-2-HTML/html.html#ID-82915075)\n       *       which suggests that browsers should use HTMLTableCellElement for\n       *       both TD and TH elements. WhatWG separates these.\n       * Test: Object.prototype.toString.call(document.createElement('td'))\n       *  - Chrome === \"[object HTMLTableCellElement]\"\n       *  - Firefox === \"[object HTMLTableCellElement]\"\n       *  - Safari === \"[object HTMLTableCellElement]\"\n       */\n      if (obj.tagName === 'TD') {\n        return 'HTMLTableDataCellElement';\n      }\n\n      /* ! Spec Conformance\n       * (https://html.spec.whatwg.org/#htmltableheadercellelement)\n       * WhatWG HTML$4.9.9 - The `td` element - Interface `HTMLTableHeaderCellElement`\n       * Note: Most browsers currently adher to the W3C DOM Level 2 spec\n       *       (https://www.w3.org/TR/DOM-Level-2-HTML/html.html#ID-82915075)\n       *       which suggests that browsers should use HTMLTableCellElement for\n       *       both TD and TH elements. WhatWG separates these.\n       * Test: Object.prototype.toString.call(document.createElement('th'))\n       *  - Chrome === \"[object HTMLTableCellElement]\"\n       *  - Firefox === \"[object HTMLTableCellElement]\"\n       *  - Safari === \"[object HTMLTableCellElement]\"\n       */\n      if (obj.tagName === 'TH') {\n        return 'HTMLTableHeaderCellElement';\n      }\n    }\n  }\n\n  /* ! Speed optimisation\n  * Pre:\n  *   Float64Array       x 625,644 ops/sec ±1.58% (80 runs sampled)\n  *   Float32Array       x 1,279,852 ops/sec ±2.91% (77 runs sampled)\n  *   Uint32Array        x 1,178,185 ops/sec ±1.95% (83 runs sampled)\n  *   Uint16Array        x 1,008,380 ops/sec ±2.25% (80 runs sampled)\n  *   Uint8Array         x 1,128,040 ops/sec ±2.11% (81 runs sampled)\n  *   Int32Array         x 1,170,119 ops/sec ±2.88% (80 runs sampled)\n  *   Int16Array         x 1,176,348 ops/sec ±5.79% (86 runs sampled)\n  *   Int8Array          x 1,058,707 ops/sec ±4.94% (77 runs sampled)\n  *   Uint8ClampedArray  x 1,110,633 ops/sec ±4.20% (80 runs sampled)\n  * Post:\n  *   Float64Array       x 7,105,671 ops/sec ±13.47% (64 runs sampled)\n  *   Float32Array       x 5,887,912 ops/sec ±1.46% (82 runs sampled)\n  *   Uint32Array        x 6,491,661 ops/sec ±1.76% (79 runs sampled)\n  *   Uint16Array        x 6,559,795 ops/sec ±1.67% (82 runs sampled)\n  *   Uint8Array         x 6,463,966 ops/sec ±1.43% (85 runs sampled)\n  *   Int32Array         x 5,641,841 ops/sec ±3.49% (81 runs sampled)\n  *   Int16Array         x 6,583,511 ops/sec ±1.98% (80 runs sampled)\n  *   Int8Array          x 6,606,078 ops/sec ±1.74% (81 runs sampled)\n  *   Uint8ClampedArray  x 6,602,224 ops/sec ±1.77% (83 runs sampled)\n  */\n  var stringTag = (symbolToStringTagExists && obj[Symbol.toStringTag]);\n  if (typeof stringTag === 'string') {\n    return stringTag;\n  }\n\n  var objPrototype = Object.getPrototypeOf(obj);\n  /* ! Speed optimisation\n  * Pre:\n  *   regex literal      x 1,772,385 ops/sec ±1.85% (77 runs sampled)\n  *   regex constructor  x 2,143,634 ops/sec ±2.46% (78 runs sampled)\n  * Post:\n  *   regex literal      x 3,928,009 ops/sec ±0.65% (78 runs sampled)\n  *   regex constructor  x 3,931,108 ops/sec ±0.58% (84 runs sampled)\n  */\n  if (objPrototype === RegExp.prototype) {\n    return 'RegExp';\n  }\n\n  /* ! Speed optimisation\n  * Pre:\n  *   date               x 2,130,074 ops/sec ±4.42% (68 runs sampled)\n  * Post:\n  *   date               x 3,953,779 ops/sec ±1.35% (77 runs sampled)\n  */\n  if (objPrototype === Date.prototype) {\n    return 'Date';\n  }\n\n  /* ! Spec Conformance\n   * (http://www.ecma-international.org/ecma-262/6.0/index.html#sec-promise.prototype-@@tostringtag)\n   * ES6$25.4.5.4 - Promise.prototype[@@toStringTag] should be \"Promise\":\n   * Test: `Object.prototype.toString.call(Promise.resolve())``\n   *  - Chrome <=47 === \"[object Object]\"\n   *  - Edge <=20 === \"[object Object]\"\n   *  - Firefox 29-Latest === \"[object Promise]\"\n   *  - Safari 7.1-Latest === \"[object Promise]\"\n   */\n  if (promiseExists && objPrototype === Promise.prototype) {\n    return 'Promise';\n  }\n\n  /* ! Speed optimisation\n  * Pre:\n  *   set                x 2,222,186 ops/sec ±1.31% (82 runs sampled)\n  * Post:\n  *   set                x 4,545,879 ops/sec ±1.13% (83 runs sampled)\n  */\n  if (setExists && objPrototype === Set.prototype) {\n    return 'Set';\n  }\n\n  /* ! Speed optimisation\n  * Pre:\n  *   map                x 2,396,842 ops/sec ±1.59% (81 runs sampled)\n  * Post:\n  *   map                x 4,183,945 ops/sec ±6.59% (82 runs sampled)\n  */\n  if (mapExists && objPrototype === Map.prototype) {\n    return 'Map';\n  }\n\n  /* ! Speed optimisation\n  * Pre:\n  *   weakset            x 1,323,220 ops/sec ±2.17% (76 runs sampled)\n  * Post:\n  *   weakset            x 4,237,510 ops/sec ±2.01% (77 runs sampled)\n  */\n  if (weakSetExists && objPrototype === WeakSet.prototype) {\n    return 'WeakSet';\n  }\n\n  /* ! Speed optimisation\n  * Pre:\n  *   weakmap            x 1,500,260 ops/sec ±2.02% (78 runs sampled)\n  * Post:\n  *   weakmap            x 3,881,384 ops/sec ±1.45% (82 runs sampled)\n  */\n  if (weakMapExists && objPrototype === WeakMap.prototype) {\n    return 'WeakMap';\n  }\n\n  /* ! Spec Conformance\n   * (http://www.ecma-international.org/ecma-262/6.0/index.html#sec-dataview.prototype-@@tostringtag)\n   * ES6$24.2.4.21 - DataView.prototype[@@toStringTag] should be \"DataView\":\n   * Test: `Object.prototype.toString.call(new DataView(new ArrayBuffer(1)))``\n   *  - Edge <=13 === \"[object Object]\"\n   */\n  if (dataViewExists && objPrototype === DataView.prototype) {\n    return 'DataView';\n  }\n\n  /* ! Spec Conformance\n   * (http://www.ecma-international.org/ecma-262/6.0/index.html#sec-%mapiteratorprototype%-@@tostringtag)\n   * ES6$23.1.5.2.2 - %MapIteratorPrototype%[@@toStringTag] should be \"Map Iterator\":\n   * Test: `Object.prototype.toString.call(new Map().entries())``\n   *  - Edge <=13 === \"[object Object]\"\n   */\n  if (mapExists && objPrototype === mapIteratorPrototype) {\n    return 'Map Iterator';\n  }\n\n  /* ! Spec Conformance\n   * (http://www.ecma-international.org/ecma-262/6.0/index.html#sec-%setiteratorprototype%-@@tostringtag)\n   * ES6$23.2.5.2.2 - %SetIteratorPrototype%[@@toStringTag] should be \"Set Iterator\":\n   * Test: `Object.prototype.toString.call(new Set().entries())``\n   *  - Edge <=13 === \"[object Object]\"\n   */\n  if (setExists && objPrototype === setIteratorPrototype) {\n    return 'Set Iterator';\n  }\n\n  /* ! Spec Conformance\n   * (http://www.ecma-international.org/ecma-262/6.0/index.html#sec-%arrayiteratorprototype%-@@tostringtag)\n   * ES6$22.1.5.2.2 - %ArrayIteratorPrototype%[@@toStringTag] should be \"Array Iterator\":\n   * Test: `Object.prototype.toString.call([][Symbol.iterator]())``\n   *  - Edge <=13 === \"[object Object]\"\n   */\n  if (arrayIteratorExists && objPrototype === arrayIteratorPrototype) {\n    return 'Array Iterator';\n  }\n\n  /* ! Spec Conformance\n   * (http://www.ecma-international.org/ecma-262/6.0/index.html#sec-%stringiteratorprototype%-@@tostringtag)\n   * ES6$21.1.5.2.2 - %StringIteratorPrototype%[@@toStringTag] should be \"String Iterator\":\n   * Test: `Object.prototype.toString.call(''[Symbol.iterator]())``\n   *  - Edge <=13 === \"[object Object]\"\n   */\n  if (stringIteratorExists && objPrototype === stringIteratorPrototype) {\n    return 'String Iterator';\n  }\n\n  /* ! Speed optimisation\n  * Pre:\n  *   object from null   x 2,424,320 ops/sec ±1.67% (76 runs sampled)\n  * Post:\n  *   object from null   x 5,838,000 ops/sec ±0.99% (84 runs sampled)\n  */\n  if (objPrototype === null) {\n    return 'Object';\n  }\n\n  return Object\n    .prototype\n    .toString\n    .call(obj)\n    .slice(toStringLeftSliceLength, toStringRightSliceLength);\n}\n\nreturn typeDetect;\n\n})));\n","\"use strict\";\n\nvar type = require(\"type-detect\");\n\n/**\n * Returns the lower-case result of running type from type-detect on the value\n * @param  {*} value\n * @returns {string}\n */\nmodule.exports = function typeOf(value) {\n    return type(value).toLowerCase();\n};\n","\"use strict\";\n\n/**\n * Returns a string representation of the value\n * @param  {*} value\n * @returns {string}\n */\nfunction valueToString(value) {\n    if (value && value.toString) {\n        // eslint-disable-next-line @sinonjs/no-prototype-methods/no-prototype-methods\n        return value.toString();\n    }\n    return String(value);\n}\n\nmodule.exports = valueToString;\n","\"use strict\";\n\nmodule.exports = {\n    global: require(\"./global\"),\n    calledInOrder: require(\"./called-in-order\"),\n    className: require(\"./class-name\"),\n    deprecated: require(\"./deprecated\"),\n    every: require(\"./every\"),\n    functionName: require(\"./function-name\"),\n    orderByFirstCall: require(\"./order-by-first-call\"),\n    prototypes: require(\"./prototypes\"),\n    typeOf: require(\"./type-of\"),\n    valueToString: require(\"./value-to-string\"),\n};\n","\"use strict\";\n\nconst arrayProto = require(\"@sinonjs/commons\").prototypes.array;\nconst hasOwnProperty =\n    require(\"@sinonjs/commons\").prototypes.object.hasOwnProperty;\n\nconst join = arrayProto.join;\nconst push = arrayProto.push;\n\n// Adapted from https://developer.mozilla.org/en/docs/ECMAScript_DontEnum_attribute#JScript_DontEnum_Bug\nconst hasDontEnumBug = (function () {\n    const obj = {\n        constructor: function () {\n            return \"0\";\n        },\n        toString: function () {\n            return \"1\";\n        },\n        valueOf: function () {\n            return \"2\";\n        },\n        toLocaleString: function () {\n            return \"3\";\n        },\n        prototype: function () {\n            return \"4\";\n        },\n        isPrototypeOf: function () {\n            return \"5\";\n        },\n        propertyIsEnumerable: function () {\n            return \"6\";\n        },\n        hasOwnProperty: function () {\n            return \"7\";\n        },\n        length: function () {\n            return \"8\";\n        },\n        unique: function () {\n            return \"9\";\n        },\n    };\n\n    const result = [];\n    for (const prop in obj) {\n        if (hasOwnProperty(obj, prop)) {\n            push(result, obj[prop]());\n        }\n    }\n    return join(result, \"\") !== \"0123456789\";\n})();\n\n/**\n *\n * @param target\n * @param sources\n * @param doCopy\n * @returns {*} target\n */\nfunction extendCommon(target, sources, doCopy) {\n    let source, i, prop;\n\n    for (i = 0; i < sources.length; i++) {\n        source = sources[i];\n\n        for (prop in source) {\n            if (hasOwnProperty(source, prop)) {\n                doCopy(target, source, prop);\n            }\n        }\n\n        // Make sure we copy (own) toString method even when in JScript with DontEnum bug\n        // See https://developer.mozilla.org/en/docs/ECMAScript_DontEnum_attribute#JScript_DontEnum_Bug\n        if (\n            hasDontEnumBug &&\n            hasOwnProperty(source, \"toString\") &&\n            source.toString !== target.toString\n        ) {\n            target.toString = source.toString;\n        }\n    }\n\n    return target;\n}\n\n/**\n * Public: Extend target in place with all (own) properties, except 'name' when [[writable]] is false,\n *         from sources in-order. Thus, last source will override properties in previous sources.\n *\n * @param {object} target - The Object to extend\n * @param {object[]} sources - Objects to copy properties from.\n * @returns {object} the extended target\n */\nmodule.exports = function extend(target, ...sources) {\n    return extendCommon(\n        target,\n        sources,\n        function copyValue(dest, source, prop) {\n            const destOwnPropertyDescriptor = Object.getOwnPropertyDescriptor(\n                dest,\n                prop,\n            );\n            const sourceOwnPropertyDescriptor = Object.getOwnPropertyDescriptor(\n                source,\n                prop,\n            );\n\n            if (prop === \"name\" && !destOwnPropertyDescriptor.writable) {\n                return;\n            }\n            const descriptors = {\n                configurable: sourceOwnPropertyDescriptor.configurable,\n                enumerable: sourceOwnPropertyDescriptor.enumerable,\n            };\n            /*\n                if the source has an Accessor property copy over the accessor functions (get and set)\n                data properties has writable attribute where as accessor property don't\n                REF: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#properties\n            */\n\n            if (hasOwnProperty(sourceOwnPropertyDescriptor, \"writable\")) {\n                descriptors.writable = sourceOwnPropertyDescriptor.writable;\n                descriptors.value = sourceOwnPropertyDescriptor.value;\n            } else {\n                if (sourceOwnPropertyDescriptor.get) {\n                    descriptors.get =\n                        sourceOwnPropertyDescriptor.get.bind(dest);\n                }\n                if (sourceOwnPropertyDescriptor.set) {\n                    descriptors.set =\n                        sourceOwnPropertyDescriptor.set.bind(dest);\n                }\n            }\n            Object.defineProperty(dest, prop, descriptors);\n        },\n    );\n};\n\n/**\n * Public: Extend target in place with all (own) properties from sources in-order. Thus, last source will\n *         override properties in previous sources. Define the properties as non enumerable.\n *\n * @param {object} target - The Object to extend\n * @param {object[]} sources - Objects to copy properties from.\n * @returns {object} the extended target\n */\nmodule.exports.nonEnum = function extendNonEnum(target, ...sources) {\n    return extendCommon(\n        target,\n        sources,\n        function copyProperty(dest, source, prop) {\n            Object.defineProperty(dest, prop, {\n                value: source[prop],\n                enumerable: false,\n                configurable: true,\n                writable: true,\n            });\n        },\n    );\n};\n","\"use strict\";\n\n/* istanbul ignore next : not testing that setTimeout works */\nfunction nextTick(callback) {\n    setTimeout(callback, 0);\n}\n\nmodule.exports = function getNextTick(process, setImmediate) {\n    if (typeof process === \"object\" && typeof process.nextTick === \"function\") {\n        return process.nextTick;\n    }\n\n    if (typeof setImmediate === \"function\") {\n        return setImmediate;\n    }\n\n    return nextTick;\n};\n","\"use strict\";\n\nconst globalObject = require(\"@sinonjs/commons\").global;\nconst getNextTick = require(\"./get-next-tick\");\n\nmodule.exports = getNextTick(globalObject.process, globalObject.setImmediate);\n","\"use strict\";\n\nconst arrayProto = require(\"@sinonjs/commons\").prototypes.array;\nconst reduce = arrayProto.reduce;\n\nmodule.exports = function exportAsyncBehaviors(behaviorMethods) {\n    return reduce(\n        Object.keys(behaviorMethods),\n        function (acc, method) {\n            // need to avoid creating another async versions of the newly added async methods\n            if (method.match(/^(callsArg|yields)/) && !method.match(/Async/)) {\n                acc[`${method}Async`] = function () {\n                    const result = behaviorMethods[method].apply(\n                        this,\n                        arguments,\n                    );\n                    this.callbackAsync = true;\n                    return result;\n                };\n            }\n            return acc;\n        },\n        {},\n    );\n};\n","\"use strict\";\n\nconst arrayProto = require(\"@sinonjs/commons\").prototypes.array;\nconst extend = require(\"./util/core/extend\");\nconst functionName = require(\"@sinonjs/commons\").functionName;\nconst nextTick = require(\"./util/core/next-tick\");\nconst valueToString = require(\"@sinonjs/commons\").valueToString;\nconst exportAsyncBehaviors = require(\"./util/core/export-async-behaviors\");\n\nconst concat = arrayProto.concat;\nconst join = arrayProto.join;\nconst reverse = arrayProto.reverse;\nconst slice = arrayProto.slice;\n\nconst useLeftMostCallback = -1;\nconst useRightMostCallback = -2;\n\nfunction getCallback(behavior, args) {\n    const callArgAt = behavior.callArgAt;\n\n    if (callArgAt >= 0) {\n        return args[callArgAt];\n    }\n\n    let argumentList;\n\n    if (callArgAt === useLeftMostCallback) {\n        argumentList = args;\n    }\n\n    if (callArgAt === useRightMostCallback) {\n        argumentList = reverse(slice(args));\n    }\n\n    const callArgProp = behavior.callArgProp;\n\n    for (let i = 0, l = argumentList.length; i < l; ++i) {\n        if (!callArgProp && typeof argumentList[i] === \"function\") {\n            return argumentList[i];\n        }\n\n        if (\n            callArgProp &&\n            argumentList[i] &&\n            typeof argumentList[i][callArgProp] === \"function\"\n        ) {\n            return argumentList[i][callArgProp];\n        }\n    }\n\n    return null;\n}\n\nfunction getCallbackError(behavior, func, args) {\n    if (behavior.callArgAt < 0) {\n        let msg;\n\n        if (behavior.callArgProp) {\n            msg = `${functionName(\n                behavior.stub,\n            )} expected to yield to '${valueToString(\n                behavior.callArgProp,\n            )}', but no object with such a property was passed.`;\n        } else {\n            msg = `${functionName(\n                behavior.stub,\n            )} expected to yield, but no callback was passed.`;\n        }\n\n        if (args.length > 0) {\n            msg += ` Received [${join(args, \", \")}]`;\n        }\n\n        return msg;\n    }\n\n    return `argument at index ${behavior.callArgAt} is not a function: ${func}`;\n}\n\nfunction ensureArgs(name, behavior, args) {\n    // map function name to internal property\n    //   callsArg => callArgAt\n    const property = name.replace(/sArg/, \"ArgAt\");\n    const index = behavior[property];\n\n    if (index >= args.length) {\n        throw new TypeError(\n            `${name} failed: ${index + 1} arguments required but only ${\n                args.length\n            } present`,\n        );\n    }\n}\n\nfunction callCallback(behavior, args) {\n    if (typeof behavior.callArgAt === \"number\") {\n        ensureArgs(\"callsArg\", behavior, args);\n        const func = getCallback(behavior, args);\n\n        if (typeof func !== \"function\") {\n            throw new TypeError(getCallbackError(behavior, func, args));\n        }\n\n        if (behavior.callbackAsync) {\n            nextTick(function () {\n                func.apply(\n                    behavior.callbackContext,\n                    behavior.callbackArguments,\n                );\n            });\n        } else {\n            return func.apply(\n                behavior.callbackContext,\n                behavior.callbackArguments,\n            );\n        }\n    }\n\n    return undefined;\n}\n\nconst proto = {\n    create: function create(stub) {\n        const behavior = extend({}, proto);\n        delete behavior.create;\n        delete behavior.addBehavior;\n        delete behavior.createBehavior;\n        behavior.stub = stub;\n\n        if (stub.defaultBehavior && stub.defaultBehavior.promiseLibrary) {\n            behavior.promiseLibrary = stub.defaultBehavior.promiseLibrary;\n        }\n\n        return behavior;\n    },\n\n    isPresent: function isPresent() {\n        return (\n            typeof this.callArgAt === \"number\" ||\n            this.exception ||\n            this.exceptionCreator ||\n            typeof this.returnArgAt === \"number\" ||\n            this.returnThis ||\n            typeof this.resolveArgAt === \"number\" ||\n            this.resolveThis ||\n            typeof this.throwArgAt === \"number\" ||\n            this.fakeFn ||\n            this.returnValueDefined\n        );\n    },\n\n    /*eslint complexity: [\"error\", 20]*/\n    invoke: function invoke(context, args) {\n        /*\n         * callCallback (conditionally) calls ensureArgs\n         *\n         * Note: callCallback intentionally happens before\n         * everything else and cannot be moved lower\n         */\n        const returnValue = callCallback(this, args);\n\n        if (this.exception) {\n            throw this.exception;\n        } else if (this.exceptionCreator) {\n            this.exception = this.exceptionCreator();\n            this.exceptionCreator = undefined;\n            throw this.exception;\n        } else if (typeof this.returnArgAt === \"number\") {\n            ensureArgs(\"returnsArg\", this, args);\n            return args[this.returnArgAt];\n        } else if (this.returnThis) {\n            return context;\n        } else if (typeof this.throwArgAt === \"number\") {\n            ensureArgs(\"throwsArg\", this, args);\n            throw args[this.throwArgAt];\n        } else if (this.fakeFn) {\n            return this.fakeFn.apply(context, args);\n        } else if (typeof this.resolveArgAt === \"number\") {\n            ensureArgs(\"resolvesArg\", this, args);\n            return (this.promiseLibrary || Promise).resolve(\n                args[this.resolveArgAt],\n            );\n        } else if (this.resolveThis) {\n            return (this.promiseLibrary || Promise).resolve(context);\n        } else if (this.resolve) {\n            return (this.promiseLibrary || Promise).resolve(this.returnValue);\n        } else if (this.reject) {\n            return (this.promiseLibrary || Promise).reject(this.returnValue);\n        } else if (this.callsThrough) {\n            const wrappedMethod = this.effectiveWrappedMethod();\n\n            return wrappedMethod.apply(context, args);\n        } else if (this.callsThroughWithNew) {\n            // Get the original method (assumed to be a constructor in this case)\n            const WrappedClass = this.effectiveWrappedMethod();\n            // Turn the arguments object into a normal array\n            const argsArray = slice(args);\n            // Call the constructor\n            const F = WrappedClass.bind.apply(\n                WrappedClass,\n                concat([null], argsArray),\n            );\n            return new F();\n        } else if (typeof this.returnValue !== \"undefined\") {\n            return this.returnValue;\n        } else if (typeof this.callArgAt === \"number\") {\n            return returnValue;\n        }\n\n        return this.returnValue;\n    },\n\n    effectiveWrappedMethod: function effectiveWrappedMethod() {\n        for (let stubb = this.stub; stubb; stubb = stubb.parent) {\n            if (stubb.wrappedMethod) {\n                return stubb.wrappedMethod;\n            }\n        }\n        throw new Error(\"Unable to find wrapped method\");\n    },\n\n    onCall: function onCall(index) {\n        return this.stub.onCall(index);\n    },\n\n    onFirstCall: function onFirstCall() {\n        return this.stub.onFirstCall();\n    },\n\n    onSecondCall: function onSecondCall() {\n        return this.stub.onSecondCall();\n    },\n\n    onThirdCall: function onThirdCall() {\n        return this.stub.onThirdCall();\n    },\n\n    withArgs: function withArgs(/* arguments */) {\n        throw new Error(\n            'Defining a stub by invoking \"stub.onCall(...).withArgs(...)\" ' +\n                'is not supported. Use \"stub.withArgs(...).onCall(...)\" ' +\n                \"to define sequential behavior for calls with certain arguments.\",\n        );\n    },\n};\n\nfunction createBehavior(behaviorMethod) {\n    return function () {\n        this.defaultBehavior = this.defaultBehavior || proto.create(this);\n        this.defaultBehavior[behaviorMethod].apply(\n            this.defaultBehavior,\n            arguments,\n        );\n        return this;\n    };\n}\n\nfunction addBehavior(stub, name, fn) {\n    proto[name] = function () {\n        fn.apply(this, concat([this], slice(arguments)));\n        return this.stub || this;\n    };\n\n    stub[name] = createBehavior(name);\n}\n\nproto.addBehavior = addBehavior;\nproto.createBehavior = createBehavior;\n\nconst asyncBehaviors = exportAsyncBehaviors(proto);\n\nmodule.exports = extend.nonEnum({}, proto, asyncBehaviors);\n","\"use strict\";\n\nconst forEach = require(\"@sinonjs/commons\").prototypes.array.forEach;\n\nfunction walkInternal(obj, iterator, context, originalObj, seen) {\n    let prop;\n    const proto = Object.getPrototypeOf(obj);\n\n    if (typeof Object.getOwnPropertyNames !== \"function\") {\n        // We explicitly want to enumerate through all of the prototype's properties\n        // in this case, therefore we deliberately leave out an own property check.\n        /* eslint-disable-next-line guard-for-in */\n        for (prop in obj) {\n            iterator.call(context, obj[prop], prop, obj);\n        }\n\n        return;\n    }\n\n    forEach(Object.getOwnPropertyNames(obj), function (k) {\n        if (seen[k] !== true) {\n            seen[k] = true;\n            const target =\n                typeof Object.getOwnPropertyDescriptor(obj, k).get ===\n                \"function\"\n                    ? originalObj\n                    : obj;\n            iterator.call(context, k, target);\n        }\n    });\n\n    if (proto) {\n        walkInternal(proto, iterator, context, originalObj, seen);\n    }\n}\n\n/* Walks the prototype chain of an object and iterates over every own property\n * name encountered. The iterator is called in the same fashion that Array.prototype.forEach\n * works, where it is passed the value, key, and own object as the 1st, 2nd, and 3rd positional\n * argument, respectively. In cases where Object.getOwnPropertyNames is not available, walk will\n * default to using a simple for..in loop.\n *\n * obj - The object to walk the prototype chain for.\n * iterator - The function to be called on each pass of the walk.\n * context - (Optional) When given, the iterator will be called with this object as the receiver.\n */\nmodule.exports = function walk(obj, iterator, context) {\n    return walkInternal(obj, iterator, context, obj, {});\n};\n","\"use strict\";\n\n/**\n * @typedef {object} PropertyDescriptor\n * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/defineProperty#description\n * @property {boolean} configurable defaults to false\n * @property {boolean} enumerable   defaults to false\n * @property {boolean} writable     defaults to false\n * @property {*} value defaults to undefined\n * @property {Function} get defaults to undefined\n * @property {Function} set defaults to undefined\n */\n\n/*\n * The following type def is strictly speaking illegal in JSDoc, but the expression forms a\n * legal Typescript union type and is understood by Visual Studio and the IntelliJ\n * family of editors. The \"TS\" flavor of JSDoc is becoming the de-facto standard these\n * days for that reason (and the fact that JSDoc is essentially unmaintained)\n */\n\n/**\n * @typedef {{isOwn: boolean} & PropertyDescriptor} SinonPropertyDescriptor\n * a slightly enriched property descriptor\n * @property {boolean} isOwn true if the descriptor is owned by this object, false if it comes from the prototype\n */\n\n/**\n * Returns a slightly modified property descriptor that one can tell is from the object or the prototype\n *\n * @param {*} object\n * @param {string} property\n * @returns {SinonPropertyDescriptor}\n */\nfunction getPropertyDescriptor(object, property) {\n    let proto = object;\n    let descriptor;\n    const isOwn = Boolean(\n        object && Object.getOwnPropertyDescriptor(object, property),\n    );\n\n    while (\n        proto &&\n        !(descriptor = Object.getOwnPropertyDescriptor(proto, property))\n    ) {\n        proto = Object.getPrototypeOf(proto);\n    }\n\n    if (descriptor) {\n        descriptor.isOwn = isOwn;\n    }\n\n    return descriptor;\n}\n\nmodule.exports = getPropertyDescriptor;\n","\"use strict\";\n\nconst walk = require(\"./util/core/walk\");\nconst getPropertyDescriptor = require(\"./util/core/get-property-descriptor\");\nconst hasOwnProperty =\n    require(\"@sinonjs/commons\").prototypes.object.hasOwnProperty;\nconst push = require(\"@sinonjs/commons\").prototypes.array.push;\n\nfunction collectMethod(methods, object, prop, propOwner) {\n    if (\n        typeof getPropertyDescriptor(propOwner, prop).value === \"function\" &&\n        hasOwnProperty(object, prop)\n    ) {\n        push(methods, object[prop]);\n    }\n}\n\n// This function returns an array of all the own methods on the passed object\nfunction collectOwnMethods(object) {\n    const methods = [];\n\n    walk(object, collectMethod.bind(null, methods, object));\n\n    return methods;\n}\n\nmodule.exports = collectOwnMethods;\n","\"use strict\";\n\nconst getPropertyDescriptor = require(\"./get-property-descriptor\");\n\nfunction isPropertyConfigurable(obj, propName) {\n    const propertyDescriptor = getPropertyDescriptor(obj, propName);\n\n    return propertyDescriptor ? propertyDescriptor.configurable : true;\n}\n\nmodule.exports = isPropertyConfigurable;\n","\"use strict\";\n\n/**\n * Compares a `value` to `NaN`\n *\n * @private\n * @param {*} value A value to examine\n * @returns {boolean} Returns `true` when `value` is `NaN`\n */\nfunction isNaN(value) {\n    // Unlike global `isNaN`, this function avoids type coercion\n    // `typeof` check avoids IE host object issues, hat tip to\n    // lodash\n\n    // eslint-disable-next-line no-self-compare\n    return typeof value === \"number\" && value !== value;\n}\n\nmodule.exports = isNaN;\n","\"use strict\";\n\n/**\n * Returns `true` when `value` is `-0`\n * @alias module:samsam.isNegZero\n * @param {*} value A value to examine\n * @returns {boolean} Returns `true` when `value` is `-0`\n */\nfunction isNegZero(value) {\n    return value === 0 && 1 / value === -Infinity;\n}\n\nmodule.exports = isNegZero;\n","\"use strict\";\n\nvar isNaN = require(\"./is-nan\");\nvar isNegZero = require(\"./is-neg-zero\");\n\n/**\n * Strict equality check according to EcmaScript Harmony's `egal`.\n *\n * **From the Harmony wiki:**\n * > An `egal` function simply makes available the internal `SameValue` function\n * > from section 9.12 of the ES5 spec. If two values are egal, then they are not\n * > observably distinguishable.\n *\n * `identical` returns `true` when `===` is `true`, except for `-0` and\n * `+0`, where it returns `false`. Additionally, it returns `true` when\n * `NaN` is compared to itself.\n * @alias module:samsam.identical\n * @param {*} obj1 The first value to compare\n * @param {*} obj2 The second value to compare\n * @returns {boolean} Returns `true` when the objects are *egal*, `false` otherwise\n */\nfunction identical(obj1, obj2) {\n    if (obj1 === obj2 || (isNaN(obj1) && isNaN(obj2))) {\n        return obj1 !== 0 || isNegZero(obj1) === isNegZero(obj2);\n    }\n\n    return false;\n}\n\nmodule.exports = identical;\n","\"use strict\";\n\nvar toString = require(\"@sinonjs/commons\").prototypes.object.toString;\n\n/**\n * Returns the internal `Class` by calling `Object.prototype.toString`\n * with the provided value as `this`. Return value is a `String`, naming the\n * internal class, e.g. \"Array\"\n *\n * @private\n * @param  {*} value - Any value\n * @returns {string} - A string representation of the `Class` of `value`\n */\nfunction getClass(value) {\n    return toString(value).split(/[ \\]]/)[1];\n}\n\nmodule.exports = getClass;\n","\"use strict\";\n\nvar getClass = require(\"./get-class\");\n\n/**\n * Returns `true` when `object` is an `arguments` object, `false` otherwise\n * @alias module:samsam.isArguments\n * @param  {*}  object - The object to examine\n * @returns {boolean} `true` when `object` is an `arguments` object\n */\nfunction isArguments(object) {\n    return getClass(object) === \"Arguments\";\n}\n\nmodule.exports = isArguments;\n","\"use strict\";\n\nvar div = typeof document !== \"undefined\" && document.createElement(\"div\");\n\n/**\n * Returns `true` when `object` is a DOM element node.\n *\n * Unlike Underscore.js/lodash, this function will return `false` if `object`\n * is an *element-like* object, i.e. a regular object with a `nodeType`\n * property that holds the value `1`.\n * @alias module:samsam.isElement\n * @param {object} object The object to examine\n * @returns {boolean} Returns `true` for DOM element nodes\n */\nfunction isElement(object) {\n    if (!object || object.nodeType !== 1 || !div) {\n        return false;\n    }\n    try {\n        object.appendChild(div);\n        object.removeChild(div);\n    } catch (e) {\n        return false;\n    }\n    return true;\n}\n\nmodule.exports = isElement;\n","\"use strict\";\n\n/**\n * Returns `true` when the argument is an instance of Set, `false` otherwise\n * @alias module:samsam.isSet\n * @param  {*}  val - A value to examine\n * @returns {boolean} Returns `true` when the argument is an instance of Set, `false` otherwise\n */\nfunction isSet(val) {\n    return (typeof Set !== \"undefined\" && val instanceof Set) || false;\n}\n\nmodule.exports = isSet;\n","\"use strict\";\n\n/**\n * Returns `true` when `value` is a Map\n *\n * @param {*} value A value to examine\n * @returns {boolean} `true` when `value` is an instance of `Map`, `false` otherwise\n * @private\n */\nfunction isMap(value) {\n    return typeof Map !== \"undefined\" && value instanceof Map;\n}\n\nmodule.exports = isMap;\n","(function (global, factory) {\n    typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory() :\n    typeof define === 'function' && define.amd ? define(factory) :\n    (global = typeof globalThis !== 'undefined' ? globalThis : global || self, global.typeDetect = factory());\n})(this, (function () { 'use strict';\n\n    var promiseExists = typeof Promise === 'function';\n    var globalObject = (function (Obj) {\n        if (typeof globalThis === 'object') {\n            return globalThis;\n        }\n        Object.defineProperty(Obj, 'typeDetectGlobalObject', {\n            get: function get() {\n                return this;\n            },\n            configurable: true,\n        });\n        var global = typeDetectGlobalObject;\n        delete Obj.typeDetectGlobalObject;\n        return global;\n    })(Object.prototype);\n    var symbolExists = typeof Symbol !== 'undefined';\n    var mapExists = typeof Map !== 'undefined';\n    var setExists = typeof Set !== 'undefined';\n    var weakMapExists = typeof WeakMap !== 'undefined';\n    var weakSetExists = typeof WeakSet !== 'undefined';\n    var dataViewExists = typeof DataView !== 'undefined';\n    var symbolIteratorExists = symbolExists && typeof Symbol.iterator !== 'undefined';\n    var symbolToStringTagExists = symbolExists && typeof Symbol.toStringTag !== 'undefined';\n    var setEntriesExists = setExists && typeof Set.prototype.entries === 'function';\n    var mapEntriesExists = mapExists && typeof Map.prototype.entries === 'function';\n    var setIteratorPrototype = setEntriesExists && Object.getPrototypeOf(new Set().entries());\n    var mapIteratorPrototype = mapEntriesExists && Object.getPrototypeOf(new Map().entries());\n    var arrayIteratorExists = symbolIteratorExists && typeof Array.prototype[Symbol.iterator] === 'function';\n    var arrayIteratorPrototype = arrayIteratorExists && Object.getPrototypeOf([][Symbol.iterator]());\n    var stringIteratorExists = symbolIteratorExists && typeof String.prototype[Symbol.iterator] === 'function';\n    var stringIteratorPrototype = stringIteratorExists && Object.getPrototypeOf(''[Symbol.iterator]());\n    var toStringLeftSliceLength = 8;\n    var toStringRightSliceLength = -1;\n    function typeDetect(obj) {\n        var typeofObj = typeof obj;\n        if (typeofObj !== 'object') {\n            return typeofObj;\n        }\n        if (obj === null) {\n            return 'null';\n        }\n        if (obj === globalObject) {\n            return 'global';\n        }\n        if (Array.isArray(obj) &&\n            (symbolToStringTagExists === false || !(Symbol.toStringTag in obj))) {\n            return 'Array';\n        }\n        if (typeof window === 'object' && window !== null) {\n            if (typeof window.location === 'object' && obj === window.location) {\n                return 'Location';\n            }\n            if (typeof window.document === 'object' && obj === window.document) {\n                return 'Document';\n            }\n            if (typeof window.navigator === 'object') {\n                if (typeof window.navigator.mimeTypes === 'object' &&\n                    obj === window.navigator.mimeTypes) {\n                    return 'MimeTypeArray';\n                }\n                if (typeof window.navigator.plugins === 'object' &&\n                    obj === window.navigator.plugins) {\n                    return 'PluginArray';\n                }\n            }\n            if ((typeof window.HTMLElement === 'function' ||\n                typeof window.HTMLElement === 'object') &&\n                obj instanceof window.HTMLElement) {\n                if (obj.tagName === 'BLOCKQUOTE') {\n                    return 'HTMLQuoteElement';\n                }\n                if (obj.tagName === 'TD') {\n                    return 'HTMLTableDataCellElement';\n                }\n                if (obj.tagName === 'TH') {\n                    return 'HTMLTableHeaderCellElement';\n                }\n            }\n        }\n        var stringTag = (symbolToStringTagExists && obj[Symbol.toStringTag]);\n        if (typeof stringTag === 'string') {\n            return stringTag;\n        }\n        var objPrototype = Object.getPrototypeOf(obj);\n        if (objPrototype === RegExp.prototype) {\n            return 'RegExp';\n        }\n        if (objPrototype === Date.prototype) {\n            return 'Date';\n        }\n        if (promiseExists && objPrototype === Promise.prototype) {\n            return 'Promise';\n        }\n        if (setExists && objPrototype === Set.prototype) {\n            return 'Set';\n        }\n        if (mapExists && objPrototype === Map.prototype) {\n            return 'Map';\n        }\n        if (weakSetExists && objPrototype === WeakSet.prototype) {\n            return 'WeakSet';\n        }\n        if (weakMapExists && objPrototype === WeakMap.prototype) {\n            return 'WeakMap';\n        }\n        if (dataViewExists && objPrototype === DataView.prototype) {\n            return 'DataView';\n        }\n        if (mapExists && objPrototype === mapIteratorPrototype) {\n            return 'Map Iterator';\n        }\n        if (setExists && objPrototype === setIteratorPrototype) {\n            return 'Set Iterator';\n        }\n        if (arrayIteratorExists && objPrototype === arrayIteratorPrototype) {\n            return 'Array Iterator';\n        }\n        if (stringIteratorExists && objPrototype === stringIteratorPrototype) {\n            return 'String Iterator';\n        }\n        if (objPrototype === null) {\n            return 'Object';\n        }\n        return Object\n            .prototype\n            .toString\n            .call(obj)\n            .slice(toStringLeftSliceLength, toStringRightSliceLength);\n    }\n\n    return typeDetect;\n\n}));\n","\"use strict\";\n\nvar ARRAY_TYPES = [\n    Array,\n    Int8Array,\n    Uint8Array,\n    Uint8ClampedArray,\n    Int16Array,\n    Uint16Array,\n    Int32Array,\n    Uint32Array,\n    Float32Array,\n    Float64Array,\n];\n\nmodule.exports = ARRAY_TYPES;\n","\"use strict\";\n\nvar functionName = require(\"@sinonjs/commons\").functionName;\nvar indexOf = require(\"@sinonjs/commons\").prototypes.array.indexOf;\nvar map = require(\"@sinonjs/commons\").prototypes.array.map;\nvar ARRAY_TYPES = require(\"./array-types\");\nvar type = require(\"type-detect\");\n\n/**\n * Returns `true` when `object` is an array type, `false` otherwise\n *\n * @param  {*}  object - The object to examine\n * @returns {boolean} `true` when `object` is an array type\n * @private\n */\nfunction isArrayType(object) {\n    return indexOf(map(ARRAY_TYPES, functionName), type(object)) !== -1;\n}\n\nmodule.exports = isArrayType;\n","\"use strict\";\n\n/**\n * Returns `true` when `value` is an instance of Date\n *\n * @private\n * @param  {Date}  value The value to examine\n * @returns {boolean}     `true` when `value` is an instance of Date\n */\nfunction isDate(value) {\n    return value instanceof Date;\n}\n\nmodule.exports = isDate;\n","\"use strict\";\n\n/**\n * Returns `true` when the argument is an iterable, `false` otherwise\n * @alias module:samsam.isIterable\n * @param  {*}  val - A value to examine\n * @returns {boolean} Returns `true` when the argument is an iterable, `false` otherwise\n */\nfunction isIterable(val) {\n    // checks for null and undefined\n    if (typeof val !== \"object\") {\n        return false;\n    }\n    return typeof val[Symbol.iterator] === \"function\";\n}\n\nmodule.exports = isIterable;\n","\"use strict\";\n\n/**\n * Returns `true` when the value is a regular Object and not a specialized Object\n *\n * This helps speed up deepEqual cyclic checks\n *\n * The premise is that only Objects are stored in the visited array.\n * So if this function returns false, we don't have to do the\n * expensive operation of searching for the value in the the array of already\n * visited objects\n *\n * @private\n * @param  {object}   value The object to examine\n * @returns {boolean}       `true` when the object is a non-specialised object\n */\nfunction isObject(value) {\n    return (\n        typeof value === \"object\" &&\n        value !== null &&\n        // none of these are collection objects, so we can return false\n        !(value instanceof Boolean) &&\n        !(value instanceof Date) &&\n        !(value instanceof Error) &&\n        !(value instanceof Number) &&\n        !(value instanceof RegExp) &&\n        !(value instanceof String)\n    );\n}\n\nmodule.exports = isObject;\n","\"use strict\";\n\nvar forEach = require(\"@sinonjs/commons\").prototypes.set.forEach;\n\n/**\n * Returns `true` when `s1` is a subset of `s2`, `false` otherwise\n *\n * @private\n * @param  {Array|Set}  s1      The target value\n * @param  {Array|Set}  s2      The containing value\n * @param  {Function}  compare A comparison function, should return `true` when\n *                             values are considered equal\n * @returns {boolean} Returns `true` when `s1` is a subset of `s2`, `false`` otherwise\n */\nfunction isSubset(s1, s2, compare) {\n    var allContained = true;\n    forEach(s1, function (v1) {\n        var includes = false;\n        forEach(s2, function (v2) {\n            if (compare(v2, v1)) {\n                includes = true;\n            }\n        });\n        allContained = allContained && includes;\n    });\n\n    return allContained;\n}\n\nmodule.exports = isSubset;\n","\"use strict\";\n\nvar valueToString = require(\"@sinonjs/commons\").valueToString;\nvar className = require(\"@sinonjs/commons\").className;\nvar typeOf = require(\"@sinonjs/commons\").typeOf;\nvar arrayProto = require(\"@sinonjs/commons\").prototypes.array;\nvar mapForEach = require(\"@sinonjs/commons\").prototypes.map.forEach;\n\nvar getClass = require(\"./get-class\");\nvar identical = require(\"./identical\");\nvar isArguments = require(\"./is-arguments\");\nvar isArrayType = require(\"./is-array-type\");\nvar isDate = require(\"./is-date\");\nvar isElement = require(\"./is-element\");\nvar isIterable = require(\"./is-iterable\");\nvar isMap = require(\"./is-map\");\nvar isNaN = require(\"./is-nan\");\nvar isObject = require(\"./is-object\");\nvar isSet = require(\"./is-set\");\nvar isSubset = require(\"./is-subset\");\n\nvar concat = arrayProto.concat;\nvar every = arrayProto.every;\nvar push = arrayProto.push;\n\nvar getTime = Date.prototype.getTime;\nvar indexOf = arrayProto.indexOf;\nvar getOwnPropertySymbols = Object.getOwnPropertySymbols;\n\n/**\n * We explicitly want to get props on proto chain\n *\n * Objects such as URL in the browser do not have any\n * enumerable keys of its own. All meaningful props\n * to compare are enumerable getters further up the chain\n * @param {object} object\n * @returns {Array<string>} the list of enumerable keys\n */\nfunction allEnumerableKeysInProtoChain(object) {\n    const keys = [];\n\n    // eslint-disable-next-line\n    for (const key in object) {\n        keys.push(key);\n    }\n    return keys;\n}\n\n/**\n * Checks whether all expected enumerable string keys are present.\n *\n * @param {Array<string>} keys\n * @param {Array<string>} expectedKeys\n * @returns {boolean} `true` when all expected keys are present\n */\nfunction hasAllEnumerableStringKeys(keys, expectedKeys) {\n    return every(expectedKeys, function (key) {\n        return indexOf(keys, key) !== -1;\n    });\n}\n\n/**\n * Deep equal comparison. Two values are \"deep equal\" when:\n *\n * - They are equal, according to samsam.identical\n * - They are both date objects representing the same time\n * - They are both arrays containing elements that are all deepEqual\n * - They are objects with the same set of properties, and each property\n * in ``actual`` is deepEqual to the corresponding property in ``expectation``\n *\n * Supports cyclic objects.\n * @alias module:samsam.deepEqual\n * @param {*} actual The object to examine\n * @param {*} expectation The object actual is expected to be equal to\n * @param {object} match A value to match on\n * @returns {boolean} Returns true when actual and expectation are considered equal\n */\nfunction deepEqualCyclic(actual, expectation, match) {\n    // used for cyclic comparison\n    // contain already visited objects\n    var actualObjects = [];\n    var expectationObjects = [];\n    // contain pathes (position in the object structure)\n    // of the already visited objects\n    // indexes same as in objects arrays\n    var actualPaths = [];\n    var expectationPaths = [];\n    // contains combinations of already compared objects\n    // in the manner: { \"$1['ref']$2['ref']\": true }\n    var compared = {};\n\n    // does the recursion for the deep equal check\n    // eslint-disable-next-line complexity\n    return (function deepEqual(\n        actualObj,\n        expectationObj,\n        actualPath,\n        expectationPath,\n    ) {\n        // If both are matchers they must be the same instance in order to be\n        // considered equal If we didn't do that we would end up running one\n        // matcher against the other\n        if (match && match.isMatcher(expectationObj)) {\n            if (match.isMatcher(actualObj)) {\n                return actualObj === expectationObj;\n            }\n            return expectationObj.test(actualObj);\n        }\n\n        var actualType = typeof actualObj;\n        var expectationType = typeof expectationObj;\n\n        if (\n            actualObj === expectationObj ||\n            isNaN(actualObj) ||\n            isNaN(expectationObj) ||\n            actualObj === null ||\n            expectationObj === null ||\n            actualObj === undefined ||\n            expectationObj === undefined ||\n            actualType !== \"object\" ||\n            expectationType !== \"object\"\n        ) {\n            return identical(actualObj, expectationObj);\n        }\n\n        // Elements are only equal if identical(expected, actual)\n        if (isElement(actualObj) || isElement(expectationObj)) {\n            return false;\n        }\n\n        var isActualDate = isDate(actualObj);\n        var isExpectationDate = isDate(expectationObj);\n        if (isActualDate || isExpectationDate) {\n            if (\n                !isActualDate ||\n                !isExpectationDate ||\n                getTime.call(actualObj) !== getTime.call(expectationObj)\n            ) {\n                return false;\n            }\n        }\n\n        if (actualObj instanceof RegExp && expectationObj instanceof RegExp) {\n            if (valueToString(actualObj) !== valueToString(expectationObj)) {\n                return false;\n            }\n        }\n\n        if (actualObj instanceof Promise && expectationObj instanceof Promise) {\n            return actualObj === expectationObj;\n        }\n\n        if (actualObj instanceof Error && expectationObj instanceof Error) {\n            return actualObj === expectationObj;\n        }\n\n        var actualClass = getClass(actualObj);\n        var expectationClass = getClass(expectationObj);\n        var actualKeys = allEnumerableKeysInProtoChain(actualObj);\n        var expectationKeys = allEnumerableKeysInProtoChain(expectationObj);\n        var actualName = className(actualObj);\n        var expectationName = className(expectationObj);\n        var expectationSymbols =\n            typeOf(getOwnPropertySymbols) === \"function\"\n                ? getOwnPropertySymbols(expectationObj)\n                : /* c8 ignore next: cannot collect coverage for engine that doesn't support Symbol */\n                  [];\n        var expectationKeysAndSymbols = concat(\n            expectationKeys,\n            expectationSymbols,\n        );\n\n        if (isArguments(actualObj) || isArguments(expectationObj)) {\n            if (actualObj.length !== expectationObj.length) {\n                return false;\n            }\n        } else {\n            if (\n                actualType !== expectationType ||\n                actualClass !== expectationClass ||\n                actualKeys.length !== expectationKeys.length ||\n                !hasAllEnumerableStringKeys(actualKeys, expectationKeys) ||\n                !hasAllEnumerableStringKeys(expectationKeys, actualKeys) ||\n                (actualName &&\n                    expectationName &&\n                    actualName !== expectationName)\n            ) {\n                return false;\n            }\n        }\n\n        if (isSet(actualObj) || isSet(expectationObj)) {\n            if (\n                !isSet(actualObj) ||\n                !isSet(expectationObj) ||\n                actualObj.size !== expectationObj.size\n            ) {\n                return false;\n            }\n\n            return isSubset(actualObj, expectationObj, deepEqual);\n        }\n\n        if (isMap(actualObj) || isMap(expectationObj)) {\n            if (\n                !isMap(actualObj) ||\n                !isMap(expectationObj) ||\n                actualObj.size !== expectationObj.size\n            ) {\n                return false;\n            }\n\n            var mapsDeeplyEqual = true;\n            mapForEach(actualObj, function (value, key) {\n                mapsDeeplyEqual =\n                    mapsDeeplyEqual &&\n                    deepEqualCyclic(value, expectationObj.get(key));\n            });\n\n            return mapsDeeplyEqual;\n        }\n\n        // jQuery objects have iteration protocols\n        // see: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Iteration_protocols\n        // But, they don't work well with the implementation concerning iterables below,\n        // so we will detect them and use jQuery's own equality function\n        /* c8 ignore start: this can only be tested in the `test-headless` script */\n        if (\n            typeof actualObj.jquery === \"string\" &&\n            typeof actualObj.is === \"function\"\n        ) {\n            return actualObj.is(expectationObj);\n        }\n        /* c8 ignore stop */\n\n        var isActualNonArrayIterable =\n            isIterable(actualObj) &&\n            !isArrayType(actualObj) &&\n            !isArguments(actualObj);\n        var isExpectationNonArrayIterable =\n            isIterable(expectationObj) &&\n            !isArrayType(expectationObj) &&\n            !isArguments(expectationObj);\n        if (isActualNonArrayIterable || isExpectationNonArrayIterable) {\n            var actualArray = Array.from(actualObj);\n            var expectationArray = Array.from(expectationObj);\n            if (actualArray.length !== expectationArray.length) {\n                return false;\n            }\n\n            var arrayDeeplyEquals = true;\n            every(actualArray, function (key) {\n                arrayDeeplyEquals =\n                    arrayDeeplyEquals &&\n                    deepEqualCyclic(actualArray[key], expectationArray[key]);\n            });\n\n            return arrayDeeplyEquals;\n        }\n\n        return every(expectationKeysAndSymbols, function (key) {\n            var actualValue = actualObj[key];\n            var expectationValue = expectationObj[key];\n            var actualObject = isObject(actualValue);\n            var expectationObject = isObject(expectationValue);\n            // determines, if the objects were already visited\n            // (it's faster to check for isObject first, than to\n            // get -1 from getIndex for non objects)\n            var actualIndex = actualObject\n                ? indexOf(actualObjects, actualValue)\n                : -1;\n            var expectationIndex = expectationObject\n                ? indexOf(expectationObjects, expectationValue)\n                : -1;\n            // determines the new paths of the objects\n            // - for non cyclic objects the current path will be extended\n            //   by current property name\n            // - for cyclic objects the stored path is taken\n            var newActualPath =\n                actualIndex !== -1\n                    ? actualPaths[actualIndex]\n                    : `${actualPath}[${JSON.stringify(key)}]`;\n            var newExpectationPath =\n                expectationIndex !== -1\n                    ? expectationPaths[expectationIndex]\n                    : `${expectationPath}[${JSON.stringify(key)}]`;\n            var combinedPath = newActualPath + newExpectationPath;\n\n            // stop recursion if current objects are already compared\n            if (compared[combinedPath]) {\n                return true;\n            }\n\n            // remember the current objects and their paths\n            if (actualIndex === -1 && actualObject) {\n                push(actualObjects, actualValue);\n                push(actualPaths, newActualPath);\n            }\n            if (expectationIndex === -1 && expectationObject) {\n                push(expectationObjects, expectationValue);\n                push(expectationPaths, newExpectationPath);\n            }\n\n            // remember that the current objects are already compared\n            if (actualObject && expectationObject) {\n                compared[combinedPath] = true;\n            }\n\n            // End of cyclic logic\n\n            // neither actualValue nor expectationValue is a cycle\n            // continue with next level\n            return deepEqual(\n                actualValue,\n                expectationValue,\n                newActualPath,\n                newExpectationPath,\n            );\n        });\n    })(actual, expectation, \"$1\", \"$2\");\n}\n\ndeepEqualCyclic.use = function (match) {\n    return function deepEqual(a, b) {\n        return deepEqualCyclic(a, b, match);\n    };\n};\n\nmodule.exports = deepEqualCyclic;\n","\"use strict\";\n\nvar slice = require(\"@sinonjs/commons\").prototypes.string.slice;\nvar typeOf = require(\"@sinonjs/commons\").typeOf;\nvar valueToString = require(\"@sinonjs/commons\").valueToString;\n\n/**\n * Creates a string represenation of an iterable object\n *\n * @private\n * @param   {object} obj The iterable object to stringify\n * @returns {string}     A string representation\n */\nfunction iterableToString(obj) {\n    if (typeOf(obj) === \"map\") {\n        return mapToString(obj);\n    }\n\n    return genericIterableToString(obj);\n}\n\n/**\n * Creates a string representation of a Map\n *\n * @private\n * @param   {Map} map    The map to stringify\n * @returns {string}     A string representation\n */\nfunction mapToString(map) {\n    var representation = \"\";\n\n    // eslint-disable-next-line @sinonjs/no-prototype-methods/no-prototype-methods\n    map.forEach(function (value, key) {\n        representation += `[${stringify(key)},${stringify(value)}],`;\n    });\n\n    representation = slice(representation, 0, -1);\n    return representation;\n}\n\n/**\n * Create a string represenation for an iterable\n *\n * @private\n * @param   {object} iterable The iterable to stringify\n * @returns {string}          A string representation\n */\nfunction genericIterableToString(iterable) {\n    var representation = \"\";\n\n    // eslint-disable-next-line @sinonjs/no-prototype-methods/no-prototype-methods\n    iterable.forEach(function (value) {\n        representation += `${stringify(value)},`;\n    });\n\n    representation = slice(representation, 0, -1);\n    return representation;\n}\n\n/**\n * Creates a string representation of the passed `item`\n *\n * @private\n * @param  {object} item The item to stringify\n * @returns {string}      A string representation of `item`\n */\nfunction stringify(item) {\n    return typeof item === \"string\" ? `'${item}'` : valueToString(item);\n}\n\nmodule.exports = iterableToString;\n","\"use strict\";\n\nvar matcherPrototype = {\n    toString: function () {\n        return this.message;\n    },\n};\n\nmatcherPrototype.or = function (valueOrMatcher) {\n    var createMatcher = require(\"../create-matcher\");\n    var isMatcher = createMatcher.isMatcher;\n\n    if (!arguments.length) {\n        throw new TypeError(\"Matcher expected\");\n    }\n\n    var m2 = isMatcher(valueOrMatcher)\n        ? valueOrMatcher\n        : createMatcher(valueOrMatcher);\n    var m1 = this;\n    var or = Object.create(matcherPrototype);\n    or.test = function (actual) {\n        return m1.test(actual) || m2.test(actual);\n    };\n    or.message = `${m1.message}.or(${m2.message})`;\n    return or;\n};\n\nmatcherPrototype.and = function (valueOrMatcher) {\n    var createMatcher = require(\"../create-matcher\");\n    var isMatcher = createMatcher.isMatcher;\n\n    if (!arguments.length) {\n        throw new TypeError(\"Matcher expected\");\n    }\n\n    var m2 = isMatcher(valueOrMatcher)\n        ? valueOrMatcher\n        : createMatcher(valueOrMatcher);\n    var m1 = this;\n    var and = Object.create(matcherPrototype);\n    and.test = function (actual) {\n        return m1.test(actual) && m2.test(actual);\n    };\n    and.message = `${m1.message}.and(${m2.message})`;\n    return and;\n};\n\nmodule.exports = matcherPrototype;\n","\"use strict\";\n\nvar isPrototypeOf = require(\"@sinonjs/commons\").prototypes.object.isPrototypeOf;\n\nvar matcherPrototype = require(\"./matcher-prototype\");\n\n/**\n * Returns `true` when `object` is a matcher\n *\n * @private\n * @param {*} object A value to examine\n * @returns {boolean} Returns `true` when `object` is a matcher\n */\nfunction isMatcher(object) {\n    return isPrototypeOf(matcherPrototype, object);\n}\n\nmodule.exports = isMatcher;\n","\"use strict\";\n\nvar isMatcher = require(\"./is-matcher\");\n\n/**\n * Throws a TypeError when `value` is not a matcher\n *\n * @private\n * @param {*} value The value to examine\n */\nfunction assertMatcher(value) {\n    if (!isMatcher(value)) {\n        throw new TypeError(\"Matcher expected\");\n    }\n}\n\nmodule.exports = assertMatcher;\n","\"use strict\";\n\n/**\n * Throws a TypeError when expected method doesn't exist\n *\n * @private\n * @param {*} value A value to examine\n * @param {string} method The name of the method to look for\n * @param {name} name A name to use for the error message\n * @param {string} methodPath The name of the method to use for error messages\n * @throws {TypeError} When the method doesn't exist\n */\nfunction assertMethodExists(value, method, name, methodPath) {\n    if (value[method] === null || value[method] === undefined) {\n        throw new TypeError(`Expected ${name} to have method ${methodPath}`);\n    }\n}\n\nmodule.exports = assertMethodExists;\n","\"use strict\";\n\nvar typeOf = require(\"@sinonjs/commons\").typeOf;\n\n/**\n * Ensures that value is of type\n *\n * @private\n * @param {*} value A value to examine\n * @param {string} type A basic JavaScript type to compare to, e.g. \"object\", \"string\"\n * @param {string} name A string to use for the error message\n * @throws {TypeError} If value is not of the expected type\n * @returns {undefined}\n */\nfunction assertType(value, type, name) {\n    var actual = typeOf(value);\n    if (actual !== type) {\n        throw new TypeError(\n            `Expected type of ${name} to be ${type}, but was ${actual}`,\n        );\n    }\n}\n\nmodule.exports = assertType;\n","\"use strict\";\n\nvar typeOf = require(\"@sinonjs/commons\").typeOf;\n\n/**\n * Returns `true` for iterables\n *\n * @private\n * @param {*} value A value to examine\n * @returns {boolean} Returns `true` when `value` looks like an iterable\n */\nfunction isIterable(value) {\n    return Boolean(value) && typeOf(value.forEach) === \"function\";\n}\n\nmodule.exports = isIterable;\n","\"use strict\";\n\nvar every = require(\"@sinonjs/commons\").prototypes.array.every;\nvar concat = require(\"@sinonjs/commons\").prototypes.array.concat;\nvar typeOf = require(\"@sinonjs/commons\").typeOf;\n\nvar deepEqualFactory = require(\"../deep-equal\").use;\n\nvar identical = require(\"../identical\");\nvar isMatcher = require(\"./is-matcher\");\n\nvar keys = Object.keys;\nvar getOwnPropertySymbols = Object.getOwnPropertySymbols;\n\n/**\n * Matches `actual` with `expectation`\n *\n * @private\n * @param {*} actual A value to examine\n * @param {object} expectation An object with properties to match on\n * @param {object} matcher A matcher to use for comparison\n * @returns {boolean} Returns true when `actual` matches all properties in `expectation`\n */\nfunction matchObject(actual, expectation, matcher) {\n    var deepEqual = deepEqualFactory(matcher);\n    if (actual === null || actual === undefined) {\n        return false;\n    }\n\n    var expectedKeys = keys(expectation);\n    if (typeOf(getOwnPropertySymbols) === \"function\") {\n        expectedKeys = concat(expectedKeys, getOwnPropertySymbols(expectation));\n    }\n\n    return every(expectedKeys, function (key) {\n        var exp = expectation[key];\n        var act = actual[key];\n\n        if (isMatcher(exp)) {\n            if (!exp.test(act)) {\n                return false;\n            }\n        } else if (typeOf(exp) === \"object\") {\n            if (identical(exp, act)) {\n                return true;\n            }\n            if (!matchObject(act, exp, matcher)) {\n                return false;\n            }\n        } else if (!deepEqual(act, exp)) {\n            return false;\n        }\n\n        return true;\n    });\n}\n\nmodule.exports = matchObject;\n","\"use strict\";\n\nvar functionName = require(\"@sinonjs/commons\").functionName;\nvar join = require(\"@sinonjs/commons\").prototypes.array.join;\nvar map = require(\"@sinonjs/commons\").prototypes.array.map;\nvar stringIndexOf = require(\"@sinonjs/commons\").prototypes.string.indexOf;\nvar valueToString = require(\"@sinonjs/commons\").valueToString;\n\nvar matchObject = require(\"./match-object\");\n\nvar createTypeMap = function (match) {\n    return {\n        function: function (m, expectation, message) {\n            m.test = expectation;\n            m.message = message || `match(${functionName(expectation)})`;\n        },\n        number: function (m, expectation) {\n            m.test = function (actual) {\n                // we need type coercion here\n                return expectation == actual; // eslint-disable-line eqeqeq\n            };\n        },\n        object: function (m, expectation) {\n            var array = [];\n\n            if (typeof expectation.test === \"function\") {\n                m.test = function (actual) {\n                    return expectation.test(actual) === true;\n                };\n                m.message = `match(${functionName(expectation.test)})`;\n                return m;\n            }\n\n            array = map(Object.keys(expectation), function (key) {\n                return `${key}: ${valueToString(expectation[key])}`;\n            });\n\n            m.test = function (actual) {\n                return matchObject(actual, expectation, match);\n            };\n            m.message = `match(${join(array, \", \")})`;\n\n            return m;\n        },\n        regexp: function (m, expectation) {\n            m.test = function (actual) {\n                return typeof actual === \"string\" && expectation.test(actual);\n            };\n        },\n        string: function (m, expectation) {\n            m.test = function (actual) {\n                return (\n                    typeof actual === \"string\" &&\n                    stringIndexOf(actual, expectation) !== -1\n                );\n            };\n            m.message = `match(\"${expectation}\")`;\n        },\n    };\n};\n\nmodule.exports = createTypeMap;\n","\"use strict\";\n\nvar arrayProto = require(\"@sinonjs/commons\").prototypes.array;\nvar deepEqual = require(\"./deep-equal\").use(createMatcher); // eslint-disable-line no-use-before-define\nvar every = require(\"@sinonjs/commons\").every;\nvar functionName = require(\"@sinonjs/commons\").functionName;\nvar iterableToString = require(\"./iterable-to-string\");\nvar objectProto = require(\"@sinonjs/commons\").prototypes.object;\nvar typeOf = require(\"@sinonjs/commons\").typeOf;\nvar valueToString = require(\"@sinonjs/commons\").valueToString;\n\nvar assertMatcher = require(\"./create-matcher/assert-matcher\");\nvar assertMethodExists = require(\"./create-matcher/assert-method-exists\");\nvar assertType = require(\"./create-matcher/assert-type\");\nvar isIterable = require(\"./create-matcher/is-iterable\");\nvar isMatcher = require(\"./create-matcher/is-matcher\");\n\nvar matcherPrototype = require(\"./create-matcher/matcher-prototype\");\n\nvar arrayIndexOf = arrayProto.indexOf;\nvar some = arrayProto.some;\n\nvar hasOwnProperty = objectProto.hasOwnProperty;\nvar objectToString = objectProto.toString;\n\nvar TYPE_MAP = require(\"./create-matcher/type-map\")(createMatcher); // eslint-disable-line no-use-before-define\n\n/**\n * Creates a matcher object for the passed expectation\n * @alias module:samsam.createMatcher\n * @param {*} expectation An expecttation\n * @param {string} message A message for the expectation\n * @returns {object} A matcher object\n */\nfunction createMatcher(expectation, message) {\n    var m = Object.create(matcherPrototype);\n    var type = typeOf(expectation);\n\n    if (message !== undefined && typeof message !== \"string\") {\n        throw new TypeError(\"Message should be a string\");\n    }\n\n    if (arguments.length > 2) {\n        throw new TypeError(\n            `Expected 1 or 2 arguments, received ${arguments.length}`,\n        );\n    }\n\n    if (type in TYPE_MAP) {\n        TYPE_MAP[type](m, expectation, message);\n    } else {\n        m.test = function (actual) {\n            return deepEqual(actual, expectation);\n        };\n    }\n\n    if (!m.message) {\n        m.message = `match(${valueToString(expectation)})`;\n    }\n\n    // ensure that nothing mutates the exported message value, ref https://github.com/sinonjs/sinon/issues/2502\n    Object.defineProperty(m, \"message\", {\n        configurable: false,\n        writable: false,\n        value: m.message,\n    });\n\n    return m;\n}\n\ncreateMatcher.isMatcher = isMatcher;\n\ncreateMatcher.any = createMatcher(function () {\n    return true;\n}, \"any\");\n\ncreateMatcher.defined = createMatcher(function (actual) {\n    return actual !== null && actual !== undefined;\n}, \"defined\");\n\ncreateMatcher.truthy = createMatcher(function (actual) {\n    return Boolean(actual);\n}, \"truthy\");\n\ncreateMatcher.falsy = createMatcher(function (actual) {\n    return !actual;\n}, \"falsy\");\n\ncreateMatcher.same = function (expectation) {\n    return createMatcher(\n        function (actual) {\n            return expectation === actual;\n        },\n        `same(${valueToString(expectation)})`,\n    );\n};\n\ncreateMatcher.in = function (arrayOfExpectations) {\n    if (typeOf(arrayOfExpectations) !== \"array\") {\n        throw new TypeError(\"array expected\");\n    }\n\n    return createMatcher(\n        function (actual) {\n            return some(arrayOfExpectations, function (expectation) {\n                return expectation === actual;\n            });\n        },\n        `in(${valueToString(arrayOfExpectations)})`,\n    );\n};\n\ncreateMatcher.typeOf = function (type) {\n    assertType(type, \"string\", \"type\");\n    return createMatcher(function (actual) {\n        return typeOf(actual) === type;\n    }, `typeOf(\"${type}\")`);\n};\n\ncreateMatcher.instanceOf = function (type) {\n    /* c8 ignore start */\n    if (\n        typeof Symbol === \"undefined\" ||\n        typeof Symbol.hasInstance === \"undefined\"\n    ) {\n        assertType(type, \"function\", \"type\");\n    } else {\n        assertMethodExists(\n            type,\n            Symbol.hasInstance,\n            \"type\",\n            \"[Symbol.hasInstance]\",\n        );\n    }\n    /* c8 ignore stop */\n    return createMatcher(\n        function (actual) {\n            return actual instanceof type;\n        },\n        `instanceOf(${functionName(type) || objectToString(type)})`,\n    );\n};\n\n/**\n * Creates a property matcher\n *\n * @private\n * @param {Function} propertyTest A function to test the property against a value\n * @param {string} messagePrefix A prefix to use for messages generated by the matcher\n * @returns {object} A matcher\n */\nfunction createPropertyMatcher(propertyTest, messagePrefix) {\n    return function (property, value) {\n        assertType(property, \"string\", \"property\");\n        var onlyProperty = arguments.length === 1;\n        var message = `${messagePrefix}(\"${property}\"`;\n        if (!onlyProperty) {\n            message += `, ${valueToString(value)}`;\n        }\n        message += \")\";\n        return createMatcher(function (actual) {\n            if (\n                actual === undefined ||\n                actual === null ||\n                !propertyTest(actual, property)\n            ) {\n                return false;\n            }\n            return onlyProperty || deepEqual(actual[property], value);\n        }, message);\n    };\n}\n\ncreateMatcher.has = createPropertyMatcher(function (actual, property) {\n    if (typeof actual === \"object\") {\n        return property in actual;\n    }\n    return actual[property] !== undefined;\n}, \"has\");\n\ncreateMatcher.hasOwn = createPropertyMatcher(function (actual, property) {\n    return hasOwnProperty(actual, property);\n}, \"hasOwn\");\n\ncreateMatcher.hasNested = function (property, value) {\n    assertType(property, \"string\", \"property\");\n    var onlyProperty = arguments.length === 1;\n    var message = `hasNested(\"${property}\"`;\n    if (!onlyProperty) {\n        message += `, ${valueToString(value)}`;\n    }\n    message += \")\";\n    return createMatcher(function (actual) {\n        const parts = property.split(/(?:\\.|\\[|\\])+?/).filter(Boolean);\n        let current = actual;\n        for (const part of parts) {\n            current = current?.[part];\n            if (current === undefined) {\n                return false;\n            }\n        }\n        return onlyProperty || deepEqual(current, value);\n    }, message);\n};\n\nvar jsonParseResultTypes = {\n    null: true,\n    boolean: true,\n    number: true,\n    string: true,\n    object: true,\n    array: true,\n};\ncreateMatcher.json = function (value) {\n    if (!jsonParseResultTypes[typeOf(value)]) {\n        throw new TypeError(\"Value cannot be the result of JSON.parse\");\n    }\n    var message = `json(${JSON.stringify(value, null, \"  \")})`;\n    return createMatcher(function (actual) {\n        var parsed;\n        try {\n            parsed = JSON.parse(actual);\n        } catch (e) {\n            return false;\n        }\n        return deepEqual(parsed, value);\n    }, message);\n};\n\ncreateMatcher.every = function (predicate) {\n    assertMatcher(predicate);\n\n    return createMatcher(function (actual) {\n        if (typeOf(actual) === \"object\") {\n            return every(Object.keys(actual), function (key) {\n                return predicate.test(actual[key]);\n            });\n        }\n\n        return (\n            isIterable(actual) &&\n            every(actual, function (element) {\n                return predicate.test(element);\n            })\n        );\n    }, `every(${predicate.message})`);\n};\n\ncreateMatcher.some = function (predicate) {\n    assertMatcher(predicate);\n\n    return createMatcher(function (actual) {\n        if (typeOf(actual) === \"object\") {\n            return !every(Object.keys(actual), function (key) {\n                return !predicate.test(actual[key]);\n            });\n        }\n\n        return (\n            isIterable(actual) &&\n            !every(actual, function (element) {\n                return !predicate.test(element);\n            })\n        );\n    }, `some(${predicate.message})`);\n};\n\ncreateMatcher.array = createMatcher.typeOf(\"array\");\n\ncreateMatcher.array.deepEquals = function (expectation) {\n    return createMatcher(\n        function (actual) {\n            // Comparing lengths is the fastest way to spot a difference before iterating through every item\n            var sameLength = actual.length === expectation.length;\n            return (\n                typeOf(actual) === \"array\" &&\n                sameLength &&\n                every(actual, function (element, index) {\n                    var expected = expectation[index];\n                    return typeOf(expected) === \"array\" &&\n                        typeOf(element) === \"array\"\n                        ? createMatcher.array.deepEquals(expected).test(element)\n                        : deepEqual(expected, element);\n                })\n            );\n        },\n        `deepEquals([${iterableToString(expectation)}])`,\n    );\n};\n\ncreateMatcher.array.startsWith = function (expectation) {\n    return createMatcher(\n        function (actual) {\n            return (\n                typeOf(actual) === \"array\" &&\n                every(expectation, function (expectedElement, index) {\n                    return actual[index] === expectedElement;\n                })\n            );\n        },\n        `startsWith([${iterableToString(expectation)}])`,\n    );\n};\n\ncreateMatcher.array.endsWith = function (expectation) {\n    return createMatcher(\n        function (actual) {\n            // This indicates the index in which we should start matching\n            var offset = actual.length - expectation.length;\n\n            return (\n                typeOf(actual) === \"array\" &&\n                every(expectation, function (expectedElement, index) {\n                    return actual[offset + index] === expectedElement;\n                })\n            );\n        },\n        `endsWith([${iterableToString(expectation)}])`,\n    );\n};\n\ncreateMatcher.array.contains = function (expectation) {\n    return createMatcher(\n        function (actual) {\n            return (\n                typeOf(actual) === \"array\" &&\n                every(expectation, function (expectedElement) {\n                    return arrayIndexOf(actual, expectedElement) !== -1;\n                })\n            );\n        },\n        `contains([${iterableToString(expectation)}])`,\n    );\n};\n\ncreateMatcher.map = createMatcher.typeOf(\"map\");\n\ncreateMatcher.map.deepEquals = function mapDeepEquals(expectation) {\n    return createMatcher(\n        function (actual) {\n            // Comparing lengths is the fastest way to spot a difference before iterating through every item\n            var sameLength = actual.size === expectation.size;\n            return (\n                typeOf(actual) === \"map\" &&\n                sameLength &&\n                every(actual, function (element, key) {\n                    return (\n                        expectation.has(key) && expectation.get(key) === element\n                    );\n                })\n            );\n        },\n        `deepEquals(Map[${iterableToString(expectation)}])`,\n    );\n};\n\ncreateMatcher.map.contains = function mapContains(expectation) {\n    return createMatcher(\n        function (actual) {\n            return (\n                typeOf(actual) === \"map\" &&\n                every(expectation, function (element, key) {\n                    return actual.has(key) && actual.get(key) === element;\n                })\n            );\n        },\n        `contains(Map[${iterableToString(expectation)}])`,\n    );\n};\n\ncreateMatcher.set = createMatcher.typeOf(\"set\");\n\ncreateMatcher.set.deepEquals = function setDeepEquals(expectation) {\n    return createMatcher(\n        function (actual) {\n            // Comparing lengths is the fastest way to spot a difference before iterating through every item\n            var sameLength = actual.size === expectation.size;\n            return (\n                typeOf(actual) === \"set\" &&\n                sameLength &&\n                every(actual, function (element) {\n                    return expectation.has(element);\n                })\n            );\n        },\n        `deepEquals(Set[${iterableToString(expectation)}])`,\n    );\n};\n\ncreateMatcher.set.contains = function setContains(expectation) {\n    return createMatcher(\n        function (actual) {\n            return (\n                typeOf(actual) === \"set\" &&\n                every(expectation, function (element) {\n                    return actual.has(element);\n                })\n            );\n        },\n        `contains(Set[${iterableToString(expectation)}])`,\n    );\n};\n\ncreateMatcher.bool = createMatcher.typeOf(\"boolean\");\ncreateMatcher.number = createMatcher.typeOf(\"number\");\ncreateMatcher.string = createMatcher.typeOf(\"string\");\ncreateMatcher.object = createMatcher.typeOf(\"object\");\ncreateMatcher.func = createMatcher.typeOf(\"function\");\ncreateMatcher.regexp = createMatcher.typeOf(\"regexp\");\ncreateMatcher.date = createMatcher.typeOf(\"date\");\ncreateMatcher.symbol = createMatcher.typeOf(\"symbol\");\n\nmodule.exports = createMatcher;\n","\"use strict\";\n\nvar valueToString = require(\"@sinonjs/commons\").valueToString;\nvar indexOf = require(\"@sinonjs/commons\").prototypes.string.indexOf;\nvar forEach = require(\"@sinonjs/commons\").prototypes.array.forEach;\nvar type = require(\"type-detect\");\n\nvar engineCanCompareMaps = typeof Array.from === \"function\";\nvar deepEqual = require(\"./deep-equal\").use(match); // eslint-disable-line no-use-before-define\nvar isArrayType = require(\"./is-array-type\");\nvar isSubset = require(\"./is-subset\");\nvar createMatcher = require(\"./create-matcher\");\n\n/**\n * Returns true when `array` contains all of `subset` as defined by the `compare`\n * argument\n *\n * @param  {Array} array   An array to search for a subset\n * @param  {Array} subset  The subset to find in the array\n * @param  {Function} compare A comparison function\n * @returns {boolean}         [description]\n * @private\n */\nfunction arrayContains(array, subset, compare) {\n    if (subset.length === 0) {\n        return true;\n    }\n    var i, l, j, k;\n    for (i = 0, l = array.length; i < l; ++i) {\n        if (compare(array[i], subset[0])) {\n            for (j = 0, k = subset.length; j < k; ++j) {\n                if (i + j >= l) {\n                    return false;\n                }\n                if (!compare(array[i + j], subset[j])) {\n                    return false;\n                }\n            }\n            return true;\n        }\n    }\n    return false;\n}\n\n/* eslint-disable complexity */\n/**\n * Matches an object with a matcher (or value)\n * @alias module:samsam.match\n * @param {object} object The object candidate to match\n * @param {object} matcherOrValue A matcher or value to match against\n * @returns {boolean} true when `object` matches `matcherOrValue`\n */\nfunction match(object, matcherOrValue) {\n    if (matcherOrValue && typeof matcherOrValue.test === \"function\") {\n        return matcherOrValue.test(object);\n    }\n\n    switch (type(matcherOrValue)) {\n        case \"bigint\":\n        case \"boolean\":\n        case \"number\":\n        case \"symbol\":\n            return matcherOrValue === object;\n        case \"function\":\n            return matcherOrValue(object) === true;\n        case \"string\":\n            var notNull = typeof object === \"string\" || Boolean(object);\n            return (\n                notNull &&\n                indexOf(\n                    valueToString(object).toLowerCase(),\n                    matcherOrValue.toLowerCase(),\n                ) >= 0\n            );\n        case \"null\":\n            return object === null;\n        case \"undefined\":\n            return typeof object === \"undefined\";\n        case \"Date\":\n            if (type(object) === \"Date\") {\n                return object.getTime() === matcherOrValue.getTime();\n            }\n            /* c8 ignore next: this is basically the rest of the function, which is covered */\n            break;\n        case \"Array\":\n        case \"Int8Array\":\n        case \"Uint8Array\":\n        case \"Uint8ClampedArray\":\n        case \"Int16Array\":\n        case \"Uint16Array\":\n        case \"Int32Array\":\n        case \"Uint32Array\":\n        case \"Float32Array\":\n        case \"Float64Array\":\n            return (\n                isArrayType(matcherOrValue) &&\n                arrayContains(object, matcherOrValue, match)\n            );\n        case \"Map\":\n            /* c8 ignore start: this is covered by a test, that is only run in IE, but we collect coverage information in node*/\n            if (!engineCanCompareMaps) {\n                throw new Error(\n                    \"The JavaScript engine does not support Array.from and cannot reliably do value comparison of Map instances\",\n                );\n            }\n            /* c8 ignore stop */\n            return (\n                type(object) === \"Map\" &&\n                arrayContains(\n                    Array.from(object),\n                    Array.from(matcherOrValue),\n                    match,\n                )\n            );\n        default:\n            break;\n    }\n\n    switch (type(object)) {\n        case \"null\":\n            return false;\n        case \"Set\":\n            return isSubset(matcherOrValue, object, match);\n        default:\n            break;\n    }\n\n    if (matcherOrValue && typeof matcherOrValue === \"object\") {\n        if (matcherOrValue === object) {\n            return true;\n        }\n        if (typeof object !== \"object\") {\n            return false;\n        }\n        var prop;\n        // eslint-disable-next-line guard-for-in\n        for (prop in matcherOrValue) {\n            var value = object[prop];\n            if (\n                typeof value === \"undefined\" &&\n                typeof object.getAttribute === \"function\"\n            ) {\n                value = object.getAttribute(prop);\n            }\n            if (\n                matcherOrValue[prop] === null ||\n                typeof matcherOrValue[prop] === \"undefined\"\n            ) {\n                if (value !== matcherOrValue[prop]) {\n                    return false;\n                }\n            } else if (\n                typeof value === \"undefined\" ||\n                !deepEqual(value, matcherOrValue[prop])\n            ) {\n                return false;\n            }\n        }\n        return true;\n    }\n    /* c8 ignore next */\n    throw new Error(\"Matcher was an unknown or unsupported type\");\n}\n/* eslint-enable complexity */\n\nforEach(Object.keys(createMatcher), function (key) {\n    match[key] = createMatcher[key];\n});\n\nmodule.exports = match;\n","\"use strict\";\n\n/**\n * @module samsam\n */\nvar identical = require(\"./identical\");\nvar isArguments = require(\"./is-arguments\");\nvar isElement = require(\"./is-element\");\nvar isNegZero = require(\"./is-neg-zero\");\nvar isSet = require(\"./is-set\");\nvar isMap = require(\"./is-map\");\nvar match = require(\"./match\");\nvar deepEqualCyclic = require(\"./deep-equal\").use(match);\nvar createMatcher = require(\"./create-matcher\");\n\nmodule.exports = {\n    createMatcher: createMatcher,\n    deepEqual: deepEqualCyclic,\n    identical: identical,\n    isArguments: isArguments,\n    isElement: isElement,\n    isMap: isMap,\n    isNegZero: isNegZero,\n    isSet: isSet,\n    match: match,\n};\n","\"use strict\";\n\nconst array = [null, \"once\", \"twice\", \"thrice\"];\n\nmodule.exports = function timesInWords(count) {\n    return array[count] || `${count || 0} times`;\n};\n","'use strict';\n\n/* eslint complexity: [2, 18], max-statements: [2, 33] */\nmodule.exports = function hasSymbols() {\n\tif (typeof Symbol !== 'function' || typeof Object.getOwnPropertySymbols !== 'function') { return false; }\n\tif (typeof Symbol.iterator === 'symbol') { return true; }\n\n\tvar obj = {};\n\tvar sym = Symbol('test');\n\tvar symObj = Object(sym);\n\tif (typeof sym === 'string') { return false; }\n\n\tif (Object.prototype.toString.call(sym) !== '[object Symbol]') { return false; }\n\tif (Object.prototype.toString.call(symObj) !== '[object Symbol]') { return false; }\n\n\t// temp disabled per https://github.com/ljharb/object.assign/issues/17\n\t// if (sym instanceof Symbol) { return false; }\n\t// temp disabled per https://github.com/WebReflection/get-own-property-symbols/issues/4\n\t// if (!(symObj instanceof Symbol)) { return false; }\n\n\t// if (typeof Symbol.prototype.toString !== 'function') { return false; }\n\t// if (String(sym) !== Symbol.prototype.toString.call(sym)) { return false; }\n\n\tvar symVal = 42;\n\tobj[sym] = symVal;\n\tfor (sym in obj) { return false; } // eslint-disable-line no-restricted-syntax, no-unreachable-loop\n\tif (typeof Object.keys === 'function' && Object.keys(obj).length !== 0) { return false; }\n\n\tif (typeof Object.getOwnPropertyNames === 'function' && Object.getOwnPropertyNames(obj).length !== 0) { return false; }\n\n\tvar syms = Object.getOwnPropertySymbols(obj);\n\tif (syms.length !== 1 || syms[0] !== sym) { return false; }\n\n\tif (!Object.prototype.propertyIsEnumerable.call(obj, sym)) { return false; }\n\n\tif (typeof Object.getOwnPropertyDescriptor === 'function') {\n\t\tvar descriptor = Object.getOwnPropertyDescriptor(obj, sym);\n\t\tif (descriptor.value !== symVal || descriptor.enumerable !== true) { return false; }\n\t}\n\n\treturn true;\n};\n","'use strict';\n\nvar hasSymbols = require('has-symbols/shams');\n\n/** @type {import('.')} */\nmodule.exports = function hasToStringTagShams() {\n\treturn hasSymbols() && !!Symbol.toStringTag;\n};\n","'use strict';\n\n/** @type {import('.')} */\nmodule.exports = Error;\n","'use strict';\n\n/** @type {import('./eval')} */\nmodule.exports = EvalError;\n","'use strict';\n\n/** @type {import('./range')} */\nmodule.exports = RangeError;\n","'use strict';\n\n/** @type {import('./ref')} */\nmodule.exports = ReferenceError;\n","'use strict';\n\n/** @type {import('./syntax')} */\nmodule.exports = SyntaxError;\n","'use strict';\n\n/** @type {import('./type')} */\nmodule.exports = TypeError;\n","'use strict';\n\n/** @type {import('./uri')} */\nmodule.exports = URIError;\n","'use strict';\n\nvar origSymbol = typeof Symbol !== 'undefined' && Symbol;\nvar hasSymbolSham = require('./shams');\n\nmodule.exports = function hasNativeSymbols() {\n\tif (typeof origSymbol !== 'function') { return false; }\n\tif (typeof Symbol !== 'function') { return false; }\n\tif (typeof origSymbol('foo') !== 'symbol') { return false; }\n\tif (typeof Symbol('bar') !== 'symbol') { return false; }\n\n\treturn hasSymbolSham();\n};\n","'use strict';\n\nvar test = {\n\t__proto__: null,\n\tfoo: {}\n};\n\nvar $Object = Object;\n\n/** @type {import('.')} */\nmodule.exports = function hasProto() {\n\t// @ts-expect-error: TS errors on an inherited property for some reason\n\treturn { __proto__: test }.foo === test.foo\n\t\t&& !(test instanceof $Object);\n};\n","'use strict';\n\n/* eslint no-invalid-this: 1 */\n\nvar ERROR_MESSAGE = 'Function.prototype.bind called on incompatible ';\nvar toStr = Object.prototype.toString;\nvar max = Math.max;\nvar funcType = '[object Function]';\n\nvar concatty = function concatty(a, b) {\n    var arr = [];\n\n    for (var i = 0; i < a.length; i += 1) {\n        arr[i] = a[i];\n    }\n    for (var j = 0; j < b.length; j += 1) {\n        arr[j + a.length] = b[j];\n    }\n\n    return arr;\n};\n\nvar slicy = function slicy(arrLike, offset) {\n    var arr = [];\n    for (var i = offset || 0, j = 0; i < arrLike.length; i += 1, j += 1) {\n        arr[j] = arrLike[i];\n    }\n    return arr;\n};\n\nvar joiny = function (arr, joiner) {\n    var str = '';\n    for (var i = 0; i < arr.length; i += 1) {\n        str += arr[i];\n        if (i + 1 < arr.length) {\n            str += joiner;\n        }\n    }\n    return str;\n};\n\nmodule.exports = function bind(that) {\n    var target = this;\n    if (typeof target !== 'function' || toStr.apply(target) !== funcType) {\n        throw new TypeError(ERROR_MESSAGE + target);\n    }\n    var args = slicy(arguments, 1);\n\n    var bound;\n    var binder = function () {\n        if (this instanceof bound) {\n            var result = target.apply(\n                this,\n                concatty(args, arguments)\n            );\n            if (Object(result) === result) {\n                return result;\n            }\n            return this;\n        }\n        return target.apply(\n            that,\n            concatty(args, arguments)\n        );\n\n    };\n\n    var boundLength = max(0, target.length - args.length);\n    var boundArgs = [];\n    for (var i = 0; i < boundLength; i++) {\n        boundArgs[i] = '$' + i;\n    }\n\n    bound = Function('binder', 'return function (' + joiny(boundArgs, ',') + '){ return binder.apply(this,arguments); }')(binder);\n\n    if (target.prototype) {\n        var Empty = function Empty() {};\n        Empty.prototype = target.prototype;\n        bound.prototype = new Empty();\n        Empty.prototype = null;\n    }\n\n    return bound;\n};\n","'use strict';\n\nvar implementation = require('./implementation');\n\nmodule.exports = Function.prototype.bind || implementation;\n","'use strict';\n\nvar call = Function.prototype.call;\nvar $hasOwn = Object.prototype.hasOwnProperty;\nvar bind = require('function-bind');\n\n/** @type {import('.')} */\nmodule.exports = bind.call(call, $hasOwn);\n","'use strict';\n\nvar undefined;\n\nvar $Error = require('es-errors');\nvar $EvalError = require('es-errors/eval');\nvar $RangeError = require('es-errors/range');\nvar $ReferenceError = require('es-errors/ref');\nvar $SyntaxError = require('es-errors/syntax');\nvar $TypeError = require('es-errors/type');\nvar $URIError = require('es-errors/uri');\n\nvar $Function = Function;\n\n// eslint-disable-next-line consistent-return\nvar getEvalledConstructor = function (expressionSyntax) {\n\ttry {\n\t\treturn $Function('\"use strict\"; return (' + expressionSyntax + ').constructor;')();\n\t} catch (e) {}\n};\n\nvar $gOPD = Object.getOwnPropertyDescriptor;\nif ($gOPD) {\n\ttry {\n\t\t$gOPD({}, '');\n\t} catch (e) {\n\t\t$gOPD = null; // this is IE 8, which has a broken gOPD\n\t}\n}\n\nvar throwTypeError = function () {\n\tthrow new $TypeError();\n};\nvar ThrowTypeError = $gOPD\n\t? (function () {\n\t\ttry {\n\t\t\t// eslint-disable-next-line no-unused-expressions, no-caller, no-restricted-properties\n\t\t\targuments.callee; // IE 8 does not throw here\n\t\t\treturn throwTypeError;\n\t\t} catch (calleeThrows) {\n\t\t\ttry {\n\t\t\t\t// IE 8 throws on Object.getOwnPropertyDescriptor(arguments, '')\n\t\t\t\treturn $gOPD(arguments, 'callee').get;\n\t\t\t} catch (gOPDthrows) {\n\t\t\t\treturn throwTypeError;\n\t\t\t}\n\t\t}\n\t}())\n\t: throwTypeError;\n\nvar hasSymbols = require('has-symbols')();\nvar hasProto = require('has-proto')();\n\nvar getProto = Object.getPrototypeOf || (\n\thasProto\n\t\t? function (x) { return x.__proto__; } // eslint-disable-line no-proto\n\t\t: null\n);\n\nvar needsEval = {};\n\nvar TypedArray = typeof Uint8Array === 'undefined' || !getProto ? undefined : getProto(Uint8Array);\n\nvar INTRINSICS = {\n\t__proto__: null,\n\t'%AggregateError%': typeof AggregateError === 'undefined' ? undefined : AggregateError,\n\t'%Array%': Array,\n\t'%ArrayBuffer%': typeof ArrayBuffer === 'undefined' ? undefined : ArrayBuffer,\n\t'%ArrayIteratorPrototype%': hasSymbols && getProto ? getProto([][Symbol.iterator]()) : undefined,\n\t'%AsyncFromSyncIteratorPrototype%': undefined,\n\t'%AsyncFunction%': needsEval,\n\t'%AsyncGenerator%': needsEval,\n\t'%AsyncGeneratorFunction%': needsEval,\n\t'%AsyncIteratorPrototype%': needsEval,\n\t'%Atomics%': typeof Atomics === 'undefined' ? undefined : Atomics,\n\t'%BigInt%': typeof BigInt === 'undefined' ? undefined : BigInt,\n\t'%BigInt64Array%': typeof BigInt64Array === 'undefined' ? undefined : BigInt64Array,\n\t'%BigUint64Array%': typeof BigUint64Array === 'undefined' ? undefined : BigUint64Array,\n\t'%Boolean%': Boolean,\n\t'%DataView%': typeof DataView === 'undefined' ? undefined : DataView,\n\t'%Date%': Date,\n\t'%decodeURI%': decodeURI,\n\t'%decodeURIComponent%': decodeURIComponent,\n\t'%encodeURI%': encodeURI,\n\t'%encodeURIComponent%': encodeURIComponent,\n\t'%Error%': $Error,\n\t'%eval%': eval, // eslint-disable-line no-eval\n\t'%EvalError%': $EvalError,\n\t'%Float32Array%': typeof Float32Array === 'undefined' ? undefined : Float32Array,\n\t'%Float64Array%': typeof Float64Array === 'undefined' ? undefined : Float64Array,\n\t'%FinalizationRegistry%': typeof FinalizationRegistry === 'undefined' ? undefined : FinalizationRegistry,\n\t'%Function%': $Function,\n\t'%GeneratorFunction%': needsEval,\n\t'%Int8Array%': typeof Int8Array === 'undefined' ? undefined : Int8Array,\n\t'%Int16Array%': typeof Int16Array === 'undefined' ? undefined : Int16Array,\n\t'%Int32Array%': typeof Int32Array === 'undefined' ? undefined : Int32Array,\n\t'%isFinite%': isFinite,\n\t'%isNaN%': isNaN,\n\t'%IteratorPrototype%': hasSymbols && getProto ? getProto(getProto([][Symbol.iterator]())) : undefined,\n\t'%JSON%': typeof JSON === 'object' ? JSON : undefined,\n\t'%Map%': typeof Map === 'undefined' ? undefined : Map,\n\t'%MapIteratorPrototype%': typeof Map === 'undefined' || !hasSymbols || !getProto ? undefined : getProto(new Map()[Symbol.iterator]()),\n\t'%Math%': Math,\n\t'%Number%': Number,\n\t'%Object%': Object,\n\t'%parseFloat%': parseFloat,\n\t'%parseInt%': parseInt,\n\t'%Promise%': typeof Promise === 'undefined' ? undefined : Promise,\n\t'%Proxy%': typeof Proxy === 'undefined' ? undefined : Proxy,\n\t'%RangeError%': $RangeError,\n\t'%ReferenceError%': $ReferenceError,\n\t'%Reflect%': typeof Reflect === 'undefined' ? undefined : Reflect,\n\t'%RegExp%': RegExp,\n\t'%Set%': typeof Set === 'undefined' ? undefined : Set,\n\t'%SetIteratorPrototype%': typeof Set === 'undefined' || !hasSymbols || !getProto ? undefined : getProto(new Set()[Symbol.iterator]()),\n\t'%SharedArrayBuffer%': typeof SharedArrayBuffer === 'undefined' ? undefined : SharedArrayBuffer,\n\t'%String%': String,\n\t'%StringIteratorPrototype%': hasSymbols && getProto ? getProto(''[Symbol.iterator]()) : undefined,\n\t'%Symbol%': hasSymbols ? Symbol : undefined,\n\t'%SyntaxError%': $SyntaxError,\n\t'%ThrowTypeError%': ThrowTypeError,\n\t'%TypedArray%': TypedArray,\n\t'%TypeError%': $TypeError,\n\t'%Uint8Array%': typeof Uint8Array === 'undefined' ? undefined : Uint8Array,\n\t'%Uint8ClampedArray%': typeof Uint8ClampedArray === 'undefined' ? undefined : Uint8ClampedArray,\n\t'%Uint16Array%': typeof Uint16Array === 'undefined' ? undefined : Uint16Array,\n\t'%Uint32Array%': typeof Uint32Array === 'undefined' ? undefined : Uint32Array,\n\t'%URIError%': $URIError,\n\t'%WeakMap%': typeof WeakMap === 'undefined' ? undefined : WeakMap,\n\t'%WeakRef%': typeof WeakRef === 'undefined' ? undefined : WeakRef,\n\t'%WeakSet%': typeof WeakSet === 'undefined' ? undefined : WeakSet\n};\n\nif (getProto) {\n\ttry {\n\t\tnull.error; // eslint-disable-line no-unused-expressions\n\t} catch (e) {\n\t\t// https://github.com/tc39/proposal-shadowrealm/pull/384#issuecomment-1364264229\n\t\tvar errorProto = getProto(getProto(e));\n\t\tINTRINSICS['%Error.prototype%'] = errorProto;\n\t}\n}\n\nvar doEval = function doEval(name) {\n\tvar value;\n\tif (name === '%AsyncFunction%') {\n\t\tvalue = getEvalledConstructor('async function () {}');\n\t} else if (name === '%GeneratorFunction%') {\n\t\tvalue = getEvalledConstructor('function* () {}');\n\t} else if (name === '%AsyncGeneratorFunction%') {\n\t\tvalue = getEvalledConstructor('async function* () {}');\n\t} else if (name === '%AsyncGenerator%') {\n\t\tvar fn = doEval('%AsyncGeneratorFunction%');\n\t\tif (fn) {\n\t\t\tvalue = fn.prototype;\n\t\t}\n\t} else if (name === '%AsyncIteratorPrototype%') {\n\t\tvar gen = doEval('%AsyncGenerator%');\n\t\tif (gen && getProto) {\n\t\t\tvalue = getProto(gen.prototype);\n\t\t}\n\t}\n\n\tINTRINSICS[name] = value;\n\n\treturn value;\n};\n\nvar LEGACY_ALIASES = {\n\t__proto__: null,\n\t'%ArrayBufferPrototype%': ['ArrayBuffer', 'prototype'],\n\t'%ArrayPrototype%': ['Array', 'prototype'],\n\t'%ArrayProto_entries%': ['Array', 'prototype', 'entries'],\n\t'%ArrayProto_forEach%': ['Array', 'prototype', 'forEach'],\n\t'%ArrayProto_keys%': ['Array', 'prototype', 'keys'],\n\t'%ArrayProto_values%': ['Array', 'prototype', 'values'],\n\t'%AsyncFunctionPrototype%': ['AsyncFunction', 'prototype'],\n\t'%AsyncGenerator%': ['AsyncGeneratorFunction', 'prototype'],\n\t'%AsyncGeneratorPrototype%': ['AsyncGeneratorFunction', 'prototype', 'prototype'],\n\t'%BooleanPrototype%': ['Boolean', 'prototype'],\n\t'%DataViewPrototype%': ['DataView', 'prototype'],\n\t'%DatePrototype%': ['Date', 'prototype'],\n\t'%ErrorPrototype%': ['Error', 'prototype'],\n\t'%EvalErrorPrototype%': ['EvalError', 'prototype'],\n\t'%Float32ArrayPrototype%': ['Float32Array', 'prototype'],\n\t'%Float64ArrayPrototype%': ['Float64Array', 'prototype'],\n\t'%FunctionPrototype%': ['Function', 'prototype'],\n\t'%Generator%': ['GeneratorFunction', 'prototype'],\n\t'%GeneratorPrototype%': ['GeneratorFunction', 'prototype', 'prototype'],\n\t'%Int8ArrayPrototype%': ['Int8Array', 'prototype'],\n\t'%Int16ArrayPrototype%': ['Int16Array', 'prototype'],\n\t'%Int32ArrayPrototype%': ['Int32Array', 'prototype'],\n\t'%JSONParse%': ['JSON', 'parse'],\n\t'%JSONStringify%': ['JSON', 'stringify'],\n\t'%MapPrototype%': ['Map', 'prototype'],\n\t'%NumberPrototype%': ['Number', 'prototype'],\n\t'%ObjectPrototype%': ['Object', 'prototype'],\n\t'%ObjProto_toString%': ['Object', 'prototype', 'toString'],\n\t'%ObjProto_valueOf%': ['Object', 'prototype', 'valueOf'],\n\t'%PromisePrototype%': ['Promise', 'prototype'],\n\t'%PromiseProto_then%': ['Promise', 'prototype', 'then'],\n\t'%Promise_all%': ['Promise', 'all'],\n\t'%Promise_reject%': ['Promise', 'reject'],\n\t'%Promise_resolve%': ['Promise', 'resolve'],\n\t'%RangeErrorPrototype%': ['RangeError', 'prototype'],\n\t'%ReferenceErrorPrototype%': ['ReferenceError', 'prototype'],\n\t'%RegExpPrototype%': ['RegExp', 'prototype'],\n\t'%SetPrototype%': ['Set', 'prototype'],\n\t'%SharedArrayBufferPrototype%': ['SharedArrayBuffer', 'prototype'],\n\t'%StringPrototype%': ['String', 'prototype'],\n\t'%SymbolPrototype%': ['Symbol', 'prototype'],\n\t'%SyntaxErrorPrototype%': ['SyntaxError', 'prototype'],\n\t'%TypedArrayPrototype%': ['TypedArray', 'prototype'],\n\t'%TypeErrorPrototype%': ['TypeError', 'prototype'],\n\t'%Uint8ArrayPrototype%': ['Uint8Array', 'prototype'],\n\t'%Uint8ClampedArrayPrototype%': ['Uint8ClampedArray', 'prototype'],\n\t'%Uint16ArrayPrototype%': ['Uint16Array', 'prototype'],\n\t'%Uint32ArrayPrototype%': ['Uint32Array', 'prototype'],\n\t'%URIErrorPrototype%': ['URIError', 'prototype'],\n\t'%WeakMapPrototype%': ['WeakMap', 'prototype'],\n\t'%WeakSetPrototype%': ['WeakSet', 'prototype']\n};\n\nvar bind = require('function-bind');\nvar hasOwn = require('hasown');\nvar $concat = bind.call(Function.call, Array.prototype.concat);\nvar $spliceApply = bind.call(Function.apply, Array.prototype.splice);\nvar $replace = bind.call(Function.call, String.prototype.replace);\nvar $strSlice = bind.call(Function.call, String.prototype.slice);\nvar $exec = bind.call(Function.call, RegExp.prototype.exec);\n\n/* adapted from https://github.com/lodash/lodash/blob/4.17.15/dist/lodash.js#L6735-L6744 */\nvar rePropName = /[^%.[\\]]+|\\[(?:(-?\\d+(?:\\.\\d+)?)|([\"'])((?:(?!\\2)[^\\\\]|\\\\.)*?)\\2)\\]|(?=(?:\\.|\\[\\])(?:\\.|\\[\\]|%$))/g;\nvar reEscapeChar = /\\\\(\\\\)?/g; /** Used to match backslashes in property paths. */\nvar stringToPath = function stringToPath(string) {\n\tvar first = $strSlice(string, 0, 1);\n\tvar last = $strSlice(string, -1);\n\tif (first === '%' && last !== '%') {\n\t\tthrow new $SyntaxError('invalid intrinsic syntax, expected closing `%`');\n\t} else if (last === '%' && first !== '%') {\n\t\tthrow new $SyntaxError('invalid intrinsic syntax, expected opening `%`');\n\t}\n\tvar result = [];\n\t$replace(string, rePropName, function (match, number, quote, subString) {\n\t\tresult[result.length] = quote ? $replace(subString, reEscapeChar, '$1') : number || match;\n\t});\n\treturn result;\n};\n/* end adaptation */\n\nvar getBaseIntrinsic = function getBaseIntrinsic(name, allowMissing) {\n\tvar intrinsicName = name;\n\tvar alias;\n\tif (hasOwn(LEGACY_ALIASES, intrinsicName)) {\n\t\talias = LEGACY_ALIASES[intrinsicName];\n\t\tintrinsicName = '%' + alias[0] + '%';\n\t}\n\n\tif (hasOwn(INTRINSICS, intrinsicName)) {\n\t\tvar value = INTRINSICS[intrinsicName];\n\t\tif (value === needsEval) {\n\t\t\tvalue = doEval(intrinsicName);\n\t\t}\n\t\tif (typeof value === 'undefined' && !allowMissing) {\n\t\t\tthrow new $TypeError('intrinsic ' + name + ' exists, but is not available. Please file an issue!');\n\t\t}\n\n\t\treturn {\n\t\t\talias: alias,\n\t\t\tname: intrinsicName,\n\t\t\tvalue: value\n\t\t};\n\t}\n\n\tthrow new $SyntaxError('intrinsic ' + name + ' does not exist!');\n};\n\nmodule.exports = function GetIntrinsic(name, allowMissing) {\n\tif (typeof name !== 'string' || name.length === 0) {\n\t\tthrow new $TypeError('intrinsic name must be a non-empty string');\n\t}\n\tif (arguments.length > 1 && typeof allowMissing !== 'boolean') {\n\t\tthrow new $TypeError('\"allowMissing\" argument must be a boolean');\n\t}\n\n\tif ($exec(/^%?[^%]*%?$/, name) === null) {\n\t\tthrow new $SyntaxError('`%` may not be present anywhere but at the beginning and end of the intrinsic name');\n\t}\n\tvar parts = stringToPath(name);\n\tvar intrinsicBaseName = parts.length > 0 ? parts[0] : '';\n\n\tvar intrinsic = getBaseIntrinsic('%' + intrinsicBaseName + '%', allowMissing);\n\tvar intrinsicRealName = intrinsic.name;\n\tvar value = intrinsic.value;\n\tvar skipFurtherCaching = false;\n\n\tvar alias = intrinsic.alias;\n\tif (alias) {\n\t\tintrinsicBaseName = alias[0];\n\t\t$spliceApply(parts, $concat([0, 1], alias));\n\t}\n\n\tfor (var i = 1, isOwn = true; i < parts.length; i += 1) {\n\t\tvar part = parts[i];\n\t\tvar first = $strSlice(part, 0, 1);\n\t\tvar last = $strSlice(part, -1);\n\t\tif (\n\t\t\t(\n\t\t\t\t(first === '\"' || first === \"'\" || first === '`')\n\t\t\t\t|| (last === '\"' || last === \"'\" || last === '`')\n\t\t\t)\n\t\t\t&& first !== last\n\t\t) {\n\t\t\tthrow new $SyntaxError('property names with quotes must have matching quotes');\n\t\t}\n\t\tif (part === 'constructor' || !isOwn) {\n\t\t\tskipFurtherCaching = true;\n\t\t}\n\n\t\tintrinsicBaseName += '.' + part;\n\t\tintrinsicRealName = '%' + intrinsicBaseName + '%';\n\n\t\tif (hasOwn(INTRINSICS, intrinsicRealName)) {\n\t\t\tvalue = INTRINSICS[intrinsicRealName];\n\t\t} else if (value != null) {\n\t\t\tif (!(part in value)) {\n\t\t\t\tif (!allowMissing) {\n\t\t\t\t\tthrow new $TypeError('base intrinsic for ' + name + ' exists, but the property is not available.');\n\t\t\t\t}\n\t\t\t\treturn void undefined;\n\t\t\t}\n\t\t\tif ($gOPD && (i + 1) >= parts.length) {\n\t\t\t\tvar desc = $gOPD(value, part);\n\t\t\t\tisOwn = !!desc;\n\n\t\t\t\t// By convention, when a data property is converted to an accessor\n\t\t\t\t// property to emulate a data property that does not suffer from\n\t\t\t\t// the override mistake, that accessor's getter is marked with\n\t\t\t\t// an `originalValue` property. Here, when we detect this, we\n\t\t\t\t// uphold the illusion by pretending to see that original data\n\t\t\t\t// property, i.e., returning the value rather than the getter\n\t\t\t\t// itself.\n\t\t\t\tif (isOwn && 'get' in desc && !('originalValue' in desc.get)) {\n\t\t\t\t\tvalue = desc.get;\n\t\t\t\t} else {\n\t\t\t\t\tvalue = value[part];\n\t\t\t\t}\n\t\t\t} else {\n\t\t\t\tisOwn = hasOwn(value, part);\n\t\t\t\tvalue = value[part];\n\t\t\t}\n\n\t\t\tif (isOwn && !skipFurtherCaching) {\n\t\t\t\tINTRINSICS[intrinsicRealName] = value;\n\t\t\t}\n\t\t}\n\t}\n\treturn value;\n};\n","'use strict';\n\nvar GetIntrinsic = require('get-intrinsic');\n\n/** @type {import('.')} */\nvar $defineProperty = GetIntrinsic('%Object.defineProperty%', true) || false;\nif ($defineProperty) {\n\ttry {\n\t\t$defineProperty({}, 'a', { value: 1 });\n\t} catch (e) {\n\t\t// IE 8 has a broken defineProperty\n\t\t$defineProperty = false;\n\t}\n}\n\nmodule.exports = $defineProperty;\n","'use strict';\n\nvar GetIntrinsic = require('get-intrinsic');\n\nvar $gOPD = GetIntrinsic('%Object.getOwnPropertyDescriptor%', true);\n\nif ($gOPD) {\n\ttry {\n\t\t$gOPD([], 'length');\n\t} catch (e) {\n\t\t// IE 8 has a broken gOPD\n\t\t$gOPD = null;\n\t}\n}\n\nmodule.exports = $gOPD;\n","'use strict';\n\nvar $defineProperty = require('es-define-property');\n\nvar $SyntaxError = require('es-errors/syntax');\nvar $TypeError = require('es-errors/type');\n\nvar gopd = require('gopd');\n\n/** @type {import('.')} */\nmodule.exports = function defineDataProperty(\n\tobj,\n\tproperty,\n\tvalue\n) {\n\tif (!obj || (typeof obj !== 'object' && typeof obj !== 'function')) {\n\t\tthrow new $TypeError('`obj` must be an object or a function`');\n\t}\n\tif (typeof property !== 'string' && typeof property !== 'symbol') {\n\t\tthrow new $TypeError('`property` must be a string or a symbol`');\n\t}\n\tif (arguments.length > 3 && typeof arguments[3] !== 'boolean' && arguments[3] !== null) {\n\t\tthrow new $TypeError('`nonEnumerable`, if provided, must be a boolean or null');\n\t}\n\tif (arguments.length > 4 && typeof arguments[4] !== 'boolean' && arguments[4] !== null) {\n\t\tthrow new $TypeError('`nonWritable`, if provided, must be a boolean or null');\n\t}\n\tif (arguments.length > 5 && typeof arguments[5] !== 'boolean' && arguments[5] !== null) {\n\t\tthrow new $TypeError('`nonConfigurable`, if provided, must be a boolean or null');\n\t}\n\tif (arguments.length > 6 && typeof arguments[6] !== 'boolean') {\n\t\tthrow new $TypeError('`loose`, if provided, must be a boolean');\n\t}\n\n\tvar nonEnumerable = arguments.length > 3 ? arguments[3] : null;\n\tvar nonWritable = arguments.length > 4 ? arguments[4] : null;\n\tvar nonConfigurable = arguments.length > 5 ? arguments[5] : null;\n\tvar loose = arguments.length > 6 ? arguments[6] : false;\n\n\t/* @type {false | TypedPropertyDescriptor<unknown>} */\n\tvar desc = !!gopd && gopd(obj, property);\n\n\tif ($defineProperty) {\n\t\t$defineProperty(obj, property, {\n\t\t\tconfigurable: nonConfigurable === null && desc ? desc.configurable : !nonConfigurable,\n\t\t\tenumerable: nonEnumerable === null && desc ? desc.enumerable : !nonEnumerable,\n\t\t\tvalue: value,\n\t\t\twritable: nonWritable === null && desc ? desc.writable : !nonWritable\n\t\t});\n\t} else if (loose || (!nonEnumerable && !nonWritable && !nonConfigurable)) {\n\t\t// must fall back to [[Set]], and was not explicitly asked to make non-enumerable, non-writable, or non-configurable\n\t\tobj[property] = value; // eslint-disable-line no-param-reassign\n\t} else {\n\t\tthrow new $SyntaxError('This environment does not support defining a property as non-configurable, non-writable, or non-enumerable.');\n\t}\n};\n","'use strict';\n\nvar $defineProperty = require('es-define-property');\n\nvar hasPropertyDescriptors = function hasPropertyDescriptors() {\n\treturn !!$defineProperty;\n};\n\nhasPropertyDescriptors.hasArrayLengthDefineBug = function hasArrayLengthDefineBug() {\n\t// node v0.6 has a bug where array lengths can be Set but not Defined\n\tif (!$defineProperty) {\n\t\treturn null;\n\t}\n\ttry {\n\t\treturn $defineProperty([], 'length', { value: 1 }).length !== 1;\n\t} catch (e) {\n\t\t// In Firefox 4-22, defining length on an array throws an exception.\n\t\treturn true;\n\t}\n};\n\nmodule.exports = hasPropertyDescriptors;\n","'use strict';\n\nvar GetIntrinsic = require('get-intrinsic');\nvar define = require('define-data-property');\nvar hasDescriptors = require('has-property-descriptors')();\nvar gOPD = require('gopd');\n\nvar $TypeError = require('es-errors/type');\nvar $floor = GetIntrinsic('%Math.floor%');\n\n/** @type {import('.')} */\nmodule.exports = function setFunctionLength(fn, length) {\n\tif (typeof fn !== 'function') {\n\t\tthrow new $TypeError('`fn` is not a function');\n\t}\n\tif (typeof length !== 'number' || length < 0 || length > 0xFFFFFFFF || $floor(length) !== length) {\n\t\tthrow new $TypeError('`length` must be a positive 32-bit integer');\n\t}\n\n\tvar loose = arguments.length > 2 && !!arguments[2];\n\n\tvar functionLengthIsConfigurable = true;\n\tvar functionLengthIsWritable = true;\n\tif ('length' in fn && gOPD) {\n\t\tvar desc = gOPD(fn, 'length');\n\t\tif (desc && !desc.configurable) {\n\t\t\tfunctionLengthIsConfigurable = false;\n\t\t}\n\t\tif (desc && !desc.writable) {\n\t\t\tfunctionLengthIsWritable = false;\n\t\t}\n\t}\n\n\tif (functionLengthIsConfigurable || functionLengthIsWritable || !loose) {\n\t\tif (hasDescriptors) {\n\t\t\tdefine(/** @type {Parameters<define>[0]} */ (fn), 'length', length, true, true);\n\t\t} else {\n\t\t\tdefine(/** @type {Parameters<define>[0]} */ (fn), 'length', length);\n\t\t}\n\t}\n\treturn fn;\n};\n","'use strict';\n\nvar bind = require('function-bind');\nvar GetIntrinsic = require('get-intrinsic');\nvar setFunctionLength = require('set-function-length');\n\nvar $TypeError = require('es-errors/type');\nvar $apply = GetIntrinsic('%Function.prototype.apply%');\nvar $call = GetIntrinsic('%Function.prototype.call%');\nvar $reflectApply = GetIntrinsic('%Reflect.apply%', true) || bind.call($call, $apply);\n\nvar $defineProperty = require('es-define-property');\nvar $max = GetIntrinsic('%Math.max%');\n\nmodule.exports = function callBind(originalFunction) {\n\tif (typeof originalFunction !== 'function') {\n\t\tthrow new $TypeError('a function is required');\n\t}\n\tvar func = $reflectApply(bind, $call, arguments);\n\treturn setFunctionLength(\n\t\tfunc,\n\t\t1 + $max(0, originalFunction.length - (arguments.length - 1)),\n\t\ttrue\n\t);\n};\n\nvar applyBind = function applyBind() {\n\treturn $reflectApply(bind, $apply, arguments);\n};\n\nif ($defineProperty) {\n\t$defineProperty(module.exports, 'apply', { value: applyBind });\n} else {\n\tmodule.exports.apply = applyBind;\n}\n","'use strict';\n\nvar GetIntrinsic = require('get-intrinsic');\n\nvar callBind = require('./');\n\nvar $indexOf = callBind(GetIntrinsic('String.prototype.indexOf'));\n\nmodule.exports = function callBoundIntrinsic(name, allowMissing) {\n\tvar intrinsic = GetIntrinsic(name, !!allowMissing);\n\tif (typeof intrinsic === 'function' && $indexOf(name, '.prototype.') > -1) {\n\t\treturn callBind(intrinsic);\n\t}\n\treturn intrinsic;\n};\n","'use strict';\n\nvar hasToStringTag = require('has-tostringtag/shams')();\nvar callBound = require('call-bind/callBound');\n\nvar $toString = callBound('Object.prototype.toString');\n\nvar isStandardArguments = function isArguments(value) {\n\tif (hasToStringTag && value && typeof value === 'object' && Symbol.toStringTag in value) {\n\t\treturn false;\n\t}\n\treturn $toString(value) === '[object Arguments]';\n};\n\nvar isLegacyArguments = function isArguments(value) {\n\tif (isStandardArguments(value)) {\n\t\treturn true;\n\t}\n\treturn value !== null &&\n\t\ttypeof value === 'object' &&\n\t\ttypeof value.length === 'number' &&\n\t\tvalue.length >= 0 &&\n\t\t$toString(value) !== '[object Array]' &&\n\t\t$toString(value.callee) === '[object Function]';\n};\n\nvar supportsStandardArguments = (function () {\n\treturn isStandardArguments(arguments);\n}());\n\nisStandardArguments.isLegacyArguments = isLegacyArguments; // for tests\n\nmodule.exports = supportsStandardArguments ? isStandardArguments : isLegacyArguments;\n","'use strict';\n\nvar toStr = Object.prototype.toString;\nvar fnToStr = Function.prototype.toString;\nvar isFnRegex = /^\\s*(?:function)?\\*/;\nvar hasToStringTag = require('has-tostringtag/shams')();\nvar getProto = Object.getPrototypeOf;\nvar getGeneratorFunc = function () { // eslint-disable-line consistent-return\n\tif (!hasToStringTag) {\n\t\treturn false;\n\t}\n\ttry {\n\t\treturn Function('return function*() {}')();\n\t} catch (e) {\n\t}\n};\nvar GeneratorFunction;\n\nmodule.exports = function isGeneratorFunction(fn) {\n\tif (typeof fn !== 'function') {\n\t\treturn false;\n\t}\n\tif (isFnRegex.test(fnToStr.call(fn))) {\n\t\treturn true;\n\t}\n\tif (!hasToStringTag) {\n\t\tvar str = toStr.call(fn);\n\t\treturn str === '[object GeneratorFunction]';\n\t}\n\tif (!getProto) {\n\t\treturn false;\n\t}\n\tif (typeof GeneratorFunction === 'undefined') {\n\t\tvar generatorFunc = getGeneratorFunc();\n\t\tGeneratorFunction = generatorFunc ? getProto(generatorFunc) : false;\n\t}\n\treturn getProto(fn) === GeneratorFunction;\n};\n","'use strict';\n\nvar fnToStr = Function.prototype.toString;\nvar reflectApply = typeof Reflect === 'object' && Reflect !== null && Reflect.apply;\nvar badArrayLike;\nvar isCallableMarker;\nif (typeof reflectApply === 'function' && typeof Object.defineProperty === 'function') {\n\ttry {\n\t\tbadArrayLike = Object.defineProperty({}, 'length', {\n\t\t\tget: function () {\n\t\t\t\tthrow isCallableMarker;\n\t\t\t}\n\t\t});\n\t\tisCallableMarker = {};\n\t\t// eslint-disable-next-line no-throw-literal\n\t\treflectApply(function () { throw 42; }, null, badArrayLike);\n\t} catch (_) {\n\t\tif (_ !== isCallableMarker) {\n\t\t\treflectApply = null;\n\t\t}\n\t}\n} else {\n\treflectApply = null;\n}\n\nvar constructorRegex = /^\\s*class\\b/;\nvar isES6ClassFn = function isES6ClassFunction(value) {\n\ttry {\n\t\tvar fnStr = fnToStr.call(value);\n\t\treturn constructorRegex.test(fnStr);\n\t} catch (e) {\n\t\treturn false; // not a function\n\t}\n};\n\nvar tryFunctionObject = function tryFunctionToStr(value) {\n\ttry {\n\t\tif (isES6ClassFn(value)) { return false; }\n\t\tfnToStr.call(value);\n\t\treturn true;\n\t} catch (e) {\n\t\treturn false;\n\t}\n};\nvar toStr = Object.prototype.toString;\nvar objectClass = '[object Object]';\nvar fnClass = '[object Function]';\nvar genClass = '[object GeneratorFunction]';\nvar ddaClass = '[object HTMLAllCollection]'; // IE 11\nvar ddaClass2 = '[object HTML document.all class]';\nvar ddaClass3 = '[object HTMLCollection]'; // IE 9-10\nvar hasToStringTag = typeof Symbol === 'function' && !!Symbol.toStringTag; // better: use `has-tostringtag`\n\nvar isIE68 = !(0 in [,]); // eslint-disable-line no-sparse-arrays, comma-spacing\n\nvar isDDA = function isDocumentDotAll() { return false; };\nif (typeof document === 'object') {\n\t// Firefox 3 canonicalizes DDA to undefined when it's not accessed directly\n\tvar all = document.all;\n\tif (toStr.call(all) === toStr.call(document.all)) {\n\t\tisDDA = function isDocumentDotAll(value) {\n\t\t\t/* globals document: false */\n\t\t\t// in IE 6-8, typeof document.all is \"object\" and it's truthy\n\t\t\tif ((isIE68 || !value) && (typeof value === 'undefined' || typeof value === 'object')) {\n\t\t\t\ttry {\n\t\t\t\t\tvar str = toStr.call(value);\n\t\t\t\t\treturn (\n\t\t\t\t\t\tstr === ddaClass\n\t\t\t\t\t\t|| str === ddaClass2\n\t\t\t\t\t\t|| str === ddaClass3 // opera 12.16\n\t\t\t\t\t\t|| str === objectClass // IE 6-8\n\t\t\t\t\t) && value('') == null; // eslint-disable-line eqeqeq\n\t\t\t\t} catch (e) { /**/ }\n\t\t\t}\n\t\t\treturn false;\n\t\t};\n\t}\n}\n\nmodule.exports = reflectApply\n\t? function isCallable(value) {\n\t\tif (isDDA(value)) { return true; }\n\t\tif (!value) { return false; }\n\t\tif (typeof value !== 'function' && typeof value !== 'object') { return false; }\n\t\ttry {\n\t\t\treflectApply(value, null, badArrayLike);\n\t\t} catch (e) {\n\t\t\tif (e !== isCallableMarker) { return false; }\n\t\t}\n\t\treturn !isES6ClassFn(value) && tryFunctionObject(value);\n\t}\n\t: function isCallable(value) {\n\t\tif (isDDA(value)) { return true; }\n\t\tif (!value) { return false; }\n\t\tif (typeof value !== 'function' && typeof value !== 'object') { return false; }\n\t\tif (hasToStringTag) { return tryFunctionObject(value); }\n\t\tif (isES6ClassFn(value)) { return false; }\n\t\tvar strClass = toStr.call(value);\n\t\tif (strClass !== fnClass && strClass !== genClass && !(/^\\[object HTML/).test(strClass)) { return false; }\n\t\treturn tryFunctionObject(value);\n\t};\n","'use strict';\n\nvar isCallable = require('is-callable');\n\nvar toStr = Object.prototype.toString;\nvar hasOwnProperty = Object.prototype.hasOwnProperty;\n\nvar forEachArray = function forEachArray(array, iterator, receiver) {\n    for (var i = 0, len = array.length; i < len; i++) {\n        if (hasOwnProperty.call(array, i)) {\n            if (receiver == null) {\n                iterator(array[i], i, array);\n            } else {\n                iterator.call(receiver, array[i], i, array);\n            }\n        }\n    }\n};\n\nvar forEachString = function forEachString(string, iterator, receiver) {\n    for (var i = 0, len = string.length; i < len; i++) {\n        // no such thing as a sparse string.\n        if (receiver == null) {\n            iterator(string.charAt(i), i, string);\n        } else {\n            iterator.call(receiver, string.charAt(i), i, string);\n        }\n    }\n};\n\nvar forEachObject = function forEachObject(object, iterator, receiver) {\n    for (var k in object) {\n        if (hasOwnProperty.call(object, k)) {\n            if (receiver == null) {\n                iterator(object[k], k, object);\n            } else {\n                iterator.call(receiver, object[k], k, object);\n            }\n        }\n    }\n};\n\nvar forEach = function forEach(list, iterator, thisArg) {\n    if (!isCallable(iterator)) {\n        throw new TypeError('iterator must be a function');\n    }\n\n    var receiver;\n    if (arguments.length >= 3) {\n        receiver = thisArg;\n    }\n\n    if (toStr.call(list) === '[object Array]') {\n        forEachArray(list, iterator, receiver);\n    } else if (typeof list === 'string') {\n        forEachString(list, iterator, receiver);\n    } else {\n        forEachObject(list, iterator, receiver);\n    }\n};\n\nmodule.exports = forEach;\n","'use strict';\n\n/** @type {import('.')} */\nmodule.exports = [\n\t'Float32Array',\n\t'Float64Array',\n\t'Int8Array',\n\t'Int16Array',\n\t'Int32Array',\n\t'Uint8Array',\n\t'Uint8ClampedArray',\n\t'Uint16Array',\n\t'Uint32Array',\n\t'BigInt64Array',\n\t'BigUint64Array'\n];\n","'use strict';\n\nvar possibleNames = require('possible-typed-array-names');\n\nvar g = typeof globalThis === 'undefined' ? global : globalThis;\n\n/** @type {import('.')} */\nmodule.exports = function availableTypedArrays() {\n\tvar /** @type {ReturnType<typeof availableTypedArrays>} */ out = [];\n\tfor (var i = 0; i < possibleNames.length; i++) {\n\t\tif (typeof g[possibleNames[i]] === 'function') {\n\t\t\t// @ts-expect-error\n\t\t\tout[out.length] = possibleNames[i];\n\t\t}\n\t}\n\treturn out;\n};\n","'use strict';\n\nvar forEach = require('for-each');\nvar availableTypedArrays = require('available-typed-arrays');\nvar callBind = require('call-bind');\nvar callBound = require('call-bind/callBound');\nvar gOPD = require('gopd');\n\n/** @type {(O: object) => string} */\nvar $toString = callBound('Object.prototype.toString');\nvar hasToStringTag = require('has-tostringtag/shams')();\n\nvar g = typeof globalThis === 'undefined' ? global : globalThis;\nvar typedArrays = availableTypedArrays();\n\nvar $slice = callBound('String.prototype.slice');\nvar getPrototypeOf = Object.getPrototypeOf; // require('getprototypeof');\n\n/** @type {<T = unknown>(array: readonly T[], value: unknown) => number} */\nvar $indexOf = callBound('Array.prototype.indexOf', true) || function indexOf(array, value) {\n\tfor (var i = 0; i < array.length; i += 1) {\n\t\tif (array[i] === value) {\n\t\t\treturn i;\n\t\t}\n\t}\n\treturn -1;\n};\n\n/** @typedef {(receiver: import('.').TypedArray) => string | typeof Uint8Array.prototype.slice.call | typeof Uint8Array.prototype.set.call} Getter */\n/** @type {{ [k in `\\$${import('.').TypedArrayName}`]?: Getter } & { __proto__: null }} */\nvar cache = { __proto__: null };\nif (hasToStringTag && gOPD && getPrototypeOf) {\n\tforEach(typedArrays, function (typedArray) {\n\t\tvar arr = new g[typedArray]();\n\t\tif (Symbol.toStringTag in arr) {\n\t\t\tvar proto = getPrototypeOf(arr);\n\t\t\t// @ts-expect-error TS won't narrow inside a closure\n\t\t\tvar descriptor = gOPD(proto, Symbol.toStringTag);\n\t\t\tif (!descriptor) {\n\t\t\t\tvar superProto = getPrototypeOf(proto);\n\t\t\t\t// @ts-expect-error TS won't narrow inside a closure\n\t\t\t\tdescriptor = gOPD(superProto, Symbol.toStringTag);\n\t\t\t}\n\t\t\t// @ts-expect-error TODO: fix\n\t\t\tcache['$' + typedArray] = callBind(descriptor.get);\n\t\t}\n\t});\n} else {\n\tforEach(typedArrays, function (typedArray) {\n\t\tvar arr = new g[typedArray]();\n\t\tvar fn = arr.slice || arr.set;\n\t\tif (fn) {\n\t\t\t// @ts-expect-error TODO: fix\n\t\t\tcache['$' + typedArray] = callBind(fn);\n\t\t}\n\t});\n}\n\n/** @type {(value: object) => false | import('.').TypedArrayName} */\nvar tryTypedArrays = function tryAllTypedArrays(value) {\n\t/** @type {ReturnType<typeof tryAllTypedArrays>} */ var found = false;\n\tforEach(\n\t\t// eslint-disable-next-line no-extra-parens\n\t\t/** @type {Record<`\\$${TypedArrayName}`, Getter>} */ /** @type {any} */ (cache),\n\t\t/** @type {(getter: Getter, name: `\\$${import('.').TypedArrayName}`) => void} */\n\t\tfunction (getter, typedArray) {\n\t\t\tif (!found) {\n\t\t\t\ttry {\n\t\t\t\t// @ts-expect-error TODO: fix\n\t\t\t\t\tif ('$' + getter(value) === typedArray) {\n\t\t\t\t\t\tfound = $slice(typedArray, 1);\n\t\t\t\t\t}\n\t\t\t\t} catch (e) { /**/ }\n\t\t\t}\n\t\t}\n\t);\n\treturn found;\n};\n\n/** @type {(value: object) => false | import('.').TypedArrayName} */\nvar trySlices = function tryAllSlices(value) {\n\t/** @type {ReturnType<typeof tryAllSlices>} */ var found = false;\n\tforEach(\n\t\t// eslint-disable-next-line no-extra-parens\n\t\t/** @type {Record<`\\$${TypedArrayName}`, Getter>} */ /** @type {any} */ (cache),\n\t\t/** @type {(getter: typeof cache, name: `\\$${import('.').TypedArrayName}`) => void} */ function (getter, name) {\n\t\t\tif (!found) {\n\t\t\t\ttry {\n\t\t\t\t\t// @ts-expect-error TODO: fix\n\t\t\t\t\tgetter(value);\n\t\t\t\t\tfound = $slice(name, 1);\n\t\t\t\t} catch (e) { /**/ }\n\t\t\t}\n\t\t}\n\t);\n\treturn found;\n};\n\n/** @type {import('.')} */\nmodule.exports = function whichTypedArray(value) {\n\tif (!value || typeof value !== 'object') { return false; }\n\tif (!hasToStringTag) {\n\t\t/** @type {string} */\n\t\tvar tag = $slice($toString(value), 8, -1);\n\t\tif ($indexOf(typedArrays, tag) > -1) {\n\t\t\treturn tag;\n\t\t}\n\t\tif (tag !== 'Object') {\n\t\t\treturn false;\n\t\t}\n\t\t// node < 0.6 hits here on real Typed Arrays\n\t\treturn trySlices(value);\n\t}\n\tif (!gOPD) { return null; } // unknown engine\n\treturn tryTypedArrays(value);\n};\n","'use strict';\n\nvar whichTypedArray = require('which-typed-array');\n\n/** @type {import('.')} */\nmodule.exports = function isTypedArray(value) {\n\treturn !!whichTypedArray(value);\n};\n","// Currently in sync with Node.js lib/internal/util/types.js\n// https://github.com/nodejs/node/commit/112cc7c27551254aa2b17098fb774867f05ed0d9\n\n'use strict';\n\nvar isArgumentsObject = require('is-arguments');\nvar isGeneratorFunction = require('is-generator-function');\nvar whichTypedArray = require('which-typed-array');\nvar isTypedArray = require('is-typed-array');\n\nfunction uncurryThis(f) {\n  return f.call.bind(f);\n}\n\nvar BigIntSupported = typeof BigInt !== 'undefined';\nvar SymbolSupported = typeof Symbol !== 'undefined';\n\nvar ObjectToString = uncurryThis(Object.prototype.toString);\n\nvar numberValue = uncurryThis(Number.prototype.valueOf);\nvar stringValue = uncurryThis(String.prototype.valueOf);\nvar booleanValue = uncurryThis(Boolean.prototype.valueOf);\n\nif (BigIntSupported) {\n  var bigIntValue = uncurryThis(BigInt.prototype.valueOf);\n}\n\nif (SymbolSupported) {\n  var symbolValue = uncurryThis(Symbol.prototype.valueOf);\n}\n\nfunction checkBoxedPrimitive(value, prototypeValueOf) {\n  if (typeof value !== 'object') {\n    return false;\n  }\n  try {\n    prototypeValueOf(value);\n    return true;\n  } catch(e) {\n    return false;\n  }\n}\n\nexports.isArgumentsObject = isArgumentsObject;\nexports.isGeneratorFunction = isGeneratorFunction;\nexports.isTypedArray = isTypedArray;\n\n// Taken from here and modified for better browser support\n// https://github.com/sindresorhus/p-is-promise/blob/cda35a513bda03f977ad5cde3a079d237e82d7ef/index.js\nfunction isPromise(input) {\n\treturn (\n\t\t(\n\t\t\ttypeof Promise !== 'undefined' &&\n\t\t\tinput instanceof Promise\n\t\t) ||\n\t\t(\n\t\t\tinput !== null &&\n\t\t\ttypeof input === 'object' &&\n\t\t\ttypeof input.then === 'function' &&\n\t\t\ttypeof input.catch === 'function'\n\t\t)\n\t);\n}\nexports.isPromise = isPromise;\n\nfunction isArrayBufferView(value) {\n  if (typeof ArrayBuffer !== 'undefined' && ArrayBuffer.isView) {\n    return ArrayBuffer.isView(value);\n  }\n\n  return (\n    isTypedArray(value) ||\n    isDataView(value)\n  );\n}\nexports.isArrayBufferView = isArrayBufferView;\n\n\nfunction isUint8Array(value) {\n  return whichTypedArray(value) === 'Uint8Array';\n}\nexports.isUint8Array = isUint8Array;\n\nfunction isUint8ClampedArray(value) {\n  return whichTypedArray(value) === 'Uint8ClampedArray';\n}\nexports.isUint8ClampedArray = isUint8ClampedArray;\n\nfunction isUint16Array(value) {\n  return whichTypedArray(value) === 'Uint16Array';\n}\nexports.isUint16Array = isUint16Array;\n\nfunction isUint32Array(value) {\n  return whichTypedArray(value) === 'Uint32Array';\n}\nexports.isUint32Array = isUint32Array;\n\nfunction isInt8Array(value) {\n  return whichTypedArray(value) === 'Int8Array';\n}\nexports.isInt8Array = isInt8Array;\n\nfunction isInt16Array(value) {\n  return whichTypedArray(value) === 'Int16Array';\n}\nexports.isInt16Array = isInt16Array;\n\nfunction isInt32Array(value) {\n  return whichTypedArray(value) === 'Int32Array';\n}\nexports.isInt32Array = isInt32Array;\n\nfunction isFloat32Array(value) {\n  return whichTypedArray(value) === 'Float32Array';\n}\nexports.isFloat32Array = isFloat32Array;\n\nfunction isFloat64Array(value) {\n  return whichTypedArray(value) === 'Float64Array';\n}\nexports.isFloat64Array = isFloat64Array;\n\nfunction isBigInt64Array(value) {\n  return whichTypedArray(value) === 'BigInt64Array';\n}\nexports.isBigInt64Array = isBigInt64Array;\n\nfunction isBigUint64Array(value) {\n  return whichTypedArray(value) === 'BigUint64Array';\n}\nexports.isBigUint64Array = isBigUint64Array;\n\nfunction isMapToString(value) {\n  return ObjectToString(value) === '[object Map]';\n}\nisMapToString.working = (\n  typeof Map !== 'undefined' &&\n  isMapToString(new Map())\n);\n\nfunction isMap(value) {\n  if (typeof Map === 'undefined') {\n    return false;\n  }\n\n  return isMapToString.working\n    ? isMapToString(value)\n    : value instanceof Map;\n}\nexports.isMap = isMap;\n\nfunction isSetToString(value) {\n  return ObjectToString(value) === '[object Set]';\n}\nisSetToString.working = (\n  typeof Set !== 'undefined' &&\n  isSetToString(new Set())\n);\nfunction isSet(value) {\n  if (typeof Set === 'undefined') {\n    return false;\n  }\n\n  return isSetToString.working\n    ? isSetToString(value)\n    : value instanceof Set;\n}\nexports.isSet = isSet;\n\nfunction isWeakMapToString(value) {\n  return ObjectToString(value) === '[object WeakMap]';\n}\nisWeakMapToString.working = (\n  typeof WeakMap !== 'undefined' &&\n  isWeakMapToString(new WeakMap())\n);\nfunction isWeakMap(value) {\n  if (typeof WeakMap === 'undefined') {\n    return false;\n  }\n\n  return isWeakMapToString.working\n    ? isWeakMapToString(value)\n    : value instanceof WeakMap;\n}\nexports.isWeakMap = isWeakMap;\n\nfunction isWeakSetToString(value) {\n  return ObjectToString(value) === '[object WeakSet]';\n}\nisWeakSetToString.working = (\n  typeof WeakSet !== 'undefined' &&\n  isWeakSetToString(new WeakSet())\n);\nfunction isWeakSet(value) {\n  return isWeakSetToString(value);\n}\nexports.isWeakSet = isWeakSet;\n\nfunction isArrayBufferToString(value) {\n  return ObjectToString(value) === '[object ArrayBuffer]';\n}\nisArrayBufferToString.working = (\n  typeof ArrayBuffer !== 'undefined' &&\n  isArrayBufferToString(new ArrayBuffer())\n);\nfunction isArrayBuffer(value) {\n  if (typeof ArrayBuffer === 'undefined') {\n    return false;\n  }\n\n  return isArrayBufferToString.working\n    ? isArrayBufferToString(value)\n    : value instanceof ArrayBuffer;\n}\nexports.isArrayBuffer = isArrayBuffer;\n\nfunction isDataViewToString(value) {\n  return ObjectToString(value) === '[object DataView]';\n}\nisDataViewToString.working = (\n  typeof ArrayBuffer !== 'undefined' &&\n  typeof DataView !== 'undefined' &&\n  isDataViewToString(new DataView(new ArrayBuffer(1), 0, 1))\n);\nfunction isDataView(value) {\n  if (typeof DataView === 'undefined') {\n    return false;\n  }\n\n  return isDataViewToString.working\n    ? isDataViewToString(value)\n    : value instanceof DataView;\n}\nexports.isDataView = isDataView;\n\n// Store a copy of SharedArrayBuffer in case it's deleted elsewhere\nvar SharedArrayBufferCopy = typeof SharedArrayBuffer !== 'undefined' ? SharedArrayBuffer : undefined;\nfunction isSharedArrayBufferToString(value) {\n  return ObjectToString(value) === '[object SharedArrayBuffer]';\n}\nfunction isSharedArrayBuffer(value) {\n  if (typeof SharedArrayBufferCopy === 'undefined') {\n    return false;\n  }\n\n  if (typeof isSharedArrayBufferToString.working === 'undefined') {\n    isSharedArrayBufferToString.working = isSharedArrayBufferToString(new SharedArrayBufferCopy());\n  }\n\n  return isSharedArrayBufferToString.working\n    ? isSharedArrayBufferToString(value)\n    : value instanceof SharedArrayBufferCopy;\n}\nexports.isSharedArrayBuffer = isSharedArrayBuffer;\n\nfunction isAsyncFunction(value) {\n  return ObjectToString(value) === '[object AsyncFunction]';\n}\nexports.isAsyncFunction = isAsyncFunction;\n\nfunction isMapIterator(value) {\n  return ObjectToString(value) === '[object Map Iterator]';\n}\nexports.isMapIterator = isMapIterator;\n\nfunction isSetIterator(value) {\n  return ObjectToString(value) === '[object Set Iterator]';\n}\nexports.isSetIterator = isSetIterator;\n\nfunction isGeneratorObject(value) {\n  return ObjectToString(value) === '[object Generator]';\n}\nexports.isGeneratorObject = isGeneratorObject;\n\nfunction isWebAssemblyCompiledModule(value) {\n  return ObjectToString(value) === '[object WebAssembly.Module]';\n}\nexports.isWebAssemblyCompiledModule = isWebAssemblyCompiledModule;\n\nfunction isNumberObject(value) {\n  return checkBoxedPrimitive(value, numberValue);\n}\nexports.isNumberObject = isNumberObject;\n\nfunction isStringObject(value) {\n  return checkBoxedPrimitive(value, stringValue);\n}\nexports.isStringObject = isStringObject;\n\nfunction isBooleanObject(value) {\n  return checkBoxedPrimitive(value, booleanValue);\n}\nexports.isBooleanObject = isBooleanObject;\n\nfunction isBigIntObject(value) {\n  return BigIntSupported && checkBoxedPrimitive(value, bigIntValue);\n}\nexports.isBigIntObject = isBigIntObject;\n\nfunction isSymbolObject(value) {\n  return SymbolSupported && checkBoxedPrimitive(value, symbolValue);\n}\nexports.isSymbolObject = isSymbolObject;\n\nfunction isBoxedPrimitive(value) {\n  return (\n    isNumberObject(value) ||\n    isStringObject(value) ||\n    isBooleanObject(value) ||\n    isBigIntObject(value) ||\n    isSymbolObject(value)\n  );\n}\nexports.isBoxedPrimitive = isBoxedPrimitive;\n\nfunction isAnyArrayBuffer(value) {\n  return typeof Uint8Array !== 'undefined' && (\n    isArrayBuffer(value) ||\n    isSharedArrayBuffer(value)\n  );\n}\nexports.isAnyArrayBuffer = isAnyArrayBuffer;\n\n['isProxy', 'isExternal', 'isModuleNamespaceObject'].forEach(function(method) {\n  Object.defineProperty(exports, method, {\n    enumerable: false,\n    value: function() {\n      throw new Error(method + ' is not supported in userland');\n    }\n  });\n});\n","module.exports = function isBuffer(arg) {\n  return arg && typeof arg === 'object'\n    && typeof arg.copy === 'function'\n    && typeof arg.fill === 'function'\n    && typeof arg.readUInt8 === 'function';\n}","if (typeof Object.create === 'function') {\n  // implementation from standard node.js 'util' module\n  module.exports = function inherits(ctor, superCtor) {\n    if (superCtor) {\n      ctor.super_ = superCtor\n      ctor.prototype = Object.create(superCtor.prototype, {\n        constructor: {\n          value: ctor,\n          enumerable: false,\n          writable: true,\n          configurable: true\n        }\n      })\n    }\n  };\n} else {\n  // old school shim for old browsers\n  module.exports = function inherits(ctor, superCtor) {\n    if (superCtor) {\n      ctor.super_ = superCtor\n      var TempCtor = function () {}\n      TempCtor.prototype = superCtor.prototype\n      ctor.prototype = new TempCtor()\n      ctor.prototype.constructor = ctor\n    }\n  }\n}\n","// Copyright Joyent, Inc. and other Node contributors.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a\n// copy of this software and associated documentation files (the\n// \"Software\"), to deal in the Software without restriction, including\n// without limitation the rights to use, copy, modify, merge, publish,\n// distribute, sublicense, and/or sell copies of the Software, and to permit\n// persons to whom the Software is furnished to do so, subject to the\n// following conditions:\n//\n// The above copyright notice and this permission notice shall be included\n// in all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS\n// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\n// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN\n// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,\n// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR\n// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE\n// USE OR OTHER DEALINGS IN THE SOFTWARE.\n\nvar getOwnPropertyDescriptors = Object.getOwnPropertyDescriptors ||\n  function getOwnPropertyDescriptors(obj) {\n    var keys = Object.keys(obj);\n    var descriptors = {};\n    for (var i = 0; i < keys.length; i++) {\n      descriptors[keys[i]] = Object.getOwnPropertyDescriptor(obj, keys[i]);\n    }\n    return descriptors;\n  };\n\nvar formatRegExp = /%[sdj%]/g;\nexports.format = function(f) {\n  if (!isString(f)) {\n    var objects = [];\n    for (var i = 0; i < arguments.length; i++) {\n      objects.push(inspect(arguments[i]));\n    }\n    return objects.join(' ');\n  }\n\n  var i = 1;\n  var args = arguments;\n  var len = args.length;\n  var str = String(f).replace(formatRegExp, function(x) {\n    if (x === '%%') return '%';\n    if (i >= len) return x;\n    switch (x) {\n      case '%s': return String(args[i++]);\n      case '%d': return Number(args[i++]);\n      case '%j':\n        try {\n          return JSON.stringify(args[i++]);\n        } catch (_) {\n          return '[Circular]';\n        }\n      default:\n        return x;\n    }\n  });\n  for (var x = args[i]; i < len; x = args[++i]) {\n    if (isNull(x) || !isObject(x)) {\n      str += ' ' + x;\n    } else {\n      str += ' ' + inspect(x);\n    }\n  }\n  return str;\n};\n\n\n// Mark that a method should not be used.\n// Returns a modified function which warns once by default.\n// If --no-deprecation is set, then it is a no-op.\nexports.deprecate = function(fn, msg) {\n  if (typeof process !== 'undefined' && process.noDeprecation === true) {\n    return fn;\n  }\n\n  // Allow for deprecating things in the process of starting up.\n  if (typeof process === 'undefined') {\n    return function() {\n      return exports.deprecate(fn, msg).apply(this, arguments);\n    };\n  }\n\n  var warned = false;\n  function deprecated() {\n    if (!warned) {\n      if (process.throwDeprecation) {\n        throw new Error(msg);\n      } else if (process.traceDeprecation) {\n        console.trace(msg);\n      } else {\n        console.error(msg);\n      }\n      warned = true;\n    }\n    return fn.apply(this, arguments);\n  }\n\n  return deprecated;\n};\n\n\nvar debugs = {};\nvar debugEnvRegex = /^$/;\n\nif (process.env.NODE_DEBUG) {\n  var debugEnv = process.env.NODE_DEBUG;\n  debugEnv = debugEnv.replace(/[|\\\\{}()[\\]^$+?.]/g, '\\\\$&')\n    .replace(/\\*/g, '.*')\n    .replace(/,/g, '$|^')\n    .toUpperCase();\n  debugEnvRegex = new RegExp('^' + debugEnv + '$', 'i');\n}\nexports.debuglog = function(set) {\n  set = set.toUpperCase();\n  if (!debugs[set]) {\n    if (debugEnvRegex.test(set)) {\n      var pid = process.pid;\n      debugs[set] = function() {\n        var msg = exports.format.apply(exports, arguments);\n        console.error('%s %d: %s', set, pid, msg);\n      };\n    } else {\n      debugs[set] = function() {};\n    }\n  }\n  return debugs[set];\n};\n\n\n/**\n * Echos the value of a value. Trys to print the value out\n * in the best way possible given the different types.\n *\n * @param {Object} obj The object to print out.\n * @param {Object} opts Optional options object that alters the output.\n */\n/* legacy: obj, showHidden, depth, colors*/\nfunction inspect(obj, opts) {\n  // default options\n  var ctx = {\n    seen: [],\n    stylize: stylizeNoColor\n  };\n  // legacy...\n  if (arguments.length >= 3) ctx.depth = arguments[2];\n  if (arguments.length >= 4) ctx.colors = arguments[3];\n  if (isBoolean(opts)) {\n    // legacy...\n    ctx.showHidden = opts;\n  } else if (opts) {\n    // got an \"options\" object\n    exports._extend(ctx, opts);\n  }\n  // set default options\n  if (isUndefined(ctx.showHidden)) ctx.showHidden = false;\n  if (isUndefined(ctx.depth)) ctx.depth = 2;\n  if (isUndefined(ctx.colors)) ctx.colors = false;\n  if (isUndefined(ctx.customInspect)) ctx.customInspect = true;\n  if (ctx.colors) ctx.stylize = stylizeWithColor;\n  return formatValue(ctx, obj, ctx.depth);\n}\nexports.inspect = inspect;\n\n\n// http://en.wikipedia.org/wiki/ANSI_escape_code#graphics\ninspect.colors = {\n  'bold' : [1, 22],\n  'italic' : [3, 23],\n  'underline' : [4, 24],\n  'inverse' : [7, 27],\n  'white' : [37, 39],\n  'grey' : [90, 39],\n  'black' : [30, 39],\n  'blue' : [34, 39],\n  'cyan' : [36, 39],\n  'green' : [32, 39],\n  'magenta' : [35, 39],\n  'red' : [31, 39],\n  'yellow' : [33, 39]\n};\n\n// Don't use 'blue' not visible on cmd.exe\ninspect.styles = {\n  'special': 'cyan',\n  'number': 'yellow',\n  'boolean': 'yellow',\n  'undefined': 'grey',\n  'null': 'bold',\n  'string': 'green',\n  'date': 'magenta',\n  // \"name\": intentionally not styling\n  'regexp': 'red'\n};\n\n\nfunction stylizeWithColor(str, styleType) {\n  var style = inspect.styles[styleType];\n\n  if (style) {\n    return '\\u001b[' + inspect.colors[style][0] + 'm' + str +\n           '\\u001b[' + inspect.colors[style][1] + 'm';\n  } else {\n    return str;\n  }\n}\n\n\nfunction stylizeNoColor(str, styleType) {\n  return str;\n}\n\n\nfunction arrayToHash(array) {\n  var hash = {};\n\n  array.forEach(function(val, idx) {\n    hash[val] = true;\n  });\n\n  return hash;\n}\n\n\nfunction formatValue(ctx, value, recurseTimes) {\n  // Provide a hook for user-specified inspect functions.\n  // Check that value is an object with an inspect function on it\n  if (ctx.customInspect &&\n      value &&\n      isFunction(value.inspect) &&\n      // Filter out the util module, it's inspect function is special\n      value.inspect !== exports.inspect &&\n      // Also filter out any prototype objects using the circular check.\n      !(value.constructor && value.constructor.prototype === value)) {\n    var ret = value.inspect(recurseTimes, ctx);\n    if (!isString(ret)) {\n      ret = formatValue(ctx, ret, recurseTimes);\n    }\n    return ret;\n  }\n\n  // Primitive types cannot have properties\n  var primitive = formatPrimitive(ctx, value);\n  if (primitive) {\n    return primitive;\n  }\n\n  // Look up the keys of the object.\n  var keys = Object.keys(value);\n  var visibleKeys = arrayToHash(keys);\n\n  if (ctx.showHidden) {\n    keys = Object.getOwnPropertyNames(value);\n  }\n\n  // IE doesn't make error fields non-enumerable\n  // http://msdn.microsoft.com/en-us/library/ie/dww52sbt(v=vs.94).aspx\n  if (isError(value)\n      && (keys.indexOf('message') >= 0 || keys.indexOf('description') >= 0)) {\n    return formatError(value);\n  }\n\n  // Some type of object without properties can be shortcutted.\n  if (keys.length === 0) {\n    if (isFunction(value)) {\n      var name = value.name ? ': ' + value.name : '';\n      return ctx.stylize('[Function' + name + ']', 'special');\n    }\n    if (isRegExp(value)) {\n      return ctx.stylize(RegExp.prototype.toString.call(value), 'regexp');\n    }\n    if (isDate(value)) {\n      return ctx.stylize(Date.prototype.toString.call(value), 'date');\n    }\n    if (isError(value)) {\n      return formatError(value);\n    }\n  }\n\n  var base = '', array = false, braces = ['{', '}'];\n\n  // Make Array say that they are Array\n  if (isArray(value)) {\n    array = true;\n    braces = ['[', ']'];\n  }\n\n  // Make functions say that they are functions\n  if (isFunction(value)) {\n    var n = value.name ? ': ' + value.name : '';\n    base = ' [Function' + n + ']';\n  }\n\n  // Make RegExps say that they are RegExps\n  if (isRegExp(value)) {\n    base = ' ' + RegExp.prototype.toString.call(value);\n  }\n\n  // Make dates with properties first say the date\n  if (isDate(value)) {\n    base = ' ' + Date.prototype.toUTCString.call(value);\n  }\n\n  // Make error with message first say the error\n  if (isError(value)) {\n    base = ' ' + formatError(value);\n  }\n\n  if (keys.length === 0 && (!array || value.length == 0)) {\n    return braces[0] + base + braces[1];\n  }\n\n  if (recurseTimes < 0) {\n    if (isRegExp(value)) {\n      return ctx.stylize(RegExp.prototype.toString.call(value), 'regexp');\n    } else {\n      return ctx.stylize('[Object]', 'special');\n    }\n  }\n\n  ctx.seen.push(value);\n\n  var output;\n  if (array) {\n    output = formatArray(ctx, value, recurseTimes, visibleKeys, keys);\n  } else {\n    output = keys.map(function(key) {\n      return formatProperty(ctx, value, recurseTimes, visibleKeys, key, array);\n    });\n  }\n\n  ctx.seen.pop();\n\n  return reduceToSingleString(output, base, braces);\n}\n\n\nfunction formatPrimitive(ctx, value) {\n  if (isUndefined(value))\n    return ctx.stylize('undefined', 'undefined');\n  if (isString(value)) {\n    var simple = '\\'' + JSON.stringify(value).replace(/^\"|\"$/g, '')\n                                             .replace(/'/g, \"\\\\'\")\n                                             .replace(/\\\\\"/g, '\"') + '\\'';\n    return ctx.stylize(simple, 'string');\n  }\n  if (isNumber(value))\n    return ctx.stylize('' + value, 'number');\n  if (isBoolean(value))\n    return ctx.stylize('' + value, 'boolean');\n  // For some reason typeof null is \"object\", so special case here.\n  if (isNull(value))\n    return ctx.stylize('null', 'null');\n}\n\n\nfunction formatError(value) {\n  return '[' + Error.prototype.toString.call(value) + ']';\n}\n\n\nfunction formatArray(ctx, value, recurseTimes, visibleKeys, keys) {\n  var output = [];\n  for (var i = 0, l = value.length; i < l; ++i) {\n    if (hasOwnProperty(value, String(i))) {\n      output.push(formatProperty(ctx, value, recurseTimes, visibleKeys,\n          String(i), true));\n    } else {\n      output.push('');\n    }\n  }\n  keys.forEach(function(key) {\n    if (!key.match(/^\\d+$/)) {\n      output.push(formatProperty(ctx, value, recurseTimes, visibleKeys,\n          key, true));\n    }\n  });\n  return output;\n}\n\n\nfunction formatProperty(ctx, value, recurseTimes, visibleKeys, key, array) {\n  var name, str, desc;\n  desc = Object.getOwnPropertyDescriptor(value, key) || { value: value[key] };\n  if (desc.get) {\n    if (desc.set) {\n      str = ctx.stylize('[Getter/Setter]', 'special');\n    } else {\n      str = ctx.stylize('[Getter]', 'special');\n    }\n  } else {\n    if (desc.set) {\n      str = ctx.stylize('[Setter]', 'special');\n    }\n  }\n  if (!hasOwnProperty(visibleKeys, key)) {\n    name = '[' + key + ']';\n  }\n  if (!str) {\n    if (ctx.seen.indexOf(desc.value) < 0) {\n      if (isNull(recurseTimes)) {\n        str = formatValue(ctx, desc.value, null);\n      } else {\n        str = formatValue(ctx, desc.value, recurseTimes - 1);\n      }\n      if (str.indexOf('\\n') > -1) {\n        if (array) {\n          str = str.split('\\n').map(function(line) {\n            return '  ' + line;\n          }).join('\\n').slice(2);\n        } else {\n          str = '\\n' + str.split('\\n').map(function(line) {\n            return '   ' + line;\n          }).join('\\n');\n        }\n      }\n    } else {\n      str = ctx.stylize('[Circular]', 'special');\n    }\n  }\n  if (isUndefined(name)) {\n    if (array && key.match(/^\\d+$/)) {\n      return str;\n    }\n    name = JSON.stringify('' + key);\n    if (name.match(/^\"([a-zA-Z_][a-zA-Z_0-9]*)\"$/)) {\n      name = name.slice(1, -1);\n      name = ctx.stylize(name, 'name');\n    } else {\n      name = name.replace(/'/g, \"\\\\'\")\n                 .replace(/\\\\\"/g, '\"')\n                 .replace(/(^\"|\"$)/g, \"'\");\n      name = ctx.stylize(name, 'string');\n    }\n  }\n\n  return name + ': ' + str;\n}\n\n\nfunction reduceToSingleString(output, base, braces) {\n  var numLinesEst = 0;\n  var length = output.reduce(function(prev, cur) {\n    numLinesEst++;\n    if (cur.indexOf('\\n') >= 0) numLinesEst++;\n    return prev + cur.replace(/\\u001b\\[\\d\\d?m/g, '').length + 1;\n  }, 0);\n\n  if (length > 60) {\n    return braces[0] +\n           (base === '' ? '' : base + '\\n ') +\n           ' ' +\n           output.join(',\\n  ') +\n           ' ' +\n           braces[1];\n  }\n\n  return braces[0] + base + ' ' + output.join(', ') + ' ' + braces[1];\n}\n\n\n// NOTE: These type checking functions intentionally don't use `instanceof`\n// because it is fragile and can be easily faked with `Object.create()`.\nexports.types = require('./support/types');\n\nfunction isArray(ar) {\n  return Array.isArray(ar);\n}\nexports.isArray = isArray;\n\nfunction isBoolean(arg) {\n  return typeof arg === 'boolean';\n}\nexports.isBoolean = isBoolean;\n\nfunction isNull(arg) {\n  return arg === null;\n}\nexports.isNull = isNull;\n\nfunction isNullOrUndefined(arg) {\n  return arg == null;\n}\nexports.isNullOrUndefined = isNullOrUndefined;\n\nfunction isNumber(arg) {\n  return typeof arg === 'number';\n}\nexports.isNumber = isNumber;\n\nfunction isString(arg) {\n  return typeof arg === 'string';\n}\nexports.isString = isString;\n\nfunction isSymbol(arg) {\n  return typeof arg === 'symbol';\n}\nexports.isSymbol = isSymbol;\n\nfunction isUndefined(arg) {\n  return arg === void 0;\n}\nexports.isUndefined = isUndefined;\n\nfunction isRegExp(re) {\n  return isObject(re) && objectToString(re) === '[object RegExp]';\n}\nexports.isRegExp = isRegExp;\nexports.types.isRegExp = isRegExp;\n\nfunction isObject(arg) {\n  return typeof arg === 'object' && arg !== null;\n}\nexports.isObject = isObject;\n\nfunction isDate(d) {\n  return isObject(d) && objectToString(d) === '[object Date]';\n}\nexports.isDate = isDate;\nexports.types.isDate = isDate;\n\nfunction isError(e) {\n  return isObject(e) &&\n      (objectToString(e) === '[object Error]' || e instanceof Error);\n}\nexports.isError = isError;\nexports.types.isNativeError = isError;\n\nfunction isFunction(arg) {\n  return typeof arg === 'function';\n}\nexports.isFunction = isFunction;\n\nfunction isPrimitive(arg) {\n  return arg === null ||\n         typeof arg === 'boolean' ||\n         typeof arg === 'number' ||\n         typeof arg === 'string' ||\n         typeof arg === 'symbol' ||  // ES6 symbol\n         typeof arg === 'undefined';\n}\nexports.isPrimitive = isPrimitive;\n\nexports.isBuffer = require('./support/isBuffer');\n\nfunction objectToString(o) {\n  return Object.prototype.toString.call(o);\n}\n\n\nfunction pad(n) {\n  return n < 10 ? '0' + n.toString(10) : n.toString(10);\n}\n\n\nvar months = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep',\n              'Oct', 'Nov', 'Dec'];\n\n// 26 Feb 16:19:34\nfunction timestamp() {\n  var d = new Date();\n  var time = [pad(d.getHours()),\n              pad(d.getMinutes()),\n              pad(d.getSeconds())].join(':');\n  return [d.getDate(), months[d.getMonth()], time].join(' ');\n}\n\n\n// log is just a thin wrapper to console.log that prepends a timestamp\nexports.log = function() {\n  console.log('%s - %s', timestamp(), exports.format.apply(exports, arguments));\n};\n\n\n/**\n * Inherit the prototype methods from one constructor into another.\n *\n * The Function.prototype.inherits from lang.js rewritten as a standalone\n * function (not on Function.prototype). NOTE: If this file is to be loaded\n * during bootstrapping this function needs to be rewritten using some native\n * functions as prototype setup using normal JavaScript does not work as\n * expected during bootstrapping (see mirror.js in r114903).\n *\n * @param {function} ctor Constructor function which needs to inherit the\n *     prototype.\n * @param {function} superCtor Constructor function to inherit prototype from.\n */\nexports.inherits = require('inherits');\n\nexports._extend = function(origin, add) {\n  // Don't do anything if add isn't an object\n  if (!add || !isObject(add)) return origin;\n\n  var keys = Object.keys(add);\n  var i = keys.length;\n  while (i--) {\n    origin[keys[i]] = add[keys[i]];\n  }\n  return origin;\n};\n\nfunction hasOwnProperty(obj, prop) {\n  return Object.prototype.hasOwnProperty.call(obj, prop);\n}\n\nvar kCustomPromisifiedSymbol = typeof Symbol !== 'undefined' ? Symbol('util.promisify.custom') : undefined;\n\nexports.promisify = function promisify(original) {\n  if (typeof original !== 'function')\n    throw new TypeError('The \"original\" argument must be of type Function');\n\n  if (kCustomPromisifiedSymbol && original[kCustomPromisifiedSymbol]) {\n    var fn = original[kCustomPromisifiedSymbol];\n    if (typeof fn !== 'function') {\n      throw new TypeError('The \"util.promisify.custom\" argument must be of type Function');\n    }\n    Object.defineProperty(fn, kCustomPromisifiedSymbol, {\n      value: fn, enumerable: false, writable: false, configurable: true\n    });\n    return fn;\n  }\n\n  function fn() {\n    var promiseResolve, promiseReject;\n    var promise = new Promise(function (resolve, reject) {\n      promiseResolve = resolve;\n      promiseReject = reject;\n    });\n\n    var args = [];\n    for (var i = 0; i < arguments.length; i++) {\n      args.push(arguments[i]);\n    }\n    args.push(function (err, value) {\n      if (err) {\n        promiseReject(err);\n      } else {\n        promiseResolve(value);\n      }\n    });\n\n    try {\n      original.apply(this, args);\n    } catch (err) {\n      promiseReject(err);\n    }\n\n    return promise;\n  }\n\n  Object.setPrototypeOf(fn, Object.getPrototypeOf(original));\n\n  if (kCustomPromisifiedSymbol) Object.defineProperty(fn, kCustomPromisifiedSymbol, {\n    value: fn, enumerable: false, writable: false, configurable: true\n  });\n  return Object.defineProperties(\n    fn,\n    getOwnPropertyDescriptors(original)\n  );\n}\n\nexports.promisify.custom = kCustomPromisifiedSymbol\n\nfunction callbackifyOnRejected(reason, cb) {\n  // `!reason` guard inspired by bluebird (Ref: https://goo.gl/t5IS6M).\n  // Because `null` is a special error value in callbacks which means \"no error\n  // occurred\", we error-wrap so the callback consumer can distinguish between\n  // \"the promise rejected with null\" or \"the promise fulfilled with undefined\".\n  if (!reason) {\n    var newReason = new Error('Promise was rejected with a falsy value');\n    newReason.reason = reason;\n    reason = newReason;\n  }\n  return cb(reason);\n}\n\nfunction callbackify(original) {\n  if (typeof original !== 'function') {\n    throw new TypeError('The \"original\" argument must be of type Function');\n  }\n\n  // We DO NOT return the promise as it gives the user a false sense that\n  // the promise is actually somehow related to the callback's execution\n  // and that the callback throwing will reject the promise.\n  function callbackified() {\n    var args = [];\n    for (var i = 0; i < arguments.length; i++) {\n      args.push(arguments[i]);\n    }\n\n    var maybeCb = args.pop();\n    if (typeof maybeCb !== 'function') {\n      throw new TypeError('The last argument must be of type Function');\n    }\n    var self = this;\n    var cb = function() {\n      return maybeCb.apply(self, arguments);\n    };\n    // In true node style we process the callback on `nextTick` with all the\n    // implications (stack, `uncaughtException`, `async_hooks`)\n    original.apply(this, args)\n      .then(function(ret) { process.nextTick(cb.bind(null, null, ret)) },\n            function(rej) { process.nextTick(callbackifyOnRejected.bind(null, rej, cb)) });\n  }\n\n  Object.setPrototypeOf(callbackified, Object.getPrototypeOf(original));\n  Object.defineProperties(callbackified,\n                          getOwnPropertyDescriptors(original));\n  return callbackified;\n}\nexports.callbackify = callbackify;\n","\"use strict\";\n/** @module */\n\nconst arrayProto = require(\"@sinonjs/commons\").prototypes.array;\nconst calledInOrder = require(\"@sinonjs/commons\").calledInOrder;\nconst createMatcher = require(\"@sinonjs/samsam\").createMatcher;\nconst orderByFirstCall = require(\"@sinonjs/commons\").orderByFirstCall;\nconst timesInWords = require(\"./util/core/times-in-words\");\nconst inspect = require(\"util\").inspect;\nconst stringSlice = require(\"@sinonjs/commons\").prototypes.string.slice;\nconst globalObject = require(\"@sinonjs/commons\").global;\n\nconst arraySlice = arrayProto.slice;\nconst concat = arrayProto.concat;\nconst forEach = arrayProto.forEach;\nconst join = arrayProto.join;\nconst splice = arrayProto.splice;\n\nfunction applyDefaults(obj, defaults) {\n    for (const key of Object.keys(defaults)) {\n        const val = obj[key];\n        if (val === null || typeof val === \"undefined\") {\n            obj[key] = defaults[key];\n        }\n    }\n}\n\n/**\n * @typedef {object} CreateAssertOptions\n * @global\n *\n * @property {boolean} [shouldLimitAssertionLogs] default is false\n * @property {number}  [assertionLogLimit] default is 10K\n */\n\n/**\n * Create an assertion object that exposes several methods to invoke\n *\n * @param {CreateAssertOptions}  [opts] options bag\n * @returns {object} object with multiple assertion methods\n */\nfunction createAssertObject(opts) {\n    const cleanedAssertOptions = opts || {};\n    applyDefaults(cleanedAssertOptions, {\n        shouldLimitAssertionLogs: false,\n        assertionLogLimit: 1e4,\n    });\n\n    const assert = {\n        fail: function fail(message) {\n            let msg = message;\n            if (cleanedAssertOptions.shouldLimitAssertionLogs) {\n                msg = message.substring(\n                    0,\n                    cleanedAssertOptions.assertionLogLimit,\n                );\n            }\n            const error = new Error(msg);\n            error.name = \"AssertError\";\n\n            throw error;\n        },\n\n        pass: function pass() {\n            return;\n        },\n\n        callOrder: function assertCallOrder() {\n            verifyIsStub.apply(null, arguments);\n            let expected = \"\";\n            let actual = \"\";\n\n            if (!calledInOrder(arguments)) {\n                try {\n                    expected = join(arguments, \", \");\n                    const calls = arraySlice(arguments);\n                    let i = calls.length;\n                    while (i) {\n                        if (!calls[--i].called) {\n                            splice(calls, i, 1);\n                        }\n                    }\n                    actual = join(orderByFirstCall(calls), \", \");\n                } catch (e) {\n                    // If this fails, we'll just fall back to the blank string\n                }\n\n                failAssertion(\n                    this,\n                    `expected ${expected} to be called in order but were called as ${actual}`,\n                );\n            } else {\n                assert.pass(\"callOrder\");\n            }\n        },\n\n        callCount: function assertCallCount(method, count) {\n            verifyIsStub(method);\n\n            let msg;\n            if (typeof count !== \"number\") {\n                msg =\n                    `expected ${inspect(count)} to be a number ` +\n                    `but was of type ${typeof count}`;\n                failAssertion(this, msg);\n            } else if (method.callCount !== count) {\n                msg =\n                    `expected %n to be called ${timesInWords(count)} ` +\n                    `but was called %c%C`;\n                failAssertion(this, method.printf(msg));\n            } else {\n                assert.pass(\"callCount\");\n            }\n        },\n\n        expose: function expose(target, options) {\n            if (!target) {\n                throw new TypeError(\"target is null or undefined\");\n            }\n\n            const o = options || {};\n            const prefix =\n                (typeof o.prefix === \"undefined\" && \"assert\") || o.prefix;\n            const includeFail =\n                typeof o.includeFail === \"undefined\" || Boolean(o.includeFail);\n            const instance = this;\n\n            forEach(Object.keys(instance), function (method) {\n                if (\n                    method !== \"expose\" &&\n                    (includeFail || !/^(fail)/.test(method))\n                ) {\n                    target[exposedName(prefix, method)] = instance[method];\n                }\n            });\n\n            return target;\n        },\n\n        match: function match(actual, expectation) {\n            const matcher = createMatcher(expectation);\n            if (matcher.test(actual)) {\n                assert.pass(\"match\");\n            } else {\n                const formatted = [\n                    \"expected value to match\",\n                    `    expected = ${inspect(expectation)}`,\n                    `    actual = ${inspect(actual)}`,\n                ];\n\n                failAssertion(this, join(formatted, \"\\n\"));\n            }\n        },\n    };\n\n    function verifyIsStub() {\n        const args = arraySlice(arguments);\n\n        forEach(args, function (method) {\n            if (!method) {\n                assert.fail(\"fake is not a spy\");\n            }\n\n            if (method.proxy && method.proxy.isSinonProxy) {\n                verifyIsStub(method.proxy);\n            } else {\n                if (typeof method !== \"function\") {\n                    assert.fail(`${method} is not a function`);\n                }\n\n                if (typeof method.getCall !== \"function\") {\n                    assert.fail(`${method} is not stubbed`);\n                }\n            }\n        });\n    }\n\n    function verifyIsValidAssertion(assertionMethod, assertionArgs) {\n        switch (assertionMethod) {\n            case \"notCalled\":\n            case \"called\":\n            case \"calledOnce\":\n            case \"calledTwice\":\n            case \"calledThrice\":\n                if (assertionArgs.length !== 0) {\n                    assert.fail(\n                        `${assertionMethod} takes 1 argument but was called with ${\n                            assertionArgs.length + 1\n                        } arguments`,\n                    );\n                }\n                break;\n            default:\n                break;\n        }\n    }\n\n    function failAssertion(object, msg) {\n        const obj = object || globalObject;\n        const failMethod = obj.fail || assert.fail;\n        failMethod.call(obj, msg);\n    }\n\n    function mirrorPropAsAssertion(name, method, message) {\n        let msg = message;\n        let meth = method;\n        if (arguments.length === 2) {\n            msg = method;\n            meth = name;\n        }\n\n        assert[name] = function (fake) {\n            verifyIsStub(fake);\n\n            const args = arraySlice(arguments, 1);\n            let failed = false;\n\n            verifyIsValidAssertion(name, args);\n\n            if (typeof meth === \"function\") {\n                failed = !meth(fake);\n            } else {\n                failed =\n                    typeof fake[meth] === \"function\"\n                        ? !fake[meth].apply(fake, args)\n                        : !fake[meth];\n            }\n\n            if (failed) {\n                failAssertion(\n                    this,\n                    (fake.printf || fake.proxy.printf).apply(\n                        fake,\n                        concat([msg], args),\n                    ),\n                );\n            } else {\n                assert.pass(name);\n            }\n        };\n    }\n\n    function exposedName(prefix, prop) {\n        return !prefix || /^fail/.test(prop)\n            ? prop\n            : prefix +\n                  stringSlice(prop, 0, 1).toUpperCase() +\n                  stringSlice(prop, 1);\n    }\n\n    mirrorPropAsAssertion(\n        \"called\",\n        \"expected %n to have been called at least once but was never called\",\n    );\n    mirrorPropAsAssertion(\n        \"notCalled\",\n        function (spy) {\n            return !spy.called;\n        },\n        \"expected %n to not have been called but was called %c%C\",\n    );\n    mirrorPropAsAssertion(\n        \"calledOnce\",\n        \"expected %n to be called once but was called %c%C\",\n    );\n    mirrorPropAsAssertion(\n        \"calledTwice\",\n        \"expected %n to be called twice but was called %c%C\",\n    );\n    mirrorPropAsAssertion(\n        \"calledThrice\",\n        \"expected %n to be called thrice but was called %c%C\",\n    );\n    mirrorPropAsAssertion(\n        \"calledOn\",\n        \"expected %n to be called with %1 as this but was called with %t\",\n    );\n    mirrorPropAsAssertion(\n        \"alwaysCalledOn\",\n        \"expected %n to always be called with %1 as this but was called with %t\",\n    );\n    mirrorPropAsAssertion(\"calledWithNew\", \"expected %n to be called with new\");\n    mirrorPropAsAssertion(\n        \"alwaysCalledWithNew\",\n        \"expected %n to always be called with new\",\n    );\n    mirrorPropAsAssertion(\n        \"calledWith\",\n        \"expected %n to be called with arguments %D\",\n    );\n    mirrorPropAsAssertion(\n        \"calledWithMatch\",\n        \"expected %n to be called with match %D\",\n    );\n    mirrorPropAsAssertion(\n        \"alwaysCalledWith\",\n        \"expected %n to always be called with arguments %D\",\n    );\n    mirrorPropAsAssertion(\n        \"alwaysCalledWithMatch\",\n        \"expected %n to always be called with match %D\",\n    );\n    mirrorPropAsAssertion(\n        \"calledWithExactly\",\n        \"expected %n to be called with exact arguments %D\",\n    );\n    mirrorPropAsAssertion(\n        \"calledOnceWith\",\n        \"expected %n to be called once and with arguments %D\",\n    );\n    mirrorPropAsAssertion(\n        \"calledOnceWithExactly\",\n        \"expected %n to be called once and with exact arguments %D\",\n    );\n    mirrorPropAsAssertion(\n        \"calledOnceWithMatch\",\n        \"expected %n to be called once and with match %D\",\n    );\n    mirrorPropAsAssertion(\n        \"alwaysCalledWithExactly\",\n        \"expected %n to always be called with exact arguments %D\",\n    );\n    mirrorPropAsAssertion(\n        \"neverCalledWith\",\n        \"expected %n to never be called with arguments %*%C\",\n    );\n    mirrorPropAsAssertion(\n        \"neverCalledWithMatch\",\n        \"expected %n to never be called with match %*%C\",\n    );\n    mirrorPropAsAssertion(\"threw\", \"%n did not throw exception%C\");\n    mirrorPropAsAssertion(\"alwaysThrew\", \"%n did not always throw exception%C\");\n\n    return assert;\n}\n\nmodule.exports = createAssertObject();\nmodule.exports.createAssertObject = createAssertObject;\n","\"use strict\";\n\nconst globalObject = require(\"@sinonjs/commons\").global;\nlet timersModule, timersPromisesModule;\nif (typeof require === \"function\" && typeof module === \"object\") {\n    try {\n        timersModule = require(\"timers\");\n    } catch (e) {\n        // ignored\n    }\n    try {\n        timersPromisesModule = require(\"timers/promises\");\n    } catch (e) {\n        // ignored\n    }\n}\n\n/**\n * @typedef {\"nextAsync\" | \"manual\" | \"interval\"} TickMode\n */\n\n/**\n * @typedef {object} NextAsyncTickMode\n * @property {\"nextAsync\"} mode\n */\n\n/**\n * @typedef {object} ManualTickMode\n * @property {\"manual\"} mode\n */\n\n/**\n * @typedef {object} IntervalTickMode\n * @property {\"interval\"} mode\n * @property {number} [delta]\n */\n\n/**\n * @typedef {IntervalTickMode | NextAsyncTickMode | ManualTickMode} TimerTickMode\n */\n\n/**\n * @typedef {object} IdleDeadline\n * @property {boolean} didTimeout - whether or not the callback was called before reaching the optional timeout\n * @property {function():number} timeRemaining - a floating-point value providing an estimate of the number of milliseconds remaining in the current idle period\n */\n\n/**\n * Queues a function to be called during a browser's idle periods\n * @callback RequestIdleCallback\n * @param {function(IdleDeadline)} callback\n * @param {{timeout: number}} options - an options object\n * @returns {number} the id\n */\n\n/**\n * @callback NextTick\n * @param {VoidVarArgsFunc} callback - the callback to run\n * @param {...*} args - optional arguments to call the callback with\n * @returns {void}\n */\n\n/**\n * @callback SetImmediate\n * @param {VoidVarArgsFunc} callback - the callback to run\n * @param {...*} args - optional arguments to call the callback with\n * @returns {NodeImmediate}\n */\n\n/**\n * @callback VoidVarArgsFunc\n * @param {...*} callback - the callback to run\n * @returns {void}\n */\n\n/**\n * @typedef RequestAnimationFrame\n * @property {function(number):void} requestAnimationFrame\n * @returns {number} - the id\n */\n\n/**\n * @typedef Performance\n * @property {function(): number} now\n */\n\n/* eslint-disable jsdoc/require-property-description */\n/**\n * @typedef {object} Clock\n * @property {number} now - the current time\n * @property {Date} Date - the Date constructor\n * @property {number} loopLimit - the maximum number of timers before assuming an infinite loop\n * @property {RequestIdleCallback} requestIdleCallback\n * @property {function(number):void} cancelIdleCallback\n * @property {setTimeout} setTimeout\n * @property {clearTimeout} clearTimeout\n * @property {NextTick} nextTick\n * @property {queueMicrotask} queueMicrotask\n * @property {setInterval} setInterval\n * @property {clearInterval} clearInterval\n * @property {SetImmediate} setImmediate\n * @property {function(NodeImmediate):void} clearImmediate\n * @property {function():number} countTimers\n * @property {RequestAnimationFrame} requestAnimationFrame\n * @property {function(number):void} cancelAnimationFrame\n * @property {function():void} runMicrotasks\n * @property {function(string | number): number} tick\n * @property {function(string | number): Promise<number>} tickAsync\n * @property {function(): number} next\n * @property {function(): Promise<number>} nextAsync\n * @property {function(): number} runAll\n * @property {function(): number} runToFrame\n * @property {function(): Promise<number>} runAllAsync\n * @property {function(): number} runToLast\n * @property {function(): Promise<number>} runToLastAsync\n * @property {function(): void} reset\n * @property {function(number | Date): void} setSystemTime\n * @property {function(number): void} jump\n * @property {Performance} performance\n * @property {function(number[]): number[]} hrtime - process.hrtime (legacy)\n * @property {function(): void} uninstall Uninstall the clock.\n * @property {Function[]} methods - the methods that are faked\n * @property {boolean} [shouldClearNativeTimers] inherited from config\n * @property {{methodName:string, original:any}[] | undefined} timersModuleMethods\n * @property {{methodName:string, original:any}[] | undefined} timersPromisesModuleMethods\n * @property {Map<function(): void, AbortSignal>} abortListenerMap\n * @property {function(TimerTickMode): void} setTickMode\n */\n/* eslint-enable jsdoc/require-property-description */\n\n/**\n * Configuration object for the `install` method.\n * @typedef {object} Config\n * @property {number|Date} [now] a number (in milliseconds) or a Date object (default epoch)\n * @property {string[]} [toFake] names of the methods that should be faked.\n * @property {number} [loopLimit] the maximum number of timers that will be run when calling runAll()\n * @property {boolean} [shouldAdvanceTime] tells FakeTimers to increment mocked time automatically (default false)\n * @property {number} [advanceTimeDelta] increment mocked time every <<advanceTimeDelta>> ms (default: 20ms)\n * @property {boolean} [shouldClearNativeTimers] forwards clear timer calls to native functions if they are not fakes (default: false)\n * @property {boolean} [ignoreMissingTimers] default is false, meaning asking to fake timers that are not present will throw an error\n */\n\n/* eslint-disable jsdoc/require-property-description */\n/**\n * The internal structure to describe a scheduled fake timer\n * @typedef {object} Timer\n * @property {Function} func\n * @property {*[]} args\n * @property {number} delay\n * @property {number} callAt\n * @property {number} createdAt\n * @property {boolean} immediate\n * @property {number} id\n * @property {Error} [error]\n */\n\n/**\n * A Node timer\n * @typedef {object} NodeImmediate\n * @property {function(): boolean} hasRef\n * @property {function(): NodeImmediate} ref\n * @property {function(): NodeImmediate} unref\n */\n/* eslint-enable jsdoc/require-property-description */\n\n/* eslint-disable complexity */\n\n/**\n * Mocks available features in the specified global namespace.\n * @param {*} _global Namespace to mock (e.g. `window`)\n * @returns {FakeTimers}\n */\nfunction withGlobal(_global) {\n    const maxTimeout = Math.pow(2, 31) - 1; //see https://heycam.github.io/webidl/#abstract-opdef-converttoint\n    const idCounterStart = 1e12; // arbitrarily large number to avoid collisions with native timer IDs\n    const NOOP = function () {\n        return undefined;\n    };\n    const NOOP_ARRAY = function () {\n        return [];\n    };\n    const isPresent = {};\n    let timeoutResult,\n        addTimerReturnsObject = false;\n\n    if (_global.setTimeout) {\n        isPresent.setTimeout = true;\n        timeoutResult = _global.setTimeout(NOOP, 0);\n        addTimerReturnsObject = typeof timeoutResult === \"object\";\n    }\n    isPresent.clearTimeout = Boolean(_global.clearTimeout);\n    isPresent.setInterval = Boolean(_global.setInterval);\n    isPresent.clearInterval = Boolean(_global.clearInterval);\n    isPresent.hrtime =\n        _global.process && typeof _global.process.hrtime === \"function\";\n    isPresent.hrtimeBigint =\n        isPresent.hrtime && typeof _global.process.hrtime.bigint === \"function\";\n    isPresent.nextTick =\n        _global.process && typeof _global.process.nextTick === \"function\";\n    const utilPromisify = _global.process && require(\"util\").promisify;\n    isPresent.performance =\n        _global.performance && typeof _global.performance.now === \"function\";\n    const hasPerformancePrototype =\n        _global.Performance &&\n        (typeof _global.Performance).match(/^(function|object)$/);\n    const hasPerformanceConstructorPrototype =\n        _global.performance &&\n        _global.performance.constructor &&\n        _global.performance.constructor.prototype;\n    isPresent.queueMicrotask = _global.hasOwnProperty(\"queueMicrotask\");\n    isPresent.requestAnimationFrame =\n        _global.requestAnimationFrame &&\n        typeof _global.requestAnimationFrame === \"function\";\n    isPresent.cancelAnimationFrame =\n        _global.cancelAnimationFrame &&\n        typeof _global.cancelAnimationFrame === \"function\";\n    isPresent.requestIdleCallback =\n        _global.requestIdleCallback &&\n        typeof _global.requestIdleCallback === \"function\";\n    isPresent.cancelIdleCallbackPresent =\n        _global.cancelIdleCallback &&\n        typeof _global.cancelIdleCallback === \"function\";\n    isPresent.setImmediate =\n        _global.setImmediate && typeof _global.setImmediate === \"function\";\n    isPresent.clearImmediate =\n        _global.clearImmediate && typeof _global.clearImmediate === \"function\";\n    isPresent.Intl = _global.Intl && typeof _global.Intl === \"object\";\n\n    if (_global.clearTimeout) {\n        _global.clearTimeout(timeoutResult);\n    }\n\n    const NativeDate = _global.Date;\n    const NativeIntl = isPresent.Intl\n        ? Object.defineProperties(\n              Object.create(null),\n              Object.getOwnPropertyDescriptors(_global.Intl),\n          )\n        : undefined;\n    let uniqueTimerId = idCounterStart;\n\n    if (NativeDate === undefined) {\n        throw new Error(\n            \"The global scope doesn't have a `Date` object\" +\n                \" (see https://github.com/sinonjs/sinon/issues/1852#issuecomment-419622780)\",\n        );\n    }\n    isPresent.Date = true;\n\n    /**\n     * The PerformanceEntry object encapsulates a single performance metric\n     * that is part of the browser's performance timeline.\n     *\n     * This is an object returned by the `mark` and `measure` methods on the Performance prototype\n     */\n    class FakePerformanceEntry {\n        constructor(name, entryType, startTime, duration) {\n            this.name = name;\n            this.entryType = entryType;\n            this.startTime = startTime;\n            this.duration = duration;\n        }\n\n        toJSON() {\n            return JSON.stringify({ ...this });\n        }\n    }\n\n    /**\n     * @param {number} num\n     * @returns {boolean}\n     */\n    function isNumberFinite(num) {\n        if (Number.isFinite) {\n            return Number.isFinite(num);\n        }\n\n        return isFinite(num);\n    }\n\n    let isNearInfiniteLimit = false;\n\n    /**\n     * @param {Clock} clock\n     * @param {number} i\n     */\n    function checkIsNearInfiniteLimit(clock, i) {\n        if (clock.loopLimit && i === clock.loopLimit - 1) {\n            isNearInfiniteLimit = true;\n        }\n    }\n\n    /**\n     *\n     */\n    function resetIsNearInfiniteLimit() {\n        isNearInfiniteLimit = false;\n    }\n\n    /**\n     * Parse strings like \"01:10:00\" (meaning 1 hour, 10 minutes, 0 seconds) into\n     * number of milliseconds. This is used to support human-readable strings passed\n     * to clock.tick()\n     * @param {string} str\n     * @returns {number}\n     */\n    function parseTime(str) {\n        if (!str) {\n            return 0;\n        }\n\n        const strings = str.split(\":\");\n        const l = strings.length;\n        let i = l;\n        let ms = 0;\n        let parsed;\n\n        if (l > 3 || !/^(\\d\\d:){0,2}\\d\\d?$/.test(str)) {\n            throw new Error(\n                \"tick only understands numbers, 'm:s' and 'h:m:s'. Each part must be two digits\",\n            );\n        }\n\n        while (i--) {\n            parsed = parseInt(strings[i], 10);\n\n            if (parsed >= 60) {\n                throw new Error(`Invalid time ${str}`);\n            }\n\n            ms += parsed * Math.pow(60, l - i - 1);\n        }\n\n        return ms * 1000;\n    }\n\n    /**\n     * Get the decimal part of the millisecond value as nanoseconds\n     * @param {number} msFloat the number of milliseconds\n     * @returns {number} an integer number of nanoseconds in the range [0,1e6)\n     *\n     * Example: nanoRemainer(123.456789) -> 456789\n     */\n    function nanoRemainder(msFloat) {\n        const modulo = 1e6;\n        const remainder = (msFloat * 1e6) % modulo;\n        const positiveRemainder =\n            remainder < 0 ? remainder + modulo : remainder;\n\n        return Math.floor(positiveRemainder);\n    }\n\n    /**\n     * Used to grok the `now` parameter to createClock.\n     * @param {Date|number} epoch the system time\n     * @returns {number}\n     */\n    function getEpoch(epoch) {\n        if (!epoch) {\n            return 0;\n        }\n        if (typeof epoch.getTime === \"function\") {\n            return epoch.getTime();\n        }\n        if (typeof epoch === \"number\") {\n            return epoch;\n        }\n        throw new TypeError(\"now should be milliseconds since UNIX epoch\");\n    }\n\n    /**\n     * @param {number} from\n     * @param {number} to\n     * @param {Timer} timer\n     * @returns {boolean}\n     */\n    function inRange(from, to, timer) {\n        return timer && timer.callAt >= from && timer.callAt <= to;\n    }\n\n    /**\n     * @param {Clock} clock\n     * @param {Timer} job\n     */\n    function getInfiniteLoopError(clock, job) {\n        const infiniteLoopError = new Error(\n            `Aborting after running ${clock.loopLimit} timers, assuming an infinite loop!`,\n        );\n\n        if (!job.error) {\n            return infiniteLoopError;\n        }\n\n        // pattern never matched in Node\n        const computedTargetPattern = /target\\.*[<|(|[].*?[>|\\]|)]\\s*/;\n        let clockMethodPattern = new RegExp(\n            String(Object.keys(clock).join(\"|\")),\n        );\n\n        if (addTimerReturnsObject) {\n            // node.js environment\n            clockMethodPattern = new RegExp(\n                `\\\\s+at (Object\\\\.)?(?:${Object.keys(clock).join(\"|\")})\\\\s+`,\n            );\n        }\n\n        let matchedLineIndex = -1;\n        job.error.stack.split(\"\\n\").some(function (line, i) {\n            // If we've matched a computed target line (e.g. setTimeout) then we\n            // don't need to look any further. Return true to stop iterating.\n            const matchedComputedTarget = line.match(computedTargetPattern);\n            /* istanbul ignore if */\n            if (matchedComputedTarget) {\n                matchedLineIndex = i;\n                return true;\n            }\n\n            // If we've matched a clock method line, then there may still be\n            // others further down the trace. Return false to keep iterating.\n            const matchedClockMethod = line.match(clockMethodPattern);\n            if (matchedClockMethod) {\n                matchedLineIndex = i;\n                return false;\n            }\n\n            // If we haven't matched anything on this line, but we matched\n            // previously and set the matched line index, then we can stop.\n            // If we haven't matched previously, then we should keep iterating.\n            return matchedLineIndex >= 0;\n        });\n\n        const stack = `${infiniteLoopError}\\n${job.type || \"Microtask\"} - ${\n            job.func.name || \"anonymous\"\n        }\\n${job.error.stack\n            .split(\"\\n\")\n            .slice(matchedLineIndex + 1)\n            .join(\"\\n\")}`;\n\n        try {\n            Object.defineProperty(infiniteLoopError, \"stack\", {\n                value: stack,\n            });\n        } catch (e) {\n            // noop\n        }\n\n        return infiniteLoopError;\n    }\n\n    //eslint-disable-next-line jsdoc/require-jsdoc\n    function createDate() {\n        class ClockDate extends NativeDate {\n            /**\n             * @param {number} year\n             * @param {number} month\n             * @param {number} date\n             * @param {number} hour\n             * @param {number} minute\n             * @param {number} second\n             * @param {number} ms\n             * @returns void\n             */\n            // eslint-disable-next-line no-unused-vars\n            constructor(year, month, date, hour, minute, second, ms) {\n                // Defensive and verbose to avoid potential harm in passing\n                // explicit undefined when user does not pass argument\n                if (arguments.length === 0) {\n                    super(ClockDate.clock.now);\n                } else {\n                    super(...arguments);\n                }\n\n                // ensures identity checks using the constructor prop still works\n                // this should have no other functional effect\n                Object.defineProperty(this, \"constructor\", {\n                    value: NativeDate,\n                    enumerable: false,\n                });\n            }\n\n            static [Symbol.hasInstance](instance) {\n                return instance instanceof NativeDate;\n            }\n        }\n\n        ClockDate.isFake = true;\n\n        if (NativeDate.now) {\n            ClockDate.now = function now() {\n                return ClockDate.clock.now;\n            };\n        }\n\n        if (NativeDate.toSource) {\n            ClockDate.toSource = function toSource() {\n                return NativeDate.toSource();\n            };\n        }\n\n        ClockDate.toString = function toString() {\n            return NativeDate.toString();\n        };\n\n        // noinspection UnnecessaryLocalVariableJS\n        /**\n         * A normal Class constructor cannot be called without `new`, but Date can, so we need\n         * to wrap it in a Proxy in order to ensure this functionality of Date is kept intact\n         * @type {ClockDate}\n         */\n        const ClockDateProxy = new Proxy(ClockDate, {\n            // handler for [[Call]] invocations (i.e. not using `new`)\n            apply() {\n                // the Date constructor called as a function, ref Ecma-262 Edition 5.1, section 15.9.2.\n                // This remains so in the 10th edition of 2019 as well.\n                if (this instanceof ClockDate) {\n                    throw new TypeError(\n                        \"A Proxy should only capture `new` calls with the `construct` handler. This is not supposed to be possible, so check the logic.\",\n                    );\n                }\n\n                return new NativeDate(ClockDate.clock.now).toString();\n            },\n        });\n\n        return ClockDateProxy;\n    }\n\n    /**\n     * Mirror Intl by default on our fake implementation\n     *\n     * Most of the properties are the original native ones,\n     * but we need to take control of those that have a\n     * dependency on the current clock.\n     * @returns {object} the partly fake Intl implementation\n     */\n    function createIntl() {\n        const ClockIntl = {};\n        /*\n         * All properties of Intl are non-enumerable, so we need\n         * to do a bit of work to get them out.\n         */\n        Object.getOwnPropertyNames(NativeIntl).forEach(\n            (property) => (ClockIntl[property] = NativeIntl[property]),\n        );\n\n        ClockIntl.DateTimeFormat = function (...args) {\n            const realFormatter = new NativeIntl.DateTimeFormat(...args);\n            const formatter = {};\n\n            [\"formatRange\", \"formatRangeToParts\", \"resolvedOptions\"].forEach(\n                (method) => {\n                    formatter[method] =\n                        realFormatter[method].bind(realFormatter);\n                },\n            );\n\n            [\"format\", \"formatToParts\"].forEach((method) => {\n                formatter[method] = function (date) {\n                    return realFormatter[method](date || ClockIntl.clock.now);\n                };\n            });\n\n            return formatter;\n        };\n\n        ClockIntl.DateTimeFormat.prototype = Object.create(\n            NativeIntl.DateTimeFormat.prototype,\n        );\n\n        ClockIntl.DateTimeFormat.supportedLocalesOf =\n            NativeIntl.DateTimeFormat.supportedLocalesOf;\n\n        return ClockIntl;\n    }\n\n    //eslint-disable-next-line jsdoc/require-jsdoc\n    function enqueueJob(clock, job) {\n        // enqueues a microtick-deferred task - ecma262/#sec-enqueuejob\n        if (!clock.jobs) {\n            clock.jobs = [];\n        }\n        clock.jobs.push(job);\n    }\n\n    //eslint-disable-next-line jsdoc/require-jsdoc\n    function runJobs(clock) {\n        // runs all microtick-deferred tasks - ecma262/#sec-runjobs\n        if (!clock.jobs) {\n            return;\n        }\n        for (let i = 0; i < clock.jobs.length; i++) {\n            const job = clock.jobs[i];\n            job.func.apply(null, job.args);\n\n            checkIsNearInfiniteLimit(clock, i);\n            if (clock.loopLimit && i > clock.loopLimit) {\n                throw getInfiniteLoopError(clock, job);\n            }\n        }\n        resetIsNearInfiniteLimit();\n        clock.jobs = [];\n    }\n\n    /**\n     * @param {Clock} clock\n     * @param {Timer} timer\n     * @returns {number} id of the created timer\n     */\n    function addTimer(clock, timer) {\n        if (timer.func === undefined) {\n            throw new Error(\"Callback must be provided to timer calls\");\n        }\n\n        if (addTimerReturnsObject) {\n            // Node.js environment\n            if (typeof timer.func !== \"function\") {\n                throw new TypeError(\n                    `[ERR_INVALID_CALLBACK]: Callback must be a function. Received ${\n                        timer.func\n                    } of type ${typeof timer.func}`,\n                );\n            }\n        }\n\n        if (isNearInfiniteLimit) {\n            timer.error = new Error();\n        }\n\n        timer.type = timer.immediate ? \"Immediate\" : \"Timeout\";\n\n        if (timer.hasOwnProperty(\"delay\")) {\n            if (typeof timer.delay !== \"number\") {\n                timer.delay = parseInt(timer.delay, 10);\n            }\n\n            if (!isNumberFinite(timer.delay)) {\n                timer.delay = 0;\n            }\n            timer.delay = timer.delay > maxTimeout ? 1 : timer.delay;\n            timer.delay = Math.max(0, timer.delay);\n        }\n\n        if (timer.hasOwnProperty(\"interval\")) {\n            timer.type = \"Interval\";\n            timer.interval = timer.interval > maxTimeout ? 1 : timer.interval;\n        }\n\n        if (timer.hasOwnProperty(\"animation\")) {\n            timer.type = \"AnimationFrame\";\n            timer.animation = true;\n        }\n\n        if (timer.hasOwnProperty(\"idleCallback\")) {\n            timer.type = \"IdleCallback\";\n            timer.idleCallback = true;\n        }\n\n        if (!clock.timers) {\n            clock.timers = {};\n        }\n\n        timer.id = uniqueTimerId++;\n        timer.createdAt = clock.now;\n        timer.callAt =\n            clock.now + (parseInt(timer.delay) || (clock.duringTick ? 1 : 0));\n\n        clock.timers[timer.id] = timer;\n\n        if (addTimerReturnsObject) {\n            const res = {\n                refed: true,\n                ref: function () {\n                    this.refed = true;\n                    return res;\n                },\n                unref: function () {\n                    this.refed = false;\n                    return res;\n                },\n                hasRef: function () {\n                    return this.refed;\n                },\n                refresh: function () {\n                    timer.callAt =\n                        clock.now +\n                        (parseInt(timer.delay) || (clock.duringTick ? 1 : 0));\n\n                    // it _might_ have been removed, but if not the assignment is perfectly fine\n                    clock.timers[timer.id] = timer;\n\n                    return res;\n                },\n                [Symbol.toPrimitive]: function () {\n                    return timer.id;\n                },\n            };\n            return res;\n        }\n\n        return timer.id;\n    }\n\n    /* eslint consistent-return: \"off\" */\n    /**\n     * Timer comparitor\n     * @param {Timer} a\n     * @param {Timer} b\n     * @returns {number}\n     */\n    function compareTimers(a, b) {\n        // Sort first by absolute timing\n        if (a.callAt < b.callAt) {\n            return -1;\n        }\n        if (a.callAt > b.callAt) {\n            return 1;\n        }\n\n        // Sort next by immediate, immediate timers take precedence\n        if (a.immediate && !b.immediate) {\n            return -1;\n        }\n        if (!a.immediate && b.immediate) {\n            return 1;\n        }\n\n        // Sort next by creation time, earlier-created timers take precedence\n        if (a.createdAt < b.createdAt) {\n            return -1;\n        }\n        if (a.createdAt > b.createdAt) {\n            return 1;\n        }\n\n        // Sort next by id, lower-id timers take precedence\n        if (a.id < b.id) {\n            return -1;\n        }\n        if (a.id > b.id) {\n            return 1;\n        }\n\n        // As timer ids are unique, no fallback `0` is necessary\n    }\n\n    /**\n     * @param {Clock} clock\n     * @param {number} from\n     * @param {number} to\n     * @returns {Timer}\n     */\n    function firstTimerInRange(clock, from, to) {\n        const timers = clock.timers;\n        let timer = null;\n        let id, isInRange;\n\n        for (id in timers) {\n            if (timers.hasOwnProperty(id)) {\n                isInRange = inRange(from, to, timers[id]);\n\n                if (\n                    isInRange &&\n                    (!timer || compareTimers(timer, timers[id]) === 1)\n                ) {\n                    timer = timers[id];\n                }\n            }\n        }\n\n        return timer;\n    }\n\n    /**\n     * @param {Clock} clock\n     * @returns {Timer}\n     */\n    function firstTimer(clock) {\n        const timers = clock.timers;\n        let timer = null;\n        let id;\n\n        for (id in timers) {\n            if (timers.hasOwnProperty(id)) {\n                if (!timer || compareTimers(timer, timers[id]) === 1) {\n                    timer = timers[id];\n                }\n            }\n        }\n\n        return timer;\n    }\n\n    /**\n     * @param {Clock} clock\n     * @returns {Timer}\n     */\n    function lastTimer(clock) {\n        const timers = clock.timers;\n        let timer = null;\n        let id;\n\n        for (id in timers) {\n            if (timers.hasOwnProperty(id)) {\n                if (!timer || compareTimers(timer, timers[id]) === -1) {\n                    timer = timers[id];\n                }\n            }\n        }\n\n        return timer;\n    }\n\n    /**\n     * @param {Clock} clock\n     * @param {Timer} timer\n     */\n    function callTimer(clock, timer) {\n        if (typeof timer.interval === \"number\") {\n            clock.timers[timer.id].callAt += timer.interval;\n        } else {\n            delete clock.timers[timer.id];\n        }\n\n        if (typeof timer.func === \"function\") {\n            timer.func.apply(null, timer.args);\n        } else {\n            /* eslint no-eval: \"off\" */\n            const eval2 = eval;\n            (function () {\n                eval2(timer.func);\n            })();\n        }\n    }\n\n    /**\n     * Gets clear handler name for a given timer type\n     * @param {string} ttype\n     */\n    function getClearHandler(ttype) {\n        if (ttype === \"IdleCallback\" || ttype === \"AnimationFrame\") {\n            return `cancel${ttype}`;\n        }\n        return `clear${ttype}`;\n    }\n\n    /**\n     * Gets schedule handler name for a given timer type\n     * @param {string} ttype\n     */\n    function getScheduleHandler(ttype) {\n        if (ttype === \"IdleCallback\" || ttype === \"AnimationFrame\") {\n            return `request${ttype}`;\n        }\n        return `set${ttype}`;\n    }\n\n    /**\n     * Creates an anonymous function to warn only once\n     */\n    function createWarnOnce() {\n        let calls = 0;\n        return function (msg) {\n            // eslint-disable-next-line\n            !calls++ && console.warn(msg);\n        };\n    }\n    const warnOnce = createWarnOnce();\n\n    /**\n     * @param {Clock} clock\n     * @param {number} timerId\n     * @param {string} ttype\n     */\n    function clearTimer(clock, timerId, ttype) {\n        if (!timerId) {\n            // null appears to be allowed in most browsers, and appears to be\n            // relied upon by some libraries, like Bootstrap carousel\n            return;\n        }\n\n        if (!clock.timers) {\n            clock.timers = {};\n        }\n\n        // in Node, the ID is stored as the primitive value for `Timeout` objects\n        // for `Immediate` objects, no ID exists, so it gets coerced to NaN\n        const id = Number(timerId);\n\n        if (Number.isNaN(id) || id < idCounterStart) {\n            const handlerName = getClearHandler(ttype);\n\n            if (clock.shouldClearNativeTimers === true) {\n                const nativeHandler = clock[`_${handlerName}`];\n                return typeof nativeHandler === \"function\"\n                    ? nativeHandler(timerId)\n                    : undefined;\n            }\n\n            // Include the stacktrace, excluding the 'error' line\n            const stackTrace = new Error().stack\n                .split(\"\\n\")\n                .slice(1)\n                .join(\"\\n\");\n\n            warnOnce(\n                `FakeTimers: ${handlerName} was invoked to clear a native timer instead of one created by this library.` +\n                    \"\\nTo automatically clean-up native timers, use `shouldClearNativeTimers`.\" +\n                    `\\n${stackTrace}`,\n            );\n        }\n\n        if (clock.timers.hasOwnProperty(id)) {\n            // check that the ID matches a timer of the correct type\n            const timer = clock.timers[id];\n            if (\n                timer.type === ttype ||\n                (timer.type === \"Timeout\" && ttype === \"Interval\") ||\n                (timer.type === \"Interval\" && ttype === \"Timeout\")\n            ) {\n                delete clock.timers[id];\n            } else {\n                const clear = getClearHandler(ttype);\n                const schedule = getScheduleHandler(timer.type);\n                throw new Error(\n                    `Cannot clear timer: timer created with ${schedule}() but cleared with ${clear}()`,\n                );\n            }\n        }\n    }\n\n    /**\n     * @param {Clock} clock\n     * @returns {Timer[]}\n     */\n    function uninstall(clock) {\n        let method, i, l;\n        const installedHrTime = \"_hrtime\";\n        const installedNextTick = \"_nextTick\";\n\n        for (i = 0, l = clock.methods.length; i < l; i++) {\n            method = clock.methods[i];\n            if (method === \"hrtime\" && _global.process) {\n                _global.process.hrtime = clock[installedHrTime];\n            } else if (method === \"nextTick\" && _global.process) {\n                _global.process.nextTick = clock[installedNextTick];\n            } else if (method === \"performance\") {\n                const originalPerfDescriptor = Object.getOwnPropertyDescriptor(\n                    clock,\n                    `_${method}`,\n                );\n                if (\n                    originalPerfDescriptor &&\n                    originalPerfDescriptor.get &&\n                    !originalPerfDescriptor.set\n                ) {\n                    Object.defineProperty(\n                        _global,\n                        method,\n                        originalPerfDescriptor,\n                    );\n                } else if (originalPerfDescriptor.configurable) {\n                    _global[method] = clock[`_${method}`];\n                }\n            } else {\n                if (_global[method] && _global[method].hadOwnProperty) {\n                    _global[method] = clock[`_${method}`];\n                } else {\n                    try {\n                        delete _global[method];\n                    } catch (ignore) {\n                        /* eslint no-empty: \"off\" */\n                    }\n                }\n            }\n            if (clock.timersModuleMethods !== undefined) {\n                for (let j = 0; j < clock.timersModuleMethods.length; j++) {\n                    const entry = clock.timersModuleMethods[j];\n                    timersModule[entry.methodName] = entry.original;\n                }\n            }\n            if (clock.timersPromisesModuleMethods !== undefined) {\n                for (\n                    let j = 0;\n                    j < clock.timersPromisesModuleMethods.length;\n                    j++\n                ) {\n                    const entry = clock.timersPromisesModuleMethods[j];\n                    timersPromisesModule[entry.methodName] = entry.original;\n                }\n            }\n        }\n\n        clock.setTickMode(\"manual\");\n\n        // Prevent multiple executions which will completely remove these props\n        clock.methods = [];\n\n        for (const [listener, signal] of clock.abortListenerMap.entries()) {\n            signal.removeEventListener(\"abort\", listener);\n            clock.abortListenerMap.delete(listener);\n        }\n\n        // return pending timers, to enable checking what timers remained on uninstall\n        if (!clock.timers) {\n            return [];\n        }\n        return Object.keys(clock.timers).map(function mapper(key) {\n            return clock.timers[key];\n        });\n    }\n\n    /**\n     * @param {object} target the target containing the method to replace\n     * @param {string} method the keyname of the method on the target\n     * @param {Clock} clock\n     */\n    function hijackMethod(target, method, clock) {\n        clock[method].hadOwnProperty = Object.prototype.hasOwnProperty.call(\n            target,\n            method,\n        );\n        clock[`_${method}`] = target[method];\n\n        if (method === \"Date\") {\n            target[method] = clock[method];\n        } else if (method === \"Intl\") {\n            target[method] = clock[method];\n        } else if (method === \"performance\") {\n            const originalPerfDescriptor = Object.getOwnPropertyDescriptor(\n                target,\n                method,\n            );\n            // JSDOM has a read only performance field so we have to save/copy it differently\n            if (\n                originalPerfDescriptor &&\n                originalPerfDescriptor.get &&\n                !originalPerfDescriptor.set\n            ) {\n                Object.defineProperty(\n                    clock,\n                    `_${method}`,\n                    originalPerfDescriptor,\n                );\n\n                const perfDescriptor = Object.getOwnPropertyDescriptor(\n                    clock,\n                    method,\n                );\n                Object.defineProperty(target, method, perfDescriptor);\n            } else {\n                target[method] = clock[method];\n            }\n        } else {\n            target[method] = function () {\n                return clock[method].apply(clock, arguments);\n            };\n\n            Object.defineProperties(\n                target[method],\n                Object.getOwnPropertyDescriptors(clock[method]),\n            );\n        }\n\n        target[method].clock = clock;\n    }\n\n    /**\n     * @param {Clock} clock\n     * @param {number} advanceTimeDelta\n     */\n    function doIntervalTick(clock, advanceTimeDelta) {\n        clock.tick(advanceTimeDelta);\n    }\n\n    /**\n     * @typedef {object} Timers\n     * @property {setTimeout} setTimeout\n     * @property {clearTimeout} clearTimeout\n     * @property {setInterval} setInterval\n     * @property {clearInterval} clearInterval\n     * @property {Date} Date\n     * @property {Intl} Intl\n     * @property {SetImmediate=} setImmediate\n     * @property {function(NodeImmediate): void=} clearImmediate\n     * @property {function(number[]):number[]=} hrtime\n     * @property {NextTick=} nextTick\n     * @property {Performance=} performance\n     * @property {RequestAnimationFrame=} requestAnimationFrame\n     * @property {boolean=} queueMicrotask\n     * @property {function(number): void=} cancelAnimationFrame\n     * @property {RequestIdleCallback=} requestIdleCallback\n     * @property {function(number): void=} cancelIdleCallback\n     */\n\n    /** @type {Timers} */\n    const timers = {\n        setTimeout: _global.setTimeout,\n        clearTimeout: _global.clearTimeout,\n        setInterval: _global.setInterval,\n        clearInterval: _global.clearInterval,\n        Date: _global.Date,\n    };\n\n    if (isPresent.setImmediate) {\n        timers.setImmediate = _global.setImmediate;\n    }\n\n    if (isPresent.clearImmediate) {\n        timers.clearImmediate = _global.clearImmediate;\n    }\n\n    if (isPresent.hrtime) {\n        timers.hrtime = _global.process.hrtime;\n    }\n\n    if (isPresent.nextTick) {\n        timers.nextTick = _global.process.nextTick;\n    }\n\n    if (isPresent.performance) {\n        timers.performance = _global.performance;\n    }\n\n    if (isPresent.requestAnimationFrame) {\n        timers.requestAnimationFrame = _global.requestAnimationFrame;\n    }\n\n    if (isPresent.queueMicrotask) {\n        timers.queueMicrotask = _global.queueMicrotask;\n    }\n\n    if (isPresent.cancelAnimationFrame) {\n        timers.cancelAnimationFrame = _global.cancelAnimationFrame;\n    }\n\n    if (isPresent.requestIdleCallback) {\n        timers.requestIdleCallback = _global.requestIdleCallback;\n    }\n\n    if (isPresent.cancelIdleCallback) {\n        timers.cancelIdleCallback = _global.cancelIdleCallback;\n    }\n\n    if (isPresent.Intl) {\n        timers.Intl = NativeIntl;\n    }\n\n    const originalSetTimeout = _global.setImmediate || _global.setTimeout;\n    const originalClearInterval = _global.clearInterval;\n    const originalSetInterval = _global.setInterval;\n\n    /**\n     * @param {Date|number} [start] the system time - non-integer values are floored\n     * @param {number} [loopLimit] maximum number of timers that will be run when calling runAll()\n     * @returns {Clock}\n     */\n    function createClock(start, loopLimit) {\n        // eslint-disable-next-line no-param-reassign\n        start = Math.floor(getEpoch(start));\n        // eslint-disable-next-line no-param-reassign\n        loopLimit = loopLimit || 1000;\n        let nanos = 0;\n        const adjustedSystemTime = [0, 0]; // [millis, nanoremainder]\n\n        const clock = {\n            now: start,\n            Date: createDate(),\n            loopLimit: loopLimit,\n            tickMode: { mode: \"manual\", counter: 0, delta: undefined },\n        };\n\n        clock.Date.clock = clock;\n\n        //eslint-disable-next-line jsdoc/require-jsdoc\n        function getTimeToNextFrame() {\n            return 16 - ((clock.now - start) % 16);\n        }\n\n        //eslint-disable-next-line jsdoc/require-jsdoc\n        function hrtime(prev) {\n            const millisSinceStart = clock.now - adjustedSystemTime[0] - start;\n            const secsSinceStart = Math.floor(millisSinceStart / 1000);\n            const remainderInNanos =\n                (millisSinceStart - secsSinceStart * 1e3) * 1e6 +\n                nanos -\n                adjustedSystemTime[1];\n\n            if (Array.isArray(prev)) {\n                if (prev[1] > 1e9) {\n                    throw new TypeError(\n                        \"Number of nanoseconds can't exceed a billion\",\n                    );\n                }\n\n                const oldSecs = prev[0];\n                let nanoDiff = remainderInNanos - prev[1];\n                let secDiff = secsSinceStart - oldSecs;\n\n                if (nanoDiff < 0) {\n                    nanoDiff += 1e9;\n                    secDiff -= 1;\n                }\n\n                return [secDiff, nanoDiff];\n            }\n            return [secsSinceStart, remainderInNanos];\n        }\n\n        /**\n         * A high resolution timestamp in milliseconds.\n         * @typedef {number} DOMHighResTimeStamp\n         */\n\n        /**\n         * performance.now()\n         * @returns {DOMHighResTimeStamp}\n         */\n        function fakePerformanceNow() {\n            const hrt = hrtime();\n            const millis = hrt[0] * 1000 + hrt[1] / 1e6;\n            return millis;\n        }\n\n        if (isPresent.hrtimeBigint) {\n            hrtime.bigint = function () {\n                const parts = hrtime();\n                return BigInt(parts[0]) * BigInt(1e9) + BigInt(parts[1]); // eslint-disable-line\n            };\n        }\n\n        if (isPresent.Intl) {\n            clock.Intl = createIntl();\n            clock.Intl.clock = clock;\n        }\n\n        /**\n         * @param {TimerTickMode} tickModeConfig - The new configuration for how the clock should tick.\n         */\n        clock.setTickMode = function (tickModeConfig) {\n            const { mode: newMode, delta: newDelta } = tickModeConfig;\n            const { mode: oldMode, delta: oldDelta } = clock.tickMode;\n            if (newMode === oldMode && newDelta === oldDelta) {\n                return;\n            }\n\n            if (oldMode === \"interval\") {\n                originalClearInterval(clock.attachedInterval);\n            }\n\n            clock.tickMode = {\n                counter: clock.tickMode.counter + 1,\n                mode: newMode,\n                delta: newDelta,\n            };\n\n            if (newMode === \"nextAsync\") {\n                advanceUntilModeChanges();\n            } else if (newMode === \"interval\") {\n                createIntervalTick(clock, newDelta || 20);\n            }\n        };\n\n        async function advanceUntilModeChanges() {\n            async function newMacrotask() {\n                // MessageChannel ensures that setTimeout is not throttled to 4ms.\n                // https://developer.mozilla.org/en-US/docs/Web/API/setTimeout#reasons_for_delays_longer_than_specified\n                // https://stackblitz.com/edit/stackblitz-starters-qtlpcc\n                const channel = new MessageChannel();\n                await new Promise((resolve) => {\n                    channel.port1.onmessage = () => {\n                        resolve();\n                        channel.port1.close();\n                    };\n                    channel.port2.postMessage(undefined);\n                });\n                channel.port1.close();\n                channel.port2.close();\n                // setTimeout ensures microtask queue is emptied\n                await new Promise((resolve) => {\n                    originalSetTimeout(resolve);\n                });\n            }\n\n            const { counter } = clock.tickMode;\n            while (clock.tickMode.counter === counter) {\n                await newMacrotask();\n                if (clock.tickMode.counter !== counter) {\n                    return;\n                }\n                clock.next();\n            }\n        }\n\n        function pauseAutoTickUntilFinished(promise) {\n            if (clock.tickMode.mode !== \"nextAsync\") {\n                return promise;\n            }\n            clock.setTickMode({ mode: \"manual\" });\n            return promise.finally(() => {\n                clock.setTickMode({ mode: \"nextAsync\" });\n            });\n        }\n\n        clock.requestIdleCallback = function requestIdleCallback(\n            func,\n            timeout,\n        ) {\n            let timeToNextIdlePeriod = 0;\n\n            if (clock.countTimers() > 0) {\n                timeToNextIdlePeriod = 50; // const for now\n            }\n\n            const result = addTimer(clock, {\n                func: func,\n                args: Array.prototype.slice.call(arguments, 2),\n                delay:\n                    typeof timeout === \"undefined\"\n                        ? timeToNextIdlePeriod\n                        : Math.min(timeout, timeToNextIdlePeriod),\n                idleCallback: true,\n            });\n\n            return Number(result);\n        };\n\n        clock.cancelIdleCallback = function cancelIdleCallback(timerId) {\n            return clearTimer(clock, timerId, \"IdleCallback\");\n        };\n\n        clock.setTimeout = function setTimeout(func, timeout) {\n            return addTimer(clock, {\n                func: func,\n                args: Array.prototype.slice.call(arguments, 2),\n                delay: timeout,\n            });\n        };\n        if (typeof _global.Promise !== \"undefined\" && utilPromisify) {\n            clock.setTimeout[utilPromisify.custom] =\n                function promisifiedSetTimeout(timeout, arg) {\n                    return new _global.Promise(function setTimeoutExecutor(\n                        resolve,\n                    ) {\n                        addTimer(clock, {\n                            func: resolve,\n                            args: [arg],\n                            delay: timeout,\n                        });\n                    });\n                };\n        }\n\n        clock.clearTimeout = function clearTimeout(timerId) {\n            return clearTimer(clock, timerId, \"Timeout\");\n        };\n\n        clock.nextTick = function nextTick(func) {\n            return enqueueJob(clock, {\n                func: func,\n                args: Array.prototype.slice.call(arguments, 1),\n                error: isNearInfiniteLimit ? new Error() : null,\n            });\n        };\n\n        clock.queueMicrotask = function queueMicrotask(func) {\n            return clock.nextTick(func); // explicitly drop additional arguments\n        };\n\n        clock.setInterval = function setInterval(func, timeout) {\n            // eslint-disable-next-line no-param-reassign\n            timeout = parseInt(timeout, 10);\n            return addTimer(clock, {\n                func: func,\n                args: Array.prototype.slice.call(arguments, 2),\n                delay: timeout,\n                interval: timeout,\n            });\n        };\n\n        clock.clearInterval = function clearInterval(timerId) {\n            return clearTimer(clock, timerId, \"Interval\");\n        };\n\n        if (isPresent.setImmediate) {\n            clock.setImmediate = function setImmediate(func) {\n                return addTimer(clock, {\n                    func: func,\n                    args: Array.prototype.slice.call(arguments, 1),\n                    immediate: true,\n                });\n            };\n\n            if (typeof _global.Promise !== \"undefined\" && utilPromisify) {\n                clock.setImmediate[utilPromisify.custom] =\n                    function promisifiedSetImmediate(arg) {\n                        return new _global.Promise(\n                            function setImmediateExecutor(resolve) {\n                                addTimer(clock, {\n                                    func: resolve,\n                                    args: [arg],\n                                    immediate: true,\n                                });\n                            },\n                        );\n                    };\n            }\n\n            clock.clearImmediate = function clearImmediate(timerId) {\n                return clearTimer(clock, timerId, \"Immediate\");\n            };\n        }\n\n        clock.countTimers = function countTimers() {\n            return (\n                Object.keys(clock.timers || {}).length +\n                (clock.jobs || []).length\n            );\n        };\n\n        clock.requestAnimationFrame = function requestAnimationFrame(func) {\n            const result = addTimer(clock, {\n                func: func,\n                delay: getTimeToNextFrame(),\n                get args() {\n                    return [fakePerformanceNow()];\n                },\n                animation: true,\n            });\n\n            return Number(result);\n        };\n\n        clock.cancelAnimationFrame = function cancelAnimationFrame(timerId) {\n            return clearTimer(clock, timerId, \"AnimationFrame\");\n        };\n\n        clock.runMicrotasks = function runMicrotasks() {\n            runJobs(clock);\n        };\n\n        /**\n         * @param {number|string} tickValue milliseconds or a string parseable by parseTime\n         * @param {boolean} isAsync\n         * @param {Function} resolve\n         * @param {Function} reject\n         * @returns {number|undefined} will return the new `now` value or nothing for async\n         */\n        function doTick(tickValue, isAsync, resolve, reject) {\n            const msFloat =\n                typeof tickValue === \"number\"\n                    ? tickValue\n                    : parseTime(tickValue);\n            const ms = Math.floor(msFloat);\n            const remainder = nanoRemainder(msFloat);\n            let nanosTotal = nanos + remainder;\n            let tickTo = clock.now + ms;\n\n            if (msFloat < 0) {\n                throw new TypeError(\"Negative ticks are not supported\");\n            }\n\n            // adjust for positive overflow\n            if (nanosTotal >= 1e6) {\n                tickTo += 1;\n                nanosTotal -= 1e6;\n            }\n\n            nanos = nanosTotal;\n            let tickFrom = clock.now;\n            let previous = clock.now;\n            // ESLint fails to detect this correctly\n            /* eslint-disable prefer-const */\n            let timer,\n                firstException,\n                oldNow,\n                nextPromiseTick,\n                compensationCheck,\n                postTimerCall;\n            /* eslint-enable prefer-const */\n\n            clock.duringTick = true;\n\n            // perform microtasks\n            oldNow = clock.now;\n            runJobs(clock);\n            if (oldNow !== clock.now) {\n                // compensate for any setSystemTime() call during microtask callback\n                tickFrom += clock.now - oldNow;\n                tickTo += clock.now - oldNow;\n            }\n\n            //eslint-disable-next-line jsdoc/require-jsdoc\n            function doTickInner() {\n                // perform each timer in the requested range\n                timer = firstTimerInRange(clock, tickFrom, tickTo);\n                // eslint-disable-next-line no-unmodified-loop-condition\n                while (timer && tickFrom <= tickTo) {\n                    if (clock.timers[timer.id]) {\n                        tickFrom = timer.callAt;\n                        clock.now = timer.callAt;\n                        oldNow = clock.now;\n                        try {\n                            runJobs(clock);\n                            callTimer(clock, timer);\n                        } catch (e) {\n                            firstException = firstException || e;\n                        }\n\n                        if (isAsync) {\n                            // finish up after native setImmediate callback to allow\n                            // all native es6 promises to process their callbacks after\n                            // each timer fires.\n                            originalSetTimeout(nextPromiseTick);\n                            return;\n                        }\n\n                        compensationCheck();\n                    }\n\n                    postTimerCall();\n                }\n\n                // perform process.nextTick()s again\n                oldNow = clock.now;\n                runJobs(clock);\n                if (oldNow !== clock.now) {\n                    // compensate for any setSystemTime() call during process.nextTick() callback\n                    tickFrom += clock.now - oldNow;\n                    tickTo += clock.now - oldNow;\n                }\n                clock.duringTick = false;\n\n                // corner case: during runJobs new timers were scheduled which could be in the range [clock.now, tickTo]\n                timer = firstTimerInRange(clock, tickFrom, tickTo);\n                if (timer) {\n                    try {\n                        clock.tick(tickTo - clock.now); // do it all again - for the remainder of the requested range\n                    } catch (e) {\n                        firstException = firstException || e;\n                    }\n                } else {\n                    // no timers remaining in the requested range: move the clock all the way to the end\n                    clock.now = tickTo;\n\n                    // update nanos\n                    nanos = nanosTotal;\n                }\n                if (firstException) {\n                    throw firstException;\n                }\n\n                if (isAsync) {\n                    resolve(clock.now);\n                } else {\n                    return clock.now;\n                }\n            }\n\n            nextPromiseTick =\n                isAsync &&\n                function () {\n                    try {\n                        compensationCheck();\n                        postTimerCall();\n                        doTickInner();\n                    } catch (e) {\n                        reject(e);\n                    }\n                };\n\n            compensationCheck = function () {\n                // compensate for any setSystemTime() call during timer callback\n                if (oldNow !== clock.now) {\n                    tickFrom += clock.now - oldNow;\n                    tickTo += clock.now - oldNow;\n                    previous += clock.now - oldNow;\n                }\n            };\n\n            postTimerCall = function () {\n                timer = firstTimerInRange(clock, previous, tickTo);\n                previous = tickFrom;\n            };\n\n            return doTickInner();\n        }\n\n        /**\n         * @param {string|number} tickValue number of milliseconds or a human-readable value like \"01:11:15\"\n         * @returns {number} will return the new `now` value\n         */\n        clock.tick = function tick(tickValue) {\n            return doTick(tickValue, false);\n        };\n\n        if (typeof _global.Promise !== \"undefined\") {\n            /**\n             * @param {string|number} tickValue number of milliseconds or a human-readable value like \"01:11:15\"\n             * @returns {Promise}\n             */\n            clock.tickAsync = function tickAsync(tickValue) {\n                return pauseAutoTickUntilFinished(\n                    new _global.Promise(function (resolve, reject) {\n                        originalSetTimeout(function () {\n                            try {\n                                doTick(tickValue, true, resolve, reject);\n                            } catch (e) {\n                                reject(e);\n                            }\n                        });\n                    }),\n                );\n            };\n        }\n\n        clock.next = function next() {\n            runJobs(clock);\n            const timer = firstTimer(clock);\n            if (!timer) {\n                return clock.now;\n            }\n\n            clock.duringTick = true;\n            try {\n                clock.now = timer.callAt;\n                callTimer(clock, timer);\n                runJobs(clock);\n                return clock.now;\n            } finally {\n                clock.duringTick = false;\n            }\n        };\n\n        if (typeof _global.Promise !== \"undefined\") {\n            clock.nextAsync = function nextAsync() {\n                return pauseAutoTickUntilFinished(\n                    new _global.Promise(function (resolve, reject) {\n                        originalSetTimeout(function () {\n                            try {\n                                const timer = firstTimer(clock);\n                                if (!timer) {\n                                    resolve(clock.now);\n                                    return;\n                                }\n\n                                let err;\n                                clock.duringTick = true;\n                                clock.now = timer.callAt;\n                                try {\n                                    callTimer(clock, timer);\n                                } catch (e) {\n                                    err = e;\n                                }\n                                clock.duringTick = false;\n\n                                originalSetTimeout(function () {\n                                    if (err) {\n                                        reject(err);\n                                    } else {\n                                        resolve(clock.now);\n                                    }\n                                });\n                            } catch (e) {\n                                reject(e);\n                            }\n                        });\n                    }),\n                );\n            };\n        }\n\n        clock.runAll = function runAll() {\n            let numTimers, i;\n            runJobs(clock);\n            for (i = 0; i < clock.loopLimit; i++) {\n                if (!clock.timers) {\n                    resetIsNearInfiniteLimit();\n                    return clock.now;\n                }\n\n                numTimers = Object.keys(clock.timers).length;\n                if (numTimers === 0) {\n                    resetIsNearInfiniteLimit();\n                    return clock.now;\n                }\n\n                clock.next();\n                checkIsNearInfiniteLimit(clock, i);\n            }\n\n            const excessJob = firstTimer(clock);\n            throw getInfiniteLoopError(clock, excessJob);\n        };\n\n        clock.runToFrame = function runToFrame() {\n            return clock.tick(getTimeToNextFrame());\n        };\n\n        if (typeof _global.Promise !== \"undefined\") {\n            clock.runAllAsync = function runAllAsync() {\n                return pauseAutoTickUntilFinished(\n                    new _global.Promise(function (resolve, reject) {\n                        let i = 0;\n                        /**\n                         *\n                         */\n                        function doRun() {\n                            originalSetTimeout(function () {\n                                try {\n                                    runJobs(clock);\n\n                                    let numTimers;\n                                    if (i < clock.loopLimit) {\n                                        if (!clock.timers) {\n                                            resetIsNearInfiniteLimit();\n                                            resolve(clock.now);\n                                            return;\n                                        }\n\n                                        numTimers = Object.keys(\n                                            clock.timers,\n                                        ).length;\n                                        if (numTimers === 0) {\n                                            resetIsNearInfiniteLimit();\n                                            resolve(clock.now);\n                                            return;\n                                        }\n\n                                        clock.next();\n\n                                        i++;\n\n                                        doRun();\n                                        checkIsNearInfiniteLimit(clock, i);\n                                        return;\n                                    }\n\n                                    const excessJob = firstTimer(clock);\n                                    reject(\n                                        getInfiniteLoopError(clock, excessJob),\n                                    );\n                                } catch (e) {\n                                    reject(e);\n                                }\n                            });\n                        }\n                        doRun();\n                    }),\n                );\n            };\n        }\n\n        clock.runToLast = function runToLast() {\n            const timer = lastTimer(clock);\n            if (!timer) {\n                runJobs(clock);\n                return clock.now;\n            }\n\n            return clock.tick(timer.callAt - clock.now);\n        };\n\n        if (typeof _global.Promise !== \"undefined\") {\n            clock.runToLastAsync = function runToLastAsync() {\n                return pauseAutoTickUntilFinished(\n                    new _global.Promise(function (resolve, reject) {\n                        originalSetTimeout(function () {\n                            try {\n                                const timer = lastTimer(clock);\n                                if (!timer) {\n                                    runJobs(clock);\n                                    resolve(clock.now);\n                                }\n\n                                resolve(\n                                    clock.tickAsync(timer.callAt - clock.now),\n                                );\n                            } catch (e) {\n                                reject(e);\n                            }\n                        });\n                    }),\n                );\n            };\n        }\n\n        clock.reset = function reset() {\n            nanos = 0;\n            clock.timers = {};\n            clock.jobs = [];\n            clock.now = start;\n        };\n\n        clock.setSystemTime = function setSystemTime(systemTime) {\n            // determine time difference\n            const newNow = getEpoch(systemTime);\n            const difference = newNow - clock.now;\n            let id, timer;\n\n            adjustedSystemTime[0] = adjustedSystemTime[0] + difference;\n            adjustedSystemTime[1] = adjustedSystemTime[1] + nanos;\n            // update 'system clock'\n            clock.now = newNow;\n            nanos = 0;\n\n            // update timers and intervals to keep them stable\n            for (id in clock.timers) {\n                if (clock.timers.hasOwnProperty(id)) {\n                    timer = clock.timers[id];\n                    timer.createdAt += difference;\n                    timer.callAt += difference;\n                }\n            }\n        };\n\n        /**\n         * @param {string|number} tickValue number of milliseconds or a human-readable value like \"01:11:15\"\n         * @returns {number} will return the new `now` value\n         */\n        clock.jump = function jump(tickValue) {\n            const msFloat =\n                typeof tickValue === \"number\"\n                    ? tickValue\n                    : parseTime(tickValue);\n            const ms = Math.floor(msFloat);\n\n            for (const timer of Object.values(clock.timers)) {\n                if (clock.now + ms > timer.callAt) {\n                    timer.callAt = clock.now + ms;\n                }\n            }\n            clock.tick(ms);\n        };\n\n        if (isPresent.performance) {\n            clock.performance = Object.create(null);\n            clock.performance.now = fakePerformanceNow;\n        }\n\n        if (isPresent.hrtime) {\n            clock.hrtime = hrtime;\n        }\n\n        return clock;\n    }\n\n    function createIntervalTick(clock, delta) {\n        const intervalTick = doIntervalTick.bind(null, clock, delta);\n        const intervalId = originalSetInterval(intervalTick, delta);\n        clock.attachedInterval = intervalId;\n    }\n\n    /* eslint-disable complexity */\n\n    /**\n     * @param {Config=} [config] Optional config\n     * @returns {Clock}\n     */\n    function install(config) {\n        if (\n            arguments.length > 1 ||\n            config instanceof Date ||\n            Array.isArray(config) ||\n            typeof config === \"number\"\n        ) {\n            throw new TypeError(\n                `FakeTimers.install called with ${String(\n                    config,\n                )} install requires an object parameter`,\n            );\n        }\n\n        if (_global.Date.isFake === true) {\n            // Timers are already faked; this is a problem.\n            // Make the user reset timers before continuing.\n            throw new TypeError(\n                \"Can't install fake timers twice on the same global object.\",\n            );\n        }\n\n        // eslint-disable-next-line no-param-reassign\n        config = typeof config !== \"undefined\" ? config : {};\n        config.shouldAdvanceTime = config.shouldAdvanceTime || false;\n        config.advanceTimeDelta = config.advanceTimeDelta || 20;\n        config.shouldClearNativeTimers =\n            config.shouldClearNativeTimers || false;\n\n        if (config.target) {\n            throw new TypeError(\n                \"config.target is no longer supported. Use `withGlobal(target)` instead.\",\n            );\n        }\n\n        /**\n         * @param {string} timer/object the name of the thing that is not present\n         * @param timer\n         */\n        function handleMissingTimer(timer) {\n            if (config.ignoreMissingTimers) {\n                return;\n            }\n\n            throw new ReferenceError(\n                `non-existent timers and/or objects cannot be faked: '${timer}'`,\n            );\n        }\n\n        let i, l;\n        const clock = createClock(config.now, config.loopLimit);\n        clock.shouldClearNativeTimers = config.shouldClearNativeTimers;\n\n        clock.uninstall = function () {\n            return uninstall(clock);\n        };\n\n        clock.abortListenerMap = new Map();\n\n        clock.methods = config.toFake || [];\n\n        if (clock.methods.length === 0) {\n            clock.methods = Object.keys(timers);\n        }\n\n        if (config.shouldAdvanceTime === true) {\n            clock.setTickMode({\n                mode: \"interval\",\n                delta: config.advanceTimeDelta,\n            });\n        }\n\n        if (clock.methods.includes(\"performance\")) {\n            const proto = (() => {\n                if (hasPerformanceConstructorPrototype) {\n                    return _global.performance.constructor.prototype;\n                }\n                if (hasPerformancePrototype) {\n                    return _global.Performance.prototype;\n                }\n            })();\n            if (proto) {\n                Object.getOwnPropertyNames(proto).forEach(function (name) {\n                    if (name !== \"now\") {\n                        clock.performance[name] =\n                            name.indexOf(\"getEntries\") === 0\n                                ? NOOP_ARRAY\n                                : NOOP;\n                    }\n                });\n                // ensure `mark` returns a value that is valid\n                clock.performance.mark = (name) =>\n                    new FakePerformanceEntry(name, \"mark\", 0, 0);\n                clock.performance.measure = (name) =>\n                    new FakePerformanceEntry(name, \"measure\", 0, 100);\n                // `timeOrigin` should return the time of when the Window session started\n                // (or the Worker was installed)\n                clock.performance.timeOrigin = getEpoch(config.now);\n            } else if ((config.toFake || []).includes(\"performance\")) {\n                return handleMissingTimer(\"performance\");\n            }\n        }\n        if (_global === globalObject && timersModule) {\n            clock.timersModuleMethods = [];\n        }\n        if (_global === globalObject && timersPromisesModule) {\n            clock.timersPromisesModuleMethods = [];\n        }\n        for (i = 0, l = clock.methods.length; i < l; i++) {\n            const nameOfMethodToReplace = clock.methods[i];\n\n            if (!isPresent[nameOfMethodToReplace]) {\n                handleMissingTimer(nameOfMethodToReplace);\n                // eslint-disable-next-line\n                continue;\n            }\n\n            if (nameOfMethodToReplace === \"hrtime\") {\n                if (\n                    _global.process &&\n                    typeof _global.process.hrtime === \"function\"\n                ) {\n                    hijackMethod(_global.process, nameOfMethodToReplace, clock);\n                }\n            } else if (nameOfMethodToReplace === \"nextTick\") {\n                if (\n                    _global.process &&\n                    typeof _global.process.nextTick === \"function\"\n                ) {\n                    hijackMethod(_global.process, nameOfMethodToReplace, clock);\n                }\n            } else {\n                hijackMethod(_global, nameOfMethodToReplace, clock);\n            }\n            if (\n                clock.timersModuleMethods !== undefined &&\n                timersModule[nameOfMethodToReplace]\n            ) {\n                const original = timersModule[nameOfMethodToReplace];\n                clock.timersModuleMethods.push({\n                    methodName: nameOfMethodToReplace,\n                    original: original,\n                });\n                timersModule[nameOfMethodToReplace] =\n                    _global[nameOfMethodToReplace];\n            }\n            if (clock.timersPromisesModuleMethods !== undefined) {\n                if (nameOfMethodToReplace === \"setTimeout\") {\n                    clock.timersPromisesModuleMethods.push({\n                        methodName: \"setTimeout\",\n                        original: timersPromisesModule.setTimeout,\n                    });\n\n                    timersPromisesModule.setTimeout = (\n                        delay,\n                        value,\n                        options = {},\n                    ) =>\n                        new Promise((resolve, reject) => {\n                            const abort = () => {\n                                options.signal.removeEventListener(\n                                    \"abort\",\n                                    abort,\n                                );\n                                clock.abortListenerMap.delete(abort);\n\n                                // This is safe, there is no code path that leads to this function\n                                // being invoked before handle has been assigned.\n                                // eslint-disable-next-line no-use-before-define\n                                clock.clearTimeout(handle);\n                                reject(options.signal.reason);\n                            };\n\n                            const handle = clock.setTimeout(() => {\n                                if (options.signal) {\n                                    options.signal.removeEventListener(\n                                        \"abort\",\n                                        abort,\n                                    );\n                                    clock.abortListenerMap.delete(abort);\n                                }\n\n                                resolve(value);\n                            }, delay);\n\n                            if (options.signal) {\n                                if (options.signal.aborted) {\n                                    abort();\n                                } else {\n                                    options.signal.addEventListener(\n                                        \"abort\",\n                                        abort,\n                                    );\n                                    clock.abortListenerMap.set(\n                                        abort,\n                                        options.signal,\n                                    );\n                                }\n                            }\n                        });\n                } else if (nameOfMethodToReplace === \"setImmediate\") {\n                    clock.timersPromisesModuleMethods.push({\n                        methodName: \"setImmediate\",\n                        original: timersPromisesModule.setImmediate,\n                    });\n\n                    timersPromisesModule.setImmediate = (value, options = {}) =>\n                        new Promise((resolve, reject) => {\n                            const abort = () => {\n                                options.signal.removeEventListener(\n                                    \"abort\",\n                                    abort,\n                                );\n                                clock.abortListenerMap.delete(abort);\n\n                                // This is safe, there is no code path that leads to this function\n                                // being invoked before handle has been assigned.\n                                // eslint-disable-next-line no-use-before-define\n                                clock.clearImmediate(handle);\n                                reject(options.signal.reason);\n                            };\n\n                            const handle = clock.setImmediate(() => {\n                                if (options.signal) {\n                                    options.signal.removeEventListener(\n                                        \"abort\",\n                                        abort,\n                                    );\n                                    clock.abortListenerMap.delete(abort);\n                                }\n\n                                resolve(value);\n                            });\n\n                            if (options.signal) {\n                                if (options.signal.aborted) {\n                                    abort();\n                                } else {\n                                    options.signal.addEventListener(\n                                        \"abort\",\n                                        abort,\n                                    );\n                                    clock.abortListenerMap.set(\n                                        abort,\n                                        options.signal,\n                                    );\n                                }\n                            }\n                        });\n                } else if (nameOfMethodToReplace === \"setInterval\") {\n                    clock.timersPromisesModuleMethods.push({\n                        methodName: \"setInterval\",\n                        original: timersPromisesModule.setInterval,\n                    });\n\n                    timersPromisesModule.setInterval = (\n                        delay,\n                        value,\n                        options = {},\n                    ) => ({\n                        [Symbol.asyncIterator]: () => {\n                            const createResolvable = () => {\n                                let resolve, reject;\n                                const promise = new Promise((res, rej) => {\n                                    resolve = res;\n                                    reject = rej;\n                                });\n                                promise.resolve = resolve;\n                                promise.reject = reject;\n                                return promise;\n                            };\n\n                            let done = false;\n                            let hasThrown = false;\n                            let returnCall;\n                            let nextAvailable = 0;\n                            const nextQueue = [];\n\n                            const handle = clock.setInterval(() => {\n                                if (nextQueue.length > 0) {\n                                    nextQueue.shift().resolve();\n                                } else {\n                                    nextAvailable++;\n                                }\n                            }, delay);\n\n                            const abort = () => {\n                                options.signal.removeEventListener(\n                                    \"abort\",\n                                    abort,\n                                );\n                                clock.abortListenerMap.delete(abort);\n\n                                clock.clearInterval(handle);\n                                done = true;\n                                for (const resolvable of nextQueue) {\n                                    resolvable.resolve();\n                                }\n                            };\n\n                            if (options.signal) {\n                                if (options.signal.aborted) {\n                                    done = true;\n                                } else {\n                                    options.signal.addEventListener(\n                                        \"abort\",\n                                        abort,\n                                    );\n                                    clock.abortListenerMap.set(\n                                        abort,\n                                        options.signal,\n                                    );\n                                }\n                            }\n\n                            return {\n                                next: async () => {\n                                    if (options.signal?.aborted && !hasThrown) {\n                                        hasThrown = true;\n                                        throw options.signal.reason;\n                                    }\n\n                                    if (done) {\n                                        return { done: true, value: undefined };\n                                    }\n\n                                    if (nextAvailable > 0) {\n                                        nextAvailable--;\n                                        return { done: false, value: value };\n                                    }\n\n                                    const resolvable = createResolvable();\n                                    nextQueue.push(resolvable);\n\n                                    await resolvable;\n\n                                    if (returnCall && nextQueue.length === 0) {\n                                        returnCall.resolve();\n                                    }\n\n                                    if (options.signal?.aborted && !hasThrown) {\n                                        hasThrown = true;\n                                        throw options.signal.reason;\n                                    }\n\n                                    if (done) {\n                                        return { done: true, value: undefined };\n                                    }\n\n                                    return { done: false, value: value };\n                                },\n                                return: async () => {\n                                    if (done) {\n                                        return { done: true, value: undefined };\n                                    }\n\n                                    if (nextQueue.length > 0) {\n                                        returnCall = createResolvable();\n                                        await returnCall;\n                                    }\n\n                                    clock.clearInterval(handle);\n                                    done = true;\n\n                                    if (options.signal) {\n                                        options.signal.removeEventListener(\n                                            \"abort\",\n                                            abort,\n                                        );\n                                        clock.abortListenerMap.delete(abort);\n                                    }\n\n                                    return { done: true, value: undefined };\n                                },\n                            };\n                        },\n                    });\n                }\n            }\n        }\n\n        return clock;\n    }\n\n    /* eslint-enable complexity */\n\n    return {\n        timers: timers,\n        createClock: createClock,\n        install: install,\n        withGlobal: withGlobal,\n    };\n}\n\n/**\n * @typedef {object} FakeTimers\n * @property {Timers} timers\n * @property {createClock} createClock\n * @property {Function} install\n * @property {withGlobal} withGlobal\n */\n\n/* eslint-enable complexity */\n\n/** @type {FakeTimers} */\nconst defaultImplementation = withGlobal(globalObject);\n\nexports.timers = defaultImplementation.timers;\nexports.createClock = defaultImplementation.createClock;\nexports.install = defaultImplementation.install;\nexports.withGlobal = withGlobal;\n","\"use strict\";\n\nconst extend = require(\"./core/extend\");\nconst FakeTimers = require(\"@sinonjs/fake-timers\");\nconst globalObject = require(\"@sinonjs/commons\").global;\n\n/**\n *\n * @param config\n * @param globalCtx\n *\n * @returns {object} the clock, after installing it on the global context, if given\n */\nfunction createClock(config, globalCtx) {\n    let FakeTimersCtx = FakeTimers;\n    if (globalCtx !== null && typeof globalCtx === \"object\") {\n        FakeTimersCtx = FakeTimers.withGlobal(globalCtx);\n    }\n    const clock = FakeTimersCtx.install(config);\n    clock.restore = clock.uninstall;\n    return clock;\n}\n\n/**\n *\n * @param obj\n * @param globalPropName\n */\nfunction addIfDefined(obj, globalPropName) {\n    const globalProp = globalObject[globalPropName];\n    if (typeof globalProp !== \"undefined\") {\n        obj[globalPropName] = globalProp;\n    }\n}\n\n/**\n * @param {number|Date|object} dateOrConfig The unix epoch value to install with (default 0)\n * @returns {object} Returns a lolex clock instance\n */\nexports.useFakeTimers = function (dateOrConfig) {\n    const hasArguments = typeof dateOrConfig !== \"undefined\";\n    const argumentIsDateLike =\n        (typeof dateOrConfig === \"number\" || dateOrConfig instanceof Date) &&\n        arguments.length === 1;\n    const argumentIsObject =\n        dateOrConfig !== null &&\n        typeof dateOrConfig === \"object\" &&\n        arguments.length === 1;\n\n    if (!hasArguments) {\n        return createClock({\n            now: 0,\n        });\n    }\n\n    if (argumentIsDateLike) {\n        return createClock({\n            now: dateOrConfig,\n        });\n    }\n\n    if (argumentIsObject) {\n        const config = extend.nonEnum({}, dateOrConfig);\n        const globalCtx = config.global;\n        delete config.global;\n        return createClock(config, globalCtx);\n    }\n\n    throw new TypeError(\n        \"useFakeTimers expected epoch or config object. See https://github.com/sinonjs/sinon\",\n    );\n};\n\nexports.clock = {\n    create: function (now) {\n        return FakeTimers.createClock(now);\n    },\n};\n\nconst timers = {\n    setTimeout: setTimeout,\n    clearTimeout: clearTimeout,\n    setInterval: setInterval,\n    clearInterval: clearInterval,\n    Date: Date,\n};\naddIfDefined(timers, \"setImmediate\");\naddIfDefined(timers, \"clearImmediate\");\n\nexports.timers = timers;\n","\"use strict\";\n\nconst push = require(\"@sinonjs/commons\").prototypes.array.push;\n\nexports.incrementCallCount = function incrementCallCount(proxy) {\n    proxy.called = true;\n    proxy.callCount += 1;\n    proxy.notCalled = false;\n    proxy.calledOnce = proxy.callCount === 1;\n    proxy.calledTwice = proxy.callCount === 2;\n    proxy.calledThrice = proxy.callCount === 3;\n};\n\nexports.createCallProperties = function createCallProperties(proxy) {\n    proxy.firstCall = proxy.getCall(0);\n    proxy.secondCall = proxy.getCall(1);\n    proxy.thirdCall = proxy.getCall(2);\n    proxy.lastCall = proxy.getCall(proxy.callCount - 1);\n};\n\nexports.delegateToCalls = function delegateToCalls(\n    proxy,\n    method,\n    matchAny,\n    actual,\n    returnsValues,\n    notCalled,\n    totalCallCount,\n) {\n    proxy[method] = function () {\n        if (!this.called) {\n            if (notCalled) {\n                return notCalled.apply(this, arguments);\n            }\n            return false;\n        }\n\n        if (totalCallCount !== undefined && this.callCount !== totalCallCount) {\n            return false;\n        }\n\n        let currentCall;\n        let matches = 0;\n        const returnValues = [];\n\n        for (let i = 0, l = this.callCount; i < l; i += 1) {\n            currentCall = this.getCall(i);\n            const returnValue = currentCall[actual || method].apply(\n                currentCall,\n                arguments,\n            );\n            push(returnValues, returnValue);\n            if (returnValue) {\n                matches += 1;\n\n                if (matchAny) {\n                    return true;\n                }\n            }\n        }\n\n        if (returnsValues) {\n            return returnValues;\n        }\n        return matches === this.callCount;\n    };\n};\n","\"use strict\";\n\nconst arrayProto = require(\"@sinonjs/commons\").prototypes.array;\nconst proxyCallUtil = require(\"./proxy-call-util\");\n\nconst push = arrayProto.push;\nconst forEach = arrayProto.forEach;\nconst concat = arrayProto.concat;\nconst ErrorConstructor = Error.prototype.constructor;\nconst bind = Function.prototype.bind;\n\nlet callId = 0;\n\nmodule.exports = function invoke(func, thisValue, args) {\n    const matchings = this.matchingFakes(args);\n    const currentCallId = callId++;\n    let exception, returnValue;\n\n    proxyCallUtil.incrementCallCount(this);\n    push(this.thisValues, thisValue);\n    push(this.args, args);\n    push(this.callIds, currentCallId);\n    forEach(matchings, function (matching) {\n        proxyCallUtil.incrementCallCount(matching);\n        push(matching.thisValues, thisValue);\n        push(matching.args, args);\n        push(matching.callIds, currentCallId);\n    });\n\n    // Make call properties available from within the spied function:\n    proxyCallUtil.createCallProperties(this);\n    forEach(matchings, proxyCallUtil.createCallProperties);\n\n    try {\n        this.invoking = true;\n\n        const thisCall = this.getCall(this.callCount - 1);\n\n        if (thisCall.calledWithNew()) {\n            // Call through with `new`\n            returnValue = new (bind.apply(\n                this.func || func,\n                concat([thisValue], args),\n            ))();\n\n            if (\n                typeof returnValue !== \"object\" &&\n                typeof returnValue !== \"function\"\n            ) {\n                returnValue = thisValue;\n            }\n        } else {\n            returnValue = (this.func || func).apply(thisValue, args);\n        }\n    } catch (e) {\n        exception = e;\n    } finally {\n        delete this.invoking;\n    }\n\n    push(this.exceptions, exception);\n    push(this.returnValues, returnValue);\n    forEach(matchings, function (matching) {\n        push(matching.exceptions, exception);\n        push(matching.returnValues, returnValue);\n    });\n\n    const err = new ErrorConstructor();\n    // 1. Please do not get stack at this point. It may be so very slow, and not actually used\n    // 2. PhantomJS does not serialize the stack trace until the error has been thrown:\n    // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Error/Stack\n    try {\n        throw err;\n    } catch (e) {\n        /* empty */\n    }\n    push(this.errorsWithCallStack, err);\n    forEach(matchings, function (matching) {\n        push(matching.errorsWithCallStack, err);\n    });\n\n    // Make return value and exception available in the calls:\n    proxyCallUtil.createCallProperties(this);\n    forEach(matchings, proxyCallUtil.createCallProperties);\n\n    if (exception !== undefined) {\n        throw exception;\n    }\n\n    return returnValue;\n};\n","\"use strict\";\n\nconst arrayProto = require(\"@sinonjs/commons\").prototypes.array;\nconst match = require(\"@sinonjs/samsam\").createMatcher;\nconst deepEqual = require(\"@sinonjs/samsam\").deepEqual;\nconst functionName = require(\"@sinonjs/commons\").functionName;\nconst inspect = require(\"util\").inspect;\nconst valueToString = require(\"@sinonjs/commons\").valueToString;\n\nconst concat = arrayProto.concat;\nconst filter = arrayProto.filter;\nconst join = arrayProto.join;\nconst map = arrayProto.map;\nconst reduce = arrayProto.reduce;\nconst slice = arrayProto.slice;\n\n/**\n * @param proxy\n * @param text\n * @param args\n */\nfunction throwYieldError(proxy, text, args) {\n    let msg = functionName(proxy) + text;\n    if (args.length) {\n        msg += ` Received [${join(slice(args), \", \")}]`;\n    }\n    throw new Error(msg);\n}\n\nconst callProto = {\n    calledOn: function calledOn(thisValue) {\n        if (match.isMatcher(thisValue)) {\n            return thisValue.test(this.thisValue);\n        }\n        return this.thisValue === thisValue;\n    },\n\n    calledWith: function calledWith() {\n        const self = this;\n        const calledWithArgs = slice(arguments);\n\n        if (calledWithArgs.length > self.args.length) {\n            return false;\n        }\n\n        return reduce(\n            calledWithArgs,\n            function (prev, arg, i) {\n                return prev && deepEqual(self.args[i], arg);\n            },\n            true,\n        );\n    },\n\n    calledWithMatch: function calledWithMatch() {\n        const self = this;\n        const calledWithMatchArgs = slice(arguments);\n\n        if (calledWithMatchArgs.length > self.args.length) {\n            return false;\n        }\n\n        return reduce(\n            calledWithMatchArgs,\n            function (prev, expectation, i) {\n                const actual = self.args[i];\n\n                return prev && match(expectation).test(actual);\n            },\n            true,\n        );\n    },\n\n    calledWithExactly: function calledWithExactly() {\n        return (\n            arguments.length === this.args.length &&\n            this.calledWith.apply(this, arguments)\n        );\n    },\n\n    notCalledWith: function notCalledWith() {\n        return !this.calledWith.apply(this, arguments);\n    },\n\n    notCalledWithMatch: function notCalledWithMatch() {\n        return !this.calledWithMatch.apply(this, arguments);\n    },\n\n    returned: function returned(value) {\n        return deepEqual(this.returnValue, value);\n    },\n\n    threw: function threw(error) {\n        if (typeof error === \"undefined\" || !this.exception) {\n            return Boolean(this.exception);\n        }\n\n        return this.exception === error || this.exception.name === error;\n    },\n\n    calledWithNew: function calledWithNew() {\n        return this.proxy.prototype && this.thisValue instanceof this.proxy;\n    },\n\n    calledBefore: function (other) {\n        return this.callId < other.callId;\n    },\n\n    calledAfter: function (other) {\n        return this.callId > other.callId;\n    },\n\n    calledImmediatelyBefore: function (other) {\n        return this.callId === other.callId - 1;\n    },\n\n    calledImmediatelyAfter: function (other) {\n        return this.callId === other.callId + 1;\n    },\n\n    callArg: function (pos) {\n        this.ensureArgIsAFunction(pos);\n        return this.args[pos]();\n    },\n\n    callArgOn: function (pos, thisValue) {\n        this.ensureArgIsAFunction(pos);\n        return this.args[pos].apply(thisValue);\n    },\n\n    callArgWith: function (pos) {\n        return this.callArgOnWith.apply(\n            this,\n            concat([pos, null], slice(arguments, 1)),\n        );\n    },\n\n    callArgOnWith: function (pos, thisValue) {\n        this.ensureArgIsAFunction(pos);\n        const args = slice(arguments, 2);\n        return this.args[pos].apply(thisValue, args);\n    },\n\n    throwArg: function (pos) {\n        if (pos > this.args.length) {\n            throw new TypeError(\n                `Not enough arguments: ${pos} required but only ${this.args.length} present`,\n            );\n        }\n\n        throw this.args[pos];\n    },\n\n    yield: function () {\n        return this.yieldOn.apply(this, concat([null], slice(arguments, 0)));\n    },\n\n    yieldOn: function (thisValue) {\n        const args = slice(this.args);\n        const yieldFn = filter(args, function (arg) {\n            return typeof arg === \"function\";\n        })[0];\n\n        if (!yieldFn) {\n            throwYieldError(\n                this.proxy,\n                \" cannot yield since no callback was passed.\",\n                args,\n            );\n        }\n\n        return yieldFn.apply(thisValue, slice(arguments, 1));\n    },\n\n    yieldTo: function (prop) {\n        return this.yieldToOn.apply(\n            this,\n            concat([prop, null], slice(arguments, 1)),\n        );\n    },\n\n    yieldToOn: function (prop, thisValue) {\n        const args = slice(this.args);\n        const yieldArg = filter(args, function (arg) {\n            return arg && typeof arg[prop] === \"function\";\n        })[0];\n        const yieldFn = yieldArg && yieldArg[prop];\n\n        if (!yieldFn) {\n            throwYieldError(\n                this.proxy,\n                ` cannot yield to '${valueToString(\n                    prop,\n                )}' since no callback was passed.`,\n                args,\n            );\n        }\n\n        return yieldFn.apply(thisValue, slice(arguments, 2));\n    },\n\n    toString: function () {\n        if (!this.args) {\n            return \":(\";\n        }\n\n        let callStr = this.proxy ? `${String(this.proxy)}(` : \"\";\n        const formattedArgs = map(this.args, function (arg) {\n            return inspect(arg);\n        });\n\n        callStr = `${callStr + join(formattedArgs, \", \")})`;\n\n        if (typeof this.returnValue !== \"undefined\") {\n            callStr += ` => ${inspect(this.returnValue)}`;\n        }\n\n        if (this.exception) {\n            callStr += ` !${this.exception.name}`;\n\n            if (this.exception.message) {\n                callStr += `(${this.exception.message})`;\n            }\n        }\n        if (this.stack) {\n            // If we have a stack, add the first frame that's in end-user code\n            // Skip the first two frames because they will refer to Sinon code\n            callStr += (this.stack.split(\"\\n\")[3] || \"unknown\").replace(\n                /^\\s*(?:at\\s+|@)?/,\n                \" at \",\n            );\n        }\n\n        return callStr;\n    },\n\n    ensureArgIsAFunction: function (pos) {\n        if (typeof this.args[pos] !== \"function\") {\n            throw new TypeError(\n                `Expected argument at position ${pos} to be a Function, but was ${typeof this\n                    .args[pos]}`,\n            );\n        }\n    },\n};\nObject.defineProperty(callProto, \"stack\", {\n    enumerable: true,\n    configurable: true,\n    get: function () {\n        return (this.errorWithCallStack && this.errorWithCallStack.stack) || \"\";\n    },\n});\n\ncallProto.invokeCallback = callProto.yield;\n\n/**\n * @param proxy\n * @param thisValue\n * @param args\n * @param returnValue\n * @param exception\n * @param id\n * @param errorWithCallStack\n *\n * @returns {object} proxyCall\n */\nfunction createProxyCall(\n    proxy,\n    thisValue,\n    args,\n    returnValue,\n    exception,\n    id,\n    errorWithCallStack,\n) {\n    if (typeof id !== \"number\") {\n        throw new TypeError(\"Call id is not a number\");\n    }\n\n    let firstArg, lastArg;\n\n    if (args.length > 0) {\n        firstArg = args[0];\n        lastArg = args[args.length - 1];\n    }\n\n    const proxyCall = Object.create(callProto);\n    const callback =\n        lastArg && typeof lastArg === \"function\" ? lastArg : undefined;\n\n    proxyCall.proxy = proxy;\n    proxyCall.thisValue = thisValue;\n    proxyCall.args = args;\n    proxyCall.firstArg = firstArg;\n    proxyCall.lastArg = lastArg;\n    proxyCall.callback = callback;\n    proxyCall.returnValue = returnValue;\n    proxyCall.exception = exception;\n    proxyCall.callId = id;\n    proxyCall.errorWithCallStack = errorWithCallStack;\n\n    return proxyCall;\n}\ncreateProxyCall.toString = callProto.toString; // used by mocks\n\nmodule.exports = createProxyCall;\n","\"use strict\";\n\nconst arrayProto = require(\"@sinonjs/commons\").prototypes.array;\nconst isPropertyConfigurable = require(\"./util/core/is-property-configurable\");\nconst exportAsyncBehaviors = require(\"./util/core/export-async-behaviors\");\nconst extend = require(\"./util/core/extend\");\n\nconst slice = arrayProto.slice;\n\nconst useLeftMostCallback = -1;\nconst useRightMostCallback = -2;\n\nfunction throwsException(fake, error, message) {\n    if (typeof error === \"function\") {\n        fake.exceptionCreator = error;\n    } else if (typeof error === \"string\") {\n        fake.exceptionCreator = function () {\n            const newException = new Error(\n                message || `Sinon-provided ${error}`,\n            );\n            newException.name = error;\n            return newException;\n        };\n    } else if (!error) {\n        fake.exceptionCreator = function () {\n            return new Error(\"Error\");\n        };\n    } else {\n        fake.exception = error;\n    }\n}\n\nconst defaultBehaviors = {\n    callsFake: function callsFake(fake, fn) {\n        fake.fakeFn = fn;\n        fake.exception = undefined;\n        fake.exceptionCreator = undefined;\n        fake.callsThrough = false;\n    },\n\n    callsArg: function callsArg(fake, index) {\n        if (typeof index !== \"number\") {\n            throw new TypeError(\"argument index is not number\");\n        }\n\n        fake.callArgAt = index;\n        fake.callbackArguments = [];\n        fake.callbackContext = undefined;\n        fake.callArgProp = undefined;\n        fake.callbackAsync = false;\n        fake.callsThrough = false;\n    },\n\n    callsArgOn: function callsArgOn(fake, index, context) {\n        if (typeof index !== \"number\") {\n            throw new TypeError(\"argument index is not number\");\n        }\n\n        fake.callArgAt = index;\n        fake.callbackArguments = [];\n        fake.callbackContext = context;\n        fake.callArgProp = undefined;\n        fake.callbackAsync = false;\n        fake.callsThrough = false;\n    },\n\n    callsArgWith: function callsArgWith(fake, index) {\n        if (typeof index !== \"number\") {\n            throw new TypeError(\"argument index is not number\");\n        }\n\n        fake.callArgAt = index;\n        fake.callbackArguments = slice(arguments, 2);\n        fake.callbackContext = undefined;\n        fake.callArgProp = undefined;\n        fake.callbackAsync = false;\n        fake.callsThrough = false;\n    },\n\n    callsArgOnWith: function callsArgWith(fake, index, context) {\n        if (typeof index !== \"number\") {\n            throw new TypeError(\"argument index is not number\");\n        }\n\n        fake.callArgAt = index;\n        fake.callbackArguments = slice(arguments, 3);\n        fake.callbackContext = context;\n        fake.callArgProp = undefined;\n        fake.callbackAsync = false;\n        fake.callsThrough = false;\n    },\n\n    yields: function (fake) {\n        fake.callArgAt = useLeftMostCallback;\n        fake.callbackArguments = slice(arguments, 1);\n        fake.callbackContext = undefined;\n        fake.callArgProp = undefined;\n        fake.callbackAsync = false;\n        fake.fakeFn = undefined;\n        fake.callsThrough = false;\n    },\n\n    yieldsRight: function (fake) {\n        fake.callArgAt = useRightMostCallback;\n        fake.callbackArguments = slice(arguments, 1);\n        fake.callbackContext = undefined;\n        fake.callArgProp = undefined;\n        fake.callbackAsync = false;\n        fake.callsThrough = false;\n        fake.fakeFn = undefined;\n    },\n\n    yieldsOn: function (fake, context) {\n        fake.callArgAt = useLeftMostCallback;\n        fake.callbackArguments = slice(arguments, 2);\n        fake.callbackContext = context;\n        fake.callArgProp = undefined;\n        fake.callbackAsync = false;\n        fake.callsThrough = false;\n        fake.fakeFn = undefined;\n    },\n\n    yieldsTo: function (fake, prop) {\n        fake.callArgAt = useLeftMostCallback;\n        fake.callbackArguments = slice(arguments, 2);\n        fake.callbackContext = undefined;\n        fake.callArgProp = prop;\n        fake.callbackAsync = false;\n        fake.callsThrough = false;\n        fake.fakeFn = undefined;\n    },\n\n    yieldsToOn: function (fake, prop, context) {\n        fake.callArgAt = useLeftMostCallback;\n        fake.callbackArguments = slice(arguments, 3);\n        fake.callbackContext = context;\n        fake.callArgProp = prop;\n        fake.callbackAsync = false;\n        fake.fakeFn = undefined;\n    },\n\n    throws: throwsException,\n    throwsException: throwsException,\n\n    returns: function returns(fake, value) {\n        fake.callsThrough = false;\n        fake.returnValue = value;\n        fake.resolve = false;\n        fake.reject = false;\n        fake.returnValueDefined = true;\n        fake.exception = undefined;\n        fake.exceptionCreator = undefined;\n        fake.fakeFn = undefined;\n    },\n\n    returnsArg: function returnsArg(fake, index) {\n        if (typeof index !== \"number\") {\n            throw new TypeError(\"argument index is not number\");\n        }\n        fake.callsThrough = false;\n\n        fake.returnArgAt = index;\n    },\n\n    throwsArg: function throwsArg(fake, index) {\n        if (typeof index !== \"number\") {\n            throw new TypeError(\"argument index is not number\");\n        }\n        fake.callsThrough = false;\n\n        fake.throwArgAt = index;\n    },\n\n    returnsThis: function returnsThis(fake) {\n        fake.returnThis = true;\n        fake.callsThrough = false;\n    },\n\n    resolves: function resolves(fake, value) {\n        fake.returnValue = value;\n        fake.resolve = true;\n        fake.resolveThis = false;\n        fake.reject = false;\n        fake.returnValueDefined = true;\n        fake.exception = undefined;\n        fake.exceptionCreator = undefined;\n        fake.fakeFn = undefined;\n        fake.callsThrough = false;\n    },\n\n    resolvesArg: function resolvesArg(fake, index) {\n        if (typeof index !== \"number\") {\n            throw new TypeError(\"argument index is not number\");\n        }\n        fake.resolveArgAt = index;\n        fake.returnValue = undefined;\n        fake.resolve = true;\n        fake.resolveThis = false;\n        fake.reject = false;\n        fake.returnValueDefined = false;\n        fake.exception = undefined;\n        fake.exceptionCreator = undefined;\n        fake.fakeFn = undefined;\n        fake.callsThrough = false;\n    },\n\n    rejects: function rejects(fake, error, message) {\n        let reason;\n        if (typeof error === \"string\") {\n            reason = new Error(message || \"\");\n            reason.name = error;\n        } else if (!error) {\n            reason = new Error(\"Error\");\n        } else {\n            reason = error;\n        }\n        fake.returnValue = reason;\n        fake.resolve = false;\n        fake.resolveThis = false;\n        fake.reject = true;\n        fake.returnValueDefined = true;\n        fake.exception = undefined;\n        fake.exceptionCreator = undefined;\n        fake.fakeFn = undefined;\n        fake.callsThrough = false;\n\n        return fake;\n    },\n\n    resolvesThis: function resolvesThis(fake) {\n        fake.returnValue = undefined;\n        fake.resolve = false;\n        fake.resolveThis = true;\n        fake.reject = false;\n        fake.returnValueDefined = false;\n        fake.exception = undefined;\n        fake.exceptionCreator = undefined;\n        fake.fakeFn = undefined;\n        fake.callsThrough = false;\n    },\n\n    callThrough: function callThrough(fake) {\n        fake.callsThrough = true;\n    },\n\n    callThroughWithNew: function callThroughWithNew(fake) {\n        fake.callsThroughWithNew = true;\n    },\n\n    get: function get(fake, getterFunction) {\n        const rootStub = fake.stub || fake;\n\n        Object.defineProperty(rootStub.rootObj, rootStub.propName, {\n            get: getterFunction,\n            configurable: isPropertyConfigurable(\n                rootStub.rootObj,\n                rootStub.propName,\n            ),\n        });\n\n        return fake;\n    },\n\n    set: function set(fake, setterFunction) {\n        const rootStub = fake.stub || fake;\n\n        Object.defineProperty(\n            rootStub.rootObj,\n            rootStub.propName,\n            // eslint-disable-next-line accessor-pairs\n            {\n                set: setterFunction,\n                configurable: isPropertyConfigurable(\n                    rootStub.rootObj,\n                    rootStub.propName,\n                ),\n            },\n        );\n\n        return fake;\n    },\n\n    value: function value(fake, newVal) {\n        const rootStub = fake.stub || fake;\n\n        Object.defineProperty(rootStub.rootObj, rootStub.propName, {\n            value: newVal,\n            enumerable: true,\n            writable: true,\n            configurable:\n                rootStub.shadowsPropOnPrototype ||\n                isPropertyConfigurable(rootStub.rootObj, rootStub.propName),\n        });\n\n        return fake;\n    },\n};\n\nconst asyncBehaviors = exportAsyncBehaviors(defaultBehaviors);\n\nmodule.exports = extend({}, defaultBehaviors, asyncBehaviors);\n","\"use strict\";\n\nmodule.exports = function toString() {\n    let i, prop, thisValue;\n    if (this.getCall && this.callCount) {\n        i = this.callCount;\n\n        while (i--) {\n            thisValue = this.getCall(i).thisValue;\n\n            // eslint-disable-next-line guard-for-in\n            for (prop in thisValue) {\n                try {\n                    if (thisValue[prop] === this) {\n                        return prop;\n                    }\n                } catch (e) {\n                    // no-op - accessing props can throw an error, nothing to do here\n                }\n            }\n        }\n    }\n\n    return this.displayName || \"sinon fake\";\n};\n","'use strict';\nmodule.exports = {\n\tstdout: false,\n\tstderr: false\n};\n","\"use strict\";\n\nmodule.exports = class Colorizer {\n    constructor(supportsColor = require(\"supports-color\")) {\n        this.supportsColor = supportsColor;\n    }\n\n    /**\n     * Should be renamed to true #privateField\n     * when we can ensure ES2022 support\n     *\n     * @private\n     */\n    colorize(str, color) {\n        if (this.supportsColor.stdout === false) {\n            return str;\n        }\n\n        return `\\x1b[${color}m${str}\\x1b[0m`;\n    }\n\n    red(str) {\n        return this.colorize(str, 31);\n    }\n\n    green(str) {\n        return this.colorize(str, 32);\n    }\n\n    cyan(str) {\n        return this.colorize(str, 96);\n    }\n\n    white(str) {\n        return this.colorize(str, 39);\n    }\n\n    bold(str) {\n        return this.colorize(str, 1);\n    }\n};\n","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nvar Diff = /** @class */ (function () {\n    function Diff() {\n    }\n    Diff.prototype.diff = function (oldStr, newStr, \n    // Type below is not accurate/complete - see above for full possibilities - but it compiles\n    options) {\n        if (options === void 0) { options = {}; }\n        var callback;\n        if (typeof options === 'function') {\n            callback = options;\n            options = {};\n        }\n        else if ('callback' in options) {\n            callback = options.callback;\n        }\n        // Allow subclasses to massage the input prior to running\n        var oldString = this.castInput(oldStr, options);\n        var newString = this.castInput(newStr, options);\n        var oldTokens = this.removeEmpty(this.tokenize(oldString, options));\n        var newTokens = this.removeEmpty(this.tokenize(newString, options));\n        return this.diffWithOptionsObj(oldTokens, newTokens, options, callback);\n    };\n    Diff.prototype.diffWithOptionsObj = function (oldTokens, newTokens, options, callback) {\n        var _this = this;\n        var _a;\n        var done = function (value) {\n            value = _this.postProcess(value, options);\n            if (callback) {\n                setTimeout(function () { callback(value); }, 0);\n                return undefined;\n            }\n            else {\n                return value;\n            }\n        };\n        var newLen = newTokens.length, oldLen = oldTokens.length;\n        var editLength = 1;\n        var maxEditLength = newLen + oldLen;\n        if (options.maxEditLength != null) {\n            maxEditLength = Math.min(maxEditLength, options.maxEditLength);\n        }\n        var maxExecutionTime = (_a = options.timeout) !== null && _a !== void 0 ? _a : Infinity;\n        var abortAfterTimestamp = Date.now() + maxExecutionTime;\n        var bestPath = [{ oldPos: -1, lastComponent: undefined }];\n        // Seed editLength = 0, i.e. the content starts with the same values\n        var newPos = this.extractCommon(bestPath[0], newTokens, oldTokens, 0, options);\n        if (bestPath[0].oldPos + 1 >= oldLen && newPos + 1 >= newLen) {\n            // Identity per the equality and tokenizer\n            return done(this.buildValues(bestPath[0].lastComponent, newTokens, oldTokens));\n        }\n        // Once we hit the right edge of the edit graph on some diagonal k, we can\n        // definitely reach the end of the edit graph in no more than k edits, so\n        // there's no point in considering any moves to diagonal k+1 any more (from\n        // which we're guaranteed to need at least k+1 more edits).\n        // Similarly, once we've reached the bottom of the edit graph, there's no\n        // point considering moves to lower diagonals.\n        // We record this fact by setting minDiagonalToConsider and\n        // maxDiagonalToConsider to some finite value once we've hit the edge of\n        // the edit graph.\n        // This optimization is not faithful to the original algorithm presented in\n        // Myers's paper, which instead pointlessly extends D-paths off the end of\n        // the edit graph - see page 7 of Myers's paper which notes this point\n        // explicitly and illustrates it with a diagram. This has major performance\n        // implications for some common scenarios. For instance, to compute a diff\n        // where the new text simply appends d characters on the end of the\n        // original text of length n, the true Myers algorithm will take O(n+d^2)\n        // time while this optimization needs only O(n+d) time.\n        var minDiagonalToConsider = -Infinity, maxDiagonalToConsider = Infinity;\n        // Main worker method. checks all permutations of a given edit length for acceptance.\n        var execEditLength = function () {\n            for (var diagonalPath = Math.max(minDiagonalToConsider, -editLength); diagonalPath <= Math.min(maxDiagonalToConsider, editLength); diagonalPath += 2) {\n                var basePath = void 0;\n                var removePath = bestPath[diagonalPath - 1], addPath = bestPath[diagonalPath + 1];\n                if (removePath) {\n                    // No one else is going to attempt to use this value, clear it\n                    // @ts-expect-error - perf optimisation. This type-violating value will never be read.\n                    bestPath[diagonalPath - 1] = undefined;\n                }\n                var canAdd = false;\n                if (addPath) {\n                    // what newPos will be after we do an insertion:\n                    var addPathNewPos = addPath.oldPos - diagonalPath;\n                    canAdd = addPath && 0 <= addPathNewPos && addPathNewPos < newLen;\n                }\n                var canRemove = removePath && removePath.oldPos + 1 < oldLen;\n                if (!canAdd && !canRemove) {\n                    // If this path is a terminal then prune\n                    // @ts-expect-error - perf optimisation. This type-violating value will never be read.\n                    bestPath[diagonalPath] = undefined;\n                    continue;\n                }\n                // Select the diagonal that we want to branch from. We select the prior\n                // path whose position in the old string is the farthest from the origin\n                // and does not pass the bounds of the diff graph\n                if (!canRemove || (canAdd && removePath.oldPos < addPath.oldPos)) {\n                    basePath = _this.addToPath(addPath, true, false, 0, options);\n                }\n                else {\n                    basePath = _this.addToPath(removePath, false, true, 1, options);\n                }\n                newPos = _this.extractCommon(basePath, newTokens, oldTokens, diagonalPath, options);\n                if (basePath.oldPos + 1 >= oldLen && newPos + 1 >= newLen) {\n                    // If we have hit the end of both strings, then we are done\n                    return done(_this.buildValues(basePath.lastComponent, newTokens, oldTokens)) || true;\n                }\n                else {\n                    bestPath[diagonalPath] = basePath;\n                    if (basePath.oldPos + 1 >= oldLen) {\n                        maxDiagonalToConsider = Math.min(maxDiagonalToConsider, diagonalPath - 1);\n                    }\n                    if (newPos + 1 >= newLen) {\n                        minDiagonalToConsider = Math.max(minDiagonalToConsider, diagonalPath + 1);\n                    }\n                }\n            }\n            editLength++;\n        };\n        // Performs the length of edit iteration. Is a bit fugly as this has to support the\n        // sync and async mode which is never fun. Loops over execEditLength until a value\n        // is produced, or until the edit length exceeds options.maxEditLength (if given),\n        // in which case it will return undefined.\n        if (callback) {\n            (function exec() {\n                setTimeout(function () {\n                    if (editLength > maxEditLength || Date.now() > abortAfterTimestamp) {\n                        return callback(undefined);\n                    }\n                    if (!execEditLength()) {\n                        exec();\n                    }\n                }, 0);\n            }());\n        }\n        else {\n            while (editLength <= maxEditLength && Date.now() <= abortAfterTimestamp) {\n                var ret = execEditLength();\n                if (ret) {\n                    return ret;\n                }\n            }\n        }\n    };\n    Diff.prototype.addToPath = function (path, added, removed, oldPosInc, options) {\n        var last = path.lastComponent;\n        if (last && !options.oneChangePerToken && last.added === added && last.removed === removed) {\n            return {\n                oldPos: path.oldPos + oldPosInc,\n                lastComponent: { count: last.count + 1, added: added, removed: removed, previousComponent: last.previousComponent }\n            };\n        }\n        else {\n            return {\n                oldPos: path.oldPos + oldPosInc,\n                lastComponent: { count: 1, added: added, removed: removed, previousComponent: last }\n            };\n        }\n    };\n    Diff.prototype.extractCommon = function (basePath, newTokens, oldTokens, diagonalPath, options) {\n        var newLen = newTokens.length, oldLen = oldTokens.length;\n        var oldPos = basePath.oldPos, newPos = oldPos - diagonalPath, commonCount = 0;\n        while (newPos + 1 < newLen && oldPos + 1 < oldLen && this.equals(oldTokens[oldPos + 1], newTokens[newPos + 1], options)) {\n            newPos++;\n            oldPos++;\n            commonCount++;\n            if (options.oneChangePerToken) {\n                basePath.lastComponent = { count: 1, previousComponent: basePath.lastComponent, added: false, removed: false };\n            }\n        }\n        if (commonCount && !options.oneChangePerToken) {\n            basePath.lastComponent = { count: commonCount, previousComponent: basePath.lastComponent, added: false, removed: false };\n        }\n        basePath.oldPos = oldPos;\n        return newPos;\n    };\n    Diff.prototype.equals = function (left, right, options) {\n        if (options.comparator) {\n            return options.comparator(left, right);\n        }\n        else {\n            return left === right\n                || (!!options.ignoreCase && left.toLowerCase() === right.toLowerCase());\n        }\n    };\n    Diff.prototype.removeEmpty = function (array) {\n        var ret = [];\n        for (var i = 0; i < array.length; i++) {\n            if (array[i]) {\n                ret.push(array[i]);\n            }\n        }\n        return ret;\n    };\n    // eslint-disable-next-line @typescript-eslint/no-unused-vars\n    Diff.prototype.castInput = function (value, options) {\n        return value;\n    };\n    // eslint-disable-next-line @typescript-eslint/no-unused-vars\n    Diff.prototype.tokenize = function (value, options) {\n        return Array.from(value);\n    };\n    Diff.prototype.join = function (chars) {\n        // Assumes ValueT is string, which is the case for most subclasses.\n        // When it's false, e.g. in diffArrays, this method needs to be overridden (e.g. with a no-op)\n        // Yes, the casts are verbose and ugly, because this pattern - of having the base class SORT OF\n        // assume tokens and values are strings, but not completely - is weird and janky.\n        return chars.join('');\n    };\n    Diff.prototype.postProcess = function (changeObjects, \n    // eslint-disable-next-line @typescript-eslint/no-unused-vars\n    options) {\n        return changeObjects;\n    };\n    Object.defineProperty(Diff.prototype, \"useLongestToken\", {\n        get: function () {\n            return false;\n        },\n        enumerable: false,\n        configurable: true\n    });\n    Diff.prototype.buildValues = function (lastComponent, newTokens, oldTokens) {\n        // First we convert our linked list of components in reverse order to an\n        // array in the right order:\n        var components = [];\n        var nextComponent;\n        while (lastComponent) {\n            components.push(lastComponent);\n            nextComponent = lastComponent.previousComponent;\n            delete lastComponent.previousComponent;\n            lastComponent = nextComponent;\n        }\n        components.reverse();\n        var componentLen = components.length;\n        var componentPos = 0, newPos = 0, oldPos = 0;\n        for (; componentPos < componentLen; componentPos++) {\n            var component = components[componentPos];\n            if (!component.removed) {\n                if (!component.added && this.useLongestToken) {\n                    var value = newTokens.slice(newPos, newPos + component.count);\n                    value = value.map(function (value, i) {\n                        var oldValue = oldTokens[oldPos + i];\n                        return oldValue.length > value.length ? oldValue : value;\n                    });\n                    component.value = this.join(value);\n                }\n                else {\n                    component.value = this.join(newTokens.slice(newPos, newPos + component.count));\n                }\n                newPos += component.count;\n                // Common case\n                if (!component.added) {\n                    oldPos += component.count;\n                }\n            }\n            else {\n                component.value = this.join(oldTokens.slice(oldPos, oldPos + component.count));\n                oldPos += component.count;\n            }\n        }\n        return components;\n    };\n    return Diff;\n}());\nexports.default = Diff;\n","\"use strict\";\nvar __extends = (this && this.__extends) || (function () {\n    var extendStatics = function (d, b) {\n        extendStatics = Object.setPrototypeOf ||\n            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||\n            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };\n        return extendStatics(d, b);\n    };\n    return function (d, b) {\n        if (typeof b !== \"function\" && b !== null)\n            throw new TypeError(\"Class extends value \" + String(b) + \" is not a constructor or null\");\n        extendStatics(d, b);\n        function __() { this.constructor = d; }\n        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\n    };\n})();\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.characterDiff = void 0;\nexports.diffChars = diffChars;\nvar base_js_1 = require(\"./base.js\");\nvar CharacterDiff = /** @class */ (function (_super) {\n    __extends(CharacterDiff, _super);\n    function CharacterDiff() {\n        return _super !== null && _super.apply(this, arguments) || this;\n    }\n    return CharacterDiff;\n}(base_js_1.default));\nexports.characterDiff = new CharacterDiff();\nfunction diffChars(oldStr, newStr, options) {\n    return exports.characterDiff.diff(oldStr, newStr, options);\n}\n","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.longestCommonPrefix = longestCommonPrefix;\nexports.longestCommonSuffix = longestCommonSuffix;\nexports.replacePrefix = replacePrefix;\nexports.replaceSuffix = replaceSuffix;\nexports.removePrefix = removePrefix;\nexports.removeSuffix = removeSuffix;\nexports.maximumOverlap = maximumOverlap;\nexports.hasOnlyWinLineEndings = hasOnlyWinLineEndings;\nexports.hasOnlyUnixLineEndings = hasOnlyUnixLineEndings;\nexports.trailingWs = trailingWs;\nexports.leadingWs = leadingWs;\nfunction longestCommonPrefix(str1, str2) {\n    var i;\n    for (i = 0; i < str1.length && i < str2.length; i++) {\n        if (str1[i] != str2[i]) {\n            return str1.slice(0, i);\n        }\n    }\n    return str1.slice(0, i);\n}\nfunction longestCommonSuffix(str1, str2) {\n    var i;\n    // Unlike longestCommonPrefix, we need a special case to handle all scenarios\n    // where we return the empty string since str1.slice(-0) will return the\n    // entire string.\n    if (!str1 || !str2 || str1[str1.length - 1] != str2[str2.length - 1]) {\n        return '';\n    }\n    for (i = 0; i < str1.length && i < str2.length; i++) {\n        if (str1[str1.length - (i + 1)] != str2[str2.length - (i + 1)]) {\n            return str1.slice(-i);\n        }\n    }\n    return str1.slice(-i);\n}\nfunction replacePrefix(string, oldPrefix, newPrefix) {\n    if (string.slice(0, oldPrefix.length) != oldPrefix) {\n        throw Error(\"string \".concat(JSON.stringify(string), \" doesn't start with prefix \").concat(JSON.stringify(oldPrefix), \"; this is a bug\"));\n    }\n    return newPrefix + string.slice(oldPrefix.length);\n}\nfunction replaceSuffix(string, oldSuffix, newSuffix) {\n    if (!oldSuffix) {\n        return string + newSuffix;\n    }\n    if (string.slice(-oldSuffix.length) != oldSuffix) {\n        throw Error(\"string \".concat(JSON.stringify(string), \" doesn't end with suffix \").concat(JSON.stringify(oldSuffix), \"; this is a bug\"));\n    }\n    return string.slice(0, -oldSuffix.length) + newSuffix;\n}\nfunction removePrefix(string, oldPrefix) {\n    return replacePrefix(string, oldPrefix, '');\n}\nfunction removeSuffix(string, oldSuffix) {\n    return replaceSuffix(string, oldSuffix, '');\n}\nfunction maximumOverlap(string1, string2) {\n    return string2.slice(0, overlapCount(string1, string2));\n}\n// Nicked from https://stackoverflow.com/a/60422853/1709587\nfunction overlapCount(a, b) {\n    // Deal with cases where the strings differ in length\n    var startA = 0;\n    if (a.length > b.length) {\n        startA = a.length - b.length;\n    }\n    var endB = b.length;\n    if (a.length < b.length) {\n        endB = a.length;\n    }\n    // Create a back-reference for each index\n    //   that should be followed in case of a mismatch.\n    //   We only need B to make these references:\n    var map = Array(endB);\n    var k = 0; // Index that lags behind j\n    map[0] = 0;\n    for (var j = 1; j < endB; j++) {\n        if (b[j] == b[k]) {\n            map[j] = map[k]; // skip over the same character (optional optimisation)\n        }\n        else {\n            map[j] = k;\n        }\n        while (k > 0 && b[j] != b[k]) {\n            k = map[k];\n        }\n        if (b[j] == b[k]) {\n            k++;\n        }\n    }\n    // Phase 2: use these references while iterating over A\n    k = 0;\n    for (var i = startA; i < a.length; i++) {\n        while (k > 0 && a[i] != b[k]) {\n            k = map[k];\n        }\n        if (a[i] == b[k]) {\n            k++;\n        }\n    }\n    return k;\n}\n/**\n * Returns true if the string consistently uses Windows line endings.\n */\nfunction hasOnlyWinLineEndings(string) {\n    return string.includes('\\r\\n') && !string.startsWith('\\n') && !string.match(/[^\\r]\\n/);\n}\n/**\n * Returns true if the string consistently uses Unix line endings.\n */\nfunction hasOnlyUnixLineEndings(string) {\n    return !string.includes('\\r\\n') && string.includes('\\n');\n}\nfunction trailingWs(string) {\n    // Yes, this looks overcomplicated and dumb - why not replace the whole function with\n    //     return string.match(/\\s*$/)[0]\n    // you ask? Because:\n    // 1. the trap described at https://markamery.com/blog/quadratic-time-regexes/ would mean doing\n    //    this would cause this function to take O(n²) time in the worst case (specifically when\n    //    there is a massive run of NON-TRAILING whitespace in `string`), and\n    // 2. the fix proposed in the same blog post, of using a negative lookbehind, is incompatible\n    //    with old Safari versions that we'd like to not break if possible (see\n    //    https://github.com/kpdecker/jsdiff/pull/550)\n    // It feels absurd to do this with an explicit loop instead of a regex, but I really can't see a\n    // better way that doesn't result in broken behaviour.\n    var i;\n    for (i = string.length - 1; i >= 0; i--) {\n        if (!string[i].match(/\\s/)) {\n            break;\n        }\n    }\n    return string.substring(i + 1);\n}\nfunction leadingWs(string) {\n    // Thankfully the annoying considerations described in trailingWs don't apply here:\n    var match = string.match(/^\\s*/);\n    return match ? match[0] : '';\n}\n","\"use strict\";\nvar __extends = (this && this.__extends) || (function () {\n    var extendStatics = function (d, b) {\n        extendStatics = Object.setPrototypeOf ||\n            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||\n            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };\n        return extendStatics(d, b);\n    };\n    return function (d, b) {\n        if (typeof b !== \"function\" && b !== null)\n            throw new TypeError(\"Class extends value \" + String(b) + \" is not a constructor or null\");\n        extendStatics(d, b);\n        function __() { this.constructor = d; }\n        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\n    };\n})();\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.wordsWithSpaceDiff = exports.wordDiff = void 0;\nexports.diffWords = diffWords;\nexports.diffWordsWithSpace = diffWordsWithSpace;\nvar base_js_1 = require(\"./base.js\");\nvar string_js_1 = require(\"../util/string.js\");\n// Based on https://en.wikipedia.org/wiki/Latin_script_in_Unicode\n//\n// Chars/ranges counted as \"word\" characters by this regex are as follows:\n//\n// + U+00AD  Soft hyphen\n// + 00C0–00FF (letters with diacritics from the Latin-1 Supplement), except:\n//   - U+00D7  × Multiplication sign\n//   - U+00F7  ÷ Division sign\n// + Latin Extended-A, 0100–017F\n// + Latin Extended-B, 0180–024F\n// + IPA Extensions, 0250–02AF\n// + Spacing Modifier Letters, 02B0–02FF, except:\n//   - U+02C7  ˇ &#711;  Caron\n//   - U+02D8  ˘ &#728;  Breve\n//   - U+02D9  ˙ &#729;  Dot Above\n//   - U+02DA  ˚ &#730;  Ring Above\n//   - U+02DB  ˛ &#731;  Ogonek\n//   - U+02DC  ˜ &#732;  Small Tilde\n//   - U+02DD  ˝ &#733;  Double Acute Accent\n// + Latin Extended Additional, 1E00–1EFF\nvar extendedWordChars = 'a-zA-Z0-9_\\\\u{AD}\\\\u{C0}-\\\\u{D6}\\\\u{D8}-\\\\u{F6}\\\\u{F8}-\\\\u{2C6}\\\\u{2C8}-\\\\u{2D7}\\\\u{2DE}-\\\\u{2FF}\\\\u{1E00}-\\\\u{1EFF}';\n// Each token is one of the following:\n// - A punctuation mark plus the surrounding whitespace\n// - A word plus the surrounding whitespace\n// - Pure whitespace (but only in the special case where the entire text\n//   is just whitespace)\n//\n// We have to include surrounding whitespace in the tokens because the two\n// alternative approaches produce horribly broken results:\n// * If we just discard the whitespace, we can't fully reproduce the original\n//   text from the sequence of tokens and any attempt to render the diff will\n//   get the whitespace wrong.\n// * If we have separate tokens for whitespace, then in a typical text every\n//   second token will be a single space character. But this often results in\n//   the optimal diff between two texts being a perverse one that preserves\n//   the spaces between words but deletes and reinserts actual common words.\n//   See https://github.com/kpdecker/jsdiff/issues/160#issuecomment-1866099640\n//   for an example.\n//\n// Keeping the surrounding whitespace of course has implications for .equals\n// and .join, not just .tokenize.\n// This regex does NOT fully implement the tokenization rules described above.\n// Instead, it gives runs of whitespace their own \"token\". The tokenize method\n// then handles stitching whitespace tokens onto adjacent word or punctuation\n// tokens.\nvar tokenizeIncludingWhitespace = new RegExp(\"[\".concat(extendedWordChars, \"]+|\\\\s+|[^\").concat(extendedWordChars, \"]\"), 'ug');\nvar WordDiff = /** @class */ (function (_super) {\n    __extends(WordDiff, _super);\n    function WordDiff() {\n        return _super !== null && _super.apply(this, arguments) || this;\n    }\n    WordDiff.prototype.equals = function (left, right, options) {\n        if (options.ignoreCase) {\n            left = left.toLowerCase();\n            right = right.toLowerCase();\n        }\n        return left.trim() === right.trim();\n    };\n    WordDiff.prototype.tokenize = function (value, options) {\n        if (options === void 0) { options = {}; }\n        var parts;\n        if (options.intlSegmenter) {\n            var segmenter = options.intlSegmenter;\n            if (segmenter.resolvedOptions().granularity != 'word') {\n                throw new Error('The segmenter passed must have a granularity of \"word\"');\n            }\n            // We want `parts` to be an array whose elements alternate between being\n            // pure whitespace and being pure non-whitespace. This is ALMOST what the\n            // segments returned by a word-based Intl.Segmenter already look like,\n            // and therefore we can ALMOST get what we want by simply doing...\n            //     parts = Array.from(segmenter.segment(value), segment => segment.segment);\n            // ... but not QUITE, because there's of one annoying special case: every\n            // newline character gets its own segment, instead of sharing a segment\n            // with other surrounding whitespace. We therefore need to manually merge\n            // consecutive segments of whitespace into a single part:\n            parts = [];\n            for (var _i = 0, _a = Array.from(segmenter.segment(value)); _i < _a.length; _i++) {\n                var segmentObj = _a[_i];\n                var segment = segmentObj.segment;\n                if (parts.length && (/\\s/).test(parts[parts.length - 1]) && (/\\s/).test(segment)) {\n                    parts[parts.length - 1] += segment;\n                }\n                else {\n                    parts.push(segment);\n                }\n            }\n        }\n        else {\n            parts = value.match(tokenizeIncludingWhitespace) || [];\n        }\n        var tokens = [];\n        var prevPart = null;\n        parts.forEach(function (part) {\n            if ((/\\s/).test(part)) {\n                if (prevPart == null) {\n                    tokens.push(part);\n                }\n                else {\n                    tokens.push(tokens.pop() + part);\n                }\n            }\n            else if (prevPart != null && (/\\s/).test(prevPart)) {\n                if (tokens[tokens.length - 1] == prevPart) {\n                    tokens.push(tokens.pop() + part);\n                }\n                else {\n                    tokens.push(prevPart + part);\n                }\n            }\n            else {\n                tokens.push(part);\n            }\n            prevPart = part;\n        });\n        return tokens;\n    };\n    WordDiff.prototype.join = function (tokens) {\n        // Tokens being joined here will always have appeared consecutively in the\n        // same text, so we can simply strip off the leading whitespace from all the\n        // tokens except the first (and except any whitespace-only tokens - but such\n        // a token will always be the first and only token anyway) and then join them\n        // and the whitespace around words and punctuation will end up correct.\n        return tokens.map(function (token, i) {\n            if (i == 0) {\n                return token;\n            }\n            else {\n                return token.replace((/^\\s+/), '');\n            }\n        }).join('');\n    };\n    WordDiff.prototype.postProcess = function (changes, options) {\n        if (!changes || options.oneChangePerToken) {\n            return changes;\n        }\n        var lastKeep = null;\n        // Change objects representing any insertion or deletion since the last\n        // \"keep\" change object. There can be at most one of each.\n        var insertion = null;\n        var deletion = null;\n        changes.forEach(function (change) {\n            if (change.added) {\n                insertion = change;\n            }\n            else if (change.removed) {\n                deletion = change;\n            }\n            else {\n                if (insertion || deletion) { // May be false at start of text\n                    dedupeWhitespaceInChangeObjects(lastKeep, deletion, insertion, change);\n                }\n                lastKeep = change;\n                insertion = null;\n                deletion = null;\n            }\n        });\n        if (insertion || deletion) {\n            dedupeWhitespaceInChangeObjects(lastKeep, deletion, insertion, null);\n        }\n        return changes;\n    };\n    return WordDiff;\n}(base_js_1.default));\nexports.wordDiff = new WordDiff();\nfunction diffWords(oldStr, newStr, options) {\n    // This option has never been documented and never will be (it's clearer to\n    // just call `diffWordsWithSpace` directly if you need that behavior), but\n    // has existed in jsdiff for a long time, so we retain support for it here\n    // for the sake of backwards compatibility.\n    if ((options === null || options === void 0 ? void 0 : options.ignoreWhitespace) != null && !options.ignoreWhitespace) {\n        return diffWordsWithSpace(oldStr, newStr, options);\n    }\n    return exports.wordDiff.diff(oldStr, newStr, options);\n}\nfunction dedupeWhitespaceInChangeObjects(startKeep, deletion, insertion, endKeep) {\n    // Before returning, we tidy up the leading and trailing whitespace of the\n    // change objects to eliminate cases where trailing whitespace in one object\n    // is repeated as leading whitespace in the next.\n    // Below are examples of the outcomes we want here to explain the code.\n    // I=insert, K=keep, D=delete\n    // 1. diffing 'foo bar baz' vs 'foo baz'\n    //    Prior to cleanup, we have K:'foo ' D:' bar ' K:' baz'\n    //    After cleanup, we want:   K:'foo ' D:'bar ' K:'baz'\n    //\n    // 2. Diffing 'foo bar baz' vs 'foo qux baz'\n    //    Prior to cleanup, we have K:'foo ' D:' bar ' I:' qux ' K:' baz'\n    //    After cleanup, we want K:'foo ' D:'bar' I:'qux' K:' baz'\n    //\n    // 3. Diffing 'foo\\nbar baz' vs 'foo baz'\n    //    Prior to cleanup, we have K:'foo ' D:'\\nbar ' K:' baz'\n    //    After cleanup, we want K'foo' D:'\\nbar' K:' baz'\n    //\n    // 4. Diffing 'foo baz' vs 'foo\\nbar baz'\n    //    Prior to cleanup, we have K:'foo\\n' I:'\\nbar ' K:' baz'\n    //    After cleanup, we ideally want K'foo' I:'\\nbar' K:' baz'\n    //    but don't actually manage this currently (the pre-cleanup change\n    //    objects don't contain enough information to make it possible).\n    //\n    // 5. Diffing 'foo   bar baz' vs 'foo  baz'\n    //    Prior to cleanup, we have K:'foo  ' D:'   bar ' K:'  baz'\n    //    After cleanup, we want K:'foo  ' D:' bar ' K:'baz'\n    //\n    // Our handling is unavoidably imperfect in the case where there's a single\n    // indel between keeps and the whitespace has changed. For instance, consider\n    // diffing 'foo\\tbar\\nbaz' vs 'foo baz'. Unless we create an extra change\n    // object to represent the insertion of the space character (which isn't even\n    // a token), we have no way to avoid losing information about the texts'\n    // original whitespace in the result we return. Still, we do our best to\n    // output something that will look sensible if we e.g. print it with\n    // insertions in green and deletions in red.\n    // Between two \"keep\" change objects (or before the first or after the last\n    // change object), we can have either:\n    // * A \"delete\" followed by an \"insert\"\n    // * Just an \"insert\"\n    // * Just a \"delete\"\n    // We handle the three cases separately.\n    if (deletion && insertion) {\n        var oldWsPrefix = (0, string_js_1.leadingWs)(deletion.value);\n        var oldWsSuffix = (0, string_js_1.trailingWs)(deletion.value);\n        var newWsPrefix = (0, string_js_1.leadingWs)(insertion.value);\n        var newWsSuffix = (0, string_js_1.trailingWs)(insertion.value);\n        if (startKeep) {\n            var commonWsPrefix = (0, string_js_1.longestCommonPrefix)(oldWsPrefix, newWsPrefix);\n            startKeep.value = (0, string_js_1.replaceSuffix)(startKeep.value, newWsPrefix, commonWsPrefix);\n            deletion.value = (0, string_js_1.removePrefix)(deletion.value, commonWsPrefix);\n            insertion.value = (0, string_js_1.removePrefix)(insertion.value, commonWsPrefix);\n        }\n        if (endKeep) {\n            var commonWsSuffix = (0, string_js_1.longestCommonSuffix)(oldWsSuffix, newWsSuffix);\n            endKeep.value = (0, string_js_1.replacePrefix)(endKeep.value, newWsSuffix, commonWsSuffix);\n            deletion.value = (0, string_js_1.removeSuffix)(deletion.value, commonWsSuffix);\n            insertion.value = (0, string_js_1.removeSuffix)(insertion.value, commonWsSuffix);\n        }\n    }\n    else if (insertion) {\n        // The whitespaces all reflect what was in the new text rather than\n        // the old, so we essentially have no information about whitespace\n        // insertion or deletion. We just want to dedupe the whitespace.\n        // We do that by having each change object keep its trailing\n        // whitespace and deleting duplicate leading whitespace where\n        // present.\n        if (startKeep) {\n            var ws = (0, string_js_1.leadingWs)(insertion.value);\n            insertion.value = insertion.value.substring(ws.length);\n        }\n        if (endKeep) {\n            var ws = (0, string_js_1.leadingWs)(endKeep.value);\n            endKeep.value = endKeep.value.substring(ws.length);\n        }\n        // otherwise we've got a deletion and no insertion\n    }\n    else if (startKeep && endKeep) {\n        var newWsFull = (0, string_js_1.leadingWs)(endKeep.value), delWsStart = (0, string_js_1.leadingWs)(deletion.value), delWsEnd = (0, string_js_1.trailingWs)(deletion.value);\n        // Any whitespace that comes straight after startKeep in both the old and\n        // new texts, assign to startKeep and remove from the deletion.\n        var newWsStart = (0, string_js_1.longestCommonPrefix)(newWsFull, delWsStart);\n        deletion.value = (0, string_js_1.removePrefix)(deletion.value, newWsStart);\n        // Any whitespace that comes straight before endKeep in both the old and\n        // new texts, and hasn't already been assigned to startKeep, assign to\n        // endKeep and remove from the deletion.\n        var newWsEnd = (0, string_js_1.longestCommonSuffix)((0, string_js_1.removePrefix)(newWsFull, newWsStart), delWsEnd);\n        deletion.value = (0, string_js_1.removeSuffix)(deletion.value, newWsEnd);\n        endKeep.value = (0, string_js_1.replacePrefix)(endKeep.value, newWsFull, newWsEnd);\n        // If there's any whitespace from the new text that HASN'T already been\n        // assigned, assign it to the start:\n        startKeep.value = (0, string_js_1.replaceSuffix)(startKeep.value, newWsFull, newWsFull.slice(0, newWsFull.length - newWsEnd.length));\n    }\n    else if (endKeep) {\n        // We are at the start of the text. Preserve all the whitespace on\n        // endKeep, and just remove whitespace from the end of deletion to the\n        // extent that it overlaps with the start of endKeep.\n        var endKeepWsPrefix = (0, string_js_1.leadingWs)(endKeep.value);\n        var deletionWsSuffix = (0, string_js_1.trailingWs)(deletion.value);\n        var overlap = (0, string_js_1.maximumOverlap)(deletionWsSuffix, endKeepWsPrefix);\n        deletion.value = (0, string_js_1.removeSuffix)(deletion.value, overlap);\n    }\n    else if (startKeep) {\n        // We are at the END of the text. Preserve all the whitespace on\n        // startKeep, and just remove whitespace from the start of deletion to\n        // the extent that it overlaps with the end of startKeep.\n        var startKeepWsSuffix = (0, string_js_1.trailingWs)(startKeep.value);\n        var deletionWsPrefix = (0, string_js_1.leadingWs)(deletion.value);\n        var overlap = (0, string_js_1.maximumOverlap)(startKeepWsSuffix, deletionWsPrefix);\n        deletion.value = (0, string_js_1.removePrefix)(deletion.value, overlap);\n    }\n}\nvar WordsWithSpaceDiff = /** @class */ (function (_super) {\n    __extends(WordsWithSpaceDiff, _super);\n    function WordsWithSpaceDiff() {\n        return _super !== null && _super.apply(this, arguments) || this;\n    }\n    WordsWithSpaceDiff.prototype.tokenize = function (value) {\n        // Slightly different to the tokenizeIncludingWhitespace regex used above in\n        // that this one treats each individual newline as a distinct token, rather\n        // than merging them into other surrounding whitespace. This was requested\n        // in https://github.com/kpdecker/jsdiff/issues/180 &\n        //    https://github.com/kpdecker/jsdiff/issues/211\n        var regex = new RegExp(\"(\\\\r?\\\\n)|[\".concat(extendedWordChars, \"]+|[^\\\\S\\\\n\\\\r]+|[^\").concat(extendedWordChars, \"]\"), 'ug');\n        return value.match(regex) || [];\n    };\n    return WordsWithSpaceDiff;\n}(base_js_1.default));\nexports.wordsWithSpaceDiff = new WordsWithSpaceDiff();\nfunction diffWordsWithSpace(oldStr, newStr, options) {\n    return exports.wordsWithSpaceDiff.diff(oldStr, newStr, options);\n}\n","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.generateOptions = generateOptions;\nfunction generateOptions(options, defaults) {\n    if (typeof options === 'function') {\n        defaults.callback = options;\n    }\n    else if (options) {\n        for (var name in options) {\n            /* istanbul ignore else */\n            if (Object.prototype.hasOwnProperty.call(options, name)) {\n                defaults[name] = options[name];\n            }\n        }\n    }\n    return defaults;\n}\n","\"use strict\";\nvar __extends = (this && this.__extends) || (function () {\n    var extendStatics = function (d, b) {\n        extendStatics = Object.setPrototypeOf ||\n            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||\n            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };\n        return extendStatics(d, b);\n    };\n    return function (d, b) {\n        if (typeof b !== \"function\" && b !== null)\n            throw new TypeError(\"Class extends value \" + String(b) + \" is not a constructor or null\");\n        extendStatics(d, b);\n        function __() { this.constructor = d; }\n        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\n    };\n})();\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.lineDiff = void 0;\nexports.diffLines = diffLines;\nexports.diffTrimmedLines = diffTrimmedLines;\nexports.tokenize = tokenize;\nvar base_js_1 = require(\"./base.js\");\nvar params_js_1 = require(\"../util/params.js\");\nvar LineDiff = /** @class */ (function (_super) {\n    __extends(LineDiff, _super);\n    function LineDiff() {\n        var _this = _super !== null && _super.apply(this, arguments) || this;\n        _this.tokenize = tokenize;\n        return _this;\n    }\n    LineDiff.prototype.equals = function (left, right, options) {\n        // If we're ignoring whitespace, we need to normalise lines by stripping\n        // whitespace before checking equality. (This has an annoying interaction\n        // with newlineIsToken that requires special handling: if newlines get their\n        // own token, then we DON'T want to trim the *newline* tokens down to empty\n        // strings, since this would cause us to treat whitespace-only line content\n        // as equal to a separator between lines, which would be weird and\n        // inconsistent with the documented behavior of the options.)\n        if (options.ignoreWhitespace) {\n            if (!options.newlineIsToken || !left.includes('\\n')) {\n                left = left.trim();\n            }\n            if (!options.newlineIsToken || !right.includes('\\n')) {\n                right = right.trim();\n            }\n        }\n        else if (options.ignoreNewlineAtEof && !options.newlineIsToken) {\n            if (left.endsWith('\\n')) {\n                left = left.slice(0, -1);\n            }\n            if (right.endsWith('\\n')) {\n                right = right.slice(0, -1);\n            }\n        }\n        return _super.prototype.equals.call(this, left, right, options);\n    };\n    return LineDiff;\n}(base_js_1.default));\nexports.lineDiff = new LineDiff();\nfunction diffLines(oldStr, newStr, options) {\n    return exports.lineDiff.diff(oldStr, newStr, options);\n}\nfunction diffTrimmedLines(oldStr, newStr, options) {\n    options = (0, params_js_1.generateOptions)(options, { ignoreWhitespace: true });\n    return exports.lineDiff.diff(oldStr, newStr, options);\n}\n// Exported standalone so it can be used from jsonDiff too.\nfunction tokenize(value, options) {\n    if (options.stripTrailingCr) {\n        // remove one \\r before \\n to match GNU diff's --strip-trailing-cr behavior\n        value = value.replace(/\\r\\n/g, '\\n');\n    }\n    var retLines = [], linesAndNewlines = value.split(/(\\n|\\r\\n)/);\n    // Ignore the final empty token that occurs if the string ends with a new line\n    if (!linesAndNewlines[linesAndNewlines.length - 1]) {\n        linesAndNewlines.pop();\n    }\n    // Merge the content and line separators into single tokens\n    for (var i = 0; i < linesAndNewlines.length; i++) {\n        var line = linesAndNewlines[i];\n        if (i % 2 && !options.newlineIsToken) {\n            retLines[retLines.length - 1] += line;\n        }\n        else {\n            retLines.push(line);\n        }\n    }\n    return retLines;\n}\n","\"use strict\";\nvar __extends = (this && this.__extends) || (function () {\n    var extendStatics = function (d, b) {\n        extendStatics = Object.setPrototypeOf ||\n            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||\n            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };\n        return extendStatics(d, b);\n    };\n    return function (d, b) {\n        if (typeof b !== \"function\" && b !== null)\n            throw new TypeError(\"Class extends value \" + String(b) + \" is not a constructor or null\");\n        extendStatics(d, b);\n        function __() { this.constructor = d; }\n        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\n    };\n})();\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.sentenceDiff = void 0;\nexports.diffSentences = diffSentences;\nvar base_js_1 = require(\"./base.js\");\nfunction isSentenceEndPunct(char) {\n    return char == '.' || char == '!' || char == '?';\n}\nvar SentenceDiff = /** @class */ (function (_super) {\n    __extends(SentenceDiff, _super);\n    function SentenceDiff() {\n        return _super !== null && _super.apply(this, arguments) || this;\n    }\n    SentenceDiff.prototype.tokenize = function (value) {\n        var _a;\n        // If in future we drop support for environments that don't support lookbehinds, we can replace\n        // this entire function with:\n        //     return value.split(/(?<=[.!?])(\\s+|$)/);\n        // but until then, for similar reasons to the trailingWs function in string.ts, we are forced\n        // to do this verbosely \"by hand\" instead of using a regex.\n        var result = [];\n        var tokenStartI = 0;\n        for (var i = 0; i < value.length; i++) {\n            if (i == value.length - 1) {\n                result.push(value.slice(tokenStartI));\n                break;\n            }\n            if (isSentenceEndPunct(value[i]) && value[i + 1].match(/\\s/)) {\n                // We've hit a sentence break - i.e. a punctuation mark followed by whitespace.\n                // We now want to push TWO tokens to the result:\n                // 1. the sentence\n                result.push(value.slice(tokenStartI, i + 1));\n                // 2. the whitespace\n                i = tokenStartI = i + 1;\n                while ((_a = value[i + 1]) === null || _a === void 0 ? void 0 : _a.match(/\\s/)) {\n                    i++;\n                }\n                result.push(value.slice(tokenStartI, i + 1));\n                // Then the next token (a sentence) starts on the character after the whitespace.\n                // (It's okay if this is off the end of the string - then the outer loop will terminate\n                // here anyway.)\n                tokenStartI = i + 1;\n            }\n        }\n        return result;\n    };\n    return SentenceDiff;\n}(base_js_1.default));\nexports.sentenceDiff = new SentenceDiff();\nfunction diffSentences(oldStr, newStr, options) {\n    return exports.sentenceDiff.diff(oldStr, newStr, options);\n}\n","\"use strict\";\nvar __extends = (this && this.__extends) || (function () {\n    var extendStatics = function (d, b) {\n        extendStatics = Object.setPrototypeOf ||\n            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||\n            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };\n        return extendStatics(d, b);\n    };\n    return function (d, b) {\n        if (typeof b !== \"function\" && b !== null)\n            throw new TypeError(\"Class extends value \" + String(b) + \" is not a constructor or null\");\n        extendStatics(d, b);\n        function __() { this.constructor = d; }\n        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\n    };\n})();\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.cssDiff = void 0;\nexports.diffCss = diffCss;\nvar base_js_1 = require(\"./base.js\");\nvar CssDiff = /** @class */ (function (_super) {\n    __extends(CssDiff, _super);\n    function CssDiff() {\n        return _super !== null && _super.apply(this, arguments) || this;\n    }\n    CssDiff.prototype.tokenize = function (value) {\n        return value.split(/([{}:;,]|\\s+)/);\n    };\n    return CssDiff;\n}(base_js_1.default));\nexports.cssDiff = new CssDiff();\nfunction diffCss(oldStr, newStr, options) {\n    return exports.cssDiff.diff(oldStr, newStr, options);\n}\n","\"use strict\";\nvar __extends = (this && this.__extends) || (function () {\n    var extendStatics = function (d, b) {\n        extendStatics = Object.setPrototypeOf ||\n            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||\n            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };\n        return extendStatics(d, b);\n    };\n    return function (d, b) {\n        if (typeof b !== \"function\" && b !== null)\n            throw new TypeError(\"Class extends value \" + String(b) + \" is not a constructor or null\");\n        extendStatics(d, b);\n        function __() { this.constructor = d; }\n        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\n    };\n})();\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.jsonDiff = void 0;\nexports.diffJson = diffJson;\nexports.canonicalize = canonicalize;\nvar base_js_1 = require(\"./base.js\");\nvar line_js_1 = require(\"./line.js\");\nvar JsonDiff = /** @class */ (function (_super) {\n    __extends(JsonDiff, _super);\n    function JsonDiff() {\n        var _this = _super !== null && _super.apply(this, arguments) || this;\n        _this.tokenize = line_js_1.tokenize;\n        return _this;\n    }\n    Object.defineProperty(JsonDiff.prototype, \"useLongestToken\", {\n        get: function () {\n            // Discriminate between two lines of pretty-printed, serialized JSON where one of them has a\n            // dangling comma and the other doesn't. Turns out including the dangling comma yields the nicest output:\n            return true;\n        },\n        enumerable: false,\n        configurable: true\n    });\n    JsonDiff.prototype.castInput = function (value, options) {\n        var undefinedReplacement = options.undefinedReplacement, _a = options.stringifyReplacer, stringifyReplacer = _a === void 0 ? function (k, v) { return typeof v === 'undefined' ? undefinedReplacement : v; } : _a;\n        return typeof value === 'string' ? value : JSON.stringify(canonicalize(value, null, null, stringifyReplacer), null, '  ');\n    };\n    JsonDiff.prototype.equals = function (left, right, options) {\n        return _super.prototype.equals.call(this, left.replace(/,([\\r\\n])/g, '$1'), right.replace(/,([\\r\\n])/g, '$1'), options);\n    };\n    return JsonDiff;\n}(base_js_1.default));\nexports.jsonDiff = new JsonDiff();\nfunction diffJson(oldStr, newStr, options) {\n    return exports.jsonDiff.diff(oldStr, newStr, options);\n}\n// This function handles the presence of circular references by bailing out when encountering an\n// object that is already on the \"stack\" of items being processed. Accepts an optional replacer\nfunction canonicalize(obj, stack, replacementStack, replacer, key) {\n    stack = stack || [];\n    replacementStack = replacementStack || [];\n    if (replacer) {\n        obj = replacer(key === undefined ? '' : key, obj);\n    }\n    var i;\n    for (i = 0; i < stack.length; i += 1) {\n        if (stack[i] === obj) {\n            return replacementStack[i];\n        }\n    }\n    var canonicalizedObj;\n    if ('[object Array]' === Object.prototype.toString.call(obj)) {\n        stack.push(obj);\n        canonicalizedObj = new Array(obj.length);\n        replacementStack.push(canonicalizedObj);\n        for (i = 0; i < obj.length; i += 1) {\n            canonicalizedObj[i] = canonicalize(obj[i], stack, replacementStack, replacer, String(i));\n        }\n        stack.pop();\n        replacementStack.pop();\n        return canonicalizedObj;\n    }\n    if (obj && obj.toJSON) {\n        obj = obj.toJSON();\n    }\n    if (typeof obj === 'object' && obj !== null) {\n        stack.push(obj);\n        canonicalizedObj = {};\n        replacementStack.push(canonicalizedObj);\n        var sortedKeys = [];\n        var key_1;\n        for (key_1 in obj) {\n            /* istanbul ignore else */\n            if (Object.prototype.hasOwnProperty.call(obj, key_1)) {\n                sortedKeys.push(key_1);\n            }\n        }\n        sortedKeys.sort();\n        for (i = 0; i < sortedKeys.length; i += 1) {\n            key_1 = sortedKeys[i];\n            canonicalizedObj[key_1] = canonicalize(obj[key_1], stack, replacementStack, replacer, key_1);\n        }\n        stack.pop();\n        replacementStack.pop();\n    }\n    else {\n        canonicalizedObj = obj;\n    }\n    return canonicalizedObj;\n}\n","\"use strict\";\nvar __extends = (this && this.__extends) || (function () {\n    var extendStatics = function (d, b) {\n        extendStatics = Object.setPrototypeOf ||\n            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||\n            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };\n        return extendStatics(d, b);\n    };\n    return function (d, b) {\n        if (typeof b !== \"function\" && b !== null)\n            throw new TypeError(\"Class extends value \" + String(b) + \" is not a constructor or null\");\n        extendStatics(d, b);\n        function __() { this.constructor = d; }\n        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\n    };\n})();\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.arrayDiff = void 0;\nexports.diffArrays = diffArrays;\nvar base_js_1 = require(\"./base.js\");\nvar ArrayDiff = /** @class */ (function (_super) {\n    __extends(ArrayDiff, _super);\n    function ArrayDiff() {\n        return _super !== null && _super.apply(this, arguments) || this;\n    }\n    ArrayDiff.prototype.tokenize = function (value) {\n        return value.slice();\n    };\n    ArrayDiff.prototype.join = function (value) {\n        return value;\n    };\n    ArrayDiff.prototype.removeEmpty = function (value) {\n        return value;\n    };\n    return ArrayDiff;\n}(base_js_1.default));\nexports.arrayDiff = new ArrayDiff();\nfunction diffArrays(oldArr, newArr, options) {\n    return exports.arrayDiff.diff(oldArr, newArr, options);\n}\n","\"use strict\";\nvar __assign = (this && this.__assign) || function () {\n    __assign = Object.assign || function(t) {\n        for (var s, i = 1, n = arguments.length; i < n; i++) {\n            s = arguments[i];\n            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))\n                t[p] = s[p];\n        }\n        return t;\n    };\n    return __assign.apply(this, arguments);\n};\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.unixToWin = unixToWin;\nexports.winToUnix = winToUnix;\nexports.isUnix = isUnix;\nexports.isWin = isWin;\nfunction unixToWin(patch) {\n    if (Array.isArray(patch)) {\n        // It would be cleaner if instead of the line below we could just write\n        //     return patch.map(unixToWin)\n        // but mysteriously TypeScript (v5.7.3 at the time of writing) does not like this and it will\n        // refuse to compile, thinking that unixToWin could then return StructuredPatch[][] and the\n        // result would be incompatible with the overload signatures.\n        // See bug report at https://github.com/microsoft/TypeScript/issues/61398.\n        return patch.map(function (p) { return unixToWin(p); });\n    }\n    return __assign(__assign({}, patch), { hunks: patch.hunks.map(function (hunk) { return (__assign(__assign({}, hunk), { lines: hunk.lines.map(function (line, i) {\n                var _a;\n                return (line.startsWith('\\\\') || line.endsWith('\\r') || ((_a = hunk.lines[i + 1]) === null || _a === void 0 ? void 0 : _a.startsWith('\\\\')))\n                    ? line\n                    : line + '\\r';\n            }) })); }) });\n}\nfunction winToUnix(patch) {\n    if (Array.isArray(patch)) {\n        // (See comment above equivalent line in unixToWin)\n        return patch.map(function (p) { return winToUnix(p); });\n    }\n    return __assign(__assign({}, patch), { hunks: patch.hunks.map(function (hunk) { return (__assign(__assign({}, hunk), { lines: hunk.lines.map(function (line) { return line.endsWith('\\r') ? line.substring(0, line.length - 1) : line; }) })); }) });\n}\n/**\n * Returns true if the patch consistently uses Unix line endings (or only involves one line and has\n * no line endings).\n */\nfunction isUnix(patch) {\n    if (!Array.isArray(patch)) {\n        patch = [patch];\n    }\n    return !patch.some(function (index) { return index.hunks.some(function (hunk) { return hunk.lines.some(function (line) { return !line.startsWith('\\\\') && line.endsWith('\\r'); }); }); });\n}\n/**\n * Returns true if the patch uses Windows line endings and only Windows line endings.\n */\nfunction isWin(patch) {\n    if (!Array.isArray(patch)) {\n        patch = [patch];\n    }\n    return patch.some(function (index) { return index.hunks.some(function (hunk) { return hunk.lines.some(function (line) { return line.endsWith('\\r'); }); }); })\n        && patch.every(function (index) { return index.hunks.every(function (hunk) { return hunk.lines.every(function (line, i) { var _a; return line.startsWith('\\\\') || line.endsWith('\\r') || ((_a = hunk.lines[i + 1]) === null || _a === void 0 ? void 0 : _a.startsWith('\\\\')); }); }); });\n}\n","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.parsePatch = parsePatch;\n/**\n * Parses a patch into structured data, in the same structure returned by `structuredPatch`.\n *\n * @return a JSON object representation of the a patch, suitable for use with the `applyPatch` method.\n */\nfunction parsePatch(uniDiff) {\n    var diffstr = uniDiff.split(/\\n/), list = [];\n    var i = 0;\n    function parseIndex() {\n        var index = {};\n        list.push(index);\n        // Parse diff metadata\n        while (i < diffstr.length) {\n            var line = diffstr[i];\n            // File header found, end parsing diff metadata\n            if ((/^(---|\\+\\+\\+|@@)\\s/).test(line)) {\n                break;\n            }\n            // Try to parse the line as a diff header, like\n            //     Index: README.md\n            // or\n            //     diff -r 9117c6561b0b -r 273ce12ad8f1 .hgignore\n            // or\n            //     Index: something with multiple words\n            // and extract the filename (or whatever else is used as an index name)\n            // from the end (i.e. 'README.md', '.hgignore', or\n            // 'something with multiple words' in the examples above).\n            //\n            // TODO: It seems awkward that we indiscriminately trim off trailing\n            //       whitespace here. Theoretically, couldn't that be meaningful -\n            //       e.g. if the patch represents a diff of a file whose name ends\n            //       with a space? Seems wrong to nuke it.\n            //       But this behaviour has been around since v2.2.1 in 2015, so if\n            //       it's going to change, it should be done cautiously and in a new\n            //       major release, for backwards-compat reasons.\n            //       -- ExplodingCabbage\n            var headerMatch = (/^(?:Index:|diff(?: -r \\w+)+)\\s+/).exec(line);\n            if (headerMatch) {\n                index.index = line.substring(headerMatch[0].length).trim();\n            }\n            i++;\n        }\n        // Parse file headers if they are defined. Unified diff requires them, but\n        // there's no technical issues to have an isolated hunk without file header\n        parseFileHeader(index);\n        parseFileHeader(index);\n        // Parse hunks\n        index.hunks = [];\n        while (i < diffstr.length) {\n            var line = diffstr[i];\n            if ((/^(Index:\\s|diff\\s|---\\s|\\+\\+\\+\\s|===================================================================)/).test(line)) {\n                break;\n            }\n            else if ((/^@@/).test(line)) {\n                index.hunks.push(parseHunk());\n            }\n            else if (line) {\n                throw new Error('Unknown line ' + (i + 1) + ' ' + JSON.stringify(line));\n            }\n            else {\n                i++;\n            }\n        }\n    }\n    // Parses the --- and +++ headers, if none are found, no lines\n    // are consumed.\n    function parseFileHeader(index) {\n        var fileHeaderMatch = (/^(---|\\+\\+\\+)\\s+/).exec(diffstr[i]);\n        if (fileHeaderMatch) {\n            var prefix = fileHeaderMatch[1], data = diffstr[i].substring(3).trim().split('\\t', 2), header = (data[1] || '').trim();\n            var fileName = data[0].replace(/\\\\\\\\/g, '\\\\');\n            if (fileName.startsWith('\"') && fileName.endsWith('\"')) {\n                fileName = fileName.substr(1, fileName.length - 2);\n            }\n            if (prefix === '---') {\n                index.oldFileName = fileName;\n                index.oldHeader = header;\n            }\n            else {\n                index.newFileName = fileName;\n                index.newHeader = header;\n            }\n            i++;\n        }\n    }\n    // Parses a hunk\n    // This assumes that we are at the start of a hunk.\n    function parseHunk() {\n        var _a;\n        var chunkHeaderIndex = i, chunkHeaderLine = diffstr[i++], chunkHeader = chunkHeaderLine.split(/@@ -(\\d+)(?:,(\\d+))? \\+(\\d+)(?:,(\\d+))? @@/);\n        var hunk = {\n            oldStart: +chunkHeader[1],\n            oldLines: typeof chunkHeader[2] === 'undefined' ? 1 : +chunkHeader[2],\n            newStart: +chunkHeader[3],\n            newLines: typeof chunkHeader[4] === 'undefined' ? 1 : +chunkHeader[4],\n            lines: []\n        };\n        // Unified Diff Format quirk: If the chunk size is 0,\n        // the first number is one lower than one would expect.\n        // https://www.artima.com/weblogs/viewpost.jsp?thread=164293\n        if (hunk.oldLines === 0) {\n            hunk.oldStart += 1;\n        }\n        if (hunk.newLines === 0) {\n            hunk.newStart += 1;\n        }\n        var addCount = 0, removeCount = 0;\n        for (; i < diffstr.length && (removeCount < hunk.oldLines || addCount < hunk.newLines || ((_a = diffstr[i]) === null || _a === void 0 ? void 0 : _a.startsWith('\\\\'))); i++) {\n            var operation = (diffstr[i].length == 0 && i != (diffstr.length - 1)) ? ' ' : diffstr[i][0];\n            if (operation === '+' || operation === '-' || operation === ' ' || operation === '\\\\') {\n                hunk.lines.push(diffstr[i]);\n                if (operation === '+') {\n                    addCount++;\n                }\n                else if (operation === '-') {\n                    removeCount++;\n                }\n                else if (operation === ' ') {\n                    addCount++;\n                    removeCount++;\n                }\n            }\n            else {\n                throw new Error(\"Hunk at line \".concat(chunkHeaderIndex + 1, \" contained invalid line \").concat(diffstr[i]));\n            }\n        }\n        // Handle the empty block count case\n        if (!addCount && hunk.newLines === 1) {\n            hunk.newLines = 0;\n        }\n        if (!removeCount && hunk.oldLines === 1) {\n            hunk.oldLines = 0;\n        }\n        // Perform sanity checking\n        if (addCount !== hunk.newLines) {\n            throw new Error('Added line count did not match for hunk at line ' + (chunkHeaderIndex + 1));\n        }\n        if (removeCount !== hunk.oldLines) {\n            throw new Error('Removed line count did not match for hunk at line ' + (chunkHeaderIndex + 1));\n        }\n        return hunk;\n    }\n    while (i < diffstr.length) {\n        parseIndex();\n    }\n    return list;\n}\n","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.default = default_1;\n// Iterator that traverses in the range of [min, max], stepping\n// by distance from a given start position. I.e. for [0, 4], with\n// start of 2, this will iterate 2, 3, 1, 4, 0.\nfunction default_1(start, minLine, maxLine) {\n    var wantForward = true, backwardExhausted = false, forwardExhausted = false, localOffset = 1;\n    return function iterator() {\n        if (wantForward && !forwardExhausted) {\n            if (backwardExhausted) {\n                localOffset++;\n            }\n            else {\n                wantForward = false;\n            }\n            // Check if trying to fit beyond text length, and if not, check it fits\n            // after offset location (or desired location on first iteration)\n            if (start + localOffset <= maxLine) {\n                return start + localOffset;\n            }\n            forwardExhausted = true;\n        }\n        if (!backwardExhausted) {\n            if (!forwardExhausted) {\n                wantForward = true;\n            }\n            // Check if trying to fit before text beginning, and if not, check it fits\n            // before offset location\n            if (minLine <= start - localOffset) {\n                return start - localOffset++;\n            }\n            backwardExhausted = true;\n            return iterator();\n        }\n        // We tried to fit hunk before text beginning and beyond text length, then\n        // hunk can't fit on the text. Return undefined\n        return undefined;\n    };\n}\n","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.applyPatch = applyPatch;\nexports.applyPatches = applyPatches;\nvar string_js_1 = require(\"../util/string.js\");\nvar line_endings_js_1 = require(\"./line-endings.js\");\nvar parse_js_1 = require(\"./parse.js\");\nvar distance_iterator_js_1 = require(\"../util/distance-iterator.js\");\n/**\n * attempts to apply a unified diff patch.\n *\n * Hunks are applied first to last.\n * `applyPatch` first tries to apply the first hunk at the line number specified in the hunk header, and with all context lines matching exactly.\n * If that fails, it tries scanning backwards and forwards, one line at a time, to find a place to apply the hunk where the context lines match exactly.\n * If that still fails, and `fuzzFactor` is greater than zero, it increments the maximum number of mismatches (missing, extra, or changed context lines) that there can be between the hunk context and a region where we are trying to apply the patch such that the hunk will still be considered to match.\n * Regardless of `fuzzFactor`, lines to be deleted in the hunk *must* be present for a hunk to match, and the context lines *immediately* before and after an insertion must match exactly.\n *\n * Once a hunk is successfully fitted, the process begins again with the next hunk.\n * Regardless of `fuzzFactor`, later hunks must be applied later in the file than earlier hunks.\n *\n * If a hunk cannot be successfully fitted *anywhere* with fewer than `fuzzFactor` mismatches, `applyPatch` fails and returns `false`.\n *\n * If a hunk is successfully fitted but not at the line number specified by the hunk header, all subsequent hunks have their target line number adjusted accordingly.\n * (e.g. if the first hunk is applied 10 lines below where the hunk header said it should fit, `applyPatch` will *start* looking for somewhere to apply the second hunk 10 lines below where its hunk header says it goes.)\n *\n * If the patch was applied successfully, returns a string containing the patched text.\n * If the patch could not be applied (because some hunks in the patch couldn't be fitted to the text in `source`), `applyPatch` returns false.\n *\n * @param patch a string diff or the output from the `parsePatch` or `structuredPatch` methods.\n */\nfunction applyPatch(source, patch, options) {\n    if (options === void 0) { options = {}; }\n    var patches;\n    if (typeof patch === 'string') {\n        patches = (0, parse_js_1.parsePatch)(patch);\n    }\n    else if (Array.isArray(patch)) {\n        patches = patch;\n    }\n    else {\n        patches = [patch];\n    }\n    if (patches.length > 1) {\n        throw new Error('applyPatch only works with a single input.');\n    }\n    return applyStructuredPatch(source, patches[0], options);\n}\nfunction applyStructuredPatch(source, patch, options) {\n    if (options === void 0) { options = {}; }\n    if (options.autoConvertLineEndings || options.autoConvertLineEndings == null) {\n        if ((0, string_js_1.hasOnlyWinLineEndings)(source) && (0, line_endings_js_1.isUnix)(patch)) {\n            patch = (0, line_endings_js_1.unixToWin)(patch);\n        }\n        else if ((0, string_js_1.hasOnlyUnixLineEndings)(source) && (0, line_endings_js_1.isWin)(patch)) {\n            patch = (0, line_endings_js_1.winToUnix)(patch);\n        }\n    }\n    // Apply the diff to the input\n    var lines = source.split('\\n'), hunks = patch.hunks, compareLine = options.compareLine || (function (lineNumber, line, operation, patchContent) { return line === patchContent; }), fuzzFactor = options.fuzzFactor || 0;\n    var minLine = 0;\n    if (fuzzFactor < 0 || !Number.isInteger(fuzzFactor)) {\n        throw new Error('fuzzFactor must be a non-negative integer');\n    }\n    // Special case for empty patch.\n    if (!hunks.length) {\n        return source;\n    }\n    // Before anything else, handle EOFNL insertion/removal. If the patch tells us to make a change\n    // to the EOFNL that is redundant/impossible - i.e. to remove a newline that's not there, or add a\n    // newline that already exists - then we either return false and fail to apply the patch (if\n    // fuzzFactor is 0) or simply ignore the problem and do nothing (if fuzzFactor is >0).\n    // If we do need to remove/add a newline at EOF, this will always be in the final hunk:\n    var prevLine = '', removeEOFNL = false, addEOFNL = false;\n    for (var i = 0; i < hunks[hunks.length - 1].lines.length; i++) {\n        var line = hunks[hunks.length - 1].lines[i];\n        if (line[0] == '\\\\') {\n            if (prevLine[0] == '+') {\n                removeEOFNL = true;\n            }\n            else if (prevLine[0] == '-') {\n                addEOFNL = true;\n            }\n        }\n        prevLine = line;\n    }\n    if (removeEOFNL) {\n        if (addEOFNL) {\n            // This means the final line gets changed but doesn't have a trailing newline in either the\n            // original or patched version. In that case, we do nothing if fuzzFactor > 0, and if\n            // fuzzFactor is 0, we simply validate that the source file has no trailing newline.\n            if (!fuzzFactor && lines[lines.length - 1] == '') {\n                return false;\n            }\n        }\n        else if (lines[lines.length - 1] == '') {\n            lines.pop();\n        }\n        else if (!fuzzFactor) {\n            return false;\n        }\n    }\n    else if (addEOFNL) {\n        if (lines[lines.length - 1] != '') {\n            lines.push('');\n        }\n        else if (!fuzzFactor) {\n            return false;\n        }\n    }\n    /**\n     * Checks if the hunk can be made to fit at the provided location with at most `maxErrors`\n     * insertions, substitutions, or deletions, while ensuring also that:\n     * - lines deleted in the hunk match exactly, and\n     * - wherever an insertion operation or block of insertion operations appears in the hunk, the\n     *   immediately preceding and following lines of context match exactly\n     *\n     * `toPos` should be set such that lines[toPos] is meant to match hunkLines[0].\n     *\n     * If the hunk can be applied, returns an object with properties `oldLineLastI` and\n     * `replacementLines`. Otherwise, returns null.\n     */\n    function applyHunk(hunkLines, toPos, maxErrors, hunkLinesI, lastContextLineMatched, patchedLines, patchedLinesLength) {\n        if (hunkLinesI === void 0) { hunkLinesI = 0; }\n        if (lastContextLineMatched === void 0) { lastContextLineMatched = true; }\n        if (patchedLines === void 0) { patchedLines = []; }\n        if (patchedLinesLength === void 0) { patchedLinesLength = 0; }\n        var nConsecutiveOldContextLines = 0;\n        var nextContextLineMustMatch = false;\n        for (; hunkLinesI < hunkLines.length; hunkLinesI++) {\n            var hunkLine = hunkLines[hunkLinesI], operation = (hunkLine.length > 0 ? hunkLine[0] : ' '), content = (hunkLine.length > 0 ? hunkLine.substr(1) : hunkLine);\n            if (operation === '-') {\n                if (compareLine(toPos + 1, lines[toPos], operation, content)) {\n                    toPos++;\n                    nConsecutiveOldContextLines = 0;\n                }\n                else {\n                    if (!maxErrors || lines[toPos] == null) {\n                        return null;\n                    }\n                    patchedLines[patchedLinesLength] = lines[toPos];\n                    return applyHunk(hunkLines, toPos + 1, maxErrors - 1, hunkLinesI, false, patchedLines, patchedLinesLength + 1);\n                }\n            }\n            if (operation === '+') {\n                if (!lastContextLineMatched) {\n                    return null;\n                }\n                patchedLines[patchedLinesLength] = content;\n                patchedLinesLength++;\n                nConsecutiveOldContextLines = 0;\n                nextContextLineMustMatch = true;\n            }\n            if (operation === ' ') {\n                nConsecutiveOldContextLines++;\n                patchedLines[patchedLinesLength] = lines[toPos];\n                if (compareLine(toPos + 1, lines[toPos], operation, content)) {\n                    patchedLinesLength++;\n                    lastContextLineMatched = true;\n                    nextContextLineMustMatch = false;\n                    toPos++;\n                }\n                else {\n                    if (nextContextLineMustMatch || !maxErrors) {\n                        return null;\n                    }\n                    // Consider 3 possibilities in sequence:\n                    // 1. lines contains a *substitution* not included in the patch context, or\n                    // 2. lines contains an *insertion* not included in the patch context, or\n                    // 3. lines contains a *deletion* not included in the patch context\n                    // The first two options are of course only possible if the line from lines is non-null -\n                    // i.e. only option 3 is possible if we've overrun the end of the old file.\n                    return (lines[toPos] && (applyHunk(hunkLines, toPos + 1, maxErrors - 1, hunkLinesI + 1, false, patchedLines, patchedLinesLength + 1) || applyHunk(hunkLines, toPos + 1, maxErrors - 1, hunkLinesI, false, patchedLines, patchedLinesLength + 1)) || applyHunk(hunkLines, toPos, maxErrors - 1, hunkLinesI + 1, false, patchedLines, patchedLinesLength));\n                }\n            }\n        }\n        // Before returning, trim any unmodified context lines off the end of patchedLines and reduce\n        // toPos (and thus oldLineLastI) accordingly. This allows later hunks to be applied to a region\n        // that starts in this hunk's trailing context.\n        patchedLinesLength -= nConsecutiveOldContextLines;\n        toPos -= nConsecutiveOldContextLines;\n        patchedLines.length = patchedLinesLength;\n        return {\n            patchedLines: patchedLines,\n            oldLineLastI: toPos - 1\n        };\n    }\n    var resultLines = [];\n    // Search best fit offsets for each hunk based on the previous ones\n    var prevHunkOffset = 0;\n    for (var i = 0; i < hunks.length; i++) {\n        var hunk = hunks[i];\n        var hunkResult = void 0;\n        var maxLine = lines.length - hunk.oldLines + fuzzFactor;\n        var toPos = void 0;\n        for (var maxErrors = 0; maxErrors <= fuzzFactor; maxErrors++) {\n            toPos = hunk.oldStart + prevHunkOffset - 1;\n            var iterator = (0, distance_iterator_js_1.default)(toPos, minLine, maxLine);\n            for (; toPos !== undefined; toPos = iterator()) {\n                hunkResult = applyHunk(hunk.lines, toPos, maxErrors);\n                if (hunkResult) {\n                    break;\n                }\n            }\n            if (hunkResult) {\n                break;\n            }\n        }\n        if (!hunkResult) {\n            return false;\n        }\n        // Copy everything from the end of where we applied the last hunk to the start of this hunk\n        for (var i_1 = minLine; i_1 < toPos; i_1++) {\n            resultLines.push(lines[i_1]);\n        }\n        // Add the lines produced by applying the hunk:\n        for (var i_2 = 0; i_2 < hunkResult.patchedLines.length; i_2++) {\n            var line = hunkResult.patchedLines[i_2];\n            resultLines.push(line);\n        }\n        // Set lower text limit to end of the current hunk, so next ones don't try\n        // to fit over already patched text\n        minLine = hunkResult.oldLineLastI + 1;\n        // Note the offset between where the patch said the hunk should've applied and where we\n        // applied it, so we can adjust future hunks accordingly:\n        prevHunkOffset = toPos + 1 - hunk.oldStart;\n    }\n    // Copy over the rest of the lines from the old text\n    for (var i = minLine; i < lines.length; i++) {\n        resultLines.push(lines[i]);\n    }\n    return resultLines.join('\\n');\n}\n/**\n * applies one or more patches.\n *\n * `patch` may be either an array of structured patch objects, or a string representing a patch in unified diff format (which may patch one or more files).\n *\n * This method will iterate over the contents of the patch and apply to data provided through callbacks. The general flow for each patch index is:\n *\n * - `options.loadFile(index, callback)` is called. The caller should then load the contents of the file and then pass that to the `callback(err, data)` callback. Passing an `err` will terminate further patch execution.\n * - `options.patched(index, content, callback)` is called once the patch has been applied. `content` will be the return value from `applyPatch`. When it's ready, the caller should call `callback(err)` callback. Passing an `err` will terminate further patch execution.\n *\n * Once all patches have been applied or an error occurs, the `options.complete(err)` callback is made.\n */\nfunction applyPatches(uniDiff, options) {\n    var spDiff = typeof uniDiff === 'string' ? (0, parse_js_1.parsePatch)(uniDiff) : uniDiff;\n    var currentIndex = 0;\n    function processIndex() {\n        var index = spDiff[currentIndex++];\n        if (!index) {\n            return options.complete();\n        }\n        options.loadFile(index, function (err, data) {\n            if (err) {\n                return options.complete(err);\n            }\n            var updatedContent = applyPatch(data, index, options);\n            options.patched(index, updatedContent, function (err) {\n                if (err) {\n                    return options.complete(err);\n                }\n                processIndex();\n            });\n        });\n    }\n    processIndex();\n}\n","\"use strict\";\nvar __assign = (this && this.__assign) || function () {\n    __assign = Object.assign || function(t) {\n        for (var s, i = 1, n = arguments.length; i < n; i++) {\n            s = arguments[i];\n            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))\n                t[p] = s[p];\n        }\n        return t;\n    };\n    return __assign.apply(this, arguments);\n};\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.reversePatch = reversePatch;\nfunction reversePatch(structuredPatch) {\n    if (Array.isArray(structuredPatch)) {\n        // (See comment in unixToWin for why we need the pointless-looking anonymous function here)\n        return structuredPatch.map(function (patch) { return reversePatch(patch); }).reverse();\n    }\n    return __assign(__assign({}, structuredPatch), { oldFileName: structuredPatch.newFileName, oldHeader: structuredPatch.newHeader, newFileName: structuredPatch.oldFileName, newHeader: structuredPatch.oldHeader, hunks: structuredPatch.hunks.map(function (hunk) {\n            return {\n                oldLines: hunk.newLines,\n                oldStart: hunk.newStart,\n                newLines: hunk.oldLines,\n                newStart: hunk.oldStart,\n                lines: hunk.lines.map(function (l) {\n                    if (l.startsWith('-')) {\n                        return \"+\".concat(l.slice(1));\n                    }\n                    if (l.startsWith('+')) {\n                        return \"-\".concat(l.slice(1));\n                    }\n                    return l;\n                })\n            };\n        }) });\n}\n","\"use strict\";\nvar __assign = (this && this.__assign) || function () {\n    __assign = Object.assign || function(t) {\n        for (var s, i = 1, n = arguments.length; i < n; i++) {\n            s = arguments[i];\n            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))\n                t[p] = s[p];\n        }\n        return t;\n    };\n    return __assign.apply(this, arguments);\n};\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.OMIT_HEADERS = exports.FILE_HEADERS_ONLY = exports.INCLUDE_HEADERS = void 0;\nexports.structuredPatch = structuredPatch;\nexports.formatPatch = formatPatch;\nexports.createTwoFilesPatch = createTwoFilesPatch;\nexports.createPatch = createPatch;\nvar line_js_1 = require(\"../diff/line.js\");\nexports.INCLUDE_HEADERS = {\n    includeIndex: true,\n    includeUnderline: true,\n    includeFileHeaders: true\n};\nexports.FILE_HEADERS_ONLY = {\n    includeIndex: false,\n    includeUnderline: false,\n    includeFileHeaders: true\n};\nexports.OMIT_HEADERS = {\n    includeIndex: false,\n    includeUnderline: false,\n    includeFileHeaders: false\n};\nfunction structuredPatch(oldFileName, newFileName, oldStr, newStr, oldHeader, newHeader, options) {\n    var optionsObj;\n    if (!options) {\n        optionsObj = {};\n    }\n    else if (typeof options === 'function') {\n        optionsObj = { callback: options };\n    }\n    else {\n        optionsObj = options;\n    }\n    if (typeof optionsObj.context === 'undefined') {\n        optionsObj.context = 4;\n    }\n    // We copy this into its own variable to placate TypeScript, which thinks\n    // optionsObj.context might be undefined in the callbacks below.\n    var context = optionsObj.context;\n    // @ts-expect-error (runtime check for something that is correctly a static type error)\n    if (optionsObj.newlineIsToken) {\n        throw new Error('newlineIsToken may not be used with patch-generation functions, only with diffing functions');\n    }\n    if (!optionsObj.callback) {\n        return diffLinesResultToPatch((0, line_js_1.diffLines)(oldStr, newStr, optionsObj));\n    }\n    else {\n        var callback_1 = optionsObj.callback;\n        (0, line_js_1.diffLines)(oldStr, newStr, __assign(__assign({}, optionsObj), { callback: function (diff) {\n                var patch = diffLinesResultToPatch(diff);\n                // TypeScript is unhappy without the cast because it does not understand that `patch` may\n                // be undefined here only if `callback` is StructuredPatchCallbackAbortable:\n                callback_1(patch);\n            } }));\n    }\n    function diffLinesResultToPatch(diff) {\n        // STEP 1: Build up the patch with no \"\\ No newline at end of file\" lines and with the arrays\n        //         of lines containing trailing newline characters. We'll tidy up later...\n        if (!diff) {\n            return;\n        }\n        diff.push({ value: '', lines: [] }); // Append an empty value to make cleanup easier\n        function contextLines(lines) {\n            return lines.map(function (entry) { return ' ' + entry; });\n        }\n        var hunks = [];\n        var oldRangeStart = 0, newRangeStart = 0, curRange = [], oldLine = 1, newLine = 1;\n        for (var i = 0; i < diff.length; i++) {\n            var current = diff[i], lines = current.lines || splitLines(current.value);\n            current.lines = lines;\n            if (current.added || current.removed) {\n                // If we have previous context, start with that\n                if (!oldRangeStart) {\n                    var prev = diff[i - 1];\n                    oldRangeStart = oldLine;\n                    newRangeStart = newLine;\n                    if (prev) {\n                        curRange = context > 0 ? contextLines(prev.lines.slice(-context)) : [];\n                        oldRangeStart -= curRange.length;\n                        newRangeStart -= curRange.length;\n                    }\n                }\n                // Output our changes\n                for (var _i = 0, lines_1 = lines; _i < lines_1.length; _i++) {\n                    var line = lines_1[_i];\n                    curRange.push((current.added ? '+' : '-') + line);\n                }\n                // Track the updated file position\n                if (current.added) {\n                    newLine += lines.length;\n                }\n                else {\n                    oldLine += lines.length;\n                }\n            }\n            else {\n                // Identical context lines. Track line changes\n                if (oldRangeStart) {\n                    // Close out any changes that have been output (or join overlapping)\n                    if (lines.length <= context * 2 && i < diff.length - 2) {\n                        // Overlapping\n                        for (var _a = 0, _b = contextLines(lines); _a < _b.length; _a++) {\n                            var line = _b[_a];\n                            curRange.push(line);\n                        }\n                    }\n                    else {\n                        // end the range and output\n                        var contextSize = Math.min(lines.length, context);\n                        for (var _c = 0, _d = contextLines(lines.slice(0, contextSize)); _c < _d.length; _c++) {\n                            var line = _d[_c];\n                            curRange.push(line);\n                        }\n                        var hunk = {\n                            oldStart: oldRangeStart,\n                            oldLines: (oldLine - oldRangeStart + contextSize),\n                            newStart: newRangeStart,\n                            newLines: (newLine - newRangeStart + contextSize),\n                            lines: curRange\n                        };\n                        hunks.push(hunk);\n                        oldRangeStart = 0;\n                        newRangeStart = 0;\n                        curRange = [];\n                    }\n                }\n                oldLine += lines.length;\n                newLine += lines.length;\n            }\n        }\n        // Step 2: eliminate the trailing `\\n` from each line of each hunk, and, where needed, add\n        //         \"\\ No newline at end of file\".\n        for (var _e = 0, hunks_1 = hunks; _e < hunks_1.length; _e++) {\n            var hunk = hunks_1[_e];\n            for (var i = 0; i < hunk.lines.length; i++) {\n                if (hunk.lines[i].endsWith('\\n')) {\n                    hunk.lines[i] = hunk.lines[i].slice(0, -1);\n                }\n                else {\n                    hunk.lines.splice(i + 1, 0, '\\\\ No newline at end of file');\n                    i++; // Skip the line we just added, then continue iterating\n                }\n            }\n        }\n        return {\n            oldFileName: oldFileName, newFileName: newFileName,\n            oldHeader: oldHeader, newHeader: newHeader,\n            hunks: hunks\n        };\n    }\n}\n/**\n * creates a unified diff patch.\n * @param patch either a single structured patch object (as returned by `structuredPatch`) or an array of them (as returned by `parsePatch`)\n */\nfunction formatPatch(patch, headerOptions) {\n    if (!headerOptions) {\n        headerOptions = exports.INCLUDE_HEADERS;\n    }\n    if (Array.isArray(patch)) {\n        if (patch.length > 1 && !headerOptions.includeFileHeaders) {\n            throw new Error('Cannot omit file headers on a multi-file patch. '\n                + '(The result would be unparseable; how would a tool trying to apply '\n                + 'the patch know which changes are to which file?)');\n        }\n        return patch.map(function (p) { return formatPatch(p, headerOptions); }).join('\\n');\n    }\n    var ret = [];\n    if (headerOptions.includeIndex && patch.oldFileName == patch.newFileName) {\n        ret.push('Index: ' + patch.oldFileName);\n    }\n    if (headerOptions.includeUnderline) {\n        ret.push('===================================================================');\n    }\n    if (headerOptions.includeFileHeaders) {\n        ret.push('--- ' + patch.oldFileName + (typeof patch.oldHeader === 'undefined' ? '' : '\\t' + patch.oldHeader));\n        ret.push('+++ ' + patch.newFileName + (typeof patch.newHeader === 'undefined' ? '' : '\\t' + patch.newHeader));\n    }\n    for (var i = 0; i < patch.hunks.length; i++) {\n        var hunk = patch.hunks[i];\n        // Unified Diff Format quirk: If the chunk size is 0,\n        // the first number is one lower than one would expect.\n        // https://www.artima.com/weblogs/viewpost.jsp?thread=164293\n        if (hunk.oldLines === 0) {\n            hunk.oldStart -= 1;\n        }\n        if (hunk.newLines === 0) {\n            hunk.newStart -= 1;\n        }\n        ret.push('@@ -' + hunk.oldStart + ',' + hunk.oldLines\n            + ' +' + hunk.newStart + ',' + hunk.newLines\n            + ' @@');\n        for (var _i = 0, _a = hunk.lines; _i < _a.length; _i++) {\n            var line = _a[_i];\n            ret.push(line);\n        }\n    }\n    return ret.join('\\n') + '\\n';\n}\nfunction createTwoFilesPatch(oldFileName, newFileName, oldStr, newStr, oldHeader, newHeader, options) {\n    if (typeof options === 'function') {\n        options = { callback: options };\n    }\n    if (!(options === null || options === void 0 ? void 0 : options.callback)) {\n        var patchObj = structuredPatch(oldFileName, newFileName, oldStr, newStr, oldHeader, newHeader, options);\n        if (!patchObj) {\n            return;\n        }\n        return formatPatch(patchObj, options === null || options === void 0 ? void 0 : options.headerOptions);\n    }\n    else {\n        var callback_2 = options.callback;\n        structuredPatch(oldFileName, newFileName, oldStr, newStr, oldHeader, newHeader, __assign(__assign({}, options), { callback: function (patchObj) {\n                if (!patchObj) {\n                    callback_2(undefined);\n                }\n                else {\n                    callback_2(formatPatch(patchObj, options.headerOptions));\n                }\n            } }));\n    }\n}\nfunction createPatch(fileName, oldStr, newStr, oldHeader, newHeader, options) {\n    return createTwoFilesPatch(fileName, fileName, oldStr, newStr, oldHeader, newHeader, options);\n}\n/**\n * Split `text` into an array of lines, including the trailing newline character (where present)\n */\nfunction splitLines(text) {\n    var hasTrailingNl = text.endsWith('\\n');\n    var result = text.split('\\n').map(function (line) { return line + '\\n'; });\n    if (hasTrailingNl) {\n        result.pop();\n    }\n    else {\n        result.push(result.pop().slice(0, -1));\n    }\n    return result;\n}\n","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.convertChangesToDMP = convertChangesToDMP;\n/**\n * converts a list of change objects to the format returned by Google's [diff-match-patch](https://github.com/google/diff-match-patch) library\n */\nfunction convertChangesToDMP(changes) {\n    var ret = [];\n    var change, operation;\n    for (var i = 0; i < changes.length; i++) {\n        change = changes[i];\n        if (change.added) {\n            operation = 1;\n        }\n        else if (change.removed) {\n            operation = -1;\n        }\n        else {\n            operation = 0;\n        }\n        ret.push([operation, change.value]);\n    }\n    return ret;\n}\n","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.convertChangesToXML = convertChangesToXML;\n/**\n * converts a list of change objects to a serialized XML format\n */\nfunction convertChangesToXML(changes) {\n    var ret = [];\n    for (var i = 0; i < changes.length; i++) {\n        var change = changes[i];\n        if (change.added) {\n            ret.push('<ins>');\n        }\n        else if (change.removed) {\n            ret.push('<del>');\n        }\n        ret.push(escapeHTML(change.value));\n        if (change.added) {\n            ret.push('</ins>');\n        }\n        else if (change.removed) {\n            ret.push('</del>');\n        }\n    }\n    return ret.join('');\n}\nfunction escapeHTML(s) {\n    var n = s;\n    n = n.replace(/&/g, '&amp;');\n    n = n.replace(/</g, '&lt;');\n    n = n.replace(/>/g, '&gt;');\n    n = n.replace(/\"/g, '&quot;');\n    return n;\n}\n","\"use strict\";\n/* See LICENSE file for terms of use */\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.canonicalize = exports.convertChangesToXML = exports.convertChangesToDMP = exports.reversePatch = exports.parsePatch = exports.applyPatches = exports.applyPatch = exports.OMIT_HEADERS = exports.FILE_HEADERS_ONLY = exports.INCLUDE_HEADERS = exports.formatPatch = exports.createPatch = exports.createTwoFilesPatch = exports.structuredPatch = exports.arrayDiff = exports.diffArrays = exports.jsonDiff = exports.diffJson = exports.cssDiff = exports.diffCss = exports.sentenceDiff = exports.diffSentences = exports.diffTrimmedLines = exports.lineDiff = exports.diffLines = exports.wordsWithSpaceDiff = exports.diffWordsWithSpace = exports.wordDiff = exports.diffWords = exports.characterDiff = exports.diffChars = exports.Diff = void 0;\n/*\n * Text diff implementation.\n *\n * This library supports the following APIs:\n * Diff.diffChars: Character by character diff\n * Diff.diffWords: Word (as defined by \\b regex) diff which ignores whitespace\n * Diff.diffLines: Line based diff\n *\n * Diff.diffCss: Diff targeted at CSS content\n *\n * These methods are based on the implementation proposed in\n * \"An O(ND) Difference Algorithm and its Variations\" (Myers, 1986).\n * http://citeseerx.ist.psu.edu/viewdoc/summary?doi=10.1.1.4.6927\n */\nvar base_js_1 = require(\"./diff/base.js\");\nexports.Diff = base_js_1.default;\nvar character_js_1 = require(\"./diff/character.js\");\nObject.defineProperty(exports, \"diffChars\", { enumerable: true, get: function () { return character_js_1.diffChars; } });\nObject.defineProperty(exports, \"characterDiff\", { enumerable: true, get: function () { return character_js_1.characterDiff; } });\nvar word_js_1 = require(\"./diff/word.js\");\nObject.defineProperty(exports, \"diffWords\", { enumerable: true, get: function () { return word_js_1.diffWords; } });\nObject.defineProperty(exports, \"diffWordsWithSpace\", { enumerable: true, get: function () { return word_js_1.diffWordsWithSpace; } });\nObject.defineProperty(exports, \"wordDiff\", { enumerable: true, get: function () { return word_js_1.wordDiff; } });\nObject.defineProperty(exports, \"wordsWithSpaceDiff\", { enumerable: true, get: function () { return word_js_1.wordsWithSpaceDiff; } });\nvar line_js_1 = require(\"./diff/line.js\");\nObject.defineProperty(exports, \"diffLines\", { enumerable: true, get: function () { return line_js_1.diffLines; } });\nObject.defineProperty(exports, \"diffTrimmedLines\", { enumerable: true, get: function () { return line_js_1.diffTrimmedLines; } });\nObject.defineProperty(exports, \"lineDiff\", { enumerable: true, get: function () { return line_js_1.lineDiff; } });\nvar sentence_js_1 = require(\"./diff/sentence.js\");\nObject.defineProperty(exports, \"diffSentences\", { enumerable: true, get: function () { return sentence_js_1.diffSentences; } });\nObject.defineProperty(exports, \"sentenceDiff\", { enumerable: true, get: function () { return sentence_js_1.sentenceDiff; } });\nvar css_js_1 = require(\"./diff/css.js\");\nObject.defineProperty(exports, \"diffCss\", { enumerable: true, get: function () { return css_js_1.diffCss; } });\nObject.defineProperty(exports, \"cssDiff\", { enumerable: true, get: function () { return css_js_1.cssDiff; } });\nvar json_js_1 = require(\"./diff/json.js\");\nObject.defineProperty(exports, \"diffJson\", { enumerable: true, get: function () { return json_js_1.diffJson; } });\nObject.defineProperty(exports, \"canonicalize\", { enumerable: true, get: function () { return json_js_1.canonicalize; } });\nObject.defineProperty(exports, \"jsonDiff\", { enumerable: true, get: function () { return json_js_1.jsonDiff; } });\nvar array_js_1 = require(\"./diff/array.js\");\nObject.defineProperty(exports, \"diffArrays\", { enumerable: true, get: function () { return array_js_1.diffArrays; } });\nObject.defineProperty(exports, \"arrayDiff\", { enumerable: true, get: function () { return array_js_1.arrayDiff; } });\nvar apply_js_1 = require(\"./patch/apply.js\");\nObject.defineProperty(exports, \"applyPatch\", { enumerable: true, get: function () { return apply_js_1.applyPatch; } });\nObject.defineProperty(exports, \"applyPatches\", { enumerable: true, get: function () { return apply_js_1.applyPatches; } });\nvar parse_js_1 = require(\"./patch/parse.js\");\nObject.defineProperty(exports, \"parsePatch\", { enumerable: true, get: function () { return parse_js_1.parsePatch; } });\nvar reverse_js_1 = require(\"./patch/reverse.js\");\nObject.defineProperty(exports, \"reversePatch\", { enumerable: true, get: function () { return reverse_js_1.reversePatch; } });\nvar create_js_1 = require(\"./patch/create.js\");\nObject.defineProperty(exports, \"structuredPatch\", { enumerable: true, get: function () { return create_js_1.structuredPatch; } });\nObject.defineProperty(exports, \"createTwoFilesPatch\", { enumerable: true, get: function () { return create_js_1.createTwoFilesPatch; } });\nObject.defineProperty(exports, \"createPatch\", { enumerable: true, get: function () { return create_js_1.createPatch; } });\nObject.defineProperty(exports, \"formatPatch\", { enumerable: true, get: function () { return create_js_1.formatPatch; } });\nObject.defineProperty(exports, \"INCLUDE_HEADERS\", { enumerable: true, get: function () { return create_js_1.INCLUDE_HEADERS; } });\nObject.defineProperty(exports, \"FILE_HEADERS_ONLY\", { enumerable: true, get: function () { return create_js_1.FILE_HEADERS_ONLY; } });\nObject.defineProperty(exports, \"OMIT_HEADERS\", { enumerable: true, get: function () { return create_js_1.OMIT_HEADERS; } });\nvar dmp_js_1 = require(\"./convert/dmp.js\");\nObject.defineProperty(exports, \"convertChangesToDMP\", { enumerable: true, get: function () { return dmp_js_1.convertChangesToDMP; } });\nvar xml_js_1 = require(\"./convert/xml.js\");\nObject.defineProperty(exports, \"convertChangesToXML\", { enumerable: true, get: function () { return xml_js_1.convertChangesToXML; } });\n","\"use strict\";\n\nconst arrayProto = require(\"@sinonjs/commons\").prototypes.array;\nconst Colorizer = require(\"./colorizer\");\nconst colororizer = new Colorizer();\nconst match = require(\"@sinonjs/samsam\").createMatcher;\nconst timesInWords = require(\"./util/core/times-in-words\");\nconst inspect = require(\"util\").inspect;\nconst jsDiff = require(\"diff\");\n\nconst join = arrayProto.join;\nconst map = arrayProto.map;\nconst push = arrayProto.push;\nconst slice = arrayProto.slice;\n\n/**\n *\n * @param matcher\n * @param calledArg\n * @param calledArgMessage\n *\n * @returns {string} the colored text\n */\nfunction colorSinonMatchText(matcher, calledArg, calledArgMessage) {\n    let calledArgumentMessage = calledArgMessage;\n    let matcherMessage = matcher.message;\n    if (!matcher.test(calledArg)) {\n        matcherMessage = colororizer.red(matcher.message);\n        if (calledArgumentMessage) {\n            calledArgumentMessage = colororizer.green(calledArgumentMessage);\n        }\n    }\n    return `${calledArgumentMessage} ${matcherMessage}`;\n}\n\n/**\n * @param diff\n *\n * @returns {string} the colored diff\n */\nfunction colorDiffText(diff) {\n    const objects = map(diff, function (part) {\n        let text = part.value;\n        if (part.added) {\n            text = colororizer.green(text);\n        } else if (part.removed) {\n            text = colororizer.red(text);\n        }\n        if (diff.length === 2) {\n            text += \" \"; // format simple diffs\n        }\n        return text;\n    });\n    return join(objects, \"\");\n}\n\n/**\n *\n * @param value\n * @returns {string} a quoted string\n */\nfunction quoteStringValue(value) {\n    if (typeof value === \"string\") {\n        return JSON.stringify(value);\n    }\n    return value;\n}\n\nmodule.exports = {\n    c: function (spyInstance) {\n        return timesInWords(spyInstance.callCount);\n    },\n\n    n: function (spyInstance) {\n        // eslint-disable-next-line @sinonjs/no-prototype-methods/no-prototype-methods\n        return spyInstance.toString();\n    },\n\n    D: function (spyInstance, args) {\n        let message = \"\";\n\n        for (let i = 0, l = spyInstance.callCount; i < l; ++i) {\n            // describe multiple calls\n            if (l > 1) {\n                message += `\\nCall ${i + 1}:`;\n            }\n            const calledArgs = spyInstance.getCall(i).args;\n            const expectedArgs = slice(args);\n\n            for (\n                let j = 0;\n                j < calledArgs.length || j < expectedArgs.length;\n                ++j\n            ) {\n                let calledArg = calledArgs[j];\n                let expectedArg = expectedArgs[j];\n                if (calledArg) {\n                    calledArg = quoteStringValue(calledArg);\n                }\n\n                if (expectedArg) {\n                    expectedArg = quoteStringValue(expectedArg);\n                }\n\n                message += \"\\n\";\n\n                const calledArgMessage =\n                    j < calledArgs.length ? inspect(calledArg) : \"\";\n                if (match.isMatcher(expectedArg)) {\n                    message += colorSinonMatchText(\n                        expectedArg,\n                        calledArg,\n                        calledArgMessage,\n                    );\n                } else {\n                    const expectedArgMessage =\n                        j < expectedArgs.length ? inspect(expectedArg) : \"\";\n                    const diff = jsDiff.diffJson(\n                        calledArgMessage,\n                        expectedArgMessage,\n                    );\n                    message += colorDiffText(diff);\n                }\n            }\n        }\n\n        return message;\n    },\n\n    C: function (spyInstance) {\n        const calls = [];\n\n        for (let i = 0, l = spyInstance.callCount; i < l; ++i) {\n            // eslint-disable-next-line @sinonjs/no-prototype-methods/no-prototype-methods\n            let stringifiedCall = `    ${spyInstance.getCall(i).toString()}`;\n            if (/\\n/.test(calls[i - 1])) {\n                stringifiedCall = `\\n${stringifiedCall}`;\n            }\n            push(calls, stringifiedCall);\n        }\n\n        return calls.length > 0 ? `\\n${join(calls, \"\\n\")}` : \"\";\n    },\n\n    t: function (spyInstance) {\n        const objects = [];\n\n        for (let i = 0, l = spyInstance.callCount; i < l; ++i) {\n            push(objects, inspect(spyInstance.thisValues[i]));\n        }\n\n        return join(objects, \", \");\n    },\n\n    \"*\": function (spyInstance, args) {\n        return join(\n            map(args, function (arg) {\n                return inspect(arg);\n            }),\n            \", \",\n        );\n    },\n};\n","\"use strict\";\n\nconst arrayProto = require(\"@sinonjs/commons\").prototypes.array;\nconst extend = require(\"./util/core/extend\");\nconst functionToString = require(\"./util/core/function-to-string\");\nconst proxyCall = require(\"./proxy-call\");\nconst proxyCallUtil = require(\"./proxy-call-util\");\nconst proxyInvoke = require(\"./proxy-invoke\");\nconst inspect = require(\"util\").inspect;\n\nconst push = arrayProto.push;\nconst forEach = arrayProto.forEach;\nconst slice = arrayProto.slice;\n\nconst emptyFakes = Object.freeze([]);\n\n// Public API\nconst proxyApi = {\n    toString: functionToString,\n\n    named: function named(name) {\n        this.displayName = name;\n        const nameDescriptor = Object.getOwnPropertyDescriptor(this, \"name\");\n        if (nameDescriptor && nameDescriptor.configurable) {\n            // IE 11 functions don't have a name.\n            // Safari 9 has names that are not configurable.\n            nameDescriptor.value = name;\n            Object.defineProperty(this, \"name\", nameDescriptor);\n        }\n        return this;\n    },\n\n    invoke: proxyInvoke,\n\n    /*\n     * Hook for derived implementation to return fake instances matching the\n     * given arguments.\n     */\n    matchingFakes: function (/*args, strict*/) {\n        return emptyFakes;\n    },\n\n    getCall: function getCall(index) {\n        let i = index;\n        if (i < 0) {\n            // Negative indices means counting backwards from the last call\n            i += this.callCount;\n        }\n        if (i < 0 || i >= this.callCount) {\n            return null;\n        }\n\n        return proxyCall(\n            this,\n            this.thisValues[i],\n            this.args[i],\n            this.returnValues[i],\n            this.exceptions[i],\n            this.callIds[i],\n            this.errorsWithCallStack[i],\n        );\n    },\n\n    getCalls: function () {\n        const calls = [];\n        let i;\n\n        for (i = 0; i < this.callCount; i++) {\n            push(calls, this.getCall(i));\n        }\n\n        return calls;\n    },\n\n    calledBefore: function calledBefore(proxy) {\n        if (!this.called) {\n            return false;\n        }\n\n        if (!proxy.called) {\n            return true;\n        }\n\n        return this.callIds[0] < proxy.callIds[proxy.callIds.length - 1];\n    },\n\n    calledAfter: function calledAfter(proxy) {\n        if (!this.called || !proxy.called) {\n            return false;\n        }\n\n        return this.callIds[this.callCount - 1] > proxy.callIds[0];\n    },\n\n    calledImmediatelyBefore: function calledImmediatelyBefore(proxy) {\n        if (!this.called || !proxy.called) {\n            return false;\n        }\n\n        return (\n            this.callIds[this.callCount - 1] ===\n            proxy.callIds[proxy.callCount - 1] - 1\n        );\n    },\n\n    calledImmediatelyAfter: function calledImmediatelyAfter(proxy) {\n        if (!this.called || !proxy.called) {\n            return false;\n        }\n\n        return (\n            this.callIds[this.callCount - 1] ===\n            proxy.callIds[proxy.callCount - 1] + 1\n        );\n    },\n\n    formatters: require(\"./spy-formatters\"),\n    printf: function (format) {\n        const spyInstance = this;\n        const args = slice(arguments, 1);\n        let formatter;\n\n        return (format || \"\").replace(/%(.)/g, function (match, specifier) {\n            formatter = proxyApi.formatters[specifier];\n\n            if (typeof formatter === \"function\") {\n                return String(formatter(spyInstance, args));\n            } else if (!isNaN(parseInt(specifier, 10))) {\n                return inspect(args[specifier - 1]);\n            }\n\n            return `%${specifier}`;\n        });\n    },\n\n    resetHistory: function () {\n        if (this.invoking) {\n            const err = new Error(\n                \"Cannot reset Sinon function while invoking it. \" +\n                    \"Move the call to .resetHistory outside of the callback.\",\n            );\n            err.name = \"InvalidResetException\";\n            throw err;\n        }\n\n        this.called = false;\n        this.notCalled = true;\n        this.calledOnce = false;\n        this.calledTwice = false;\n        this.calledThrice = false;\n        this.callCount = 0;\n        this.firstCall = null;\n        this.secondCall = null;\n        this.thirdCall = null;\n        this.lastCall = null;\n        this.args = [];\n        this.firstArg = null;\n        this.lastArg = null;\n        this.returnValues = [];\n        this.thisValues = [];\n        this.exceptions = [];\n        this.callIds = [];\n        this.errorsWithCallStack = [];\n\n        if (this.fakes) {\n            forEach(this.fakes, function (fake) {\n                fake.resetHistory();\n            });\n        }\n\n        return this;\n    },\n};\n\nconst delegateToCalls = proxyCallUtil.delegateToCalls;\ndelegateToCalls(proxyApi, \"calledOn\", true);\ndelegateToCalls(proxyApi, \"alwaysCalledOn\", false, \"calledOn\");\ndelegateToCalls(proxyApi, \"calledWith\", true);\ndelegateToCalls(\n    proxyApi,\n    \"calledOnceWith\",\n    true,\n    \"calledWith\",\n    false,\n    undefined,\n    1,\n);\ndelegateToCalls(proxyApi, \"calledWithMatch\", true);\ndelegateToCalls(proxyApi, \"alwaysCalledWith\", false, \"calledWith\");\ndelegateToCalls(proxyApi, \"alwaysCalledWithMatch\", false, \"calledWithMatch\");\ndelegateToCalls(proxyApi, \"calledWithExactly\", true);\ndelegateToCalls(\n    proxyApi,\n    \"calledOnceWithExactly\",\n    true,\n    \"calledWithExactly\",\n    false,\n    undefined,\n    1,\n);\ndelegateToCalls(\n    proxyApi,\n    \"calledOnceWithMatch\",\n    true,\n    \"calledWithMatch\",\n    false,\n    undefined,\n    1,\n);\ndelegateToCalls(\n    proxyApi,\n    \"alwaysCalledWithExactly\",\n    false,\n    \"calledWithExactly\",\n);\ndelegateToCalls(\n    proxyApi,\n    \"neverCalledWith\",\n    false,\n    \"notCalledWith\",\n    false,\n    function () {\n        return true;\n    },\n);\ndelegateToCalls(\n    proxyApi,\n    \"neverCalledWithMatch\",\n    false,\n    \"notCalledWithMatch\",\n    false,\n    function () {\n        return true;\n    },\n);\ndelegateToCalls(proxyApi, \"threw\", true);\ndelegateToCalls(proxyApi, \"alwaysThrew\", false, \"threw\");\ndelegateToCalls(proxyApi, \"returned\", true);\ndelegateToCalls(proxyApi, \"alwaysReturned\", false, \"returned\");\ndelegateToCalls(proxyApi, \"calledWithNew\", true);\ndelegateToCalls(proxyApi, \"alwaysCalledWithNew\", false, \"calledWithNew\");\n\nfunction createProxy(func, originalFunc) {\n    const proxy = wrapFunction(func, originalFunc);\n\n    // Inherit function properties:\n    extend(proxy, func);\n\n    proxy.prototype = func.prototype;\n\n    extend.nonEnum(proxy, proxyApi);\n\n    return proxy;\n}\n\nfunction wrapFunction(func, originalFunc) {\n    const arity = originalFunc.length;\n    let p;\n    // Do not change this to use an eval. Projects that depend on sinon block the use of eval.\n    // ref: https://github.com/sinonjs/sinon/issues/710\n    switch (arity) {\n        /*eslint-disable no-unused-vars, max-len*/\n        case 0:\n            p = function proxy() {\n                return p.invoke(func, this, slice(arguments));\n            };\n            break;\n        case 1:\n            p = function proxy(a) {\n                return p.invoke(func, this, slice(arguments));\n            };\n            break;\n        case 2:\n            p = function proxy(a, b) {\n                return p.invoke(func, this, slice(arguments));\n            };\n            break;\n        case 3:\n            p = function proxy(a, b, c) {\n                return p.invoke(func, this, slice(arguments));\n            };\n            break;\n        case 4:\n            p = function proxy(a, b, c, d) {\n                return p.invoke(func, this, slice(arguments));\n            };\n            break;\n        case 5:\n            p = function proxy(a, b, c, d, e) {\n                return p.invoke(func, this, slice(arguments));\n            };\n            break;\n        case 6:\n            p = function proxy(a, b, c, d, e, f) {\n                return p.invoke(func, this, slice(arguments));\n            };\n            break;\n        case 7:\n            p = function proxy(a, b, c, d, e, f, g) {\n                return p.invoke(func, this, slice(arguments));\n            };\n            break;\n        case 8:\n            p = function proxy(a, b, c, d, e, f, g, h) {\n                return p.invoke(func, this, slice(arguments));\n            };\n            break;\n        case 9:\n            p = function proxy(a, b, c, d, e, f, g, h, i) {\n                return p.invoke(func, this, slice(arguments));\n            };\n            break;\n        case 10:\n            p = function proxy(a, b, c, d, e, f, g, h, i, j) {\n                return p.invoke(func, this, slice(arguments));\n            };\n            break;\n        case 11:\n            p = function proxy(a, b, c, d, e, f, g, h, i, j, k) {\n                return p.invoke(func, this, slice(arguments));\n            };\n            break;\n        case 12:\n            p = function proxy(a, b, c, d, e, f, g, h, i, j, k, l) {\n                return p.invoke(func, this, slice(arguments));\n            };\n            break;\n        default:\n            p = function proxy() {\n                return p.invoke(func, this, slice(arguments));\n            };\n            break;\n        /*eslint-enable*/\n    }\n    const nameDescriptor = Object.getOwnPropertyDescriptor(\n        originalFunc,\n        \"name\",\n    );\n    if (nameDescriptor && nameDescriptor.configurable) {\n        // IE 11 functions don't have a name.\n        // Safari 9 has names that are not configurable.\n        Object.defineProperty(p, \"name\", nameDescriptor);\n    }\n    extend.nonEnum(p, {\n        isSinonProxy: true,\n\n        called: false,\n        notCalled: true,\n        calledOnce: false,\n        calledTwice: false,\n        calledThrice: false,\n        callCount: 0,\n        firstCall: null,\n        firstArg: null,\n        secondCall: null,\n        thirdCall: null,\n        lastCall: null,\n        lastArg: null,\n        args: [],\n        returnValues: [],\n        thisValues: [],\n        exceptions: [],\n        callIds: [],\n        errorsWithCallStack: [],\n    });\n    return p;\n}\n\nmodule.exports = createProxy;\n","\"use strict\";\n\n/**\n * @param {*} object\n * @param {string} property\n * @returns {boolean} whether a prop exists in the prototype chain\n */\nfunction isNonExistentProperty(object, property) {\n    return Boolean(\n        object && typeof property !== \"undefined\" && !(property in object),\n    );\n}\n\nmodule.exports = isNonExistentProperty;\n","\"use strict\";\n\n/**\n * Verify if an object is a ECMAScript Module\n *\n * As the exports from a module is immutable we cannot alter the exports\n * using spies or stubs. Let the consumer know this to avoid bug reports\n * on weird error messages.\n *\n * @param {object} object The object to examine\n * @returns {boolean} true when the object is a module\n */\nmodule.exports = function (object) {\n    return (\n        object &&\n        typeof Symbol !== \"undefined\" &&\n        object[Symbol.toStringTag] === \"Module\" &&\n        Object.isSealed(object)\n    );\n};\n","\"use strict\";\n\nconst functionName = require(\"@sinonjs/commons\").functionName;\n\nconst getPropertyDescriptor = require(\"./get-property-descriptor\");\nconst walk = require(\"./walk\");\n\n/**\n * A utility that allows traversing an object, applying mutating functions on the properties\n *\n * @param {Function} mutator called on each property\n * @param {object} object the object we are walking over\n * @param {Function} filter a predicate (boolean function) that will decide whether or not to apply the mutator to the current property\n * @returns {void} nothing\n */\nfunction walkObject(mutator, object, filter) {\n    let called = false;\n    const name = functionName(mutator);\n\n    if (!object) {\n        throw new Error(\n            `Trying to ${name} object but received ${String(object)}`,\n        );\n    }\n\n    walk(object, function (prop, propOwner) {\n        // we don't want to stub things like toString(), valueOf(), etc. so we only stub if the object\n        // is not Object.prototype\n        if (\n            propOwner !== Object.prototype &&\n            prop !== \"constructor\" &&\n            typeof getPropertyDescriptor(propOwner, prop).value === \"function\"\n        ) {\n            if (filter) {\n                if (filter(object, prop)) {\n                    called = true;\n                    mutator(object, prop);\n                }\n            } else {\n                called = true;\n                mutator(object, prop);\n            }\n        }\n    });\n\n    if (!called) {\n        throw new Error(\n            `Found no methods on object to which we could apply mutations`,\n        );\n    }\n\n    return object;\n}\n\nmodule.exports = walkObject;\n","\"use strict\";\n\nconst sinonTypeSymbolProperty = Symbol(\"SinonType\");\n\nmodule.exports = {\n    /**\n     * Set the type of a Sinon object to make it possible to identify it later at runtime\n     *\n     * @param {object|Function} object  object/function to set the type on\n     * @param {string} type the named type of the object/function\n     */\n    set(object, type) {\n        Object.defineProperty(object, sinonTypeSymbolProperty, {\n            value: type,\n            configurable: false,\n            enumerable: false,\n        });\n    },\n    get(object) {\n        return object && object[sinonTypeSymbolProperty];\n    },\n};\n","\"use strict\";\n\n// eslint-disable-next-line no-empty-function\nconst noop = () => {};\nconst getPropertyDescriptor = require(\"./get-property-descriptor\");\nconst extend = require(\"./extend\");\nconst sinonType = require(\"./sinon-type\");\nconst hasOwnProperty =\n    require(\"@sinonjs/commons\").prototypes.object.hasOwnProperty;\nconst valueToString = require(\"@sinonjs/commons\").valueToString;\nconst push = require(\"@sinonjs/commons\").prototypes.array.push;\n\nfunction isFunction(obj) {\n    return (\n        typeof obj === \"function\" ||\n        Boolean(obj && obj.constructor && obj.call && obj.apply)\n    );\n}\n\nfunction mirrorProperties(target, source) {\n    for (const prop in source) {\n        if (!hasOwnProperty(target, prop)) {\n            target[prop] = source[prop];\n        }\n    }\n}\n\nfunction getAccessor(object, property, method) {\n    const accessors = [\"get\", \"set\"];\n    const descriptor = getPropertyDescriptor(object, property);\n\n    for (let i = 0; i < accessors.length; i++) {\n        if (\n            descriptor[accessors[i]] &&\n            descriptor[accessors[i]].name === method.name\n        ) {\n            return accessors[i];\n        }\n    }\n    return null;\n}\n\n// Cheap way to detect if we have ES5 support.\nconst hasES5Support = \"keys\" in Object;\n\nmodule.exports = function wrapMethod(object, property, method) {\n    if (!object) {\n        throw new TypeError(\"Should wrap property of object\");\n    }\n\n    if (typeof method !== \"function\" && typeof method !== \"object\") {\n        throw new TypeError(\n            \"Method wrapper should be a function or a property descriptor\",\n        );\n    }\n\n    function checkWrappedMethod(wrappedMethod) {\n        let error;\n\n        if (!isFunction(wrappedMethod)) {\n            error = new TypeError(\n                `Attempted to wrap ${typeof wrappedMethod} property ${valueToString(\n                    property,\n                )} as function`,\n            );\n        } else if (wrappedMethod.restore && wrappedMethod.restore.sinon) {\n            error = new TypeError(\n                `Attempted to wrap ${valueToString(\n                    property,\n                )} which is already wrapped`,\n            );\n        } else if (wrappedMethod.calledBefore) {\n            const verb = wrappedMethod.returns ? \"stubbed\" : \"spied on\";\n            error = new TypeError(\n                `Attempted to wrap ${valueToString(\n                    property,\n                )} which is already ${verb}`,\n            );\n        }\n\n        if (error) {\n            if (wrappedMethod && wrappedMethod.stackTraceError) {\n                error.stack += `\\n--------------\\n${wrappedMethod.stackTraceError.stack}`;\n            }\n            throw error;\n        }\n    }\n\n    let error, wrappedMethod, i, wrappedMethodDesc, target, accessor;\n\n    const wrappedMethods = [];\n\n    function simplePropertyAssignment() {\n        wrappedMethod = object[property];\n        checkWrappedMethod(wrappedMethod);\n        object[property] = method;\n        method.displayName = property;\n    }\n\n    // Firefox has a problem when using hasOwn.call on objects from other frames.\n    const owned = object.hasOwnProperty\n        ? object.hasOwnProperty(property) // eslint-disable-line @sinonjs/no-prototype-methods/no-prototype-methods\n        : hasOwnProperty(object, property);\n\n    if (hasES5Support) {\n        const methodDesc =\n            typeof method === \"function\" ? { value: method } : method;\n        wrappedMethodDesc = getPropertyDescriptor(object, property);\n\n        if (!wrappedMethodDesc) {\n            error = new TypeError(\n                `Attempted to wrap ${typeof wrappedMethod} property ${property} as function`,\n            );\n        } else if (\n            wrappedMethodDesc.restore &&\n            wrappedMethodDesc.restore.sinon\n        ) {\n            error = new TypeError(\n                `Attempted to wrap ${property} which is already wrapped`,\n            );\n        }\n        if (error) {\n            if (wrappedMethodDesc && wrappedMethodDesc.stackTraceError) {\n                error.stack += `\\n--------------\\n${wrappedMethodDesc.stackTraceError.stack}`;\n            }\n            throw error;\n        }\n\n        const types = Object.keys(methodDesc);\n        for (i = 0; i < types.length; i++) {\n            wrappedMethod = wrappedMethodDesc[types[i]];\n            checkWrappedMethod(wrappedMethod);\n            push(wrappedMethods, wrappedMethod);\n        }\n\n        mirrorProperties(methodDesc, wrappedMethodDesc);\n        for (i = 0; i < types.length; i++) {\n            mirrorProperties(methodDesc[types[i]], wrappedMethodDesc[types[i]]);\n        }\n\n        // you are not allowed to flip the configurable prop on an\n        // existing descriptor to anything but false (#2514)\n        if (!owned) {\n            methodDesc.configurable = true;\n        }\n\n        Object.defineProperty(object, property, methodDesc);\n\n        // catch failing assignment\n        // this is the converse of the check in `.restore` below\n        if (typeof method === \"function\" && object[property] !== method) {\n            // correct any wrongdoings caused by the defineProperty call above,\n            // such as adding new items (if object was a Storage object)\n            delete object[property];\n            simplePropertyAssignment();\n        }\n    } else {\n        simplePropertyAssignment();\n    }\n\n    extendObjectWithWrappedMethods();\n\n    function extendObjectWithWrappedMethods() {\n        for (i = 0; i < wrappedMethods.length; i++) {\n            accessor = getAccessor(object, property, wrappedMethods[i]);\n            target = accessor ? method[accessor] : method;\n            extend.nonEnum(target, {\n                displayName: property,\n                wrappedMethod: wrappedMethods[i],\n\n                // Set up an Error object for a stack trace which can be used later to find what line of\n                // code the original method was created on.\n                stackTraceError: new Error(\"Stack Trace for original\"),\n\n                restore: restore,\n            });\n\n            target.restore.sinon = true;\n            if (!hasES5Support) {\n                mirrorProperties(target, wrappedMethod);\n            }\n        }\n    }\n\n    function restore() {\n        accessor = getAccessor(object, property, this.wrappedMethod);\n        let descriptor;\n        // For prototype properties try to reset by delete first.\n        // If this fails (ex: localStorage on mobile safari) then force a reset\n        // via direct assignment.\n        if (accessor) {\n            if (!owned) {\n                try {\n                    // In some cases `delete` may throw an error\n                    delete object[property][accessor];\n                } catch (e) {} // eslint-disable-line no-empty\n                // For native code functions `delete` fails without throwing an error\n                // on Chrome < 43, PhantomJS, etc.\n            } else if (hasES5Support) {\n                descriptor = getPropertyDescriptor(object, property);\n                descriptor[accessor] = wrappedMethodDesc[accessor];\n                Object.defineProperty(object, property, descriptor);\n            }\n\n            if (hasES5Support) {\n                descriptor = getPropertyDescriptor(object, property);\n                if (descriptor && descriptor.value === target) {\n                    object[property][accessor] = this.wrappedMethod;\n                }\n            } else {\n                // Use strict equality comparison to check failures then force a reset\n                // via direct assignment.\n                if (object[property][accessor] === target) {\n                    object[property][accessor] = this.wrappedMethod;\n                }\n            }\n        } else {\n            if (!owned) {\n                try {\n                    delete object[property];\n                } catch (e) {} // eslint-disable-line no-empty\n            } else if (hasES5Support) {\n                Object.defineProperty(object, property, wrappedMethodDesc);\n            }\n\n            if (hasES5Support) {\n                descriptor = getPropertyDescriptor(object, property);\n                if (descriptor && descriptor.value === target) {\n                    object[property] = this.wrappedMethod;\n                }\n            } else {\n                if (object[property] === target) {\n                    object[property] = this.wrappedMethod;\n                }\n            }\n        }\n        if (sinonType.get(object) === \"stub-instance\") {\n            // this is simply to avoid errors after restoring if something should\n            // traverse the object in a cleanup phase, ref #2477\n            object[property] = noop;\n        }\n    }\n\n    return method;\n};\n","\"use strict\";\n\nconst arrayProto = require(\"@sinonjs/commons\").prototypes.array;\nconst createProxy = require(\"./proxy\");\nconst extend = require(\"./util/core/extend\");\nconst functionName = require(\"@sinonjs/commons\").functionName;\nconst getPropertyDescriptor = require(\"./util/core/get-property-descriptor\");\nconst deepEqual = require(\"@sinonjs/samsam\").deepEqual;\nconst isEsModule = require(\"./util/core/is-es-module\");\nconst proxyCallUtil = require(\"./proxy-call-util\");\nconst walkObject = require(\"./util/core/walk-object\");\nconst wrapMethod = require(\"./util/core/wrap-method\");\nconst valueToString = require(\"@sinonjs/commons\").valueToString;\n\n/* cache references to library methods so that they also can be stubbed without problems */\nconst forEach = arrayProto.forEach;\nconst pop = arrayProto.pop;\nconst push = arrayProto.push;\nconst slice = arrayProto.slice;\nconst filter = Array.prototype.filter;\n\nlet uuid = 0;\n\nfunction matches(fake, args, strict) {\n    const margs = fake.matchingArguments;\n    if (\n        margs.length <= args.length &&\n        deepEqual(slice(args, 0, margs.length), margs)\n    ) {\n        return !strict || margs.length === args.length;\n    }\n    return false;\n}\n\n// Public API\nconst spyApi = {\n    withArgs: function () {\n        const args = slice(arguments);\n        const matching = pop(this.matchingFakes(args, true));\n        if (matching) {\n            return matching;\n        }\n\n        const original = this;\n        const fake = this.instantiateFake();\n        fake.matchingArguments = args;\n        fake.parent = this;\n        push(this.fakes, fake);\n\n        fake.withArgs = function () {\n            return original.withArgs.apply(original, arguments);\n        };\n\n        forEach(original.args, function (arg, i) {\n            if (!matches(fake, arg)) {\n                return;\n            }\n\n            proxyCallUtil.incrementCallCount(fake);\n            push(fake.thisValues, original.thisValues[i]);\n            push(fake.args, arg);\n            push(fake.returnValues, original.returnValues[i]);\n            push(fake.exceptions, original.exceptions[i]);\n            push(fake.callIds, original.callIds[i]);\n        });\n\n        proxyCallUtil.createCallProperties(fake);\n\n        return fake;\n    },\n\n    // Override proxy default implementation\n    matchingFakes: function (args, strict) {\n        return filter.call(this.fakes, function (fake) {\n            return matches(fake, args, strict);\n        });\n    },\n};\n\n/* eslint-disable @sinonjs/no-prototype-methods/no-prototype-methods */\nconst delegateToCalls = proxyCallUtil.delegateToCalls;\ndelegateToCalls(spyApi, \"callArg\", false, \"callArgWith\", true, function () {\n    throw new Error(\n        `${this.toString()} cannot call arg since it was not yet invoked.`,\n    );\n});\nspyApi.callArgWith = spyApi.callArg;\ndelegateToCalls(spyApi, \"callArgOn\", false, \"callArgOnWith\", true, function () {\n    throw new Error(\n        `${this.toString()} cannot call arg since it was not yet invoked.`,\n    );\n});\nspyApi.callArgOnWith = spyApi.callArgOn;\ndelegateToCalls(spyApi, \"throwArg\", false, \"throwArg\", false, function () {\n    throw new Error(\n        `${this.toString()} cannot throw arg since it was not yet invoked.`,\n    );\n});\ndelegateToCalls(spyApi, \"yield\", false, \"yield\", true, function () {\n    throw new Error(\n        `${this.toString()} cannot yield since it was not yet invoked.`,\n    );\n});\n// \"invokeCallback\" is an alias for \"yield\" since \"yield\" is invalid in strict mode.\nspyApi.invokeCallback = spyApi.yield;\ndelegateToCalls(spyApi, \"yieldOn\", false, \"yieldOn\", true, function () {\n    throw new Error(\n        `${this.toString()} cannot yield since it was not yet invoked.`,\n    );\n});\ndelegateToCalls(spyApi, \"yieldTo\", false, \"yieldTo\", true, function (property) {\n    throw new Error(\n        `${this.toString()} cannot yield to '${valueToString(\n            property,\n        )}' since it was not yet invoked.`,\n    );\n});\ndelegateToCalls(\n    spyApi,\n    \"yieldToOn\",\n    false,\n    \"yieldToOn\",\n    true,\n    function (property) {\n        throw new Error(\n            `${this.toString()} cannot yield to '${valueToString(\n                property,\n            )}' since it was not yet invoked.`,\n        );\n    },\n);\n\nfunction createSpy(func) {\n    let name;\n    let funk = func;\n\n    if (typeof funk !== \"function\") {\n        funk = function () {\n            return;\n        };\n    } else {\n        name = functionName(funk);\n    }\n\n    const proxy = createProxy(funk, funk);\n\n    // Inherit spy API:\n    extend.nonEnum(proxy, spyApi);\n    extend.nonEnum(proxy, {\n        displayName: name || \"spy\",\n        fakes: [],\n        instantiateFake: createSpy,\n        id: `spy#${uuid++}`,\n    });\n    return proxy;\n}\n\nfunction spy(object, property, types) {\n    if (isEsModule(object)) {\n        throw new TypeError(\"ES Modules cannot be spied\");\n    }\n\n    if (!property && typeof object === \"function\") {\n        return createSpy(object);\n    }\n\n    if (!property && typeof object === \"object\") {\n        return walkObject(spy, object);\n    }\n\n    if (!object && !property) {\n        return createSpy(function () {\n            return;\n        });\n    }\n\n    if (!types) {\n        return wrapMethod(object, property, createSpy(object[property]));\n    }\n\n    const descriptor = {};\n    const methodDesc = getPropertyDescriptor(object, property);\n\n    forEach(types, function (type) {\n        descriptor[type] = createSpy(methodDesc[type]);\n    });\n\n    return wrapMethod(object, property, descriptor);\n}\n\nextend(spy, spyApi);\nmodule.exports = spy;\n","\"use strict\";\nconst valueToString = require(\"@sinonjs/commons\").valueToString;\n\nfunction throwOnFalsyObject(object, property) {\n    if (property && !object) {\n        const type = object === null ? \"null\" : \"undefined\";\n        throw new Error(\n            `Trying to stub property '${valueToString(property)}' of ${type}`,\n        );\n    }\n}\n\nmodule.exports = throwOnFalsyObject;\n","\"use strict\";\n\nconst arrayProto = require(\"@sinonjs/commons\").prototypes.array;\nconst behavior = require(\"./behavior\");\nconst behaviors = require(\"./default-behaviors\");\nconst createProxy = require(\"./proxy\");\nconst functionName = require(\"@sinonjs/commons\").functionName;\nconst hasOwnProperty =\n    require(\"@sinonjs/commons\").prototypes.object.hasOwnProperty;\nconst isNonExistentProperty = require(\"./util/core/is-non-existent-property\");\nconst spy = require(\"./spy\");\nconst extend = require(\"./util/core/extend\");\nconst getPropertyDescriptor = require(\"./util/core/get-property-descriptor\");\nconst isEsModule = require(\"./util/core/is-es-module\");\nconst sinonType = require(\"./util/core/sinon-type\");\nconst wrapMethod = require(\"./util/core/wrap-method\");\nconst throwOnFalsyObject = require(\"./throw-on-falsy-object\");\nconst valueToString = require(\"@sinonjs/commons\").valueToString;\nconst walkObject = require(\"./util/core/walk-object\");\n\nconst forEach = arrayProto.forEach;\nconst pop = arrayProto.pop;\nconst slice = arrayProto.slice;\nconst sort = arrayProto.sort;\n\nlet uuid = 0;\n\nfunction createStub(originalFunc) {\n    // eslint-disable-next-line prefer-const\n    let proxy;\n\n    function functionStub() {\n        const args = slice(arguments);\n        const matchings = proxy.matchingFakes(args);\n\n        const fnStub =\n            pop(\n                sort(matchings, function (a, b) {\n                    return (\n                        a.matchingArguments.length - b.matchingArguments.length\n                    );\n                }),\n            ) || proxy;\n        return getCurrentBehavior(fnStub).invoke(this, arguments);\n    }\n\n    proxy = createProxy(functionStub, originalFunc || functionStub);\n    // Inherit spy API:\n    extend.nonEnum(proxy, spy);\n    // Inherit stub API:\n    extend.nonEnum(proxy, stub);\n\n    const name = originalFunc ? functionName(originalFunc) : null;\n    extend.nonEnum(proxy, {\n        fakes: [],\n        instantiateFake: createStub,\n        displayName: name || \"stub\",\n        defaultBehavior: null,\n        behaviors: [],\n        id: `stub#${uuid++}`,\n    });\n\n    sinonType.set(proxy, \"stub\");\n\n    return proxy;\n}\n\nfunction stub(object, property) {\n    if (arguments.length > 2) {\n        throw new TypeError(\n            \"stub(obj, 'meth', fn) has been removed, see documentation\",\n        );\n    }\n\n    if (isEsModule(object)) {\n        throw new TypeError(\"ES Modules cannot be stubbed\");\n    }\n\n    throwOnFalsyObject.apply(null, arguments);\n\n    if (isNonExistentProperty(object, property)) {\n        throw new TypeError(\n            `Cannot stub non-existent property ${valueToString(property)}`,\n        );\n    }\n\n    const actualDescriptor = getPropertyDescriptor(object, property);\n\n    assertValidPropertyDescriptor(actualDescriptor, property);\n\n    const isObjectOrFunction =\n        typeof object === \"object\" || typeof object === \"function\";\n    const isStubbingEntireObject =\n        typeof property === \"undefined\" && isObjectOrFunction;\n    const isCreatingNewStub = !object && typeof property === \"undefined\";\n    const isStubbingNonFuncProperty =\n        isObjectOrFunction &&\n        typeof property !== \"undefined\" &&\n        (typeof actualDescriptor === \"undefined\" ||\n            typeof actualDescriptor.value !== \"function\");\n\n    if (isStubbingEntireObject) {\n        return walkObject(stub, object);\n    }\n\n    if (isCreatingNewStub) {\n        return createStub();\n    }\n\n    const func =\n        typeof actualDescriptor.value === \"function\"\n            ? actualDescriptor.value\n            : null;\n    const s = createStub(func);\n\n    extend.nonEnum(s, {\n        rootObj: object,\n        propName: property,\n        shadowsPropOnPrototype: !actualDescriptor.isOwn,\n        restore: function restore() {\n            if (actualDescriptor !== undefined && actualDescriptor.isOwn) {\n                Object.defineProperty(object, property, actualDescriptor);\n                return;\n            }\n\n            delete object[property];\n        },\n    });\n\n    return isStubbingNonFuncProperty ? s : wrapMethod(object, property, s);\n}\n\nfunction assertValidPropertyDescriptor(descriptor, property) {\n    if (!descriptor || !property) {\n        return;\n    }\n    if (descriptor.isOwn && !descriptor.configurable && !descriptor.writable) {\n        throw new TypeError(\n            `The descriptor for property \\`${property}\\` is non-configurable and non-writable. ` +\n                `Sinon cannot stub properties that are immutable. ` +\n                `See https://sinonjs.org/faq#property-descriptor-errors for help fixing this issue.`,\n        );\n    }\n    if ((descriptor.get || descriptor.set) && !descriptor.configurable) {\n        throw new TypeError(\n            `Descriptor for accessor property ${property} is non-configurable`,\n        );\n    }\n    if (isDataDescriptor(descriptor) && !descriptor.writable) {\n        throw new TypeError(\n            `Descriptor for data property ${property} is non-writable`,\n        );\n    }\n}\n\nfunction isDataDescriptor(descriptor) {\n    return (\n        !descriptor.value &&\n        !descriptor.writable &&\n        !descriptor.set &&\n        !descriptor.get\n    );\n}\n\n/*eslint-disable no-use-before-define*/\nfunction getParentBehaviour(stubInstance) {\n    return stubInstance.parent && getCurrentBehavior(stubInstance.parent);\n}\n\nfunction getDefaultBehavior(stubInstance) {\n    return (\n        stubInstance.defaultBehavior ||\n        getParentBehaviour(stubInstance) ||\n        behavior.create(stubInstance)\n    );\n}\n\nfunction getCurrentBehavior(stubInstance) {\n    const currentBehavior = stubInstance.behaviors[stubInstance.callCount - 1];\n    return currentBehavior && currentBehavior.isPresent()\n        ? currentBehavior\n        : getDefaultBehavior(stubInstance);\n}\n/*eslint-enable no-use-before-define*/\n\nconst proto = {\n    resetBehavior: function () {\n        this.defaultBehavior = null;\n        this.behaviors = [];\n\n        delete this.returnValue;\n        delete this.returnArgAt;\n        delete this.throwArgAt;\n        delete this.resolveArgAt;\n        delete this.fakeFn;\n        this.returnThis = false;\n        this.resolveThis = false;\n\n        forEach(this.fakes, function (fake) {\n            fake.resetBehavior();\n        });\n    },\n\n    reset: function () {\n        this.resetHistory();\n        this.resetBehavior();\n    },\n\n    onCall: function onCall(index) {\n        if (!this.behaviors[index]) {\n            this.behaviors[index] = behavior.create(this);\n        }\n\n        return this.behaviors[index];\n    },\n\n    onFirstCall: function onFirstCall() {\n        return this.onCall(0);\n    },\n\n    onSecondCall: function onSecondCall() {\n        return this.onCall(1);\n    },\n\n    onThirdCall: function onThirdCall() {\n        return this.onCall(2);\n    },\n\n    withArgs: function withArgs() {\n        const fake = spy.withArgs.apply(this, arguments);\n        if (this.defaultBehavior && this.defaultBehavior.promiseLibrary) {\n            fake.defaultBehavior =\n                fake.defaultBehavior || behavior.create(fake);\n            fake.defaultBehavior.promiseLibrary =\n                this.defaultBehavior.promiseLibrary;\n        }\n        return fake;\n    },\n};\n\nforEach(Object.keys(behavior), function (method) {\n    if (\n        hasOwnProperty(behavior, method) &&\n        !hasOwnProperty(proto, method) &&\n        method !== \"create\" &&\n        method !== \"invoke\"\n    ) {\n        proto[method] = behavior.createBehavior(method);\n    }\n});\n\nforEach(Object.keys(behaviors), function (method) {\n    if (hasOwnProperty(behaviors, method) && !hasOwnProperty(proto, method)) {\n        behavior.addBehavior(stub, method, behaviors[method]);\n    }\n});\n\nextend(stub, proto);\nmodule.exports = stub;\n","\"use strict\";\n\nconst arrayProto = require(\"@sinonjs/commons\").prototypes.array;\nconst proxyInvoke = require(\"./proxy-invoke\");\nconst proxyCallToString = require(\"./proxy-call\").toString;\nconst timesInWords = require(\"./util/core/times-in-words\");\nconst extend = require(\"./util/core/extend\");\nconst match = require(\"@sinonjs/samsam\").createMatcher;\nconst stub = require(\"./stub\");\nconst assert = require(\"./assert\");\nconst deepEqual = require(\"@sinonjs/samsam\").deepEqual;\nconst inspect = require(\"util\").inspect;\nconst valueToString = require(\"@sinonjs/commons\").valueToString;\n\nconst every = arrayProto.every;\nconst forEach = arrayProto.forEach;\nconst push = arrayProto.push;\nconst slice = arrayProto.slice;\n\nfunction callCountInWords(callCount) {\n    if (callCount === 0) {\n        return \"never called\";\n    }\n\n    return `called ${timesInWords(callCount)}`;\n}\n\nfunction expectedCallCountInWords(expectation) {\n    const min = expectation.minCalls;\n    const max = expectation.maxCalls;\n\n    if (typeof min === \"number\" && typeof max === \"number\") {\n        let str = timesInWords(min);\n\n        if (min !== max) {\n            str = `at least ${str} and at most ${timesInWords(max)}`;\n        }\n\n        return str;\n    }\n\n    if (typeof min === \"number\") {\n        return `at least ${timesInWords(min)}`;\n    }\n\n    return `at most ${timesInWords(max)}`;\n}\n\nfunction receivedMinCalls(expectation) {\n    const hasMinLimit = typeof expectation.minCalls === \"number\";\n    return !hasMinLimit || expectation.callCount >= expectation.minCalls;\n}\n\nfunction receivedMaxCalls(expectation) {\n    if (typeof expectation.maxCalls !== \"number\") {\n        return false;\n    }\n\n    return expectation.callCount === expectation.maxCalls;\n}\n\nfunction verifyMatcher(possibleMatcher, arg) {\n    const isMatcher = match.isMatcher(possibleMatcher);\n\n    return (isMatcher && possibleMatcher.test(arg)) || true;\n}\n\nconst mockExpectation = {\n    minCalls: 1,\n    maxCalls: 1,\n\n    create: function create(methodName) {\n        const expectation = extend.nonEnum(stub(), mockExpectation);\n        delete expectation.create;\n        expectation.method = methodName;\n\n        return expectation;\n    },\n\n    invoke: function invoke(func, thisValue, args) {\n        this.verifyCallAllowed(thisValue, args);\n\n        return proxyInvoke.apply(this, arguments);\n    },\n\n    atLeast: function atLeast(num) {\n        if (typeof num !== \"number\") {\n            throw new TypeError(`'${valueToString(num)}' is not number`);\n        }\n\n        if (!this.limitsSet) {\n            this.maxCalls = null;\n            this.limitsSet = true;\n        }\n\n        this.minCalls = num;\n\n        return this;\n    },\n\n    atMost: function atMost(num) {\n        if (typeof num !== \"number\") {\n            throw new TypeError(`'${valueToString(num)}' is not number`);\n        }\n\n        if (!this.limitsSet) {\n            this.minCalls = null;\n            this.limitsSet = true;\n        }\n\n        this.maxCalls = num;\n\n        return this;\n    },\n\n    never: function never() {\n        return this.exactly(0);\n    },\n\n    once: function once() {\n        return this.exactly(1);\n    },\n\n    twice: function twice() {\n        return this.exactly(2);\n    },\n\n    thrice: function thrice() {\n        return this.exactly(3);\n    },\n\n    exactly: function exactly(num) {\n        if (typeof num !== \"number\") {\n            throw new TypeError(`'${valueToString(num)}' is not a number`);\n        }\n\n        this.atLeast(num);\n        return this.atMost(num);\n    },\n\n    met: function met() {\n        return !this.failed && receivedMinCalls(this);\n    },\n\n    verifyCallAllowed: function verifyCallAllowed(thisValue, args) {\n        const expectedArguments = this.expectedArguments;\n\n        if (receivedMaxCalls(this)) {\n            this.failed = true;\n            mockExpectation.fail(\n                `${this.method} already called ${timesInWords(this.maxCalls)}`,\n            );\n        }\n\n        if (\"expectedThis\" in this && this.expectedThis !== thisValue) {\n            mockExpectation.fail(\n                `${this.method} called with ${valueToString(\n                    thisValue,\n                )} as thisValue, expected ${valueToString(this.expectedThis)}`,\n            );\n        }\n\n        if (!(\"expectedArguments\" in this)) {\n            return;\n        }\n\n        if (!args) {\n            mockExpectation.fail(\n                `${this.method} received no arguments, expected ${inspect(\n                    expectedArguments,\n                )}`,\n            );\n        }\n\n        if (args.length < expectedArguments.length) {\n            mockExpectation.fail(\n                `${this.method} received too few arguments (${inspect(\n                    args,\n                )}), expected ${inspect(expectedArguments)}`,\n            );\n        }\n\n        if (\n            this.expectsExactArgCount &&\n            args.length !== expectedArguments.length\n        ) {\n            mockExpectation.fail(\n                `${this.method} received too many arguments (${inspect(\n                    args,\n                )}), expected ${inspect(expectedArguments)}`,\n            );\n        }\n\n        forEach(\n            expectedArguments,\n            function (expectedArgument, i) {\n                if (!verifyMatcher(expectedArgument, args[i])) {\n                    mockExpectation.fail(\n                        `${this.method} received wrong arguments ${inspect(\n                            args,\n                        )}, didn't match ${String(expectedArguments)}`,\n                    );\n                }\n\n                if (!deepEqual(args[i], expectedArgument)) {\n                    mockExpectation.fail(\n                        `${this.method} received wrong arguments ${inspect(\n                            args,\n                        )}, expected ${inspect(expectedArguments)}`,\n                    );\n                }\n            },\n            this,\n        );\n    },\n\n    allowsCall: function allowsCall(thisValue, args) {\n        const expectedArguments = this.expectedArguments;\n\n        if (this.met() && receivedMaxCalls(this)) {\n            return false;\n        }\n\n        if (\"expectedThis\" in this && this.expectedThis !== thisValue) {\n            return false;\n        }\n\n        if (!(\"expectedArguments\" in this)) {\n            return true;\n        }\n\n        // eslint-disable-next-line no-underscore-dangle\n        const _args = args || [];\n\n        if (_args.length < expectedArguments.length) {\n            return false;\n        }\n\n        if (\n            this.expectsExactArgCount &&\n            _args.length !== expectedArguments.length\n        ) {\n            return false;\n        }\n\n        return every(expectedArguments, function (expectedArgument, i) {\n            if (!verifyMatcher(expectedArgument, _args[i])) {\n                return false;\n            }\n\n            if (!deepEqual(_args[i], expectedArgument)) {\n                return false;\n            }\n\n            return true;\n        });\n    },\n\n    withArgs: function withArgs() {\n        this.expectedArguments = slice(arguments);\n        return this;\n    },\n\n    withExactArgs: function withExactArgs() {\n        this.withArgs.apply(this, arguments);\n        this.expectsExactArgCount = true;\n        return this;\n    },\n\n    on: function on(thisValue) {\n        this.expectedThis = thisValue;\n        return this;\n    },\n\n    toString: function () {\n        const args = slice(this.expectedArguments || []);\n\n        if (!this.expectsExactArgCount) {\n            push(args, \"[...]\");\n        }\n\n        const callStr = proxyCallToString.call({\n            proxy: this.method || \"anonymous mock expectation\",\n            args: args,\n        });\n\n        const message = `${callStr.replace(\n            \", [...\",\n            \"[, ...\",\n        )} ${expectedCallCountInWords(this)}`;\n\n        if (this.met()) {\n            return `Expectation met: ${message}`;\n        }\n\n        return `Expected ${message} (${callCountInWords(this.callCount)})`;\n    },\n\n    verify: function verify() {\n        if (!this.met()) {\n            mockExpectation.fail(String(this));\n        } else {\n            mockExpectation.pass(String(this));\n        }\n\n        return true;\n    },\n\n    pass: function pass(message) {\n        assert.pass(message);\n    },\n\n    fail: function fail(message) {\n        const exception = new Error(message);\n        exception.name = \"ExpectationError\";\n\n        throw exception;\n    },\n};\n\nmodule.exports = mockExpectation;\n","\"use strict\";\n\nconst arrayProto = require(\"@sinonjs/commons\").prototypes.array;\nconst mockExpectation = require(\"./mock-expectation\");\nconst proxyCallToString = require(\"./proxy-call\").toString;\nconst extend = require(\"./util/core/extend\");\nconst deepEqual = require(\"@sinonjs/samsam\").deepEqual;\nconst wrapMethod = require(\"./util/core/wrap-method\");\n\nconst concat = arrayProto.concat;\nconst filter = arrayProto.filter;\nconst forEach = arrayProto.forEach;\nconst every = arrayProto.every;\nconst join = arrayProto.join;\nconst push = arrayProto.push;\nconst slice = arrayProto.slice;\nconst unshift = arrayProto.unshift;\n\nfunction mock(object) {\n    if (!object || typeof object === \"string\") {\n        return mockExpectation.create(object ? object : \"Anonymous mock\");\n    }\n\n    return mock.create(object);\n}\n\nfunction each(collection, callback) {\n    const col = collection || [];\n\n    forEach(col, callback);\n}\n\nfunction arrayEquals(arr1, arr2, compareLength) {\n    if (compareLength && arr1.length !== arr2.length) {\n        return false;\n    }\n\n    return every(arr1, function (element, i) {\n        return deepEqual(arr2[i], element);\n    });\n}\n\nextend(mock, {\n    create: function create(object) {\n        if (!object) {\n            throw new TypeError(\"object is null\");\n        }\n\n        const mockObject = extend.nonEnum({}, mock, { object: object });\n        delete mockObject.create;\n\n        return mockObject;\n    },\n\n    expects: function expects(method) {\n        if (!method) {\n            throw new TypeError(\"method is falsy\");\n        }\n\n        if (!this.expectations) {\n            this.expectations = {};\n            this.proxies = [];\n            this.failures = [];\n        }\n\n        if (!this.expectations[method]) {\n            this.expectations[method] = [];\n            const mockObject = this;\n\n            wrapMethod(this.object, method, function () {\n                return mockObject.invokeMethod(method, this, arguments);\n            });\n\n            push(this.proxies, method);\n        }\n\n        const expectation = mockExpectation.create(method);\n        expectation.wrappedMethod = this.object[method].wrappedMethod;\n        push(this.expectations[method], expectation);\n\n        return expectation;\n    },\n\n    restore: function restore() {\n        const object = this.object;\n\n        each(this.proxies, function (proxy) {\n            if (typeof object[proxy].restore === \"function\") {\n                object[proxy].restore();\n            }\n        });\n    },\n\n    verify: function verify() {\n        const expectations = this.expectations || {};\n        const messages = this.failures ? slice(this.failures) : [];\n        const met = [];\n\n        each(this.proxies, function (proxy) {\n            each(expectations[proxy], function (expectation) {\n                if (!expectation.met()) {\n                    push(messages, String(expectation));\n                } else {\n                    push(met, String(expectation));\n                }\n            });\n        });\n\n        this.restore();\n\n        if (messages.length > 0) {\n            mockExpectation.fail(join(concat(messages, met), \"\\n\"));\n        } else if (met.length > 0) {\n            mockExpectation.pass(join(concat(messages, met), \"\\n\"));\n        }\n\n        return true;\n    },\n\n    invokeMethod: function invokeMethod(method, thisValue, args) {\n        /* if we cannot find any matching files we will explicitly call mockExpection#fail with error messages */\n        /* eslint consistent-return: \"off\" */\n        const expectations =\n            this.expectations && this.expectations[method]\n                ? this.expectations[method]\n                : [];\n        const currentArgs = args || [];\n        let available;\n\n        const expectationsWithMatchingArgs = filter(\n            expectations,\n            function (expectation) {\n                const expectedArgs = expectation.expectedArguments || [];\n\n                return arrayEquals(\n                    expectedArgs,\n                    currentArgs,\n                    expectation.expectsExactArgCount,\n                );\n            },\n        );\n\n        const expectationsToApply = filter(\n            expectationsWithMatchingArgs,\n            function (expectation) {\n                return (\n                    !expectation.met() &&\n                    expectation.allowsCall(thisValue, args)\n                );\n            },\n        );\n\n        if (expectationsToApply.length > 0) {\n            return expectationsToApply[0].apply(thisValue, args);\n        }\n\n        const messages = [];\n        let exhausted = 0;\n\n        forEach(expectationsWithMatchingArgs, function (expectation) {\n            if (expectation.allowsCall(thisValue, args)) {\n                available = available || expectation;\n            } else {\n                exhausted += 1;\n            }\n        });\n\n        if (available && exhausted === 0) {\n            return available.apply(thisValue, args);\n        }\n\n        forEach(expectations, function (expectation) {\n            push(messages, `    ${String(expectation)}`);\n        });\n\n        unshift(\n            messages,\n            `Unexpected call: ${proxyCallToString.call({\n                proxy: method,\n                args: args,\n            })}`,\n        );\n\n        const err = new Error();\n        if (!err.stack) {\n            // PhantomJS does not serialize the stack trace until the error has been thrown\n            try {\n                throw err;\n            } catch (e) {\n                /* empty */\n            }\n        }\n        push(\n            this.failures,\n            `Unexpected call: ${proxyCallToString.call({\n                proxy: method,\n                args: args,\n                stack: err.stack,\n            })}`,\n        );\n\n        mockExpectation.fail(join(messages, \"\\n\"));\n    },\n});\n\nmodule.exports = mock;\n","\"use strict\";\n\nconst stub = require(\"./stub\");\nconst sinonType = require(\"./util/core/sinon-type\");\nconst forEach = require(\"@sinonjs/commons\").prototypes.array.forEach;\n\nfunction isStub(value) {\n    return sinonType.get(value) === \"stub\";\n}\n\nmodule.exports = function createStubInstance(constructor, overrides) {\n    if (typeof constructor !== \"function\") {\n        throw new TypeError(\"The constructor should be a function.\");\n    }\n\n    const stubInstance = Object.create(constructor.prototype);\n    sinonType.set(stubInstance, \"stub-instance\");\n\n    const stubbedObject = stub(stubInstance);\n\n    forEach(Object.keys(overrides || {}), function (propertyName) {\n        if (propertyName in stubbedObject) {\n            const value = overrides[propertyName];\n            if (isStub(value)) {\n                stubbedObject[propertyName] = value;\n            } else {\n                stubbedObject[propertyName].returns(value);\n            }\n        } else {\n            throw new Error(\n                `Cannot stub ${propertyName}. Property does not exist!`,\n            );\n        }\n    });\n    return stubbedObject;\n};\n","\"use strict\";\n\nconst arrayProto = require(\"@sinonjs/commons\").prototypes.array;\nconst createProxy = require(\"./proxy\");\nconst nextTick = require(\"./util/core/next-tick\");\n\nconst slice = arrayProto.slice;\n\nmodule.exports = fake;\n\n/**\n * Returns a `fake` that records all calls, arguments and return values.\n *\n * When an `f` argument is supplied, this implementation will be used.\n *\n * @example\n * // create an empty fake\n * var f1 = sinon.fake();\n *\n * f1();\n *\n * f1.calledOnce()\n * // true\n *\n * @example\n * function greet(greeting) {\n *   console.log(`Hello ${greeting}`);\n * }\n *\n * // create a fake with implementation\n * var f2 = sinon.fake(greet);\n *\n * // Hello world\n * f2(\"world\");\n *\n * f2.calledWith(\"world\");\n * // true\n *\n * @param {Function|undefined} f\n * @returns {Function}\n * @namespace\n */\nfunction fake(f) {\n    if (arguments.length > 0 && typeof f !== \"function\") {\n        throw new TypeError(\"Expected f argument to be a Function\");\n    }\n\n    return wrapFunc(f);\n}\n\n/**\n * Creates a `fake` that returns the provided `value`, as well as recording all\n * calls, arguments and return values.\n *\n * @example\n * var f1 = sinon.fake.returns(42);\n *\n * f1();\n * // 42\n *\n * @memberof fake\n * @param {*} value\n * @returns {Function}\n */\nfake.returns = function returns(value) {\n    // eslint-disable-next-line jsdoc/require-jsdoc\n    function f() {\n        return value;\n    }\n\n    return wrapFunc(f);\n};\n\n/**\n * Creates a `fake` that throws an Error.\n * If the `value` argument does not have Error in its prototype chain, it will\n * be used for creating a new error.\n *\n * @example\n * var f1 = sinon.fake.throws(\"hello\");\n *\n * f1();\n * // Uncaught Error: hello\n *\n * @example\n * var f2 = sinon.fake.throws(new TypeError(\"Invalid argument\"));\n *\n * f2();\n * // Uncaught TypeError: Invalid argument\n *\n * @memberof fake\n * @param {*|Error} value\n * @returns {Function}\n */\nfake.throws = function throws(value) {\n    // eslint-disable-next-line jsdoc/require-jsdoc\n    function f() {\n        throw getError(value);\n    }\n\n    return wrapFunc(f);\n};\n\n/**\n * Creates a `fake` that returns a promise that resolves to the passed `value`\n * argument.\n *\n * @example\n * var f1 = sinon.fake.resolves(\"apple pie\");\n *\n * await f1();\n * // \"apple pie\"\n *\n * @memberof fake\n * @param {*} value\n * @returns {Function}\n */\nfake.resolves = function resolves(value) {\n    // eslint-disable-next-line jsdoc/require-jsdoc\n    function f() {\n        return Promise.resolve(value);\n    }\n\n    return wrapFunc(f);\n};\n\n/**\n * Creates a `fake` that returns a promise that rejects to the passed `value`\n * argument. When `value` does not have Error in its prototype chain, it will be\n * wrapped in an Error.\n *\n * @example\n * var f1 = sinon.fake.rejects(\":(\");\n *\n * try {\n *   await f1();\n * } catch (error) {\n *   console.log(error);\n *   // \":(\"\n * }\n *\n * @memberof fake\n * @param {*} value\n * @returns {Function}\n */\nfake.rejects = function rejects(value) {\n    // eslint-disable-next-line jsdoc/require-jsdoc\n    function f() {\n        return Promise.reject(getError(value));\n    }\n\n    return wrapFunc(f);\n};\n\n/**\n * Returns a `fake` that calls the callback with the defined arguments.\n *\n * @example\n * function callback() {\n *   console.log(arguments.join(\"*\"));\n * }\n *\n * const f1 = sinon.fake.yields(\"apple\", \"pie\");\n *\n * f1(callback);\n * // \"apple*pie\"\n *\n * @memberof fake\n * @returns {Function}\n */\nfake.yields = function yields() {\n    const values = slice(arguments);\n\n    // eslint-disable-next-line jsdoc/require-jsdoc\n    function f() {\n        const callback = arguments[arguments.length - 1];\n        if (typeof callback !== \"function\") {\n            throw new TypeError(\"Expected last argument to be a function\");\n        }\n\n        callback.apply(null, values);\n    }\n\n    return wrapFunc(f);\n};\n\n/**\n * Returns a `fake` that calls the callback **asynchronously** with the\n * defined arguments.\n *\n * @example\n * function callback() {\n *   console.log(arguments.join(\"*\"));\n * }\n *\n * const f1 = sinon.fake.yields(\"apple\", \"pie\");\n *\n * f1(callback);\n *\n * setTimeout(() => {\n *   // \"apple*pie\"\n * });\n *\n * @memberof fake\n * @returns {Function}\n */\nfake.yieldsAsync = function yieldsAsync() {\n    const values = slice(arguments);\n\n    // eslint-disable-next-line jsdoc/require-jsdoc\n    function f() {\n        const callback = arguments[arguments.length - 1];\n        if (typeof callback !== \"function\") {\n            throw new TypeError(\"Expected last argument to be a function\");\n        }\n        nextTick(function () {\n            callback.apply(null, values);\n        });\n    }\n\n    return wrapFunc(f);\n};\n\nlet uuid = 0;\n/**\n * Creates a proxy (sinon concept) from the passed function.\n *\n * @private\n * @param  {Function} f\n * @returns {Function}\n */\nfunction wrapFunc(f) {\n    const fakeInstance = function () {\n        let firstArg, lastArg;\n\n        if (arguments.length > 0) {\n            firstArg = arguments[0];\n            lastArg = arguments[arguments.length - 1];\n        }\n\n        const callback =\n            lastArg && typeof lastArg === \"function\" ? lastArg : undefined;\n\n        /* eslint-disable no-use-before-define */\n        proxy.firstArg = firstArg;\n        proxy.lastArg = lastArg;\n        proxy.callback = callback;\n\n        return f && f.apply(this, arguments);\n    };\n    const proxy = createProxy(fakeInstance, f || fakeInstance);\n\n    proxy.displayName = \"fake\";\n    proxy.id = `fake#${uuid++}`;\n\n    return proxy;\n}\n\n/**\n * Returns an Error instance from the passed value, if the value is not\n * already an Error instance.\n *\n * @private\n * @param  {*} value [description]\n * @returns {Error}       [description]\n */\nfunction getError(value) {\n    return value instanceof Error ? value : new Error(value);\n}\n","\"use strict\";\n\nconst arrayProto = require(\"@sinonjs/commons\").prototypes.array;\nconst logger = require(\"@sinonjs/commons\").deprecated;\nconst collectOwnMethods = require(\"./collect-own-methods\");\nconst getPropertyDescriptor = require(\"./util/core/get-property-descriptor\");\nconst isPropertyConfigurable = require(\"./util/core/is-property-configurable\");\nconst match = require(\"@sinonjs/samsam\").createMatcher;\nconst sinonAssert = require(\"./assert\");\nconst sinonClock = require(\"./util/fake-timers\");\nconst sinonMock = require(\"./mock\");\nconst sinonSpy = require(\"./spy\");\nconst sinonStub = require(\"./stub\");\nconst sinonCreateStubInstance = require(\"./create-stub-instance\");\nconst sinonFake = require(\"./fake\");\nconst valueToString = require(\"@sinonjs/commons\").valueToString;\n\nconst DEFAULT_LEAK_THRESHOLD = 10000;\n\nconst filter = arrayProto.filter;\nconst forEach = arrayProto.forEach;\nconst push = arrayProto.push;\nconst reverse = arrayProto.reverse;\n\nfunction applyOnEach(fakes, method) {\n    const matchingFakes = filter(fakes, function (fake) {\n        return typeof fake[method] === \"function\";\n    });\n\n    forEach(matchingFakes, function (fake) {\n        fake[method]();\n    });\n}\n\nfunction throwOnAccessors(descriptor) {\n    if (typeof descriptor.get === \"function\") {\n        throw new Error(\"Use sandbox.replaceGetter for replacing getters\");\n    }\n\n    if (typeof descriptor.set === \"function\") {\n        throw new Error(\"Use sandbox.replaceSetter for replacing setters\");\n    }\n}\n\nfunction verifySameType(object, property, replacement) {\n    if (typeof object[property] !== typeof replacement) {\n        throw new TypeError(\n            `Cannot replace ${typeof object[\n                property\n            ]} with ${typeof replacement}`,\n        );\n    }\n}\n\nfunction checkForValidArguments(descriptor, property, replacement) {\n    if (typeof descriptor === \"undefined\") {\n        throw new TypeError(\n            `Cannot replace non-existent property ${valueToString(\n                property,\n            )}. Perhaps you meant sandbox.define()?`,\n        );\n    }\n\n    if (typeof replacement === \"undefined\") {\n        throw new TypeError(\"Expected replacement argument to be defined\");\n    }\n}\n\n/**\n * A sinon sandbox\n *\n * @param opts\n * @param {object} [opts.assertOptions] see the CreateAssertOptions in ./assert\n * @class\n */\nfunction Sandbox(opts = {}) {\n    const sandbox = this;\n    const assertOptions = opts.assertOptions || {};\n    let fakeRestorers = [];\n\n    let collection = [];\n    let loggedLeakWarning = false;\n    sandbox.leakThreshold = DEFAULT_LEAK_THRESHOLD;\n\n    function addToCollection(object) {\n        if (\n            push(collection, object) > sandbox.leakThreshold &&\n            !loggedLeakWarning\n        ) {\n            // eslint-disable-next-line no-console\n            logger.printWarning(\n                \"Potential memory leak detected; be sure to call restore() to clean up your sandbox. To suppress this warning, modify the leakThreshold property of your sandbox.\",\n            );\n            loggedLeakWarning = true;\n        }\n    }\n\n    sandbox.assert = sinonAssert.createAssertObject(assertOptions);\n\n    // this is for testing only\n    sandbox.getFakes = function getFakes() {\n        return collection;\n    };\n\n    sandbox.createStubInstance = function createStubInstance() {\n        const stubbed = sinonCreateStubInstance.apply(null, arguments);\n\n        const ownMethods = collectOwnMethods(stubbed);\n\n        forEach(ownMethods, function (method) {\n            addToCollection(method);\n        });\n\n        return stubbed;\n    };\n\n    sandbox.inject = function inject(obj) {\n        obj.spy = function () {\n            return sandbox.spy.apply(null, arguments);\n        };\n\n        obj.stub = function () {\n            return sandbox.stub.apply(null, arguments);\n        };\n\n        obj.mock = function () {\n            return sandbox.mock.apply(null, arguments);\n        };\n\n        obj.createStubInstance = function () {\n            return sandbox.createStubInstance.apply(sandbox, arguments);\n        };\n\n        obj.fake = function () {\n            return sandbox.fake.apply(null, arguments);\n        };\n\n        obj.define = function () {\n            return sandbox.define.apply(null, arguments);\n        };\n\n        obj.replace = function () {\n            return sandbox.replace.apply(null, arguments);\n        };\n\n        obj.replaceSetter = function () {\n            return sandbox.replaceSetter.apply(null, arguments);\n        };\n\n        obj.replaceGetter = function () {\n            return sandbox.replaceGetter.apply(null, arguments);\n        };\n\n        if (sandbox.clock) {\n            obj.clock = sandbox.clock;\n        }\n\n        obj.match = match;\n\n        return obj;\n    };\n\n    sandbox.mock = function mock() {\n        const m = sinonMock.apply(null, arguments);\n\n        addToCollection(m);\n\n        return m;\n    };\n\n    sandbox.reset = function reset() {\n        applyOnEach(collection, \"reset\");\n        applyOnEach(collection, \"resetHistory\");\n    };\n\n    sandbox.resetBehavior = function resetBehavior() {\n        applyOnEach(collection, \"resetBehavior\");\n    };\n\n    sandbox.resetHistory = function resetHistory() {\n        function privateResetHistory(f) {\n            const method = f.resetHistory || f.reset;\n            if (method) {\n                method.call(f);\n            }\n        }\n\n        forEach(collection, privateResetHistory);\n    };\n\n    sandbox.restore = function restore() {\n        if (arguments.length) {\n            throw new Error(\n                \"sandbox.restore() does not take any parameters. Perhaps you meant stub.restore()\",\n            );\n        }\n\n        reverse(collection);\n        applyOnEach(collection, \"restore\");\n        collection = [];\n\n        forEach(fakeRestorers, function (restorer) {\n            restorer();\n        });\n        fakeRestorers = [];\n\n        sandbox.restoreContext();\n    };\n\n    sandbox.restoreContext = function restoreContext() {\n        if (!sandbox.injectedKeys) {\n            return;\n        }\n\n        forEach(sandbox.injectedKeys, function (injectedKey) {\n            delete sandbox.injectInto[injectedKey];\n        });\n\n        sandbox.injectedKeys.length = 0;\n    };\n\n    /**\n     * Creates a restorer function for the property\n     *\n     * @param {object|Function} object\n     * @param {string} property\n     * @param {boolean} forceAssignment\n     * @returns {Function} restorer function\n     */\n    function getFakeRestorer(object, property, forceAssignment = false) {\n        const descriptor = getPropertyDescriptor(object, property);\n        const value = forceAssignment && object[property];\n\n        function restorer() {\n            if (forceAssignment) {\n                object[property] = value;\n            } else if (descriptor?.isOwn) {\n                Object.defineProperty(object, property, descriptor);\n            } else {\n                delete object[property];\n            }\n        }\n\n        restorer.object = object;\n        restorer.property = property;\n        return restorer;\n    }\n\n    function verifyNotReplaced(object, property) {\n        forEach(fakeRestorers, function (fakeRestorer) {\n            if (\n                fakeRestorer.object === object &&\n                fakeRestorer.property === property\n            ) {\n                throw new TypeError(\n                    `Attempted to replace ${property} which is already replaced`,\n                );\n            }\n        });\n    }\n\n    /**\n     * Replace an existing property\n     *\n     * @param {object|Function} object\n     * @param {string} property\n     * @param {*} replacement a fake, stub, spy or any other value\n     * @returns {*}\n     */\n    sandbox.replace = function replace(object, property, replacement) {\n        const descriptor = getPropertyDescriptor(object, property);\n        checkForValidArguments(descriptor, property, replacement);\n        throwOnAccessors(descriptor);\n        verifySameType(object, property, replacement);\n\n        verifyNotReplaced(object, property);\n\n        // store a function for restoring the replaced property\n        push(fakeRestorers, getFakeRestorer(object, property));\n\n        object[property] = replacement;\n\n        return replacement;\n    };\n\n    sandbox.replace.usingAccessor = function replaceUsingAccessor(\n        object,\n        property,\n        replacement,\n    ) {\n        const descriptor = getPropertyDescriptor(object, property);\n        checkForValidArguments(descriptor, property, replacement);\n        verifySameType(object, property, replacement);\n\n        verifyNotReplaced(object, property);\n\n        // store a function for restoring the replaced property\n        push(fakeRestorers, getFakeRestorer(object, property, true));\n\n        object[property] = replacement;\n\n        return replacement;\n    };\n\n    sandbox.define = function define(object, property, value) {\n        const descriptor = getPropertyDescriptor(object, property);\n\n        if (descriptor) {\n            throw new TypeError(\n                `Cannot define the already existing property ${valueToString(\n                    property,\n                )}. Perhaps you meant sandbox.replace()?`,\n            );\n        }\n\n        if (typeof value === \"undefined\") {\n            throw new TypeError(\"Expected value argument to be defined\");\n        }\n\n        verifyNotReplaced(object, property);\n\n        // store a function for restoring the defined property\n        push(fakeRestorers, getFakeRestorer(object, property));\n\n        object[property] = value;\n\n        return value;\n    };\n\n    sandbox.replaceGetter = function replaceGetter(\n        object,\n        property,\n        replacement,\n    ) {\n        const descriptor = getPropertyDescriptor(object, property);\n\n        if (typeof descriptor === \"undefined\") {\n            throw new TypeError(\n                `Cannot replace non-existent property ${valueToString(\n                    property,\n                )}`,\n            );\n        }\n\n        if (typeof replacement !== \"function\") {\n            throw new TypeError(\n                \"Expected replacement argument to be a function\",\n            );\n        }\n\n        if (typeof descriptor.get !== \"function\") {\n            throw new Error(\"`object.property` is not a getter\");\n        }\n\n        verifyNotReplaced(object, property);\n\n        // store a function for restoring the replaced property\n        push(fakeRestorers, getFakeRestorer(object, property));\n\n        Object.defineProperty(object, property, {\n            get: replacement,\n            configurable: isPropertyConfigurable(object, property),\n        });\n\n        return replacement;\n    };\n\n    sandbox.replaceSetter = function replaceSetter(\n        object,\n        property,\n        replacement,\n    ) {\n        const descriptor = getPropertyDescriptor(object, property);\n\n        if (typeof descriptor === \"undefined\") {\n            throw new TypeError(\n                `Cannot replace non-existent property ${valueToString(\n                    property,\n                )}`,\n            );\n        }\n\n        if (typeof replacement !== \"function\") {\n            throw new TypeError(\n                \"Expected replacement argument to be a function\",\n            );\n        }\n\n        if (typeof descriptor.set !== \"function\") {\n            throw new Error(\"`object.property` is not a setter\");\n        }\n\n        verifyNotReplaced(object, property);\n\n        // store a function for restoring the replaced property\n        push(fakeRestorers, getFakeRestorer(object, property));\n\n        // eslint-disable-next-line accessor-pairs\n        Object.defineProperty(object, property, {\n            set: replacement,\n            configurable: isPropertyConfigurable(object, property),\n        });\n\n        return replacement;\n    };\n\n    function commonPostInitSetup(args, spy, isStub) {\n        const [object, property, types] = args;\n\n        const isSpyingOnEntireObject =\n            typeof property === \"undefined\" &&\n            (typeof object === \"object\" ||\n                (isStub && typeof object === \"function\"));\n\n        if (isSpyingOnEntireObject) {\n            const ownMethods = collectOwnMethods(spy);\n\n            forEach(ownMethods, function (method) {\n                addToCollection(method);\n            });\n        } else if (Array.isArray(types)) {\n            for (const accessorType of types) {\n                addToCollection(spy[accessorType]);\n            }\n        } else {\n            addToCollection(spy);\n        }\n\n        return spy;\n    }\n\n    sandbox.spy = function spy() {\n        const createdSpy = sinonSpy.apply(sinonSpy, arguments);\n        return commonPostInitSetup(arguments, createdSpy, false);\n    };\n\n    sandbox.stub = function stub() {\n        const createdStub = sinonStub.apply(sinonStub, arguments);\n        return commonPostInitSetup(arguments, createdStub, true);\n    };\n\n    // eslint-disable-next-line no-unused-vars\n    sandbox.fake = function fake(f) {\n        const s = sinonFake.apply(sinonFake, arguments);\n\n        addToCollection(s);\n\n        return s;\n    };\n\n    forEach(Object.keys(sinonFake), function (key) {\n        const fakeBehavior = sinonFake[key];\n        if (typeof fakeBehavior === \"function\") {\n            sandbox.fake[key] = function () {\n                const s = fakeBehavior.apply(fakeBehavior, arguments);\n\n                addToCollection(s);\n\n                return s;\n            };\n        }\n    });\n\n    sandbox.useFakeTimers = function useFakeTimers(args) {\n        const clock = sinonClock.useFakeTimers.call(null, args);\n\n        sandbox.clock = clock;\n        addToCollection(clock);\n\n        return clock;\n    };\n\n    sandbox.verify = function verify() {\n        applyOnEach(collection, \"verify\");\n    };\n\n    sandbox.verifyAndRestore = function verifyAndRestore() {\n        let exception;\n\n        try {\n            sandbox.verify();\n        } catch (e) {\n            exception = e;\n        }\n\n        sandbox.restore();\n\n        if (exception) {\n            throw exception;\n        }\n    };\n}\n\nSandbox.prototype.match = match;\n\nmodule.exports = Sandbox;\n","\"use strict\";\n\nconst arrayProto = require(\"@sinonjs/commons\").prototypes.array;\nconst Sandbox = require(\"./sandbox\");\n\nconst forEach = arrayProto.forEach;\nconst push = arrayProto.push;\n\nfunction prepareSandboxFromConfig(config) {\n    const sandbox = new Sandbox({ assertOptions: config.assertOptions });\n\n    if (config.useFakeTimers) {\n        if (typeof config.useFakeTimers === \"object\") {\n            sandbox.useFakeTimers(config.useFakeTimers);\n        } else {\n            sandbox.useFakeTimers();\n        }\n    }\n\n    return sandbox;\n}\n\nfunction exposeValue(sandbox, config, key, value) {\n    if (!value) {\n        return;\n    }\n\n    if (config.injectInto && !(key in config.injectInto)) {\n        config.injectInto[key] = value;\n        push(sandbox.injectedKeys, key);\n    } else {\n        push(sandbox.args, value);\n    }\n}\n\n/**\n * Options to customize a sandbox\n *\n * The sandbox's methods can be injected into another object for\n * convenience. The `injectInto` configuration option can name an\n * object to add properties to.\n *\n * @typedef {object} SandboxConfig\n * @property {string[]} properties The properties of the API to expose on the sandbox. Examples: ['spy', 'fake', 'restore']\n * @property {object} injectInto an object in which to inject properties from the sandbox (a facade). This is mostly an integration feature (sinon-test being one).\n * @property {boolean} useFakeTimers  whether timers are faked by default\n * @property {object} [assertOptions] see CreateAssertOptions in ./assert\n *\n * This type def is really suffering from JSDoc not having standardized\n * how to reference types defined in other modules :(\n */\n\n/**\n * A configured sinon sandbox (private type)\n *\n * @typedef {object} ConfiguredSinonSandboxType\n * @private\n * @augments Sandbox\n * @property {string[]} injectedKeys the keys that have been injected (from config.injectInto)\n * @property {*[]} args the arguments for the sandbox\n */\n\n/**\n * Create a sandbox\n *\n * As of Sinon 5 the `sinon` instance itself is a Sandbox, so you\n * hardly ever need to create additional instances for the sake of testing\n *\n * @param config {SandboxConfig}\n * @returns {Sandbox}\n */\nfunction createSandbox(config) {\n    if (!config) {\n        return new Sandbox();\n    }\n\n    const configuredSandbox = prepareSandboxFromConfig(config);\n    configuredSandbox.args = configuredSandbox.args || [];\n    configuredSandbox.injectedKeys = [];\n    configuredSandbox.injectInto = config.injectInto;\n    const exposed = configuredSandbox.inject({});\n\n    if (config.properties) {\n        forEach(config.properties, function (prop) {\n            const value =\n                exposed[prop] || (prop === \"sandbox\" && configuredSandbox);\n            exposeValue(configuredSandbox, config, prop, value);\n        });\n    } else {\n        exposeValue(configuredSandbox, config, \"sandbox\");\n    }\n\n    return configuredSandbox;\n}\n\nmodule.exports = createSandbox;\n","\"use strict\";\n\nfunction isRestorable(obj) {\n    return (\n        typeof obj === \"function\" &&\n        typeof obj.restore === \"function\" &&\n        obj.restore.sinon\n    );\n}\n\nmodule.exports = isRestorable;\n","\"use strict\";\n\nconst fake = require(\"./fake\");\nconst isRestorable = require(\"./util/core/is-restorable\");\n\nconst STATUS_PENDING = \"pending\";\nconst STATUS_RESOLVED = \"resolved\";\nconst STATUS_REJECTED = \"rejected\";\n\n/**\n * Returns a fake for a given function or undefined. If no function is given, a\n * new fake is returned. If the given function is already a fake, it is\n * returned as is. Otherwise the given function is wrapped in a new fake.\n *\n * @param {Function} [executor] The optional executor function.\n * @returns {Function}\n */\nfunction getFakeExecutor(executor) {\n    if (isRestorable(executor)) {\n        return executor;\n    }\n    if (executor) {\n        return fake(executor);\n    }\n    return fake();\n}\n\n/**\n * Returns a new promise that exposes it's internal `status`, `resolvedValue`\n * and `rejectedValue` and can be resolved or rejected from the outside by\n * calling `resolve(value)` or `reject(reason)`.\n *\n * @param {Function} [executor] The optional executor function.\n * @returns {Promise}\n */\nfunction promise(executor) {\n    const fakeExecutor = getFakeExecutor(executor);\n    const sinonPromise = new Promise(fakeExecutor);\n\n    sinonPromise.status = STATUS_PENDING;\n    sinonPromise\n        .then(function (value) {\n            sinonPromise.status = STATUS_RESOLVED;\n            sinonPromise.resolvedValue = value;\n        })\n        .catch(function (reason) {\n            sinonPromise.status = STATUS_REJECTED;\n            sinonPromise.rejectedValue = reason;\n        });\n\n    /**\n     * Resolves or rejects the promise with the given status and value.\n     *\n     * @param {string} status\n     * @param {*} value\n     * @param {Function} callback\n     */\n    function finalize(status, value, callback) {\n        if (sinonPromise.status !== STATUS_PENDING) {\n            throw new Error(`Promise already ${sinonPromise.status}`);\n        }\n\n        sinonPromise.status = status;\n        callback(value);\n    }\n\n    sinonPromise.resolve = function (value) {\n        finalize(STATUS_RESOLVED, value, fakeExecutor.firstCall.args[0]);\n        // Return the promise so that callers can await it:\n        return sinonPromise;\n    };\n    sinonPromise.reject = function (reason) {\n        finalize(STATUS_REJECTED, reason, fakeExecutor.firstCall.args[1]);\n        // Return a new promise that resolves when the sinon promise was\n        // rejected, so that callers can await it:\n        return new Promise(function (resolve) {\n            sinonPromise.catch(() => resolve());\n        });\n    };\n\n    return sinonPromise;\n}\n\nmodule.exports = promise;\n","\"use strict\";\n\nconst walkObject = require(\"./util/core/walk-object\");\n\nfunction filter(object, property) {\n    return object[property].restore && object[property].restore.sinon;\n}\n\nfunction restore(object, property) {\n    object[property].restore();\n}\n\nfunction restoreObject(object) {\n    return walkObject(restore, object, filter);\n}\n\nmodule.exports = restoreObject;\n","\"use strict\";\n\nconst createApi = require(\"./create-sinon-api\");\n\nmodule.exports = createApi();\n","\"use strict\";\n\nconst behavior = require(\"./sinon/behavior\");\nconst createSandbox = require(\"./sinon/create-sandbox\");\nconst extend = require(\"./sinon/util/core/extend\");\nconst fakeTimers = require(\"./sinon/util/fake-timers\");\nconst Sandbox = require(\"./sinon/sandbox\");\nconst stub = require(\"./sinon/stub\");\nconst promise = require(\"./sinon/promise\");\n\n/**\n * @returns {object} a configured sandbox\n */\nmodule.exports = function createApi() {\n    const apiMethods = {\n        createSandbox: createSandbox,\n        match: require(\"@sinonjs/samsam\").createMatcher,\n        restoreObject: require(\"./sinon/restore-object\"),\n\n        expectation: require(\"./sinon/mock-expectation\"),\n\n        // fake timers\n        timers: fakeTimers.timers,\n\n        addBehavior: function (name, fn) {\n            behavior.addBehavior(stub, name, fn);\n        },\n\n        // fake promise\n        promise: promise,\n    };\n\n    const sandbox = new Sandbox();\n    return extend(sandbox, apiMethods);\n};\n"]}