Added node_modules for the updating to work properly.

52 files changed, 1299 insertions, 0 deletions

diff --git a/node_modules/@sinonjs/commons/CHANGES.md b/node_modules/@sinonjs/commons/CHANGES.md
new file mode 100644
index 0000000..9d30695
--- /dev/null
+++ b/node_modules/@sinonjs/commons/CHANGES.md
@@ -0,0 +1,57 @@
+# Changes
+
+## 1.8.3
+
+- [`6af2d0c`](https://github.com/sinonjs/commons/commit/6af2d0cf33e9fd1e4aaef5308fd16a9cd78a5782)
+  Bump y18n from 4.0.0 to 4.0.1 (dependabot[bot])
+    >
+    > Bumps [y18n](https://github.com/yargs/y18n) from 4.0.0 to 4.0.1.
+    > - [Release notes](https://github.com/yargs/y18n/releases)
+    > - [Changelog](https://github.com/yargs/y18n/blob/master/CHANGELOG.md)
+    > - [Commits](https://github.com/yargs/y18n/commits)
+    >
+    > Signed-off-by: dependabot[bot] <support@github.com>
+
+_Released on 2021-04-08._
+
+## 1.8.2
+
+- [`6b7a796`](https://github.com/sinonjs/commons/commit/6b7a796ffc088b43dc283cc4477a7d641720dc96)
+  Add .d.ts files to package (Morgan Roderick)
+    >
+    > In order to improve the experience of TypeScript users, we are compiling
+    > `.d.ts` files from the JSDoc and distributing them with the package
+    >
+
+_Released on 2021-01-13._
+
+## 1.8.1
+
+- [`07b9e7a`](https://github.com/sinonjs/commons/commit/07b9e7a1d784771273a9a58d74945bbc7319b5d4)
+  Optimize npm package size (Uladzimir Havenchyk)
+
+_Released on 2020-07-17._
+
+## 1.8.0
+
+- [`4282205`](https://github.com/sinonjs/commons/commit/4282205343a4dcde2a35ccf2a8c2094300dad369)
+  Emit deprecationg warnings in node, and keep console info in browsers (mshaaban0)
+
+_Released on 2020-05-20._
+
+## 1.7.2
+
+- [`76ad9c1`](https://github.com/sinonjs/commons/commit/76ad9c16bad29f72420ed55bdf45b65d076108c8)
+  Fix generators causing exceptions in function-name (Sebastian Mayr)
+
+_Released on 2020-04-08._
+
+## 1.7.1
+
+- [`0486d25`](https://github.com/sinonjs/commons/commit/0486d250ecec9b5f9aa2210357767e413f4162d3)
+  Upgrade eslint-config-sinon, add eslint-plugin-jsdoc (Morgan Roderick)
+    >
+    > This adds linting of jsdoc
+    >
+
+_Released on 2020-02-19._
diff --git a/node_modules/@sinonjs/commons/LICENSE b/node_modules/@sinonjs/commons/LICENSE
new file mode 100644
index 0000000..5a77f0a
--- /dev/null
+++ b/node_modules/@sinonjs/commons/LICENSE
@@ -0,0 +1,29 @@
+BSD 3-Clause License
+
+Copyright (c) 2018, Sinon.JS
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+* Redistributions of source code must retain the above copyright notice, this
+  list of conditions and the following disclaimer.
+
+* Redistributions in binary form must reproduce the above copyright notice,
+  this list of conditions and the following disclaimer in the documentation
+  and/or other materials provided with the distribution.
+
+* Neither the name of the copyright holder nor the names of its
+  contributors may be used to endorse or promote products derived from
+  this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
diff --git a/node_modules/@sinonjs/commons/README.md b/node_modules/@sinonjs/commons/README.md
new file mode 100644
index 0000000..9c420ba
--- /dev/null
+++ b/node_modules/@sinonjs/commons/README.md
@@ -0,0 +1,16 @@
+# commons
+
+[![CircleCI](https://circleci.com/gh/sinonjs/commons.svg?style=svg)](https://circleci.com/gh/sinonjs/commons)
+[![codecov](https://codecov.io/gh/sinonjs/commons/branch/master/graph/badge.svg)](https://codecov.io/gh/sinonjs/commons)
+<a href="CODE_OF_CONDUCT.md"><img src="https://img.shields.io/badge/Contributor%20Covenant-v2.0%20adopted-ff69b4.svg" alt="Contributor Covenant" /></a>
+
+Simple functions shared among the sinon end user libraries
+
+## Rules
+
+-   Follows the [Sinon.JS compatibility](https://github.com/sinonjs/sinon/blob/master/CONTRIBUTING.md#compatibility)
+-   100% test coverage
+-   Code formatted using [Prettier](https://prettier.io)
+-   No side effects welcome! (only pure functions)
+-   No platform specific functions
+-   One export per file (any bundler can do tree shaking)
diff --git a/node_modules/@sinonjs/commons/lib/called-in-order.js b/node_modules/@sinonjs/commons/lib/called-in-order.js
new file mode 100644
index 0000000..4edb67f
--- /dev/null
+++ b/node_modules/@sinonjs/commons/lib/called-in-order.js
@@ -0,0 +1,57 @@
+"use strict";
+
+var every = require("./prototypes/array").every;
+
+/**
+ * @private
+ */
+function hasCallsLeft(callMap, spy) {
+    if (callMap[spy.id] === undefined) {
+        callMap[spy.id] = 0;
+    }
+
+    return callMap[spy.id] < spy.callCount;
+}
+
+/**
+ * @private
+ */
+function checkAdjacentCalls(callMap, spy, index, spies) {
+    var calledBeforeNext = true;
+
+    if (index !== spies.length - 1) {
+        calledBeforeNext = spy.calledBefore(spies[index + 1]);
+    }
+
+    if (hasCallsLeft(callMap, spy) && calledBeforeNext) {
+        callMap[spy.id] += 1;
+        return true;
+    }
+
+    return false;
+}
+
+/**
+ * A Sinon proxy object (fake, spy, stub)
+ *
+ * @typedef {object} SinonProxy
+ * @property {Function} calledBefore - A method that determines if this proxy was called before another one
+ * @property {string} id - Some id
+ * @property {number} callCount - Number of times this proxy has been called
+ */
+
+/**
+ * Returns true when the spies have been called in the order they were supplied in
+ *
+ * @param  {SinonProxy[] | SinonProxy} spies An array of proxies, or several proxies as arguments
+ * @returns {boolean} true when spies are called in order, false otherwise
+ */
+function calledInOrder(spies) {
+    var callMap = {};
+    // eslint-disable-next-line no-underscore-dangle
+    var _spies = arguments.length > 1 ? arguments : spies;
+
+    return every(_spies, checkAdjacentCalls.bind(null, callMap));
+}
+
+module.exports = calledInOrder;
diff --git a/node_modules/@sinonjs/commons/lib/called-in-order.test.js b/node_modules/@sinonjs/commons/lib/called-in-order.test.js
new file mode 100644
index 0000000..00d8b8b
--- /dev/null
+++ b/node_modules/@sinonjs/commons/lib/called-in-order.test.js
@@ -0,0 +1,121 @@
+"use strict";
+
+var assert = require("@sinonjs/referee-sinon").assert;
+var calledInOrder = require("./called-in-order");
+var sinon = require("@sinonjs/referee-sinon").sinon;
+
+var testObject1 = {
+    someFunction: function() {
+        return;
+    }
+};
+var testObject2 = {
+    otherFunction: function() {
+        return;
+    }
+};
+var testObject3 = {
+    thirdFunction: function() {
+        return;
+    }
+};
+
+function testMethod() {
+    testObject1.someFunction();
+    testObject2.otherFunction();
+    testObject2.otherFunction();
+    testObject2.otherFunction();
+    testObject3.thirdFunction();
+}
+
+describe("calledInOrder", function() {
+    beforeEach(function() {
+        sinon.stub(testObject1, "someFunction");
+        sinon.stub(testObject2, "otherFunction");
+        sinon.stub(testObject3, "thirdFunction");
+        testMethod();
+    });
+    afterEach(function() {
+        testObject1.someFunction.restore();
+        testObject2.otherFunction.restore();
+        testObject3.thirdFunction.restore();
+    });
+
+    describe("given single array argument", function() {
+        describe("when stubs were called in expected order", function() {
+            it("returns true", function() {
+                assert.isTrue(
+                    calledInOrder([
+                        testObject1.someFunction,
+                        testObject2.otherFunction
+                    ])
+                );
+                assert.isTrue(
+                    calledInOrder([
+                        testObject1.someFunction,
+                        testObject2.otherFunction,
+                        testObject2.otherFunction,
+                        testObject3.thirdFunction
+                    ])
+                );
+            });
+        });
+
+        describe("when stubs were called in unexpected order", function() {
+            it("returns false", function() {
+                assert.isFalse(
+                    calledInOrder([
+                        testObject2.otherFunction,
+                        testObject1.someFunction
+                    ])
+                );
+                assert.isFalse(
+                    calledInOrder([
+                        testObject2.otherFunction,
+                        testObject1.someFunction,
+                        testObject1.someFunction,
+                        testObject3.thirdFunction
+                    ])
+                );
+            });
+        });
+    });
+
+    describe("given multiple arguments", function() {
+        describe("when stubs were called in expected order", function() {
+            it("returns true", function() {
+                assert.isTrue(
+                    calledInOrder(
+                        testObject1.someFunction,
+                        testObject2.otherFunction
+                    )
+                );
+                assert.isTrue(
+                    calledInOrder(
+                        testObject1.someFunction,
+                        testObject2.otherFunction,
+                        testObject3.thirdFunction
+                    )
+                );
+            });
+        });
+
+        describe("when stubs were called in unexpected order", function() {
+            it("returns false", function() {
+                assert.isFalse(
+                    calledInOrder(
+                        testObject2.otherFunction,
+                        testObject1.someFunction
+                    )
+                );
+                assert.isFalse(
+                    calledInOrder(
+                        testObject2.otherFunction,
+                        testObject1.someFunction,
+                        testObject3.thirdFunction
+                    )
+                );
+            });
+        });
+    });
+});
diff --git a/node_modules/@sinonjs/commons/lib/class-name.js b/node_modules/@sinonjs/commons/lib/class-name.js
new file mode 100644
index 0000000..bcd26ba
--- /dev/null
+++ b/node_modules/@sinonjs/commons/lib/class-name.js
@@ -0,0 +1,27 @@
+"use strict";
+
+var functionName = require("./function-name");
+
+/**
+ * Returns a display name for a value from a constructor
+ *
+ * @param  {object} value A value to examine
+ * @returns {(string|null)} A string or null
+ */
+function className(value) {
+    return (
+        (value.constructor && value.constructor.name) ||
+        // The next branch is for IE11 support only:
+        // Because the name property is not set on the prototype
+        // of the Function object, we finally try to grab the
+        // name from its definition. This will never be reached
+        // in node, so we are not able to test this properly.
+        // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function/name
+        (typeof value.constructor === "function" &&
+            /* istanbul ignore next */
+            functionName(value.constructor)) ||
+        null
+    );
+}
+
+module.exports = className;
diff --git a/node_modules/@sinonjs/commons/lib/class-name.test.js b/node_modules/@sinonjs/commons/lib/class-name.test.js
new file mode 100644
index 0000000..d091506
--- /dev/null
+++ b/node_modules/@sinonjs/commons/lib/class-name.test.js
@@ -0,0 +1,37 @@
+"use strict";
+/* eslint-disable no-empty-function */
+
+var assert = require("@sinonjs/referee").assert;
+var className = require("./class-name");
+
+describe("className", function() {
+    it("returns the class name of an instance", function() {
+        // Because eslint-config-sinon disables es6, we can't
+        // use a class definition here
+        // https://github.com/sinonjs/eslint-config-sinon/blob/master/index.js
+        // var instance = new (class TestClass {})();
+        var instance = new (function TestClass() {})();
+        var name = className(instance);
+        assert.equals(name, "TestClass");
+    });
+
+    it("returns 'Object' for {}", function() {
+        var name = className({});
+        assert.equals(name, "Object");
+    });
+
+    it("returns null for an object that has no prototype", function() {
+        var obj = Object.create(null);
+        var name = className(obj);
+        assert.equals(name, null);
+    });
+
+    it("returns null for an object whose prototype was mangled", function() {
+        // This is what Node v6 and v7 do for objects returned by querystring.parse()
+        function MangledObject() {}
+        MangledObject.prototype = Object.create(null);
+        var obj = new MangledObject();
+        var name = className(obj);
+        assert.equals(name, null);
+    });
+});
diff --git a/node_modules/@sinonjs/commons/lib/deprecated.js b/node_modules/@sinonjs/commons/lib/deprecated.js
new file mode 100644
index 0000000..ad68cc9
--- /dev/null
+++ b/node_modules/@sinonjs/commons/lib/deprecated.js
@@ -0,0 +1,58 @@
+/* eslint-disable no-console */
+"use strict";
+
+/**
+ * Returns a function that will invoke the supplied function and print a
+ * deprecation warning to the console each time it is called.
+ *
+ * @param  {Function} func
+ * @param  {string} msg
+ * @returns {Function}
+ */
+exports.wrap = function(func, msg) {
+    var wrapped = function() {
+        exports.printWarning(msg);
+        return func.apply(this, arguments);
+    };
+    if (func.prototype) {
+        wrapped.prototype = func.prototype;
+    }
+    return wrapped;
+};
+
+/**
+ * Returns a string which can be supplied to `wrap()` to notify the user that a
+ * particular part of the sinon API has been deprecated.
+ *
+ * @param  {string} packageName
+ * @param  {string} funcName
+ * @returns {string}
+ */
+exports.defaultMsg = function(packageName, funcName) {
+    return (
+        packageName +
+        "." +
+        funcName +
+        " is deprecated and will be removed from the public API in a future version of " +
+        packageName +
+        "."
+    );
+};
+
+/**
+ * Prints a warning on the console, when it exists
+ *
+ * @param  {string} msg
+ * @returns {undefined}
+ */
+exports.printWarning = function(msg) {
+    /* istanbul ignore next */
+    if (typeof process === "object" && process.emitWarning) {
+        // Emit Warnings in Node
+        process.emitWarning(msg);
+    } else if (console.info) {
+        console.info(msg);
+    } else {
+        console.log(msg);
+    }
+};
diff --git a/node_modules/@sinonjs/commons/lib/deprecated.test.js b/node_modules/@sinonjs/commons/lib/deprecated.test.js
new file mode 100644
index 0000000..9034345
--- /dev/null
+++ b/node_modules/@sinonjs/commons/lib/deprecated.test.js
@@ -0,0 +1,100 @@
+/* eslint-disable no-console */
+"use strict";
+
+var assert = require("@sinonjs/referee-sinon").assert;
+var sinon = require("@sinonjs/referee-sinon").sinon;
+
+var deprecated = require("./deprecated");
+
+var msg = "test";
+
+describe("deprecated", function() {
+    describe("defaultMsg", function() {
+        it("should return a string", function() {
+            assert.equals(
+                deprecated.defaultMsg("sinon", "someFunc"),
+                "sinon.someFunc is deprecated and will be removed from the public API in a future version of sinon."
+            );
+        });
+    });
+
+    describe("printWarning", function() {
+        beforeEach(function() {
+            sinon.replace(process, "emitWarning", sinon.fake());
+        });
+
+        afterEach(sinon.restore);
+
+        describe("when `process.emitWarning` is defined", function() {
+            it("should call process.emitWarning with a msg", function() {
+                deprecated.printWarning(msg);
+                assert.calledOnceWith(process.emitWarning, msg);
+            });
+        });
+
+        describe("when `process.emitWarning` is undefined", function() {
+            beforeEach(function() {
+                sinon.replace(console, "info", sinon.fake());
+                sinon.replace(console, "log", sinon.fake());
+                process.emitWarning = undefined;
+            });
+
+            afterEach(sinon.restore);
+
+            describe("when `console.info` is defined", function() {
+                it("should call `console.info` with a message", function() {
+                    deprecated.printWarning(msg);
+                    assert.calledOnceWith(console.info, msg);
+                });
+            });
+
+            describe("when `console.info` is undefined", function() {
+                it("should call `console.log` with a message", function() {
+                    console.info = undefined;
+                    deprecated.printWarning(msg);
+                    assert.calledOnceWith(console.log, msg);
+                });
+            });
+        });
+    });
+
+    describe("wrap", function() {
+        var method = sinon.fake();
+        var wrapped;
+
+        beforeEach(function() {
+            wrapped = deprecated.wrap(method, msg);
+        });
+
+        it("should return a wrapper function", function() {
+            assert.match(wrapped, sinon.match.func);
+        });
+
+        it("should assign the prototype of the passed method", function() {
+            assert.equals(method.prototype, wrapped.prototype);
+        });
+
+        context("when the passed method has falsy prototype", function() {
+            it("should not be assigned to the wrapped method", function() {
+                method.prototype = null;
+                wrapped = deprecated.wrap(method, msg);
+                assert.match(wrapped.prototype, sinon.match.object);
+            });
+        });
+
+        context("when invoking the wrapped function", function() {
+            before(function() {
+                sinon.replace(deprecated, "printWarning", sinon.fake());
+                wrapped({});
+            });
+
+            it("should call `printWarning` before invoking", function() {
+                assert.calledOnceWith(deprecated.printWarning, msg);
+            });
+
+            it("should invoke the passed method with the given arguments", function() {
+                assert.calledOnceWith(method, {});
+            });
+        });
+    });
+});
diff --git a/node_modules/@sinonjs/commons/lib/every.js b/node_modules/@sinonjs/commons/lib/every.js
new file mode 100644
index 0000000..08274b4
--- /dev/null
+++ b/node_modules/@sinonjs/commons/lib/every.js
@@ -0,0 +1,27 @@
+"use strict";
+
+/**
+ * Returns true when fn returns true for all members of obj.
+ * This is an every implementation that works for all iterables
+ *
+ * @param  {object}   obj
+ * @param  {Function} fn
+ * @returns {boolean}
+ */
+module.exports = function every(obj, fn) {
+    var pass = true;
+
+    try {
+        // eslint-disable-next-line @sinonjs/no-prototype-methods/no-prototype-methods
+        obj.forEach(function() {
+            if (!fn.apply(this, arguments)) {
+                // Throwing an error is the only way to break `forEach`
+                throw new Error();
+            }
+        });
+    } catch (e) {
+        pass = false;
+    }
+
+    return pass;
+};
diff --git a/node_modules/@sinonjs/commons/lib/every.test.js b/node_modules/@sinonjs/commons/lib/every.test.js
new file mode 100644
index 0000000..f893d43
--- /dev/null
+++ b/node_modules/@sinonjs/commons/lib/every.test.js
@@ -0,0 +1,41 @@
+"use strict";
+
+var assert = require("@sinonjs/referee-sinon").assert;
+var sinon = require("@sinonjs/referee-sinon").sinon;
+var every = require("./every");
+
+describe("util/core/every", function() {
+    it("returns true when the callback function returns true for every element in an iterable", function() {
+        var obj = [true, true, true, true];
+        var allTrue = every(obj, function(val) {
+            return val;
+        });
+
+        assert(allTrue);
+    });
+
+    it("returns false when the callback function returns false for any element in an iterable", function() {
+        var obj = [true, true, true, false];
+        var result = every(obj, function(val) {
+            return val;
+        });
+
+        assert.isFalse(result);
+    });
+
+    it("calls the given callback once for each item in an iterable until it returns false", function() {
+        var iterableOne = [true, true, true, true];
+        var iterableTwo = [true, true, false, true];
+        var callback = sinon.spy(function(val) {
+            return val;
+        });
+
+        every(iterableOne, callback);
+        assert.equals(callback.callCount, 4);
+
+        callback.resetHistory();
+
+        every(iterableTwo, callback);
+        assert.equals(callback.callCount, 3);
+    });
+});
diff --git a/node_modules/@sinonjs/commons/lib/function-name.js b/node_modules/@sinonjs/commons/lib/function-name.js
new file mode 100644
index 0000000..199b04e
--- /dev/null
+++ b/node_modules/@sinonjs/commons/lib/function-name.js
@@ -0,0 +1,29 @@
+"use strict";
+
+/**
+ * Returns a display name for a function
+ *
+ * @param  {Function} func
+ * @returns {string}
+ */
+module.exports = function functionName(func) {
+    if (!func) {
+        return "";
+    }
+
+    try {
+        return (
+            func.displayName ||
+            func.name ||
+            // Use function decomposition as a last resort to get function
+            // name. Does not rely on function decomposition to work - if it
+            // doesn't debugging will be slightly less informative
+            // (i.e. toString will say 'spy' rather than 'myFunc').
+            (String(func).match(/function ([^\s(]+)/) || [])[1]
+        );
+    } catch (e) {
+        // Stringify may fail and we might get an exception, as a last-last
+        // resort fall back to empty string.
+        return "";
+    }
+};
diff --git a/node_modules/@sinonjs/commons/lib/function-name.test.js b/node_modules/@sinonjs/commons/lib/function-name.test.js
new file mode 100644
index 0000000..6dda3a4
--- /dev/null
+++ b/node_modules/@sinonjs/commons/lib/function-name.test.js
@@ -0,0 +1,76 @@
+"use strict";
+
+var jsc = require("jsverify");
+var refute = require("@sinonjs/referee-sinon").refute;
+
+var functionName = require("./function-name");
+
+describe("function-name", function() {
+    it("should return empty string if func is falsy", function() {
+        jsc.assertForall("falsy", function(fn) {
+            return functionName(fn) === "";
+        });
+    });
+
+    it("should use displayName by default", function() {
+        jsc.assertForall("nestring", function(displayName) {
+            var fn = { displayName: displayName };
+
+            return functionName(fn) === fn.displayName;
+        });
+    });
+
+    it("should use name if displayName is not available", function() {
+        jsc.assertForall("nestring", function(name) {
+            var fn = { name: name };
+
+            return functionName(fn) === fn.name;
+        });
+    });
+
+    it("should fallback to string parsing", function() {
+        jsc.assertForall("nat", function(naturalNumber) {
+            var name = "fn" + naturalNumber;
+            var fn = {
+                toString: function() {
+                    return "\nfunction " + name;
+                }
+            };
+
+            return functionName(fn) === name;
+        });
+    });
+
+    it("should not fail when a name cannot be found", function() {
+        refute.exception(function() {
+            var fn = {
+                toString: function() {
+                    return "\nfunction (";
+                }
+            };
+
+            functionName(fn);
+        });
+    });
+
+    it("should not fail when toString is undefined", function() {
+        refute.exception(function() {
+            functionName(Object.create(null));
+        });
+    });
+
+    it("should not fail when toString throws", function() {
+        refute.exception(function() {
+            var fn;
+            try {
+                // eslint-disable-next-line no-eval
+                fn = eval("(function*() {})")().constructor;
+            } catch (e) {
+                // env doesn't support generators
+                return;
+            }
+
+            functionName(fn);
+        });
+    });
+});
diff --git a/node_modules/@sinonjs/commons/lib/global.js b/node_modules/@sinonjs/commons/lib/global.js
new file mode 100644
index 0000000..51715a2
--- /dev/null
+++ b/node_modules/@sinonjs/commons/lib/global.js
@@ -0,0 +1,22 @@
+"use strict";
+
+/**
+ * A reference to the global object
+ *
+ * @type {object} globalObject
+ */
+var globalObject;
+
+/* istanbul ignore else */
+if (typeof global !== "undefined") {
+    // Node
+    globalObject = global;
+} else if (typeof window !== "undefined") {
+    // Browser
+    globalObject = window;
+} else {
+    // WebWorker
+    globalObject = self;
+}
+
+module.exports = globalObject;
diff --git a/node_modules/@sinonjs/commons/lib/global.test.js b/node_modules/@sinonjs/commons/lib/global.test.js
new file mode 100644
index 0000000..e49b3da
--- /dev/null
+++ b/node_modules/@sinonjs/commons/lib/global.test.js
@@ -0,0 +1,16 @@
+"use strict";
+
+var assert = require("@sinonjs/referee-sinon").assert;
+var globalObject = require("./global");
+
+describe("global", function() {
+    before(function() {
+        if (typeof global === "undefined") {
+            this.skip();
+        }
+    });
+
+    it("is same as global", function() {
+        assert.same(globalObject, global);
+    });
+});
diff --git a/node_modules/@sinonjs/commons/lib/index.js b/node_modules/@sinonjs/commons/lib/index.js
new file mode 100644
index 0000000..5404857
--- /dev/null
+++ b/node_modules/@sinonjs/commons/lib/index.js
@@ -0,0 +1,14 @@
+"use strict";
+
+module.exports = {
+    global: require("./global"),
+    calledInOrder: require("./called-in-order"),
+    className: require("./class-name"),
+    deprecated: require("./deprecated"),
+    every: require("./every"),
+    functionName: require("./function-name"),
+    orderByFirstCall: require("./order-by-first-call"),
+    prototypes: require("./prototypes"),
+    typeOf: require("./type-of"),
+    valueToString: require("./value-to-string")
+};
diff --git a/node_modules/@sinonjs/commons/lib/index.test.js b/node_modules/@sinonjs/commons/lib/index.test.js
new file mode 100644
index 0000000..cac58a0
--- /dev/null
+++ b/node_modules/@sinonjs/commons/lib/index.test.js
@@ -0,0 +1,29 @@
+"use strict";
+
+var assert = require("@sinonjs/referee-sinon").assert;
+var index = require("./index");
+
+var expectedMethods = [
+    "calledInOrder",
+    "className",
+    "every",
+    "functionName",
+    "orderByFirstCall",
+    "typeOf",
+    "valueToString"
+];
+var expectedObjectProperties = ["deprecated", "prototypes"];
+
+describe("package", function() {
+    expectedMethods.forEach(function(name) {
+        it("should export a method named " + name, function() {
+            assert.isFunction(index[name]);
+        });
+    });
+
+    expectedObjectProperties.forEach(function(name) {
+        it("should export an object property named " + name, function() {
+            assert.isObject(index[name]);
+        });
+    });
+});
diff --git a/node_modules/@sinonjs/commons/lib/order-by-first-call.js b/node_modules/@sinonjs/commons/lib/order-by-first-call.js
new file mode 100644
index 0000000..c3d47ed
--- /dev/null
+++ b/node_modules/@sinonjs/commons/lib/order-by-first-call.js
@@ -0,0 +1,36 @@
+"use strict";
+
+var sort = require("./prototypes/array").sort;
+var slice = require("./prototypes/array").slice;
+
+/**
+ * @private
+ */
+function comparator(a, b) {
+    // uuid, won't ever be equal
+    var aCall = a.getCall(0);
+    var bCall = b.getCall(0);
+    var aId = (aCall && aCall.callId) || -1;
+    var bId = (bCall && bCall.callId) || -1;
+
+    return aId < bId ? -1 : 1;
+}
+
+/**
+ * A Sinon proxy object (fake, spy, stub)
+ *
+ * @typedef {object} SinonProxy
+ * @property {Function} getCall - A method that can return the first call
+ */
+
+/**
+ * Sorts an array of SinonProxy instances (fake, spy, stub) by their first call
+ *
+ * @param  {SinonProxy[] | SinonProxy} spies
+ * @returns {SinonProxy[]}
+ */
+function orderByFirstCall(spies) {
+    return sort(slice(spies), comparator);
+}
+
+module.exports = orderByFirstCall;
diff --git a/node_modules/@sinonjs/commons/lib/order-by-first-call.test.js b/node_modules/@sinonjs/commons/lib/order-by-first-call.test.js
new file mode 100644
index 0000000..485ad43
--- /dev/null
+++ b/node_modules/@sinonjs/commons/lib/order-by-first-call.test.js
@@ -0,0 +1,52 @@
+"use strict";
+
+var assert = require("@sinonjs/referee-sinon").assert;
+var knuthShuffle = require("knuth-shuffle").knuthShuffle;
+var sinon = require("@sinonjs/referee-sinon").sinon;
+var orderByFirstCall = require("./order-by-first-call");
+
+describe("orderByFirstCall", function() {
+    it("should order an Array of spies by the callId of the first call, ascending", function() {
+        // create an array of spies
+        var spies = [
+            sinon.spy(),
+            sinon.spy(),
+            sinon.spy(),
+            sinon.spy(),
+            sinon.spy(),
+            sinon.spy()
+        ];
+
+        // call all the spies
+        spies.forEach(function(spy) {
+            spy();
+        });
+
+        // add a few uncalled spies
+        spies.push(sinon.spy());
+        spies.push(sinon.spy());
+
+        // randomise the order of the spies
+        knuthShuffle(spies);
+
+        var sortedSpies = orderByFirstCall(spies);
+
+        assert.equals(sortedSpies.length, spies.length);
+
+        var orderedByFirstCall = sortedSpies.every(function(spy, index) {
+            if (index + 1 === sortedSpies.length) {
+                return true;
+            }
+            var nextSpy = sortedSpies[index + 1];
+
+            // uncalled spies should be ordered first
+            if (!spy.called) {
+                return true;
+            }
+
+            return spy.calledImmediatelyBefore(nextSpy);
+        });
+
+        assert.isTrue(orderedByFirstCall);
+    });
+});
diff --git a/node_modules/@sinonjs/commons/lib/prototypes/README.md b/node_modules/@sinonjs/commons/lib/prototypes/README.md
new file mode 100644
index 0000000..aff3d91
--- /dev/null
+++ b/node_modules/@sinonjs/commons/lib/prototypes/README.md
@@ -0,0 +1,43 @@
+# Prototypes
+
+The functions in this folder are to be use for keeping cached references to the built-in prototypes, so that people can't inadvertently break the library by making mistakes in userland.
+
+See https://github.com/sinonjs/sinon/pull/1523
+
+## Without cached references
+
+```js
+// in userland, the library user needs to replace the filter method on
+// Array.prototype
+var array = [1, 2, 3];
+sinon.replace(array, "filter", sinon.fake.returns(2));
+
+// in a sinon module, the library author needs to use the filter method
+var someArray = ["a", "b", 42, "c"];
+var answer = filter(someArray, function(v) {
+    return v === 42;
+});
+
+console.log(answer);
+// => 2
+```
+
+## With cached references
+
+```js
+// in userland, the library user needs to replace the filter method on
+// Array.prototype
+var array = [1, 2, 3];
+sinon.replace(array, "filter", sinon.fake.returns(2));
+
+// in a sinon module, the library author needs to use the filter method
+// get a reference to the original Array.prototype.filter
+var filter = require("@sinonjs/commons").prototypes.array.filter;
+var someArray = ["a", "b", 42, "c"];
+var answer = filter(someArray, function(v) {
+    return v === 42;
+});
+
+console.log(answer);
+// => 42
+```
diff --git a/node_modules/@sinonjs/commons/lib/prototypes/array.js b/node_modules/@sinonjs/commons/lib/prototypes/array.js
new file mode 100644
index 0000000..0e332b5
--- /dev/null
+++ b/node_modules/@sinonjs/commons/lib/prototypes/array.js
@@ -0,0 +1,5 @@
+"use strict";
+
+var copyPrototype = require("./copy-prototype");
+
+module.exports = copyPrototype(Array.prototype);
diff --git a/node_modules/@sinonjs/commons/lib/prototypes/copy-prototype.js b/node_modules/@sinonjs/commons/lib/prototypes/copy-prototype.js
new file mode 100644
index 0000000..0560a00
--- /dev/null
+++ b/node_modules/@sinonjs/commons/lib/prototypes/copy-prototype.js
@@ -0,0 +1,21 @@
+"use strict";
+
+var call = Function.call;
+
+module.exports = function copyPrototypeMethods(prototype) {
+    // eslint-disable-next-line @sinonjs/no-prototype-methods/no-prototype-methods
+    return Object.getOwnPropertyNames(prototype).reduce(function(result, name) {
+        // ignore size because it throws from Map
+        if (
+            name !== "size" &&
+            name !== "caller" &&
+            name !== "callee" &&
+            name !== "arguments" &&
+            typeof prototype[name] === "function"
+        ) {
+            result[name] = call.bind(prototype[name]);
+        }
+
+        return result;
+    }, Object.create(null));
+};
diff --git a/node_modules/@sinonjs/commons/lib/prototypes/function.js b/node_modules/@sinonjs/commons/lib/prototypes/function.js
new file mode 100644
index 0000000..28d0cb3
--- /dev/null
+++ b/node_modules/@sinonjs/commons/lib/prototypes/function.js
@@ -0,0 +1,5 @@
+"use strict";
+
+var copyPrototype = require("./copy-prototype");
+
+module.exports = copyPrototype(Function.prototype);
diff --git a/node_modules/@sinonjs/commons/lib/prototypes/index.js b/node_modules/@sinonjs/commons/lib/prototypes/index.js
new file mode 100644
index 0000000..6ca7f84
--- /dev/null
+++ b/node_modules/@sinonjs/commons/lib/prototypes/index.js
@@ -0,0 +1,10 @@
+"use strict";
+
+module.exports = {
+    array: require("./array"),
+    function: require("./function"),
+    map: require("./map"),
+    object: require("./object"),
+    set: require("./set"),
+    string: require("./string")
+};
diff --git a/node_modules/@sinonjs/commons/lib/prototypes/index.test.js b/node_modules/@sinonjs/commons/lib/prototypes/index.test.js
new file mode 100644
index 0000000..926f4f1
--- /dev/null
+++ b/node_modules/@sinonjs/commons/lib/prototypes/index.test.js
@@ -0,0 +1,51 @@
+"use strict";
+
+var assert = require("@sinonjs/referee-sinon").assert;
+
+var arrayProto = require("./index").array;
+var functionProto = require("./index").function;
+var mapProto = require("./index").map;
+var objectProto = require("./index").object;
+var setProto = require("./index").set;
+var stringProto = require("./index").string;
+
+describe("prototypes", function() {
+    describe(".array", function() {
+        verifyProperties(arrayProto, Array);
+    });
+    describe(".function", function() {
+        verifyProperties(functionProto, Function);
+    });
+    describe(".map", function() {
+        verifyProperties(mapProto, Map);
+    });
+    describe(".object", function() {
+        verifyProperties(objectProto, Object);
+    });
+    describe(".set", function() {
+        verifyProperties(setProto, Set);
+    });
+    describe(".string", function() {
+        verifyProperties(stringProto, String);
+    });
+});
+
+function verifyProperties(p, origin) {
+    it("should have all the methods of the origin prototype", function() {
+        var methodNames = Object.getOwnPropertyNames(origin.prototype).filter(
+            function(name) {
+                return (
+                    name !== "size" &&
+                    name !== "caller" &&
+                    name !== "callee" &&
+                    name !== "arguments" &&
+                    typeof origin.prototype[name] === "function"
+                );
+            }
+        );
+
+        methodNames.forEach(function(name) {
+            assert.isTrue(Object.prototype.hasOwnProperty.call(p, name), name);
+        });
+    });
+}
diff --git a/node_modules/@sinonjs/commons/lib/prototypes/map.js b/node_modules/@sinonjs/commons/lib/prototypes/map.js
new file mode 100644
index 0000000..793d08b
--- /dev/null
+++ b/node_modules/@sinonjs/commons/lib/prototypes/map.js
@@ -0,0 +1,5 @@
+"use strict";
+
+var copyPrototype = require("./copy-prototype");
+
+module.exports = copyPrototype(Map.prototype);
diff --git a/node_modules/@sinonjs/commons/lib/prototypes/object.js b/node_modules/@sinonjs/commons/lib/prototypes/object.js
new file mode 100644
index 0000000..5b18b56
--- /dev/null
+++ b/node_modules/@sinonjs/commons/lib/prototypes/object.js
@@ -0,0 +1,5 @@
+"use strict";
+
+var copyPrototype = require("./copy-prototype");
+
+module.exports = copyPrototype(Object.prototype);
diff --git a/node_modules/@sinonjs/commons/lib/prototypes/set.js b/node_modules/@sinonjs/commons/lib/prototypes/set.js
new file mode 100644
index 0000000..b5ade92
--- /dev/null
+++ b/node_modules/@sinonjs/commons/lib/prototypes/set.js
@@ -0,0 +1,5 @@
+"use strict";
+
+var copyPrototype = require("./copy-prototype");
+
+module.exports = copyPrototype(Set.prototype);
diff --git a/node_modules/@sinonjs/commons/lib/prototypes/string.js b/node_modules/@sinonjs/commons/lib/prototypes/string.js
new file mode 100644
index 0000000..edc905e
--- /dev/null
+++ b/node_modules/@sinonjs/commons/lib/prototypes/string.js
@@ -0,0 +1,5 @@
+"use strict";
+
+var copyPrototype = require("./copy-prototype");
+
+module.exports = copyPrototype(String.prototype);
diff --git a/node_modules/@sinonjs/commons/lib/type-of.js b/node_modules/@sinonjs/commons/lib/type-of.js
new file mode 100644
index 0000000..97a0bb9
--- /dev/null
+++ b/node_modules/@sinonjs/commons/lib/type-of.js
@@ -0,0 +1,13 @@
+"use strict";
+
+var type = require("type-detect");
+
+/**
+ * Returns the lower-case result of running type from type-detect on the value
+ *
+ * @param  {*} value
+ * @returns {string}
+ */
+module.exports = function typeOf(value) {
+    return type(value).toLowerCase();
+};
diff --git a/node_modules/@sinonjs/commons/lib/type-of.test.js b/node_modules/@sinonjs/commons/lib/type-of.test.js
new file mode 100644
index 0000000..5fcfc74
--- /dev/null
+++ b/node_modules/@sinonjs/commons/lib/type-of.test.js
@@ -0,0 +1,51 @@
+"use strict";
+
+var assert = require("@sinonjs/referee-sinon").assert;
+var typeOf = require("./type-of");
+
+describe("typeOf", function() {
+    it("returns boolean", function() {
+        assert.equals(typeOf(false), "boolean");
+    });
+
+    it("returns string", function() {
+        assert.equals(typeOf("Sinon.JS"), "string");
+    });
+
+    it("returns number", function() {
+        assert.equals(typeOf(123), "number");
+    });
+
+    it("returns object", function() {
+        assert.equals(typeOf({}), "object");
+    });
+
+    it("returns function", function() {
+        assert.equals(
+            typeOf(function() {
+                return undefined;
+            }),
+            "function"
+        );
+    });
+
+    it("returns undefined", function() {
+        assert.equals(typeOf(undefined), "undefined");
+    });
+
+    it("returns null", function() {
+        assert.equals(typeOf(null), "null");
+    });
+
+    it("returns array", function() {
+        assert.equals(typeOf([]), "array");
+    });
+
+    it("returns regexp", function() {
+        assert.equals(typeOf(/.*/), "regexp");
+    });
+
+    it("returns date", function() {
+        assert.equals(typeOf(new Date()), "date");
+    });
+});
diff --git a/node_modules/@sinonjs/commons/lib/value-to-string.js b/node_modules/@sinonjs/commons/lib/value-to-string.js
new file mode 100644
index 0000000..fb14782
--- /dev/null
+++ b/node_modules/@sinonjs/commons/lib/value-to-string.js
@@ -0,0 +1,17 @@
+"use strict";
+
+/**
+ * Returns a string representation of the value
+ *
+ * @param  {*} value
+ * @returns {string}
+ */
+function valueToString(value) {
+    if (value && value.toString) {
+        // eslint-disable-next-line @sinonjs/no-prototype-methods/no-prototype-methods
+        return value.toString();
+    }
+    return String(value);
+}
+
+module.exports = valueToString;
diff --git a/node_modules/@sinonjs/commons/lib/value-to-string.test.js b/node_modules/@sinonjs/commons/lib/value-to-string.test.js
new file mode 100644
index 0000000..5cae501
--- /dev/null
+++ b/node_modules/@sinonjs/commons/lib/value-to-string.test.js
@@ -0,0 +1,20 @@
+"use strict";
+
+var assert = require("@sinonjs/referee-sinon").assert;
+var valueToString = require("./value-to-string");
+
+describe("util/core/valueToString", function() {
+    it("returns string representation of an object", function() {
+        var obj = {};
+
+        assert.equals(valueToString(obj), obj.toString());
+    });
+
+    it("returns 'null' for literal null'", function() {
+        assert.equals(valueToString(null), "null");
+    });
+
+    it("returns 'undefined' for literal undefined", function() {
+        assert.equals(valueToString(undefined), "undefined");
+    });
+});
diff --git a/node_modules/@sinonjs/commons/package.json b/node_modules/@sinonjs/commons/package.json
new file mode 100644
index 0000000..f0e6c14
--- /dev/null
+++ b/node_modules/@sinonjs/commons/package.json
@@ -0,0 +1,67 @@
+{
+  "name": "@sinonjs/commons",
+  "version": "1.8.3",
+  "description": "Simple functions shared among the sinon end user libraries",
+  "main": "lib/index.js",
+  "types": "./types/index.d.ts",
+  "scripts": {
+    "build": "rm -rf types && tsc",
+    "lint": "eslint .",
+    "precommit": "lint-staged",
+    "test": "mocha --recursive -R dot \"lib/**/*.test.js\"",
+    "test-check-coverage": "npm run test-coverage && nyc check-coverage --branches 100 --functions 100 --lines 100",
+    "test-coverage": "nyc --reporter text --reporter html --reporter lcovonly npm run test",
+    "prepublishOnly": "npm run build",
+    "prettier:check": "prettier --check '**/*.{js,css,md}'",
+    "prettier:write": "prettier --write '**/*.{js,css,md}'",
+    "preversion": "npm run test-check-coverage",
+    "version": "changes --commits --footer",
+    "postversion": "git push --follow-tags && npm publish"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/sinonjs/commons.git"
+  },
+  "files": [
+    "lib",
+    "types"
+  ],
+  "author": "",
+  "license": "BSD-3-Clause",
+  "bugs": {
+    "url": "https://github.com/sinonjs/commons/issues"
+  },
+  "homepage": "https://github.com/sinonjs/commons#readme",
+  "lint-staged": {
+    "*.{js,css,md}": "prettier --check",
+    "*.js": "eslint"
+  },
+  "devDependencies": {
+    "@sinonjs/eslint-plugin-no-prototype-methods": "^0.1.0",
+    "@sinonjs/referee-sinon": "7.0.2",
+    "@studio/changes": "^2.0.0",
+    "eslint": "^6.1.0",
+    "eslint-config-prettier": "^6.3.0",
+    "eslint-config-sinon": "^4.0.0",
+    "eslint-plugin-ie11": "^1.0.0",
+    "eslint-plugin-jsdoc": "^22.1.0",
+    "eslint-plugin-mocha": "^6.1.1",
+    "eslint-plugin-prettier": "^3.0.0",
+    "husky": "4.2.3",
+    "jsverify": "0.8.4",
+    "knuth-shuffle": "^1.0.8",
+    "lint-staged": "10.1.1",
+    "mocha": "7.1.0",
+    "nyc": "15.0.0",
+    "prettier": "^1.14.3",
+    "typescript": "^4.1.3"
+  },
+  "dependencies": {
+    "type-detect": "4.0.8"
+  },
+  "husky": {
+    "hooks": {
+      "pre-commit": "lint-staged"
+    }
+  }
+}
diff --git a/node_modules/@sinonjs/commons/types/called-in-order.d.ts b/node_modules/@sinonjs/commons/types/called-in-order.d.ts
new file mode 100644
index 0000000..1a4508b
--- /dev/null
+++ b/node_modules/@sinonjs/commons/types/called-in-order.d.ts
@@ -0,0 +1,36 @@
+export = calledInOrder;
+/**
+ * A Sinon proxy object (fake, spy, stub)
+ *
+ * @typedef {object} SinonProxy
+ * @property {Function} calledBefore - A method that determines if this proxy was called before another one
+ * @property {string} id - Some id
+ * @property {number} callCount - Number of times this proxy has been called
+ */
+/**
+ * Returns true when the spies have been called in the order they were supplied in
+ *
+ * @param  {SinonProxy[] | SinonProxy} spies An array of proxies, or several proxies as arguments
+ * @returns {boolean} true when spies are called in order, false otherwise
+ */
+declare function calledInOrder(spies: SinonProxy[] | SinonProxy, ...args: any[]): boolean;
+declare namespace calledInOrder {
+    export { SinonProxy };
+}
+/**
+ * A Sinon proxy object (fake, spy, stub)
+ */
+type SinonProxy = {
+    /**
+     * - A method that determines if this proxy was called before another one
+     */
+    calledBefore: Function;
+    /**
+     * - Some id
+     */
+    id: string;
+    /**
+     * - Number of times this proxy has been called
+     */
+    callCount: number;
+};
diff --git a/node_modules/@sinonjs/commons/types/class-name.d.ts b/node_modules/@sinonjs/commons/types/class-name.d.ts
new file mode 100644
index 0000000..df3687b
--- /dev/null
+++ b/node_modules/@sinonjs/commons/types/class-name.d.ts
@@ -0,0 +1,8 @@
+export = className;
+/**
+ * Returns a display name for a value from a constructor
+ *
+ * @param  {object} value A value to examine
+ * @returns {(string|null)} A string or null
+ */
+declare function className(value: object): (string | null);
diff --git a/node_modules/@sinonjs/commons/types/deprecated.d.ts b/node_modules/@sinonjs/commons/types/deprecated.d.ts
new file mode 100644
index 0000000..81a35bf
--- /dev/null
+++ b/node_modules/@sinonjs/commons/types/deprecated.d.ts
@@ -0,0 +1,3 @@
+export function wrap(func: Function, msg: string): Function;
+export function defaultMsg(packageName: string, funcName: string): string;
+export function printWarning(msg: string): undefined;
diff --git a/node_modules/@sinonjs/commons/types/every.d.ts b/node_modules/@sinonjs/commons/types/every.d.ts
new file mode 100644
index 0000000..bcfa64e
--- /dev/null
+++ b/node_modules/@sinonjs/commons/types/every.d.ts
@@ -0,0 +1,2 @@
+declare function _exports(obj: object, fn: Function): boolean;
+export = _exports;
diff --git a/node_modules/@sinonjs/commons/types/function-name.d.ts b/node_modules/@sinonjs/commons/types/function-name.d.ts
new file mode 100644
index 0000000..f27d519
--- /dev/null
+++ b/node_modules/@sinonjs/commons/types/function-name.d.ts
@@ -0,0 +1,2 @@
+declare function _exports(func: Function): string;
+export = _exports;
diff --git a/node_modules/@sinonjs/commons/types/global.d.ts b/node_modules/@sinonjs/commons/types/global.d.ts
new file mode 100644
index 0000000..0f54a63
--- /dev/null
+++ b/node_modules/@sinonjs/commons/types/global.d.ts
@@ -0,0 +1,7 @@
+export = globalObject;
+/**
+ * A reference to the global object
+ *
+ * @type {object} globalObject
+ */
+declare var globalObject: object;
diff --git a/node_modules/@sinonjs/commons/types/index.d.ts b/node_modules/@sinonjs/commons/types/index.d.ts
new file mode 100644
index 0000000..7d675b1
--- /dev/null
+++ b/node_modules/@sinonjs/commons/types/index.d.ts
@@ -0,0 +1,17 @@
+export const global: any;
+export const calledInOrder: typeof import("./called-in-order");
+export const className: typeof import("./class-name");
+export const deprecated: typeof import("./deprecated");
+export const every: (obj: any, fn: Function) => boolean;
+export const functionName: (func: Function) => string;
+export const orderByFirstCall: typeof import("./order-by-first-call");
+export const prototypes: {
+    array: any;
+    function: any;
+    map: any;
+    object: any;
+    set: any;
+    string: any;
+};
+export const typeOf: (value: any) => string;
+export const valueToString: typeof import("./value-to-string");
diff --git a/node_modules/@sinonjs/commons/types/order-by-first-call.d.ts b/node_modules/@sinonjs/commons/types/order-by-first-call.d.ts
new file mode 100644
index 0000000..a9a6037
--- /dev/null
+++ b/node_modules/@sinonjs/commons/types/order-by-first-call.d.ts
@@ -0,0 +1,26 @@
+export = orderByFirstCall;
+/**
+ * A Sinon proxy object (fake, spy, stub)
+ *
+ * @typedef {object} SinonProxy
+ * @property {Function} getCall - A method that can return the first call
+ */
+/**
+ * Sorts an array of SinonProxy instances (fake, spy, stub) by their first call
+ *
+ * @param  {SinonProxy[] | SinonProxy} spies
+ * @returns {SinonProxy[]}
+ */
+declare function orderByFirstCall(spies: SinonProxy[] | SinonProxy): SinonProxy[];
+declare namespace orderByFirstCall {
+    export { SinonProxy };
+}
+/**
+ * A Sinon proxy object (fake, spy, stub)
+ */
+type SinonProxy = {
+    /**
+     * - A method that can return the first call
+     */
+    getCall: Function;
+};
diff --git a/node_modules/@sinonjs/commons/types/prototypes/array.d.ts b/node_modules/@sinonjs/commons/types/prototypes/array.d.ts
new file mode 100644
index 0000000..1cce635
--- /dev/null
+++ b/node_modules/@sinonjs/commons/types/prototypes/array.d.ts
@@ -0,0 +1,2 @@
+declare const _exports: any;
+export = _exports;
diff --git a/node_modules/@sinonjs/commons/types/prototypes/copy-prototype.d.ts b/node_modules/@sinonjs/commons/types/prototypes/copy-prototype.d.ts
new file mode 100644
index 0000000..1479b93
--- /dev/null
+++ b/node_modules/@sinonjs/commons/types/prototypes/copy-prototype.d.ts
@@ -0,0 +1,2 @@
+declare function _exports(prototype: any): any;
+export = _exports;
diff --git a/node_modules/@sinonjs/commons/types/prototypes/function.d.ts b/node_modules/@sinonjs/commons/types/prototypes/function.d.ts
new file mode 100644
index 0000000..1cce635
--- /dev/null
+++ b/node_modules/@sinonjs/commons/types/prototypes/function.d.ts
@@ -0,0 +1,2 @@
+declare const _exports: any;
+export = _exports;
diff --git a/node_modules/@sinonjs/commons/types/prototypes/index.d.ts b/node_modules/@sinonjs/commons/types/prototypes/index.d.ts
new file mode 100644
index 0000000..0026d6c
--- /dev/null
+++ b/node_modules/@sinonjs/commons/types/prototypes/index.d.ts
@@ -0,0 +1,7 @@
+export declare const array: any;
+declare const _function: any;
+export { _function as function };
+export declare const map: any;
+export declare const object: any;
+export declare const set: any;
+export declare const string: any;
diff --git a/node_modules/@sinonjs/commons/types/prototypes/map.d.ts b/node_modules/@sinonjs/commons/types/prototypes/map.d.ts
new file mode 100644
index 0000000..1cce635
--- /dev/null
+++ b/node_modules/@sinonjs/commons/types/prototypes/map.d.ts
@@ -0,0 +1,2 @@
+declare const _exports: any;
+export = _exports;
diff --git a/node_modules/@sinonjs/commons/types/prototypes/object.d.ts b/node_modules/@sinonjs/commons/types/prototypes/object.d.ts
new file mode 100644
index 0000000..1cce635
--- /dev/null
+++ b/node_modules/@sinonjs/commons/types/prototypes/object.d.ts
@@ -0,0 +1,2 @@
+declare const _exports: any;
+export = _exports;
diff --git a/node_modules/@sinonjs/commons/types/prototypes/set.d.ts b/node_modules/@sinonjs/commons/types/prototypes/set.d.ts
new file mode 100644
index 0000000..1cce635
--- /dev/null
+++ b/node_modules/@sinonjs/commons/types/prototypes/set.d.ts
@@ -0,0 +1,2 @@
+declare const _exports: any;
+export = _exports;
diff --git a/node_modules/@sinonjs/commons/types/prototypes/string.d.ts b/node_modules/@sinonjs/commons/types/prototypes/string.d.ts
new file mode 100644
index 0000000..1cce635
--- /dev/null
+++ b/node_modules/@sinonjs/commons/types/prototypes/string.d.ts
@@ -0,0 +1,2 @@
+declare const _exports: any;
+export = _exports;
diff --git a/node_modules/@sinonjs/commons/types/type-of.d.ts b/node_modules/@sinonjs/commons/types/type-of.d.ts
new file mode 100644
index 0000000..fc72887
--- /dev/null
+++ b/node_modules/@sinonjs/commons/types/type-of.d.ts
@@ -0,0 +1,2 @@
+declare function _exports(value: any): string;
+export = _exports;
diff --git a/node_modules/@sinonjs/commons/types/value-to-string.d.ts b/node_modules/@sinonjs/commons/types/value-to-string.d.ts
new file mode 100644
index 0000000..19b086c
--- /dev/null
+++ b/node_modules/@sinonjs/commons/types/value-to-string.d.ts
@@ -0,0 +1,8 @@
+export = valueToString;
+/**
+ * Returns a string representation of the value
+ *
+ * @param  {*} value
+ * @returns {string}
+ */
+declare function valueToString(value: any): string;