Update checked-in dependencies

node_modules/sinon/lib/sinon/util/core/default-config.js

@@ -13,8 +13,8 @@ module.exports = {
         "replace",
         "replaceSetter",
         "replaceGetter",
-        "createStubInstance"
+        "createStubInstance",
     ],
     useFakeTimers: true,
-    useFakeServer: true
+    useFakeServer: true,
 };

node_modules/sinon/lib/sinon/util/core/export-async-behaviors.js

@@ -6,10 +6,10 @@ var reduce = arrayProto.reduce;
 module.exports = function exportAsyncBehaviors(behaviorMethods) {
     return reduce(
         Object.keys(behaviorMethods),
-        function(acc, method) {
+        function (acc, method) {
             // need to avoid creating another async versions of the newly added async methods
             if (method.match(/^(callsArg|yields)/) && !method.match(/Async/)) {
-                acc[method + "Async"] = function() {
+                acc[`${method}Async`] = function () {
                     var result = behaviorMethods[method].apply(this, arguments);
                     this.callbackAsync = true;
                     return result;

node_modules/sinon/lib/sinon/util/core/extend.js

@@ -1,45 +1,45 @@
 "use strict";
 
 var arrayProto = require("@sinonjs/commons").prototypes.array;
-var hasOwnProperty = require("@sinonjs/commons").prototypes.object.hasOwnProperty;
+var hasOwnProperty =
+    require("@sinonjs/commons").prototypes.object.hasOwnProperty;
 
 var join = arrayProto.join;
 var push = arrayProto.push;
-var slice = arrayProto.slice;
 
 // Adapted from https://developer.mozilla.org/en/docs/ECMAScript_DontEnum_attribute#JScript_DontEnum_Bug
-var hasDontEnumBug = (function() {
+var hasDontEnumBug = (function () {
     var obj = {
-        constructor: function() {
+        constructor: function () {
             return "0";
         },
-        toString: function() {
+        toString: function () {
             return "1";
         },
-        valueOf: function() {
+        valueOf: function () {
             return "2";
         },
-        toLocaleString: function() {
+        toLocaleString: function () {
             return "3";
         },
-        prototype: function() {
+        prototype: function () {
             return "4";
         },
-        isPrototypeOf: function() {
+        isPrototypeOf: function () {
             return "5";
         },
-        propertyIsEnumerable: function() {
+        propertyIsEnumerable: function () {
             return "6";
         },
-        hasOwnProperty: function() {
+        hasOwnProperty: function () {
             return "7";
         },
-        length: function() {
+        length: function () {
             return "8";
         },
-        unique: function() {
+        unique: function () {
             return "9";
-        }
+        },
     };
 
     var result = [];
@@ -65,7 +65,11 @@ function extendCommon(target, sources, doCopy) {
 
         // Make sure we copy (own) toString method even when in JScript with DontEnum bug
         // See https://developer.mozilla.org/en/docs/ECMAScript_DontEnum_attribute#JScript_DontEnum_Bug
-        if (hasDontEnumBug && hasOwnProperty(source, "toString") && source.toString !== target.toString) {
+        if (
+            hasDontEnumBug &&
+            hasOwnProperty(source, "toString") &&
+            source.toString !== target.toString
+        ) {
             target.toString = source.toString;
         }
     }
@@ -73,39 +77,78 @@ function extendCommon(target, sources, doCopy) {
     return target;
 }
 
-/** Public: Extend target in place with all (own) properties from sources in-order. Thus, last source will
- *         override properties in previous sources.
+/** Public: Extend target in place with all (own) properties, except 'name' when [[writable]] is false,
+ *         from sources in-order. Thus, last source will override properties in previous sources.
  *
- * @arg {Object} target - The Object to extend
- * @arg {Object[]} sources - Objects to copy properties from.
+ * @param {object} target - The Object to extend
+ * @param {object[]} sources - Objects to copy properties from.
  *
- * @returns {Object} the extended target
+ * @returns {object} the extended target
  */
-module.exports = function extend(target /*, sources */) {
-    var sources = slice(arguments, 1);
+module.exports = function extend(target, ...sources) {
+    return extendCommon(
+        target,
+        sources,
+        function copyValue(dest, source, prop) {
+            var destOwnPropertyDescriptor = Object.getOwnPropertyDescriptor(
+                dest,
+                prop
+            );
+            var sourceOwnPropertyDescriptor = Object.getOwnPropertyDescriptor(
+                source,
+                prop
+            );
 
-    return extendCommon(target, sources, function copyValue(dest, source, prop) {
-        dest[prop] = source[prop];
-    });
+            if (prop === "name" && !destOwnPropertyDescriptor.writable) {
+                return;
+            }
+            const descriptors = {
+                configurable: sourceOwnPropertyDescriptor.configurable,
+                enumerable: sourceOwnPropertyDescriptor.enumerable,
+            };
+            /*
+                if the sorce has an Accessor property copy over the accessor functions (get and set)
+                data properties has writable attribute where as acessor property don't
+                REF: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#properties
+            */
+
+            if (hasOwnProperty(sourceOwnPropertyDescriptor, "writable")) {
+                descriptors.writable = sourceOwnPropertyDescriptor.writable;
+                descriptors.value = sourceOwnPropertyDescriptor.value;
+            } else {
+                if (sourceOwnPropertyDescriptor.get) {
+                    descriptors.get =
+                        sourceOwnPropertyDescriptor.get.bind(dest);
+                }
+                if (sourceOwnPropertyDescriptor.set) {
+                    descriptors.set =
+                        sourceOwnPropertyDescriptor.set.bind(dest);
+                }
+            }
+            Object.defineProperty(dest, prop, descriptors);
+        }
+    );
 };
 
 /** Public: Extend target in place with all (own) properties from sources in-order. Thus, last source will
  *         override properties in previous sources. Define the properties as non enumerable.
  *
- * @arg {Object} target - The Object to extend
- * @arg {Object[]} sources - Objects to copy properties from.
+ * @param {object} target - The Object to extend
+ * @param {object[]} sources - Objects to copy properties from.
  *
- * @returns {Object} the extended target
+ * @returns {object} the extended target
  */
-module.exports.nonEnum = function extendNonEnum(target /*, sources */) {
-    var sources = slice(arguments, 1);
-
-    return extendCommon(target, sources, function copyProperty(dest, source, prop) {
-        Object.defineProperty(dest, prop, {
-            value: source[prop],
-            enumerable: false,
-            configurable: true,
-            writable: true
-        });
-    });
+module.exports.nonEnum = function extendNonEnum(target, ...sources) {
+    return extendCommon(
+        target,
+        sources,
+        function copyProperty(dest, source, prop) {
+            Object.defineProperty(dest, prop, {
+                value: source[prop],
+                enumerable: false,
+                configurable: true,
+                writable: true,
+            });
+        }
+    );
 };

node_modules/sinon/lib/sinon/util/core/format.js

@@ -1,12 +1,6 @@
 "use strict";
 
-var formatio = require("@sinonjs/formatio");
-
-var formatter = formatio.configure({
-    quoteStrings: false,
-    limitChildrenCount: 250
-});
-
+var inspect = require("util").inspect;
 var customFormatter;
 
 function format() {
@@ -14,10 +8,10 @@ function format() {
         return customFormatter.apply(null, arguments);
     }
 
-    return formatter.ascii.apply(formatter, arguments);
+    return inspect.apply(inspect, arguments);
 }
 
-format.setFormatter = function(aCustomFormatter) {
+format.setFormatter = function (aCustomFormatter) {
     if (typeof aCustomFormatter !== "function") {
         throw new Error("format.setFormatter must be called with a function");
     }

node_modules/sinon/lib/sinon/util/core/get-config.js

@@ -1,7 +1,8 @@
 "use strict";
 
 var defaultConfig = require("./default-config");
-var hasOwnProperty = require("@sinonjs/commons").prototypes.object.hasOwnProperty;
+var hasOwnProperty =
+    require("@sinonjs/commons").prototypes.object.hasOwnProperty;
 
 module.exports = function getConfig(custom) {
     var config = {};
@@ -10,7 +11,9 @@ module.exports = function getConfig(custom) {
 
     for (prop in defaultConfig) {
         if (hasOwnProperty(defaultConfig, prop)) {
-            config[prop] = hasOwnProperty(kustom, prop) ? kustom[prop] : defaultConfig[prop];
+            config[prop] = hasOwnProperty(kustom, prop)
+                ? kustom[prop]
+                : defaultConfig[prop];
         }
     }
 

node_modules/sinon/lib/sinon/util/core/get-property-descriptor.js

@@ -3,9 +3,14 @@
 module.exports = function getPropertyDescriptor(object, property) {
     var proto = object;
     var descriptor;
-    var isOwn = Boolean(object && Object.getOwnPropertyDescriptor(object, property));
+    var isOwn = Boolean(
+        object && Object.getOwnPropertyDescriptor(object, property)
+    );
 
-    while (proto && !(descriptor = Object.getOwnPropertyDescriptor(proto, property))) {
+    while (
+        proto &&
+        !(descriptor = Object.getOwnPropertyDescriptor(proto, property))
+    ) {
         proto = Object.getPrototypeOf(proto);
     }
 

node_modules/sinon/lib/sinon/util/core/is-es-module.js

@@ -7,12 +7,15 @@
  * using spies or stubs. Let the consumer know this to avoid bug reports
  * on weird error messages.
  *
- * @param {Object} object The object to examine
+ * @param {object} object The object to examine
  *
- * @returns {Boolean} true when the object is a module
+ * @returns {boolean} true when the object is a module
  */
-module.exports = function(object) {
+module.exports = function (object) {
     return (
-        object && typeof Symbol !== "undefined" && object[Symbol.toStringTag] === "Module" && Object.isSealed(object)
+        object &&
+        typeof Symbol !== "undefined" &&
+        object[Symbol.toStringTag] === "Module" &&
+        Object.isSealed(object)
     );
 };

node_modules/sinon/lib/sinon/util/core/is-non-existent-property.js

@@ -2,11 +2,13 @@
 
 /**
  * @param {*} object
- * @param {String} property
- * @returns whether a prop exists in the prototype chain
+ * @param {string} property
+ * @returns {boolean} whether a prop exists in the prototype chain
  */
 function isNonExistentProperty(object, property) {
-    return object && typeof property !== "undefined" && !(property in object);
+    return Boolean(
+        object && typeof property !== "undefined" && !(property in object)
+    );
 }
 
 module.exports = isNonExistentProperty;

node_modules/sinon/lib/sinon/util/core/is-restorable.js

@@ -1,7 +1,11 @@
 "use strict";
 
 function isRestorable(obj) {
-    return typeof obj === "function" && typeof obj.restore === "function" && obj.restore.sinon;
+    return (
+        typeof obj === "function" &&
+        typeof obj.restore === "function" &&
+        obj.restore.sinon
+    );
 }
 
 module.exports = isRestorable;

node_modules/sinon/lib/sinon/util/core/restore.js

@@ -5,7 +5,7 @@ var walk = require("./walk");
 
 module.exports = function restore(object) {
     if (object !== null && typeof object === "object") {
-        walk(object, function(prop) {
+        walk(object, function (prop) {
             if (isRestorable(object[prop])) {
                 object[prop].restore();
             }

node_modules/sinon/lib/sinon/util/core/times-in-words.js

@@ -3,5 +3,5 @@
 var array = [null, "once", "twice", "thrice"];
 
 module.exports = function timesInWords(count) {
-    return array[count] || (count || 0) + " times";
+    return array[count] || `${count || 0} times`;
 };

node_modules/sinon/lib/sinon/util/core/walk-object.js

@@ -10,10 +10,12 @@ function walkObject(predicate, object, filter) {
     var name = functionName(predicate);
 
     if (!object) {
-        throw new Error("Trying to " + name + " object but received " + String(object));
+        throw new Error(
+            `Trying to ${name} object but received ${String(object)}`
+        );
     }
 
-    walk(object, function(prop, propOwner) {
+    walk(object, function (prop, propOwner) {
         // we don't want to stub things like toString(), valueOf(), etc. so we only stub if the object
         // is not Object.prototype
         if (
@@ -34,7 +36,7 @@ function walkObject(predicate, object, filter) {
     });
 
     if (!called) {
-        throw new Error("Expected to " + name + " methods on object but found none");
+        throw new Error(`Expected to ${name} methods on object but found none`);
     }
 
     return object;

node_modules/sinon/lib/sinon/util/core/walk.js

@@ -16,10 +16,14 @@ function walkInternal(obj, iterator, context, originalObj, seen) {
         return;
     }
 
-    forEach(Object.getOwnPropertyNames(obj), function(k) {
+    forEach(Object.getOwnPropertyNames(obj), function (k) {
         if (seen[k] !== true) {
             seen[k] = true;
-            var target = typeof Object.getOwnPropertyDescriptor(obj, k).get === "function" ? originalObj : obj;
+            var target =
+                typeof Object.getOwnPropertyDescriptor(obj, k).get ===
+                "function"
+                    ? originalObj
+                    : obj;
             iterator.call(context, k, target);
         }
     });

node_modules/sinon/lib/sinon/util/core/wrap-method.js

@@ -2,11 +2,16 @@
 
 var getPropertyDescriptor = require("./get-property-descriptor");
 var extend = require("./extend");
-var hasOwnProperty = require("@sinonjs/commons").prototypes.object.hasOwnProperty;
+var hasOwnProperty =
+    require("@sinonjs/commons").prototypes.object.hasOwnProperty;
 var valueToString = require("@sinonjs/commons").valueToString;
+var push = require("@sinonjs/commons").prototypes.array.push;
 
 function isFunction(obj) {
-    return typeof obj === "function" || Boolean(obj && obj.constructor && obj.call && obj.apply);
+    return (
+        typeof obj === "function" ||
+        Boolean(obj && obj.constructor && obj.call && obj.apply)
+    );
 }
 
 function mirrorProperties(target, source) {
@@ -17,6 +22,21 @@ function mirrorProperties(target, source) {
     }
 }
 
+function getAccessor(object, property, method) {
+    var accessors = ["get", "set"];
+    var descriptor = getPropertyDescriptor(object, property);
+
+    for (var i = 0; i < accessors.length; i++) {
+        if (
+            descriptor[accessors[i]] &&
+            descriptor[accessors[i]].name === method.name
+        ) {
+            return accessors[i];
+        }
+    }
+    return null;
+}
+
 // Cheap way to detect if we have ES5 support.
 var hasES5Support = "keys" in Object;
 
@@ -26,7 +46,9 @@ module.exports = function wrapMethod(object, property, method) {
     }
 
     if (typeof method !== "function" && typeof method !== "object") {
-        throw new TypeError("Method wrapper should be a function or a property descriptor");
+        throw new TypeError(
+            "Method wrapper should be a function or a property descriptor"
+        );
     }
 
     function checkWrappedMethod(wrappedMethod) {
@@ -34,24 +56,42 @@ module.exports = function wrapMethod(object, property, method) {
 
         if (!isFunction(wrappedMethod)) {
             error = new TypeError(
-                "Attempted to wrap " + typeof wrappedMethod + " property " + valueToString(property) + " as function"
+                `Attempted to wrap ${typeof wrappedMethod} property ${valueToString(
+                    property
+                )} as function`
             );
         } else if (wrappedMethod.restore && wrappedMethod.restore.sinon) {
-            error = new TypeError("Attempted to wrap " + valueToString(property) + " which is already wrapped");
+            error = new TypeError(
+                `Attempted to wrap ${valueToString(
+                    property
+                )} which is already wrapped`
+            );
         } else if (wrappedMethod.calledBefore) {
             var verb = wrappedMethod.returns ? "stubbed" : "spied on";
-            error = new TypeError("Attempted to wrap " + valueToString(property) + " which is already " + verb);
+            error = new TypeError(
+                `Attempted to wrap ${valueToString(
+                    property
+                )} which is already ${verb}`
+            );
         }
 
         if (error) {
             if (wrappedMethod && wrappedMethod.stackTraceError) {
-                error.stack += "\n--------------\n" + wrappedMethod.stackTraceError.stack;
+                error.stack += `\n--------------\n${wrappedMethod.stackTraceError.stack}`;
             }
             throw error;
         }
     }
 
-    var error, wrappedMethod, i, wrappedMethodDesc;
+    var error,
+        wrappedMethods,
+        wrappedMethod,
+        i,
+        wrappedMethodDesc,
+        target,
+        accessor;
+
+    wrappedMethods = [];
 
     function simplePropertyAssignment() {
         wrappedMethod = object[property];
@@ -61,23 +101,30 @@ module.exports = function wrapMethod(object, property, method) {
     }
 
     // Firefox has a problem when using hasOwn.call on objects from other frames.
-    /* eslint-disable-next-line local-rules/no-prototype-methods */
-    var owned = object.hasOwnProperty ? object.hasOwnProperty(property) : hasOwnProperty(object, property);
+    var owned = object.hasOwnProperty
+        ? object.hasOwnProperty(property) // eslint-disable-line @sinonjs/no-prototype-methods/no-prototype-methods
+        : hasOwnProperty(object, property);
 
     if (hasES5Support) {
-        var methodDesc = typeof method === "function" ? { value: method } : method;
+        var methodDesc =
+            typeof method === "function" ? { value: method } : method;
         wrappedMethodDesc = getPropertyDescriptor(object, property);
 
         if (!wrappedMethodDesc) {
             error = new TypeError(
-                "Attempted to wrap " + typeof wrappedMethod + " property " + property + " as function"
+                `Attempted to wrap ${typeof wrappedMethod} property ${property} as function`
+            );
+        } else if (
+            wrappedMethodDesc.restore &&
+            wrappedMethodDesc.restore.sinon
+        ) {
+            error = new TypeError(
+                `Attempted to wrap ${property} which is already wrapped`
             );
-        } else if (wrappedMethodDesc.restore && wrappedMethodDesc.restore.sinon) {
-            error = new TypeError("Attempted to wrap " + property + " which is already wrapped");
         }
         if (error) {
             if (wrappedMethodDesc && wrappedMethodDesc.stackTraceError) {
-                error.stack += "\n--------------\n" + wrappedMethodDesc.stackTraceError.stack;
+                error.stack += `\n--------------\n${wrappedMethodDesc.stackTraceError.stack}`;
             }
             throw error;
         }
@@ -86,6 +133,7 @@ module.exports = function wrapMethod(object, property, method) {
         for (i = 0; i < types.length; i++) {
             wrappedMethod = wrappedMethodDesc[types[i]];
             checkWrappedMethod(wrappedMethod);
+            push(wrappedMethods, wrappedMethod);
         }
 
         mirrorProperties(methodDesc, wrappedMethodDesc);
@@ -106,49 +154,82 @@ module.exports = function wrapMethod(object, property, method) {
         simplePropertyAssignment();
     }
 
-    extend.nonEnum(method, {
-        displayName: property,
+    extendObjectWithWrappedMethods();
 
-        wrappedMethod: wrappedMethod,
+    function extendObjectWithWrappedMethods() {
+        for (i = 0; i < wrappedMethods.length; i++) {
+            accessor = getAccessor(object, property, wrappedMethods[i]);
+            target = accessor ? method[accessor] : method;
+            extend.nonEnum(target, {
+                displayName: property,
+                wrappedMethod: wrappedMethods[i],
 
-        // Set up an Error object for a stack trace which can be used later to find what line of
-        // code the original method was created on.
-        stackTraceError: new Error("Stack Trace for original"),
+                // Set up an Error object for a stack trace which can be used later to find what line of
+                // code the original method was created on.
+                stackTraceError: new Error("Stack Trace for original"),
 
-        restore: function() {
-            // For prototype properties try to reset by delete first.
-            // If this fails (ex: localStorage on mobile safari) then force a reset
-            // via direct assignment.
+                restore: restore,
+            });
+
+            target.restore.sinon = true;
+            if (!hasES5Support) {
+                mirrorProperties(target, wrappedMethod);
+            }
+        }
+    }
+
+    function restore() {
+        accessor = getAccessor(object, property, this.wrappedMethod);
+        var descriptor;
+        // For prototype properties try to reset by delete first.
+        // If this fails (ex: localStorage on mobile safari) then force a reset
+        // via direct assignment.
+        if (accessor) {
             if (!owned) {
-                // In some cases `delete` may throw an error
                 try {
-                    delete object[property];
+                    // In some cases `delete` may throw an error
+                    delete object[property][accessor];
                 } catch (e) {} // eslint-disable-line no-empty
                 // For native code functions `delete` fails without throwing an error
                 // on Chrome < 43, PhantomJS, etc.
+            } else if (hasES5Support) {
+                descriptor = getPropertyDescriptor(object, property);
+                descriptor[accessor] = wrappedMethodDesc[accessor];
+                Object.defineProperty(object, property, descriptor);
+            }
+
+            if (hasES5Support) {
+                descriptor = getPropertyDescriptor(object, property);
+                if (descriptor && descriptor.value === target) {
+                    object[property][accessor] = this.wrappedMethod;
+                }
+            } else {
+                // Use strict equality comparison to check failures then force a reset
+                // via direct assignment.
+                if (object[property][accessor] === target) {
+                    object[property][accessor] = this.wrappedMethod;
+                }
+            }
+        } else {
+            if (!owned) {
+                try {
+                    delete object[property];
+                } catch (e) {} // eslint-disable-line no-empty
             } else if (hasES5Support) {
                 Object.defineProperty(object, property, wrappedMethodDesc);
             }
 
             if (hasES5Support) {
-                var descriptor = getPropertyDescriptor(object, property);
-                if (descriptor && descriptor.value === method) {
-                    object[property] = wrappedMethod;
+                descriptor = getPropertyDescriptor(object, property);
+                if (descriptor && descriptor.value === target) {
+                    object[property] = this.wrappedMethod;
                 }
             } else {
-                // Use strict equality comparison to check failures then force a reset
-                // via direct assignment.
-                if (object[property] === method) {
-                    object[property] = wrappedMethod;
+                if (object[property] === target) {
+                    object[property] = this.wrappedMethod;
                 }
             }
         }
-    });
-
-    method.restore.sinon = true;
-
-    if (!hasES5Support) {
-        mirrorProperties(method, wrappedMethod);
     }
 
     return method;

node_modules/sinon/lib/sinon/util/fake-timers.js

@@ -22,24 +22,28 @@ function addIfDefined(obj, globalPropName) {
 }
 
 /**
- * @param {number|Date|Object} dateOrConfig The unix epoch value to install with (default 0)
- * @returns {Object} Returns a lolex clock instance
+ * @param {number|Date|object} dateOrConfig The unix epoch value to install with (default 0)
+ * @returns {object} Returns a lolex clock instance
  */
-exports.useFakeTimers = function(dateOrConfig) {
+exports.useFakeTimers = function (dateOrConfig) {
     var hasArguments = typeof dateOrConfig !== "undefined";
     var argumentIsDateLike =
-        (typeof dateOrConfig === "number" || dateOrConfig instanceof Date) && arguments.length === 1;
-    var argumentIsObject = dateOrConfig !== null && typeof dateOrConfig === "object" && arguments.length === 1;
+        (typeof dateOrConfig === "number" || dateOrConfig instanceof Date) &&
+        arguments.length === 1;
+    var argumentIsObject =
+        dateOrConfig !== null &&
+        typeof dateOrConfig === "object" &&
+        arguments.length === 1;
 
     if (!hasArguments) {
         return createClock({
-            now: 0
+            now: 0,
         });
     }
 
     if (argumentIsDateLike) {
         return createClock({
-            now: dateOrConfig
+            now: dateOrConfig,
         });
     }
 
@@ -50,13 +54,15 @@ exports.useFakeTimers = function(dateOrConfig) {
         return createClock(config, globalCtx);
     }
 
-    throw new TypeError("useFakeTimers expected epoch or config object. See https://github.com/sinonjs/sinon");
+    throw new TypeError(
+        "useFakeTimers expected epoch or config object. See https://github.com/sinonjs/sinon"
+    );
 };
 
 exports.clock = {
-    create: function(now) {
+    create: function (now) {
         return FakeTimers.createClock(now);
-    }
+    },
 };
 
 var timers = {
@@ -64,7 +70,7 @@ var timers = {
     clearTimeout: clearTimeout,
     setInterval: setInterval,
     clearInterval: clearInterval,
-    Date: Date
+    Date: Date,
 };
 addIfDefined(timers, "setImmediate");
 addIfDefined(timers, "clearImmediate");