initial commit of actions

github/codeql-action-v1/node_modules/@sinonjs/samsam/lib/array-types.js

@@ -0,0 +1,16 @@
+"use strict";
+
+var ARRAY_TYPES = [
+    Array,
+    Int8Array,
+    Uint8Array,
+    Uint8ClampedArray,
+    Int16Array,
+    Uint16Array,
+    Int32Array,
+    Uint32Array,
+    Float32Array,
+    Float64Array,
+];
+
+module.exports = ARRAY_TYPES;

github/codeql-action-v1/node_modules/@sinonjs/samsam/lib/create-matcher.js

@@ -0,0 +1,371 @@
+"use strict";
+
+var arrayProto = require("@sinonjs/commons").prototypes.array;
+var deepEqual = require("./deep-equal").use(createMatcher); // eslint-disable-line no-use-before-define
+var every = require("@sinonjs/commons").every;
+var functionName = require("@sinonjs/commons").functionName;
+var get = require("lodash.get");
+var iterableToString = require("./iterable-to-string");
+var objectProto = require("@sinonjs/commons").prototypes.object;
+var typeOf = require("@sinonjs/commons").typeOf;
+var valueToString = require("@sinonjs/commons").valueToString;
+
+var assertMatcher = require("./create-matcher/assert-matcher");
+var assertMethodExists = require("./create-matcher/assert-method-exists");
+var assertType = require("./create-matcher/assert-type");
+var isIterable = require("./create-matcher/is-iterable");
+var isMatcher = require("./create-matcher/is-matcher");
+
+var matcherPrototype = require("./create-matcher/matcher-prototype");
+
+var arrayIndexOf = arrayProto.indexOf;
+var some = arrayProto.some;
+
+var hasOwnProperty = objectProto.hasOwnProperty;
+var objectToString = objectProto.toString;
+
+var TYPE_MAP = require("./create-matcher/type-map")(createMatcher); // eslint-disable-line no-use-before-define
+
+/**
+ * Creates a matcher object for the passed expectation
+ *
+ * @alias module:samsam.createMatcher
+ * @param {*} expectation An expecttation
+ * @param {string} message A message for the expectation
+ * @returns {object} A matcher object
+ */
+function createMatcher(expectation, message) {
+    var m = Object.create(matcherPrototype);
+    var type = typeOf(expectation);
+
+    if (message !== undefined && typeof message !== "string") {
+        throw new TypeError("Message should be a string");
+    }
+
+    if (arguments.length > 2) {
+        throw new TypeError(
+            `Expected 1 or 2 arguments, received ${arguments.length}`
+        );
+    }
+
+    if (type in TYPE_MAP) {
+        TYPE_MAP[type](m, expectation, message);
+    } else {
+        m.test = function (actual) {
+            return deepEqual(actual, expectation);
+        };
+    }
+
+    if (!m.message) {
+        m.message = `match(${valueToString(expectation)})`;
+    }
+
+    return m;
+}
+
+createMatcher.isMatcher = isMatcher;
+
+createMatcher.any = createMatcher(function () {
+    return true;
+}, "any");
+
+createMatcher.defined = createMatcher(function (actual) {
+    return actual !== null && actual !== undefined;
+}, "defined");
+
+createMatcher.truthy = createMatcher(function (actual) {
+    return Boolean(actual);
+}, "truthy");
+
+createMatcher.falsy = createMatcher(function (actual) {
+    return !actual;
+}, "falsy");
+
+createMatcher.same = function (expectation) {
+    return createMatcher(function (actual) {
+        return expectation === actual;
+    }, `same(${valueToString(expectation)})`);
+};
+
+createMatcher.in = function (arrayOfExpectations) {
+    if (typeOf(arrayOfExpectations) !== "array") {
+        throw new TypeError("array expected");
+    }
+
+    return createMatcher(function (actual) {
+        return some(arrayOfExpectations, function (expectation) {
+            return expectation === actual;
+        });
+    }, `in(${valueToString(arrayOfExpectations)})`);
+};
+
+createMatcher.typeOf = function (type) {
+    assertType(type, "string", "type");
+    return createMatcher(function (actual) {
+        return typeOf(actual) === type;
+    }, `typeOf("${type}")`);
+};
+
+createMatcher.instanceOf = function (type) {
+    /* istanbul ignore if */
+    if (
+        typeof Symbol === "undefined" ||
+        typeof Symbol.hasInstance === "undefined"
+    ) {
+        assertType(type, "function", "type");
+    } else {
+        assertMethodExists(
+            type,
+            Symbol.hasInstance,
+            "type",
+            "[Symbol.hasInstance]"
+        );
+    }
+    return createMatcher(function (actual) {
+        return actual instanceof type;
+    }, `instanceOf(${functionName(type) || objectToString(type)})`);
+};
+
+/**
+ * Creates a property matcher
+ *
+ * @private
+ * @param {Function} propertyTest A function to test the property against a value
+ * @param {string} messagePrefix A prefix to use for messages generated by the matcher
+ * @returns {object} A matcher
+ */
+function createPropertyMatcher(propertyTest, messagePrefix) {
+    return function (property, value) {
+        assertType(property, "string", "property");
+        var onlyProperty = arguments.length === 1;
+        var message = `${messagePrefix}("${property}"`;
+        if (!onlyProperty) {
+            message += `, ${valueToString(value)}`;
+        }
+        message += ")";
+        return createMatcher(function (actual) {
+            if (
+                actual === undefined ||
+                actual === null ||
+                !propertyTest(actual, property)
+            ) {
+                return false;
+            }
+            return onlyProperty || deepEqual(actual[property], value);
+        }, message);
+    };
+}
+
+createMatcher.has = createPropertyMatcher(function (actual, property) {
+    if (typeof actual === "object") {
+        return property in actual;
+    }
+    return actual[property] !== undefined;
+}, "has");
+
+createMatcher.hasOwn = createPropertyMatcher(function (actual, property) {
+    return hasOwnProperty(actual, property);
+}, "hasOwn");
+
+createMatcher.hasNested = function (property, value) {
+    assertType(property, "string", "property");
+    var onlyProperty = arguments.length === 1;
+    var message = `hasNested("${property}"`;
+    if (!onlyProperty) {
+        message += `, ${valueToString(value)}`;
+    }
+    message += ")";
+    return createMatcher(function (actual) {
+        if (
+            actual === undefined ||
+            actual === null ||
+            get(actual, property) === undefined
+        ) {
+            return false;
+        }
+        return onlyProperty || deepEqual(get(actual, property), value);
+    }, message);
+};
+
+var jsonParseResultTypes = {
+    null: true,
+    boolean: true,
+    number: true,
+    string: true,
+    object: true,
+    array: true,
+};
+createMatcher.json = function (value) {
+    if (!jsonParseResultTypes[typeOf(value)]) {
+        throw new TypeError("Value cannot be the result of JSON.parse");
+    }
+    var message = `json(${JSON.stringify(value, null, "  ")})`;
+    return createMatcher(function (actual) {
+        var parsed;
+        try {
+            parsed = JSON.parse(actual);
+        } catch (e) {
+            return false;
+        }
+        return deepEqual(parsed, value);
+    }, message);
+};
+
+createMatcher.every = function (predicate) {
+    assertMatcher(predicate);
+
+    return createMatcher(function (actual) {
+        if (typeOf(actual) === "object") {
+            return every(Object.keys(actual), function (key) {
+                return predicate.test(actual[key]);
+            });
+        }
+
+        return (
+            isIterable(actual) &&
+            every(actual, function (element) {
+                return predicate.test(element);
+            })
+        );
+    }, `every(${predicate.message})`);
+};
+
+createMatcher.some = function (predicate) {
+    assertMatcher(predicate);
+
+    return createMatcher(function (actual) {
+        if (typeOf(actual) === "object") {
+            return !every(Object.keys(actual), function (key) {
+                return !predicate.test(actual[key]);
+            });
+        }
+
+        return (
+            isIterable(actual) &&
+            !every(actual, function (element) {
+                return !predicate.test(element);
+            })
+        );
+    }, `some(${predicate.message})`);
+};
+
+createMatcher.array = createMatcher.typeOf("array");
+
+createMatcher.array.deepEquals = function (expectation) {
+    return createMatcher(function (actual) {
+        // Comparing lengths is the fastest way to spot a difference before iterating through every item
+        var sameLength = actual.length === expectation.length;
+        return (
+            typeOf(actual) === "array" &&
+            sameLength &&
+            every(actual, function (element, index) {
+                var expected = expectation[index];
+                return typeOf(expected) === "array" &&
+                    typeOf(element) === "array"
+                    ? createMatcher.array.deepEquals(expected).test(element)
+                    : deepEqual(expected, element);
+            })
+        );
+    }, `deepEquals([${iterableToString(expectation)}])`);
+};
+
+createMatcher.array.startsWith = function (expectation) {
+    return createMatcher(function (actual) {
+        return (
+            typeOf(actual) === "array" &&
+            every(expectation, function (expectedElement, index) {
+                return actual[index] === expectedElement;
+            })
+        );
+    }, `startsWith([${iterableToString(expectation)}])`);
+};
+
+createMatcher.array.endsWith = function (expectation) {
+    return createMatcher(function (actual) {
+        // This indicates the index in which we should start matching
+        var offset = actual.length - expectation.length;
+
+        return (
+            typeOf(actual) === "array" &&
+            every(expectation, function (expectedElement, index) {
+                return actual[offset + index] === expectedElement;
+            })
+        );
+    }, `endsWith([${iterableToString(expectation)}])`);
+};
+
+createMatcher.array.contains = function (expectation) {
+    return createMatcher(function (actual) {
+        return (
+            typeOf(actual) === "array" &&
+            every(expectation, function (expectedElement) {
+                return arrayIndexOf(actual, expectedElement) !== -1;
+            })
+        );
+    }, `contains([${iterableToString(expectation)}])`);
+};
+
+createMatcher.map = createMatcher.typeOf("map");
+
+createMatcher.map.deepEquals = function mapDeepEquals(expectation) {
+    return createMatcher(function (actual) {
+        // Comparing lengths is the fastest way to spot a difference before iterating through every item
+        var sameLength = actual.size === expectation.size;
+        return (
+            typeOf(actual) === "map" &&
+            sameLength &&
+            every(actual, function (element, key) {
+                return expectation.has(key) && expectation.get(key) === element;
+            })
+        );
+    }, `deepEquals(Map[${iterableToString(expectation)}])`);
+};
+
+createMatcher.map.contains = function mapContains(expectation) {
+    return createMatcher(function (actual) {
+        return (
+            typeOf(actual) === "map" &&
+            every(expectation, function (element, key) {
+                return actual.has(key) && actual.get(key) === element;
+            })
+        );
+    }, `contains(Map[${iterableToString(expectation)}])`);
+};
+
+createMatcher.set = createMatcher.typeOf("set");
+
+createMatcher.set.deepEquals = function setDeepEquals(expectation) {
+    return createMatcher(function (actual) {
+        // Comparing lengths is the fastest way to spot a difference before iterating through every item
+        var sameLength = actual.size === expectation.size;
+        return (
+            typeOf(actual) === "set" &&
+            sameLength &&
+            every(actual, function (element) {
+                return expectation.has(element);
+            })
+        );
+    }, `deepEquals(Set[${iterableToString(expectation)}])`);
+};
+
+createMatcher.set.contains = function setContains(expectation) {
+    return createMatcher(function (actual) {
+        return (
+            typeOf(actual) === "set" &&
+            every(expectation, function (element) {
+                return actual.has(element);
+            })
+        );
+    }, `contains(Set[${iterableToString(expectation)}])`);
+};
+
+createMatcher.bool = createMatcher.typeOf("boolean");
+createMatcher.number = createMatcher.typeOf("number");
+createMatcher.string = createMatcher.typeOf("string");
+createMatcher.object = createMatcher.typeOf("object");
+createMatcher.func = createMatcher.typeOf("function");
+createMatcher.regexp = createMatcher.typeOf("regexp");
+createMatcher.date = createMatcher.typeOf("date");
+createMatcher.symbol = createMatcher.typeOf("symbol");
+
+module.exports = createMatcher;

github/codeql-action-v1/node_modules/@sinonjs/samsam/lib/create-matcher/assert-matcher.js

@@ -0,0 +1,17 @@
+"use strict";
+
+var isMatcher = require("./is-matcher");
+
+/**
+ * Throws a TypeError when `value` is not a matcher
+ *
+ * @private
+ * @param {*} value The value to examine
+ */
+function assertMatcher(value) {
+    if (!isMatcher(value)) {
+        throw new TypeError("Matcher expected");
+    }
+}
+
+module.exports = assertMatcher;

github/codeql-action-v1/node_modules/@sinonjs/samsam/lib/create-matcher/assert-method-exists.js

@@ -0,0 +1,19 @@
+"use strict";
+
+/**
+ * Throws a TypeError when expected method doesn't exist
+ *
+ * @private
+ * @param {*} value A value to examine
+ * @param {string} method The name of the method to look for
+ * @param {name} name A name to use for the error message
+ * @param {string} methodPath The name of the method to use for error messages
+ * @throws {TypeError} When the method doesn't exist
+ */
+function assertMethodExists(value, method, name, methodPath) {
+    if (value[method] === null || value[method] === undefined) {
+        throw new TypeError(`Expected ${name} to have method ${methodPath}`);
+    }
+}
+
+module.exports = assertMethodExists;

github/codeql-action-v1/node_modules/@sinonjs/samsam/lib/create-matcher/assert-type.js

@@ -0,0 +1,24 @@
+"use strict";
+
+var typeOf = require("@sinonjs/commons").typeOf;
+
+/**
+ * Ensures that value is of type
+ *
+ * @private
+ * @param {*} value A value to examine
+ * @param {string} type A basic JavaScript type to compare to, e.g. "object", "string"
+ * @param {string} name A string to use for the error message
+ * @throws {TypeError} If value is not of the expected type
+ * @returns {undefined}
+ */
+function assertType(value, type, name) {
+    var actual = typeOf(value);
+    if (actual !== type) {
+        throw new TypeError(
+            `Expected type of ${name} to be ${type}, but was ${actual}`
+        );
+    }
+}
+
+module.exports = assertType;

github/codeql-action-v1/node_modules/@sinonjs/samsam/lib/create-matcher/is-iterable.js

@@ -0,0 +1,16 @@
+"use strict";
+
+var typeOf = require("@sinonjs/commons").typeOf;
+
+/**
+ * Returns `true` for iterables
+ *
+ * @private
+ * @param {*} value A value to examine
+ * @returns {boolean} Returns `true` when `value` looks like an iterable
+ */
+function isIterable(value) {
+    return Boolean(value) && typeOf(value.forEach) === "function";
+}
+
+module.exports = isIterable;

github/codeql-action-v1/node_modules/@sinonjs/samsam/lib/create-matcher/is-matcher.js

@@ -0,0 +1,18 @@
+"use strict";
+
+var isPrototypeOf = require("@sinonjs/commons").prototypes.object.isPrototypeOf;
+
+var matcherPrototype = require("./matcher-prototype");
+
+/**
+ * Returns `true` when `object` is a matcher
+ *
+ * @private
+ * @param {*} object A value to examine
+ * @returns {boolean} Returns `true` when `object` is a matcher
+ */
+function isMatcher(object) {
+    return isPrototypeOf(matcherPrototype, object);
+}
+
+module.exports = isMatcher;

github/codeql-action-v1/node_modules/@sinonjs/samsam/lib/create-matcher/match-object.js

@@ -0,0 +1,55 @@
+"use strict";
+
+var every = require("@sinonjs/commons").prototypes.array.every;
+var concat = require("@sinonjs/commons").prototypes.array.concat;
+var typeOf = require("@sinonjs/commons").typeOf;
+
+var deepEqualFactory = require("../deep-equal").use;
+
+var isMatcher = require("./is-matcher");
+
+var keys = Object.keys;
+var getOwnPropertySymbols = Object.getOwnPropertySymbols;
+
+/**
+ * Matches `actual` with `expectation`
+ *
+ * @private
+ * @param {*} actual A value to examine
+ * @param {object} expectation An object with properties to match on
+ * @param {object} matcher A matcher to use for comparison
+ * @returns {boolean} Returns true when `actual` matches all properties in `expectation`
+ */
+function matchObject(actual, expectation, matcher) {
+    var deepEqual = deepEqualFactory(matcher);
+    if (actual === null || actual === undefined) {
+        return false;
+    }
+
+    var expectedKeys = keys(expectation);
+    /* istanbul ignore else: cannot collect coverage for engine that doesn't support Symbol */
+    if (typeOf(getOwnPropertySymbols) === "function") {
+        expectedKeys = concat(expectedKeys, getOwnPropertySymbols(expectation));
+    }
+
+    return every(expectedKeys, function (key) {
+        var exp = expectation[key];
+        var act = actual[key];
+
+        if (isMatcher(exp)) {
+            if (!exp.test(act)) {
+                return false;
+            }
+        } else if (typeOf(exp) === "object") {
+            if (!matchObject(act, exp, matcher)) {
+                return false;
+            }
+        } else if (!deepEqual(act, exp)) {
+            return false;
+        }
+
+        return true;
+    });
+}
+
+module.exports = matchObject;

github/codeql-action-v1/node_modules/@sinonjs/samsam/lib/create-matcher/matcher-prototype.js

@@ -0,0 +1,49 @@
+"use strict";
+
+var matcherPrototype = {
+    toString: function () {
+        return this.message;
+    },
+};
+
+matcherPrototype.or = function (valueOrMatcher) {
+    var createMatcher = require("../create-matcher");
+    var isMatcher = createMatcher.isMatcher;
+
+    if (!arguments.length) {
+        throw new TypeError("Matcher expected");
+    }
+
+    var m2 = isMatcher(valueOrMatcher)
+        ? valueOrMatcher
+        : createMatcher(valueOrMatcher);
+    var m1 = this;
+    var or = Object.create(matcherPrototype);
+    or.test = function (actual) {
+        return m1.test(actual) || m2.test(actual);
+    };
+    or.message = `${m1.message}.or(${m2.message})`;
+    return or;
+};
+
+matcherPrototype.and = function (valueOrMatcher) {
+    var createMatcher = require("../create-matcher");
+    var isMatcher = createMatcher.isMatcher;
+
+    if (!arguments.length) {
+        throw new TypeError("Matcher expected");
+    }
+
+    var m2 = isMatcher(valueOrMatcher)
+        ? valueOrMatcher
+        : createMatcher(valueOrMatcher);
+    var m1 = this;
+    var and = Object.create(matcherPrototype);
+    and.test = function (actual) {
+        return m1.test(actual) && m2.test(actual);
+    };
+    and.message = `${m1.message}.and(${m2.message})`;
+    return and;
+};
+
+module.exports = matcherPrototype;

github/codeql-action-v1/node_modules/@sinonjs/samsam/lib/create-matcher/type-map.js

@@ -0,0 +1,62 @@
+"use strict";
+
+var functionName = require("@sinonjs/commons").functionName;
+var join = require("@sinonjs/commons").prototypes.array.join;
+var map = require("@sinonjs/commons").prototypes.array.map;
+var stringIndexOf = require("@sinonjs/commons").prototypes.string.indexOf;
+var valueToString = require("@sinonjs/commons").valueToString;
+
+var matchObject = require("./match-object");
+
+var createTypeMap = function (match) {
+    return {
+        function: function (m, expectation, message) {
+            m.test = expectation;
+            m.message = message || `match(${functionName(expectation)})`;
+        },
+        number: function (m, expectation) {
+            m.test = function (actual) {
+                // we need type coercion here
+                return expectation == actual; // eslint-disable-line eqeqeq
+            };
+        },
+        object: function (m, expectation) {
+            var array = [];
+
+            if (typeof expectation.test === "function") {
+                m.test = function (actual) {
+                    return expectation.test(actual) === true;
+                };
+                m.message = `match(${functionName(expectation.test)})`;
+                return m;
+            }
+
+            array = map(Object.keys(expectation), function (key) {
+                return `${key}: ${valueToString(expectation[key])}`;
+            });
+
+            m.test = function (actual) {
+                return matchObject(actual, expectation, match);
+            };
+            m.message = `match(${join(array, ", ")})`;
+
+            return m;
+        },
+        regexp: function (m, expectation) {
+            m.test = function (actual) {
+                return typeof actual === "string" && expectation.test(actual);
+            };
+        },
+        string: function (m, expectation) {
+            m.test = function (actual) {
+                return (
+                    typeof actual === "string" &&
+                    stringIndexOf(actual, expectation) !== -1
+                );
+            };
+            m.message = `match("${expectation}")`;
+        },
+    };
+};
+
+module.exports = createTypeMap;

github/codeql-action-v1/node_modules/@sinonjs/samsam/lib/create-set.js

@@ -0,0 +1,34 @@
+"use strict";
+
+var typeOf = require("@sinonjs/commons").typeOf;
+var forEach = require("@sinonjs/commons").prototypes.array.forEach;
+
+/**
+ * This helper makes it convenient to create Set instances from a
+ * collection, an overcomes the shortcoming that IE11 doesn't support
+ * collection arguments
+ *
+ * @private
+ * @param  {Array} array An array to create a set from
+ * @returns {Set} A set (unique) containing the members from array
+ *
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Set
+ */
+function createSet(array) {
+    if (arguments.length > 0 && !Array.isArray(array)) {
+        throw new TypeError(
+            "createSet can be called with either no arguments or an Array"
+        );
+    }
+
+    var items = typeOf(array) === "array" ? array : [];
+    var set = new Set();
+
+    forEach(items, function (item) {
+        set.add(item);
+    });
+
+    return set;
+}
+
+module.exports = createSet;

github/codeql-action-v1/node_modules/@sinonjs/samsam/lib/deep-equal-benchmark.js

@@ -0,0 +1,74 @@
+"use strict";
+
+var Benchmark = require("benchmark");
+var deepEqual = require("./deep-equal");
+
+var suite = new Benchmark.Suite();
+var complex1 = {
+    "1e116061-59bf-433a-8ab0-017b67a51d26":
+        "a7fd22ab-e809-414f-ad55-9c97598395d8",
+    "3824e8b7-22f5-489c-9919-43b432e3af6b":
+        "548baefd-f43c-4dc9-9df5-f7c9c96223b0",
+    "123e5750-eb66-45e5-a770-310879203b33":
+        "89ff817d-65a2-4598-b190-21c128096e6a",
+    "1d66be95-8aaa-4167-9a47-e7ee19bb0735":
+        "64349492-56e8-4100-9552-a89fb4a9aef4",
+    "f5538565-dc92-4ee4-a762-1ba5fe0528f6": {
+        "53631f78-2f2a-448f-89c7-ed3585e8e6f0":
+            "2cce00ee-f5ee-43ef-878f-958597b23225",
+        "73e8298b-72fd-4969-afc1-d891b61e744f":
+            "4e57aa30-af51-4d78-887c-019755e5d117",
+        "85439907-5b0e-4a08-8cfa-902a68dc3cc0":
+            "9639add9-6897-4cf0-b3d3-2ebf9c214f01",
+        "d4ae9d87-bd6c-47e0-95a1-6f4eb4211549":
+            "41fd3dd2-43ce-47f2-b92e-462474d07a6f",
+        "f70345a2-0ea3-45a6-bafa-8c7a72379277": {
+            "1bce714b-cd0a-417d-9a0c-bf4b7d35c0c4":
+                "3b8b0dde-e2ed-4b34-ac8d-729ba3c9667e",
+            "13e05c60-97d1-43f0-a6ef-d5247f4dd11f":
+                "60f685a4-6558-4ade-9d4b-28281c3989db",
+            "925b2609-e7b7-42f5-82cf-2d995697cec5":
+                "79115261-8161-4a6c-9487-47847276a717",
+            "52d644ac-7b33-4b79-b5b3-5afe7fd4ec2c": [
+                "3c2ae716-92f1-4a3d-b98f-50ea49f51c45",
+                "de76b822-71b3-4b5a-a041-4140378b70e2",
+                "0302a405-1d58-44fa-a0c6-dd07bb0ca26e",
+                new Date(),
+                new Error(),
+                new RegExp(),
+                // eslint-disable-next-line no-undef
+                new Map(),
+                new Set(),
+                // eslint-disable-next-line no-undef
+                new WeakMap(),
+                // eslint-disable-next-line no-undef
+                new WeakSet(),
+            ],
+        },
+    },
+};
+var complex2 = Object.create(complex1);
+
+var cyclic1 = {
+    "4a092cd1-225e-4739-8331-d6564aafb702":
+        "d0cebbe0-23fb-4cc4-8fa0-ef11ceedf12e",
+};
+cyclic1.cyclicRef = cyclic1;
+
+var cyclic2 = Object.create(cyclic1);
+
+// add tests
+suite
+    .add("complex objects", function () {
+        return deepEqual(complex1, complex2);
+    })
+    .add("cyclic references", function () {
+        return deepEqual(cyclic1, cyclic2);
+    })
+    // add listeners
+    .on("cycle", function (event) {
+        // eslint-disable-next-line no-console
+        console.log(String(event.target));
+    })
+    // run async
+    .run({ async: true });

github/codeql-action-v1/node_modules/@sinonjs/samsam/lib/deep-equal.js

@@ -0,0 +1,291 @@
+"use strict";
+
+var valueToString = require("@sinonjs/commons").valueToString;
+var className = require("@sinonjs/commons").className;
+var typeOf = require("@sinonjs/commons").typeOf;
+var arrayProto = require("@sinonjs/commons").prototypes.array;
+var objectProto = require("@sinonjs/commons").prototypes.object;
+var mapForEach = require("@sinonjs/commons").prototypes.map.forEach;
+
+var getClass = require("./get-class");
+var identical = require("./identical");
+var isArguments = require("./is-arguments");
+var isArrayType = require("./is-array-type");
+var isDate = require("./is-date");
+var isElement = require("./is-element");
+var isIterable = require("./is-iterable");
+var isMap = require("./is-map");
+var isNaN = require("./is-nan");
+var isObject = require("./is-object");
+var isSet = require("./is-set");
+var isSubset = require("./is-subset");
+
+var concat = arrayProto.concat;
+var every = arrayProto.every;
+var push = arrayProto.push;
+
+var getTime = Date.prototype.getTime;
+var hasOwnProperty = objectProto.hasOwnProperty;
+var indexOf = arrayProto.indexOf;
+var keys = Object.keys;
+var getOwnPropertySymbols = Object.getOwnPropertySymbols;
+
+/**
+ * Deep equal comparison. Two values are "deep equal" when:
+ *
+ *   - They are equal, according to samsam.identical
+ *   - They are both date objects representing the same time
+ *   - They are both arrays containing elements that are all deepEqual
+ *   - They are objects with the same set of properties, and each property
+ *     in ``actual`` is deepEqual to the corresponding property in ``expectation``
+ *
+ * Supports cyclic objects.
+ *
+ * @alias module:samsam.deepEqual
+ * @param {*} actual The object to examine
+ * @param {*} expectation The object actual is expected to be equal to
+ * @param {object} match A value to match on
+ * @returns {boolean} Returns true when actual and expectation are considered equal
+ */
+function deepEqualCyclic(actual, expectation, match) {
+    // used for cyclic comparison
+    // contain already visited objects
+    var actualObjects = [];
+    var expectationObjects = [];
+    // contain pathes (position in the object structure)
+    // of the already visited objects
+    // indexes same as in objects arrays
+    var actualPaths = [];
+    var expectationPaths = [];
+    // contains combinations of already compared objects
+    // in the manner: { "$1['ref']$2['ref']": true }
+    var compared = {};
+
+    // does the recursion for the deep equal check
+    // eslint-disable-next-line complexity
+    return (function deepEqual(
+        actualObj,
+        expectationObj,
+        actualPath,
+        expectationPath
+    ) {
+        // If both are matchers they must be the same instance in order to be
+        // considered equal If we didn't do that we would end up running one
+        // matcher against the other
+        if (match && match.isMatcher(expectationObj)) {
+            if (match.isMatcher(actualObj)) {
+                return actualObj === expectationObj;
+            }
+            return expectationObj.test(actualObj);
+        }
+
+        var actualType = typeof actualObj;
+        var expectationType = typeof expectationObj;
+
+        if (
+            actualObj === expectationObj ||
+            isNaN(actualObj) ||
+            isNaN(expectationObj) ||
+            actualObj === null ||
+            expectationObj === null ||
+            actualObj === undefined ||
+            expectationObj === undefined ||
+            actualType !== "object" ||
+            expectationType !== "object"
+        ) {
+            return identical(actualObj, expectationObj);
+        }
+
+        // Elements are only equal if identical(expected, actual)
+        if (isElement(actualObj) || isElement(expectationObj)) {
+            return false;
+        }
+
+        var isActualDate = isDate(actualObj);
+        var isExpectationDate = isDate(expectationObj);
+        if (isActualDate || isExpectationDate) {
+            if (
+                !isActualDate ||
+                !isExpectationDate ||
+                getTime.call(actualObj) !== getTime.call(expectationObj)
+            ) {
+                return false;
+            }
+        }
+
+        if (actualObj instanceof RegExp && expectationObj instanceof RegExp) {
+            if (valueToString(actualObj) !== valueToString(expectationObj)) {
+                return false;
+            }
+        }
+
+        if (actualObj instanceof Promise && expectationObj instanceof Promise) {
+            return actualObj === expectationObj;
+        }
+
+        if (actualObj instanceof Error && expectationObj instanceof Error) {
+            return actualObj === expectationObj;
+        }
+
+        var actualClass = getClass(actualObj);
+        var expectationClass = getClass(expectationObj);
+        var actualKeys = keys(actualObj);
+        var expectationKeys = keys(expectationObj);
+        var actualName = className(actualObj);
+        var expectationName = className(expectationObj);
+        var expectationSymbols =
+            typeOf(getOwnPropertySymbols) === "function"
+                ? getOwnPropertySymbols(expectationObj)
+                : /* istanbul ignore next: cannot collect coverage for engine that doesn't support Symbol */
+                  [];
+        var expectationKeysAndSymbols = concat(
+            expectationKeys,
+            expectationSymbols
+        );
+
+        if (isArguments(actualObj) || isArguments(expectationObj)) {
+            if (actualObj.length !== expectationObj.length) {
+                return false;
+            }
+        } else {
+            if (
+                actualType !== expectationType ||
+                actualClass !== expectationClass ||
+                actualKeys.length !== expectationKeys.length ||
+                (actualName &&
+                    expectationName &&
+                    actualName !== expectationName)
+            ) {
+                return false;
+            }
+        }
+
+        if (isSet(actualObj) || isSet(expectationObj)) {
+            if (
+                !isSet(actualObj) ||
+                !isSet(expectationObj) ||
+                actualObj.size !== expectationObj.size
+            ) {
+                return false;
+            }
+
+            return isSubset(actualObj, expectationObj, deepEqual);
+        }
+
+        if (isMap(actualObj) || isMap(expectationObj)) {
+            if (
+                !isMap(actualObj) ||
+                !isMap(expectationObj) ||
+                actualObj.size !== expectationObj.size
+            ) {
+                return false;
+            }
+
+            var mapsDeeplyEqual = true;
+            mapForEach(actualObj, function (value, key) {
+                mapsDeeplyEqual =
+                    mapsDeeplyEqual &&
+                    deepEqualCyclic(value, expectationObj.get(key));
+            });
+
+            return mapsDeeplyEqual;
+        }
+
+        var isActualNonArrayIterable =
+            isIterable(actualObj) &&
+            !isArrayType(actualObj) &&
+            !isArguments(actualObj);
+        var isExpectationNonArrayIterable =
+            isIterable(expectation) &&
+            !isArrayType(expectation) &&
+            !isArguments(expectation);
+        if (isActualNonArrayIterable || isExpectationNonArrayIterable) {
+            var actualArray = Array.from(actualObj);
+            var expectationArray = Array.from(expectation);
+            if (actualArray.length !== expectationArray.length) {
+                return false;
+            }
+
+            var arrayDeeplyEquals = true;
+            every(actualArray, function (key) {
+                arrayDeeplyEquals =
+                    arrayDeeplyEquals &&
+                    deepEqualCyclic(actualArray[key], expectationArray[key]);
+            });
+
+            return arrayDeeplyEquals;
+        }
+
+        return every(expectationKeysAndSymbols, function (key) {
+            if (!hasOwnProperty(actualObj, key)) {
+                return false;
+            }
+
+            var actualValue = actualObj[key];
+            var expectationValue = expectationObj[key];
+            var actualObject = isObject(actualValue);
+            var expectationObject = isObject(expectationValue);
+            // determines, if the objects were already visited
+            // (it's faster to check for isObject first, than to
+            // get -1 from getIndex for non objects)
+            var actualIndex = actualObject
+                ? indexOf(actualObjects, actualValue)
+                : -1;
+            var expectationIndex = expectationObject
+                ? indexOf(expectationObjects, expectationValue)
+                : -1;
+            // determines the new paths of the objects
+            // - for non cyclic objects the current path will be extended
+            //   by current property name
+            // - for cyclic objects the stored path is taken
+            var newActualPath =
+                actualIndex !== -1
+                    ? actualPaths[actualIndex]
+                    : `${actualPath}[${JSON.stringify(key)}]`;
+            var newExpectationPath =
+                expectationIndex !== -1
+                    ? expectationPaths[expectationIndex]
+                    : `${expectationPath}[${JSON.stringify(key)}]`;
+            var combinedPath = newActualPath + newExpectationPath;
+
+            // stop recursion if current objects are already compared
+            if (compared[combinedPath]) {
+                return true;
+            }
+
+            // remember the current objects and their paths
+            if (actualIndex === -1 && actualObject) {
+                push(actualObjects, actualValue);
+                push(actualPaths, newActualPath);
+            }
+            if (expectationIndex === -1 && expectationObject) {
+                push(expectationObjects, expectationValue);
+                push(expectationPaths, newExpectationPath);
+            }
+
+            // remember that the current objects are already compared
+            if (actualObject && expectationObject) {
+                compared[combinedPath] = true;
+            }
+
+            // End of cyclic logic
+
+            // neither actualValue nor expectationValue is a cycle
+            // continue with next level
+            return deepEqual(
+                actualValue,
+                expectationValue,
+                newActualPath,
+                newExpectationPath
+            );
+        });
+    })(actual, expectation, "$1", "$2");
+}
+
+deepEqualCyclic.use = function (match) {
+    return function deepEqual(a, b) {
+        return deepEqualCyclic(a, b, match);
+    };
+};
+
+module.exports = deepEqualCyclic;

github/codeql-action-v1/node_modules/@sinonjs/samsam/lib/get-class.js

@@ -0,0 +1,18 @@
+"use strict";
+
+var toString = require("@sinonjs/commons").prototypes.object.toString;
+
+/**
+ * Returns the internal `Class` by calling `Object.prototype.toString`
+ * with the provided value as `this`. Return value is a `String`, naming the
+ * internal class, e.g. "Array"
+ *
+ * @private
+ * @param  {*} value - Any value
+ * @returns {string} - A string representation of the `Class` of `value`
+ */
+function getClass(value) {
+    return toString(value).split(/[ \]]/)[1];
+}
+
+module.exports = getClass;

github/codeql-action-v1/node_modules/@sinonjs/samsam/lib/identical.js

@@ -0,0 +1,31 @@
+"use strict";
+
+var isNaN = require("./is-nan");
+var isNegZero = require("./is-neg-zero");
+
+/**
+ * Strict equality check according to EcmaScript Harmony's `egal`.
+ *
+ * **From the Harmony wiki:**
+ * > An `egal` function simply makes available the internal `SameValue` function
+ * > from section 9.12 of the ES5 spec. If two values are egal, then they are not
+ * > observably distinguishable.
+ *
+ * `identical` returns `true` when `===` is `true`, except for `-0` and
+ * `+0`, where it returns `false`. Additionally, it returns `true` when
+ * `NaN` is compared to itself.
+ *
+ * @alias module:samsam.identical
+ * @param {*} obj1 The first value to compare
+ * @param {*} obj2 The second value to compare
+ * @returns {boolean} Returns `true` when the objects are *egal*, `false` otherwise
+ */
+function identical(obj1, obj2) {
+    if (obj1 === obj2 || (isNaN(obj1) && isNaN(obj2))) {
+        return obj1 !== 0 || isNegZero(obj1) === isNegZero(obj2);
+    }
+
+    return false;
+}
+
+module.exports = identical;

github/codeql-action-v1/node_modules/@sinonjs/samsam/lib/is-arguments.js

@@ -0,0 +1,16 @@
+"use strict";
+
+var getClass = require("./get-class");
+
+/**
+ * Returns `true` when `object` is an `arguments` object, `false` otherwise
+ *
+ * @alias module:samsam.isArguments
+ * @param  {*}  object - The object to examine
+ * @returns {boolean} `true` when `object` is an `arguments` object
+ */
+function isArguments(object) {
+    return getClass(object) === "Arguments";
+}
+
+module.exports = isArguments;

github/codeql-action-v1/node_modules/@sinonjs/samsam/lib/is-array-type.js

@@ -0,0 +1,20 @@
+"use strict";
+
+var functionName = require("@sinonjs/commons").functionName;
+var indexOf = require("@sinonjs/commons").prototypes.array.indexOf;
+var map = require("@sinonjs/commons").prototypes.array.map;
+var ARRAY_TYPES = require("./array-types");
+var type = require("type-detect");
+
+/**
+ * Returns `true` when `object` is an array type, `false` otherwise
+ *
+ * @param  {*}  object - The object to examine
+ * @returns {boolean} `true` when `object` is an array type
+ * @private
+ */
+function isArrayType(object) {
+    return indexOf(map(ARRAY_TYPES, functionName), type(object)) !== -1;
+}
+
+module.exports = isArrayType;

github/codeql-action-v1/node_modules/@sinonjs/samsam/lib/is-date.js

@@ -0,0 +1,14 @@
+"use strict";
+
+/**
+ * Returns `true` when `value` is an instance of Date
+ *
+ * @private
+ * @param  {Date}  value The value to examine
+ * @returns {boolean}     `true` when `value` is an instance of Date
+ */
+function isDate(value) {
+    return value instanceof Date;
+}
+
+module.exports = isDate;

github/codeql-action-v1/node_modules/@sinonjs/samsam/lib/is-element.js

@@ -0,0 +1,29 @@
+"use strict";
+
+var div = typeof document !== "undefined" && document.createElement("div");
+
+/**
+ * Returns `true` when `object` is a DOM element node.
+ *
+ * Unlike Underscore.js/lodash, this function will return `false` if `object`
+ * is an *element-like* object, i.e. a regular object with a `nodeType`
+ * property that holds the value `1`.
+ *
+ * @alias module:samsam.isElement
+ * @param {object} object The object to examine
+ * @returns {boolean} Returns `true` for DOM element nodes
+ */
+function isElement(object) {
+    if (!object || object.nodeType !== 1 || !div) {
+        return false;
+    }
+    try {
+        object.appendChild(div);
+        object.removeChild(div);
+    } catch (e) {
+        return false;
+    }
+    return true;
+}
+
+module.exports = isElement;

github/codeql-action-v1/node_modules/@sinonjs/samsam/lib/is-iterable.js

@@ -0,0 +1,18 @@
+"use strict";
+
+/**
+ * Returns `true` when the argument is an iterable, `false` otherwise
+ *
+ * @alias module:samsam.isIterable
+ * @param  {*}  val - A value to examine
+ * @returns {boolean} Returns `true` when the argument is an iterable, `false` otherwise
+ */
+function isIterable(val) {
+    // checks for null and undefined
+    if (typeof val !== "object") {
+        return false;
+    }
+    return typeof val[Symbol.iterator] === "function";
+}
+
+module.exports = isIterable;

github/codeql-action-v1/node_modules/@sinonjs/samsam/lib/is-map.js

@@ -0,0 +1,14 @@
+"use strict";
+
+/**
+ * Returns `true` when `value` is a Map
+ *
+ * @param {*} value A value to examine
+ * @returns {boolean} `true` when `value` is an instance of `Map`, `false` otherwise
+ * @private
+ */
+function isMap(value) {
+    return typeof Map !== "undefined" && value instanceof Map;
+}
+
+module.exports = isMap;

github/codeql-action-v1/node_modules/@sinonjs/samsam/lib/is-nan.js

@@ -0,0 +1,19 @@
+"use strict";
+
+/**
+ * Compares a `value` to `NaN`
+ *
+ * @private
+ * @param {*} value A value to examine
+ * @returns {boolean} Returns `true` when `value` is `NaN`
+ */
+function isNaN(value) {
+    // Unlike global `isNaN`, this function avoids type coercion
+    // `typeof` check avoids IE host object issues, hat tip to
+    // lodash
+
+    // eslint-disable-next-line no-self-compare
+    return typeof value === "number" && value !== value;
+}
+
+module.exports = isNaN;

github/codeql-action-v1/node_modules/@sinonjs/samsam/lib/is-neg-zero.js

@@ -0,0 +1,14 @@
+"use strict";
+
+/**
+ * Returns `true` when `value` is `-0`
+ *
+ * @alias module:samsam.isNegZero
+ * @param {*} value A value to examine
+ * @returns {boolean} Returns `true` when `value` is `-0`
+ */
+function isNegZero(value) {
+    return value === 0 && 1 / value === -Infinity;
+}
+
+module.exports = isNegZero;

github/codeql-action-v1/node_modules/@sinonjs/samsam/lib/is-object.js

@@ -0,0 +1,31 @@
+"use strict";
+
+/**
+ * Returns `true` when the value is a regular Object and not a specialized Object
+ *
+ * This helps speed up deepEqual cyclic checks
+ *
+ * The premise is that only Objects are stored in the visited array.
+ * So if this function returns false, we don't have to do the
+ * expensive operation of searching for the value in the the array of already
+ * visited objects
+ *
+ * @private
+ * @param  {object}   value The object to examine
+ * @returns {boolean}       `true` when the object is a non-specialised object
+ */
+function isObject(value) {
+    return (
+        typeof value === "object" &&
+        value !== null &&
+        // none of these are collection objects, so we can return false
+        !(value instanceof Boolean) &&
+        !(value instanceof Date) &&
+        !(value instanceof Error) &&
+        !(value instanceof Number) &&
+        !(value instanceof RegExp) &&
+        !(value instanceof String)
+    );
+}
+
+module.exports = isObject;

github/codeql-action-v1/node_modules/@sinonjs/samsam/lib/is-set.js

@@ -0,0 +1,14 @@
+"use strict";
+
+/**
+ * Returns `true` when the argument is an instance of Set, `false` otherwise
+ *
+ * @alias module:samsam.isSet
+ * @param  {*}  val - A value to examine
+ * @returns {boolean} Returns `true` when the argument is an instance of Set, `false` otherwise
+ */
+function isSet(val) {
+    return (typeof Set !== "undefined" && val instanceof Set) || false;
+}
+
+module.exports = isSet;

github/codeql-action-v1/node_modules/@sinonjs/samsam/lib/is-subset.js

@@ -0,0 +1,30 @@
+"use strict";
+
+var forEach = require("@sinonjs/commons").prototypes.set.forEach;
+
+/**
+ * Returns `true` when `s1` is a subset of `s2`, `false` otherwise
+ *
+ * @private
+ * @param  {Array|Set}  s1      The target value
+ * @param  {Array|Set}  s2      The containing value
+ * @param  {Function}  compare A comparison function, should return `true` when
+ *                             values are considered equal
+ * @returns {boolean} Returns `true` when `s1` is a subset of `s2`, `false`` otherwise
+ */
+function isSubset(s1, s2, compare) {
+    var allContained = true;
+    forEach(s1, function (v1) {
+        var includes = false;
+        forEach(s2, function (v2) {
+            if (compare(v2, v1)) {
+                includes = true;
+            }
+        });
+        allContained = allContained && includes;
+    });
+
+    return allContained;
+}
+
+module.exports = isSubset;

github/codeql-action-v1/node_modules/@sinonjs/samsam/lib/iterable-to-string.js

@@ -0,0 +1,71 @@
+"use strict";
+
+var slice = require("@sinonjs/commons").prototypes.string.slice;
+var typeOf = require("@sinonjs/commons").typeOf;
+var valueToString = require("@sinonjs/commons").valueToString;
+
+/**
+ * Creates a string represenation of an iterable object
+ *
+ * @private
+ * @param   {object} obj The iterable object to stringify
+ * @returns {string}     A string representation
+ */
+function iterableToString(obj) {
+    if (typeOf(obj) === "map") {
+        return mapToString(obj);
+    }
+
+    return genericIterableToString(obj);
+}
+
+/**
+ * Creates a string representation of a Map
+ *
+ * @private
+ * @param   {Map} map    The map to stringify
+ * @returns {string}     A string representation
+ */
+function mapToString(map) {
+    var representation = "";
+
+    // eslint-disable-next-line @sinonjs/no-prototype-methods/no-prototype-methods
+    map.forEach(function (value, key) {
+        representation += `[${stringify(key)},${stringify(value)}],`;
+    });
+
+    representation = slice(representation, 0, -1);
+    return representation;
+}
+
+/**
+ * Create a string represenation for an iterable
+ *
+ * @private
+ * @param   {object} iterable The iterable to stringify
+ * @returns {string}          A string representation
+ */
+function genericIterableToString(iterable) {
+    var representation = "";
+
+    // eslint-disable-next-line @sinonjs/no-prototype-methods/no-prototype-methods
+    iterable.forEach(function (value) {
+        representation += `${stringify(value)},`;
+    });
+
+    representation = slice(representation, 0, -1);
+    return representation;
+}
+
+/**
+ * Creates a string representation of the passed `item`
+ *
+ * @private
+ * @param  {object} item The item to stringify
+ * @returns {string}      A string representation of `item`
+ */
+function stringify(item) {
+    return typeof item === "string" ? `'${item}'` : valueToString(item);
+}
+
+module.exports = iterableToString;

github/codeql-action-v1/node_modules/@sinonjs/samsam/lib/match.js

@@ -0,0 +1,174 @@
+"use strict";
+
+var valueToString = require("@sinonjs/commons").valueToString;
+var indexOf = require("@sinonjs/commons").prototypes.string.indexOf;
+var forEach = require("@sinonjs/commons").prototypes.array.forEach;
+var type = require("type-detect");
+
+var engineCanCompareMaps = typeof Array.from === "function";
+var deepEqual = require("./deep-equal").use(match); // eslint-disable-line no-use-before-define
+var isArrayType = require("./is-array-type");
+var isSubset = require("./is-subset");
+var createMatcher = require("./create-matcher");
+
+/**
+ * Returns true when `array` contains all of `subset` as defined by the `compare`
+ * argument
+ *
+ * @param  {Array} array   An array to search for a subset
+ * @param  {Array} subset  The subset to find in the array
+ * @param  {Function} compare A comparison function
+ * @returns {boolean}         [description]
+ * @private
+ */
+function arrayContains(array, subset, compare) {
+    if (subset.length === 0) {
+        return true;
+    }
+    var i, l, j, k;
+    for (i = 0, l = array.length; i < l; ++i) {
+        if (compare(array[i], subset[0])) {
+            for (j = 0, k = subset.length; j < k; ++j) {
+                if (i + j >= l) {
+                    return false;
+                }
+                if (!compare(array[i + j], subset[j])) {
+                    return false;
+                }
+            }
+            return true;
+        }
+    }
+    return false;
+}
+
+/* eslint-disable complexity */
+/**
+ * Matches an object with a matcher (or value)
+ *
+ * @alias module:samsam.match
+ * @param {object} object The object candidate to match
+ * @param {object} matcherOrValue A matcher or value to match against
+ * @returns {boolean} true when `object` matches `matcherOrValue`
+ */
+function match(object, matcherOrValue) {
+    if (matcherOrValue && typeof matcherOrValue.test === "function") {
+        return matcherOrValue.test(object);
+    }
+
+    switch (type(matcherOrValue)) {
+        case "bigint":
+        case "boolean":
+        case "number":
+        case "symbol":
+            return matcherOrValue === object;
+        case "function":
+            return matcherOrValue(object) === true;
+        case "string":
+            var notNull = typeof object === "string" || Boolean(object);
+            return (
+                notNull &&
+                indexOf(
+                    valueToString(object).toLowerCase(),
+                    matcherOrValue.toLowerCase()
+                ) >= 0
+            );
+        case "null":
+            return object === null;
+        case "undefined":
+            return typeof object === "undefined";
+        case "Date":
+            /* istanbul ignore else */
+            if (type(object) === "Date") {
+                return object.getTime() === matcherOrValue.getTime();
+            }
+            /* istanbul ignore next: this is basically the rest of the function, which is covered */
+            break;
+        case "Array":
+        case "Int8Array":
+        case "Uint8Array":
+        case "Uint8ClampedArray":
+        case "Int16Array":
+        case "Uint16Array":
+        case "Int32Array":
+        case "Uint32Array":
+        case "Float32Array":
+        case "Float64Array":
+            return (
+                isArrayType(matcherOrValue) &&
+                arrayContains(object, matcherOrValue, match)
+            );
+        case "Map":
+            /* istanbul ignore next: this is covered by a test, that is only run in IE, but we collect coverage information in node*/
+            if (!engineCanCompareMaps) {
+                throw new Error(
+                    "The JavaScript engine does not support Array.from and cannot reliably do value comparison of Map instances"
+                );
+            }
+
+            return (
+                type(object) === "Map" &&
+                arrayContains(
+                    Array.from(object),
+                    Array.from(matcherOrValue),
+                    match
+                )
+            );
+        default:
+            break;
+    }
+
+    switch (type(object)) {
+        case "null":
+            return false;
+        case "Set":
+            return isSubset(matcherOrValue, object, match);
+        default:
+            break;
+    }
+
+    /* istanbul ignore else */
+    if (matcherOrValue && typeof matcherOrValue === "object") {
+        if (matcherOrValue === object) {
+            return true;
+        }
+        if (typeof object !== "object") {
+            return false;
+        }
+        var prop;
+        // eslint-disable-next-line guard-for-in
+        for (prop in matcherOrValue) {
+            var value = object[prop];
+            if (
+                typeof value === "undefined" &&
+                typeof object.getAttribute === "function"
+            ) {
+                value = object.getAttribute(prop);
+            }
+            if (
+                matcherOrValue[prop] === null ||
+                typeof matcherOrValue[prop] === "undefined"
+            ) {
+                if (value !== matcherOrValue[prop]) {
+                    return false;
+                }
+            } else if (
+                typeof value === "undefined" ||
+                !deepEqual(value, matcherOrValue[prop])
+            ) {
+                return false;
+            }
+        }
+        return true;
+    }
+
+    /* istanbul ignore next */
+    throw new Error("Matcher was an unknown or unsupported type");
+}
+/* eslint-enable complexity */
+
+forEach(Object.keys(createMatcher), function (key) {
+    match[key] = createMatcher[key];
+});
+
+module.exports = match;

github/codeql-action-v1/node_modules/@sinonjs/samsam/lib/samsam.js

@@ -0,0 +1,26 @@
+"use strict";
+
+/**
+ * @module samsam
+ */
+var identical = require("./identical");
+var isArguments = require("./is-arguments");
+var isElement = require("./is-element");
+var isNegZero = require("./is-neg-zero");
+var isSet = require("./is-set");
+var isMap = require("./is-map");
+var match = require("./match");
+var deepEqualCyclic = require("./deep-equal").use(match);
+var createMatcher = require("./create-matcher");
+
+module.exports = {
+    createMatcher: createMatcher,
+    deepEqual: deepEqualCyclic,
+    identical: identical,
+    isArguments: isArguments,
+    isElement: isElement,
+    isMap: isMap,
+    isNegZero: isNegZero,
+    isSet: isSet,
+    match: match,
+};