Revert "Merge branch 'MLAB-677' into 'testing'"

This reverts commit f83b6c2a, reversing
changes made to c2b73ce6.

node_modules/@humanwhocodes/object-schema/LICENSE

+BSD 3-Clause License
+
+Copyright (c) 2019, Human Who Codes
+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.

node_modules/@humanwhocodes/object-schema/README.md

+# JavaScript ObjectSchema Package
+
+by [Nicholas C. Zakas](https://humanwhocodes.com)
+
+If you find this useful, please consider supporting my work with a [donation](https://humanwhocodes.com/donate).
+
+## Overview
+
+A JavaScript object merge/validation utility where you can define a different merge and validation strategy for each key. This is helpful when you need to validate complex data structures and then merge them in a way that is more complex than `Object.assign()`.
+
+## Installation
+
+You can install using either npm:
+
+```
+npm install @humanwhocodes/object-schema
+```
+
+Or Yarn:
+
+```
+yarn add @humanwhocodes/object-schema
+```
+
+## Usage
+
+Use CommonJS to get access to the `ObjectSchema` constructor:
+
+```js
+const { ObjectSchema } = require("@humanwhocodes/object-schema");
+
+const schema = new ObjectSchema({
+
+    // define a definition for the "downloads" key
+    downloads: {
+        required: true,
+        merge(value1, value2) {
+            return value1 + value2;
+        },
+        validate(value) {
+            if (typeof value !== "number") {
+                throw new Error("Expected downloads to be a number.");
+            }
+        }
+    },
+
+    // define a strategy for the "versions" key
+    version: {
+        required: true,
+        merge(value1, value2) {
+            return value1.concat(value2);
+        },
+        validate(value) {
+            if (!Array.isArray(value)) {
+                throw new Error("Expected versions to be an array.");
+            }
+        }
+    }
+});
+
+const record1 = {
+    downloads: 25,
+    versions: [
+        "v1.0.0",
+        "v1.1.0",
+        "v1.2.0"
+    ]
+};
+
+const record2 = {
+    downloads: 125,
+    versions: [
+        "v2.0.0",
+        "v2.1.0",
+        "v3.0.0"
+    ]
+};
+
+// make sure the records are valid
+schema.validate(record1);
+schema.validate(record2);
+
+// merge together (schema.merge() accepts any number of objects)
+const result = schema.merge(record1, record2);
+
+// result looks like this:
+
+const result = {
+    downloads: 75,
+    versions: [
+        "v1.0.0",
+        "v1.1.0",
+        "v1.2.0",
+        "v2.0.0",
+        "v2.1.0",
+        "v3.0.0"
+    ]
+};
+```
+
+## Tips and Tricks
+
+### Named merge strategies
+
+Instead of specifying a `merge()` method, you can specify one of the following strings to use a default merge strategy:
+
+* `"assign"` - use `Object.assign()` to merge the two values into one object.
+* `"overwrite"` - the second value always replaces the first.
+* `"replace"` - the second value replaces the first if the second is not `undefined`.
+
+For example:
+
+```js
+const schema = new ObjectSchema({
+    name: {
+        merge: "replace",
+        validate() {}
+    }
+});
+```
+
+### Named validation strategies
+
+Instead of specifying a `validate()` method, you can specify one of the following strings to use a default validation strategy:
+
+* `"array"` - value must be an array.
+* `"boolean"` - value must be a boolean.
+* `"number"` - value must be a number.
+* `"object"` - value must be an object.
+* `"object?"` - value must be an object or null.
+* `"string"` - value must be a string.
+* `"string!"` - value must be a non-empty string.
+
+For example:
+
+```js
+const schema = new ObjectSchema({
+    name: {
+        merge: "replace",
+        validate: "string"
+    }
+});
+```
+
+### Subschemas
+
+If you are defining a key that is, itself, an object, you can simplify the process by using a subschema. Instead of defining `merge()` and `validate()`, assign a `schema` key that contains a schema definition, like this:
+
+```js
+const schema = new ObjectSchema({
+    name: {
+        schema: {
+            first: {
+                merge: "replace",
+                validate: "string"
+            },
+            last: {
+                merge: "replace",
+                validate: "string"
+            }
+        }
+    }
+});
+
+schema.validate({
+    name: {
+        first: "n",
+        last: "z"
+    }
+});
+```
+
+### Remove Keys During Merge
+
+If the merge strategy for a key returns `undefined`, then the key will not appear in the final object. For example:
+
+```js
+const schema = new ObjectSchema({
+    date: {
+        merge() {
+            return undefined;
+        },
+        validate(value) {
+            Date.parse(value);  // throws an error when invalid
+        }
+    }
+});
+
+const object1 = { date: "5/5/2005" };
+const object2 = { date: "6/6/2006" };
+
+const result = schema.merge(object1, object2);
+
+console.log("date" in result);  // false
+```
+
+### Requiring Another Key Be Present
+
+If you'd like the presence of one key to require the presence of another key, you can use the `requires` property to specify an array of other properties that any key requires. For example:
+
+```js
+const schema = new ObjectSchema();
+
+const schema = new ObjectSchema({
+    date: {
+        merge() {
+            return undefined;
+        },
+        validate(value) {
+            Date.parse(value);  // throws an error when invalid
+        }
+    },
+    time: {
+        requires: ["date"],
+        merge(first, second) {
+            return second;
+        },
+        validate(value) {
+            // ...
+        }
+    }
+});
+
+// throws error: Key "time" requires keys "date"
+schema.validate({
+    time: "13:45"
+});
+```
+
+In this example, even though `date` is an optional key, it is required to be present whenever `time` is present.
+
+## License
+
+BSD 3-Clause

node_modules/@humanwhocodes/object-schema/package.json

+{
+  "name": "@humanwhocodes/object-schema",
+  "version": "1.2.1",
+  "description": "An object schema merger/validator",
+  "main": "src/index.js",
+  "directories": {
+    "test": "tests"
+  },
+  "scripts": {
+    "test": "mocha tests/"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/humanwhocodes/object-schema.git"
+  },
+  "keywords": [
+    "object",
+    "validation",
+    "schema",
+    "merge"
+  ],
+  "author": "Nicholas C. Zakas",
+  "license": "BSD-3-Clause",
+  "bugs": {
+    "url": "https://github.com/humanwhocodes/object-schema/issues"
+  },
+  "homepage": "https://github.com/humanwhocodes/object-schema#readme",
+  "devDependencies": {
+    "chai": "^4.2.0",
+    "eslint": "^5.13.0",
+    "mocha": "^5.2.0"
+  }
+}

node_modules/@humanwhocodes/object-schema/src/index.js

+/**
+ * @filedescription Object Schema Package
+ */
+
+exports.ObjectSchema = require("./object-schema").ObjectSchema;
+exports.MergeStrategy = require("./merge-strategy").MergeStrategy;
+exports.ValidationStrategy = require("./validation-strategy").ValidationStrategy;

node_modules/@humanwhocodes/object-schema/src/merge-strategy.js

+/**
+ * @filedescription Merge Strategy
+ */
+
+"use strict";
+
+//-----------------------------------------------------------------------------
+// Class
+//-----------------------------------------------------------------------------
+
+/**
+ * Container class for several different merge strategies.
+ */
+class MergeStrategy {
+
+    /**
+     * Merges two keys by overwriting the first with the second.
+     * @param {*} value1 The value from the first object key. 
+     * @param {*} value2 The value from the second object key.
+     * @returns {*} The second value.
+     */
+    static overwrite(value1, value2) {
+        return value2;
+    }
+
+    /**
+     * Merges two keys by replacing the first with the second only if the
+     * second is defined.
+     * @param {*} value1 The value from the first object key. 
+     * @param {*} value2 The value from the second object key.
+     * @returns {*} The second value if it is defined.
+     */
+    static replace(value1, value2) {
+        if (typeof value2 !== "undefined") {
+            return value2;
+        }
+
+        return value1;
+    }
+
+    /**
+     * Merges two properties by assigning properties from the second to the first.
+     * @param {*} value1 The value from the first object key.
+     * @param {*} value2 The value from the second object key.
+     * @returns {*} A new object containing properties from both value1 and
+     *      value2.
+     */
+    static assign(value1, value2) {
+        return Object.assign({}, value1, value2);
+    }
+}
+
+exports.MergeStrategy = MergeStrategy;

node_modules/@humanwhocodes/object-schema/src/object-schema.js

+/**
+ * @filedescription Object Schema
+ */
+
+"use strict";
+
+//-----------------------------------------------------------------------------
+// Requirements
+//-----------------------------------------------------------------------------
+
+const { MergeStrategy } = require("./merge-strategy");
+const { ValidationStrategy } = require("./validation-strategy");
+
+//-----------------------------------------------------------------------------
+// Private
+//-----------------------------------------------------------------------------
+
+const strategies = Symbol("strategies");
+const requiredKeys = Symbol("requiredKeys");
+
+/**
+ * Validates a schema strategy.
+ * @param {string} name The name of the key this strategy is for.
+ * @param {Object} strategy The strategy for the object key.
+ * @param {boolean} [strategy.required=true] Whether the key is required.
+ * @param {string[]} [strategy.requires] Other keys that are required when
+ *      this key is present.
+ * @param {Function} strategy.merge A method to call when merging two objects
+ *      with the same key.
+ * @param {Function} strategy.validate A method to call when validating an
+ *      object with the key.
+ * @returns {void}
+ * @throws {Error} When the strategy is missing a name.
+ * @throws {Error} When the strategy is missing a merge() method.
+ * @throws {Error} When the strategy is missing a validate() method.
+ */
+function validateDefinition(name, strategy) {
+
+    let hasSchema = false;
+    if (strategy.schema) {
+        if (typeof strategy.schema === "object") {
+            hasSchema = true;
+        } else {
+            throw new TypeError("Schema must be an object.");
+        }
+    }
+
+    if (typeof strategy.merge === "string") {
+        if (!(strategy.merge in MergeStrategy)) {
+            throw new TypeError(`Definition for key "${name}" missing valid merge strategy.`);
+        }
+    } else if (!hasSchema && typeof strategy.merge !== "function") {
+        throw new TypeError(`Definition for key "${name}" must have a merge property.`);
+    }
+
+    if (typeof strategy.validate === "string") {
+        if (!(strategy.validate in ValidationStrategy)) {
+            throw new TypeError(`Definition for key "${name}" missing valid validation strategy.`);
+        }
+    } else if (!hasSchema && typeof strategy.validate !== "function") {
+        throw new TypeError(`Definition for key "${name}" must have a validate() method.`);
+    }
+}
+
+
+//-----------------------------------------------------------------------------
+// Class
+//-----------------------------------------------------------------------------
+
+/**
+ * Represents an object validation/merging schema.
+ */
+class ObjectSchema {
+
+    /**
+     * Creates a new instance.
+     */
+    constructor(definitions) {
+
+        if (!definitions) {
+            throw new Error("Schema definitions missing.");
+        }
+
+        /**
+         * Track all strategies in the schema by key.
+         * @type {Map}
+         * @property strategies
+         */
+        this[strategies] = new Map();
+
+        /**
+         * Separately track any keys that are required for faster validation.
+         * @type {Map}
+         * @property requiredKeys
+         */
+        this[requiredKeys] = new Map();
+
+        // add in all strategies
+        for (const key of Object.keys(definitions)) {
+            validateDefinition(key, definitions[key]);
+
+            // normalize merge and validate methods if subschema is present
+            if (typeof definitions[key].schema === "object") {
+                const schema = new ObjectSchema(definitions[key].schema);
+                definitions[key] = {
+                    ...definitions[key],
+                    merge(first = {}, second = {}) {
+                        return schema.merge(first, second);
+                    },
+                    validate(value) {
+                        ValidationStrategy.object(value);
+                        schema.validate(value);
+                    }
+                };
+            }
+
+            // normalize the merge method in case there's a string
+            if (typeof definitions[key].merge === "string") {
+                definitions[key] = {
+                    ...definitions[key],
+                    merge: MergeStrategy[definitions[key].merge]
+                };
+            };
+
+            // normalize the validate method in case there's a string
+            if (typeof definitions[key].validate === "string") {
+                definitions[key] = {
+                    ...definitions[key],
+                    validate: ValidationStrategy[definitions[key].validate]
+                };
+            };
+
+            this[strategies].set(key, definitions[key]);
+
+            if (definitions[key].required) {
+                this[requiredKeys].set(key, definitions[key]);
+            }
+        }
+    }
+
+    /**
+     * Determines if a strategy has been registered for the given object key.
+     * @param {string} key The object key to find a strategy for.
+     * @returns {boolean} True if the key has a strategy registered, false if not. 
+     */
+    hasKey(key) {
+        return this[strategies].has(key);
+    }
+
+    /**
+     * Merges objects together to create a new object comprised of the keys
+     * of the all objects. Keys are merged based on the each key's merge
+     * strategy.
+     * @param {...Object} objects The objects to merge.
+     * @returns {Object} A new object with a mix of all objects' keys.
+     * @throws {Error} If any object is invalid.
+     */
+    merge(...objects) {
+
+        // double check arguments
+        if (objects.length < 2) {
+            throw new Error("merge() requires at least two arguments.");
+        }
+
+        if (objects.some(object => (object == null || typeof object !== "object"))) {
+            throw new Error("All arguments must be objects.");
+        }
+
+        return objects.reduce((result, object) => {
+            
+            this.validate(object);
+            
+            for (const [key, strategy] of this[strategies]) {
+                try {
+                    if (key in result || key in object) {
+                        const value = strategy.merge.call(this, result[key], object[key]);
+                        if (value !== undefined) {
+                            result[key] = value;
+                        }
+                    }
+                } catch (ex) {
+                    ex.message = `Key "${key}": ` + ex.message;
+                    throw ex;
+                }
+            }
+            return result;
+        }, {});
+    }
+
+    /**
+     * Validates an object's keys based on the validate strategy for each key.
+     * @param {Object} object The object to validate.
+     * @returns {void}
+     * @throws {Error} When the object is invalid. 
+     */
+    validate(object) {
+
+        // check existing keys first
+        for (const key of Object.keys(object)) {
+
+            // check to see if the key is defined
+            if (!this.hasKey(key)) {
+                throw new Error(`Unexpected key "${key}" found.`);
+            }
+
+            // validate existing keys
+            const strategy = this[strategies].get(key);
+
+            // first check to see if any other keys are required
+            if (Array.isArray(strategy.requires)) {
+                if (!strategy.requires.every(otherKey => otherKey in object)) {
+                    throw new Error(`Key "${key}" requires keys "${strategy.requires.join("\", \"")}".`);
+                }
+            }
+
+            // now apply remaining validation strategy
+            try {
+                strategy.validate.call(strategy, object[key]);
+            } catch (ex) {
+                ex.message = `Key "${key}": ` + ex.message;
+                throw ex;
+            }
+        }
+
+        // ensure required keys aren't missing
+        for (const [key] of this[requiredKeys]) {
+            if (!(key in object)) {
+                throw new Error(`Missing required key "${key}".`);
+            }
+        }
+
+    }
+}
+
+exports.ObjectSchema = ObjectSchema;

node_modules/@humanwhocodes/object-schema/src/validation-strategy.js

+/**
+ * @filedescription Validation Strategy
+ */
+
+"use strict";
+
+//-----------------------------------------------------------------------------
+// Class
+//-----------------------------------------------------------------------------
+
+/**
+ * Container class for several different validation strategies.
+ */
+class ValidationStrategy {
+
+    /**
+     * Validates that a value is an array.
+     * @param {*} value The value to validate.
+     * @returns {void}
+     * @throws {TypeError} If the value is invalid. 
+     */
+    static array(value) {
+        if (!Array.isArray(value)) {
+            throw new TypeError("Expected an array.");
+        }
+    }
+
+    /**
+     * Validates that a value is a boolean.
+     * @param {*} value The value to validate.
+     * @returns {void}
+     * @throws {TypeError} If the value is invalid. 
+     */
+    static boolean(value) {
+        if (typeof value !== "boolean") {
+            throw new TypeError("Expected a Boolean.");
+        }
+    }
+
+    /**
+     * Validates that a value is a number.
+     * @param {*} value The value to validate.
+     * @returns {void}
+     * @throws {TypeError} If the value is invalid. 
+     */
+    static number(value) {
+        if (typeof value !== "number") {
+            throw new TypeError("Expected a number.");
+        }
+    }
+
+    /**
+     * Validates that a value is a object.
+     * @param {*} value The value to validate.
+     * @returns {void}
+     * @throws {TypeError} If the value is invalid. 
+     */
+    static object(value) {
+        if (!value || typeof value !== "object") {
+            throw new TypeError("Expected an object.");
+        }
+    }
+
+    /**
+     * Validates that a value is a object or null.
+     * @param {*} value The value to validate.
+     * @returns {void}
+     * @throws {TypeError} If the value is invalid. 
+     */
+    static "object?"(value) {
+        if (typeof value !== "object") {
+            throw new TypeError("Expected an object or null.");
+        }
+    }
+
+    /**
+     * Validates that a value is a string.
+     * @param {*} value The value to validate.
+     * @returns {void}
+     * @throws {TypeError} If the value is invalid. 
+     */
+    static string(value) {
+        if (typeof value !== "string") {
+            throw new TypeError("Expected a string.");
+        }
+    }
+
+    /**
+     * Validates that a value is a non-empty string.
+     * @param {*} value The value to validate.
+     * @returns {void}
+     * @throws {TypeError} If the value is invalid. 
+     */
+    static "string!"(value) {
+        if (typeof value !== "string" || value.length === 0) {
+            throw new TypeError("Expected a non-empty string.");
+        }
+    }
+
+}
+
+exports.ValidationStrategy = ValidationStrategy;

node_modules/@humanwhocodes/object-schema/tests/merge-strategy.js

+/**
+ * @filedescription Merge Strategy Tests
+ */
+/* global it, describe, beforeEach */
+
+"use strict";
+
+//-----------------------------------------------------------------------------
+// Requirements
+//-----------------------------------------------------------------------------
+
+const assert = require("chai").assert;
+const { MergeStrategy } = require("../src/");
+
+//-----------------------------------------------------------------------------
+// Class
+//-----------------------------------------------------------------------------
+
+describe("MergeStrategy", () => {
+
+
+    describe("overwrite()", () => {
+
+        it("should overwrite the first value with the second when the second is defined", () => {
+            const result = MergeStrategy.overwrite(1, 2);
+            assert.strictEqual(result, 2);
+        });
+
+        it("should overwrite the first value with the second when the second is undefined", () => {
+            const result = MergeStrategy.overwrite(1, undefined);
+            assert.strictEqual(result, undefined);
+        });
+
+    });
+
+    describe("replace()", () => {
+
+        it("should overwrite the first value with the second when the second is defined", () => {
+            const result = MergeStrategy.replace(1, 2);
+            assert.strictEqual(result, 2);
+        });
+
+        it("should return the first value when the second is undefined", () => {
+            const result = MergeStrategy.replace(1, undefined);
+            assert.strictEqual(result, 1);
+        });
+
+    });
+
+    describe("assign()", () => {
+
+        it("should merge properties from two objects when called", () => {
+
+            const object1 = { foo: 1, bar: 3 };
+            const object2 = { foo: 2 };            
+            
+            const result = MergeStrategy.assign(object1, object2);
+            assert.deepStrictEqual(result, {
+                foo: 2,
+                bar: 3
+            });
+        });
+
+    });
+
+});

node_modules/@humanwhocodes/object-schema/tests/object-schema.js

+/**
+ * @filedescription Object Schema Tests
+ */
+/* global it, describe, beforeEach */
+
+"use strict";
+
+//-----------------------------------------------------------------------------
+// Requirements
+//-----------------------------------------------------------------------------
+
+const assert = require("chai").assert;
+const { ObjectSchema } = require("../src/");
+
+//-----------------------------------------------------------------------------
+// Class
+//-----------------------------------------------------------------------------
+
+describe("ObjectSchema", () => {
+
+    let schema;
+
+    describe("new ObjectSchema()", () => {
+
+        it("should add a new key when a strategy is passed", () => {
+            schema = new ObjectSchema({
+                foo: {
+                    merge() {},
+                    validate() {}
+                }
+            });
+
+            assert.isTrue(schema.hasKey("foo"));
+        });
+
+        it("should throw an error when a strategy is missing a merge() method", () => {
+            assert.throws(() => {
+                schema = new ObjectSchema({
+                    foo: {
+                        validate() { }
+                    }
+                });
+            }, /Definition for key "foo" must have a merge property/);
+        });
+
+        it("should throw an error when a strategy is missing a merge() method", () => {
+            assert.throws(() => {
+                schema = new ObjectSchema();
+            }, /Schema definitions missing/);
+        });
+
+        it("should throw an error when a strategy is missing a validate() method", () => {
+            assert.throws(() => {
+                schema = new ObjectSchema({
+                    foo: {
+                        merge() { },
+                    }
+                });
+            }, /Definition for key "foo" must have a validate\(\) method/);
+        });
+
+        it("should throw an error when merge is an invalid string", () => {
+            assert.throws(() => {
+                new ObjectSchema({
+                    foo: {
+                        merge: "bar",
+                        validate() { }
+                    }
+                });
+            }, /key "foo" missing valid merge strategy/);
+        });
+
+        it("should throw an error when validate is an invalid string", () => {
+            assert.throws(() => {
+                new ObjectSchema({
+                    foo: {
+                        merge: "assign",
+                        validate: "s"
+                    }
+                });
+            }, /key "foo" missing valid validation strategy/);
+        });
+
+    });
+
+
+    describe("merge()", () => {
+
+        it("should throw an error when an unexpected key is found", () => {
+            let schema = new ObjectSchema({});
+
+            assert.throws(() => {
+                schema.merge({ foo: true }, { foo: true });
+            }, /Unexpected key "foo"/);
+        });
+
+        it("should throw an error when merge() throws an error", () => {
+            let schema = new ObjectSchema({
+                foo: {
+                    merge() {
+                        throw new Error("Boom!");
+                    },
+                    validate() {}
+                }
+            });
+
+            assert.throws(() => {
+                schema.merge({ foo: true }, { foo: true });
+            }, /Key "foo": Boom!/);
+        
+        });
+
+        it("should call the merge() strategy for one key when called", () => {
+            
+            schema = new ObjectSchema({
+                foo: {
+                    merge() {
+                        return "bar";
+                    },
+                    validate() {}
+                }
+            });
+
+            const result = schema.merge({ foo: true }, { foo: false });
+            assert.propertyVal(result, "foo", "bar");
+        });
+
+        it("should not call the merge() strategy when both objects don't contain the key", () => {
+            
+            let called = false;
+
+            schema = new ObjectSchema({
+                foo: {
+                    merge() {
+                        called = true;
+                    },
+                    validate() {}
+                }
+            });
+
+            schema.merge({}, {});
+            assert.isFalse(called, "The merge() strategy should not have been called.");
+        });
+
+        it("should omit returning the key when the merge() strategy returns undefined", () => {
+            schema = new ObjectSchema({
+                foo: {
+                    merge() {
+                        return undefined;
+                    },
+                    validate() { }
+                }
+            });
+            
+            const result = schema.merge({ foo: true }, { foo: false });
+            assert.notProperty(result, "foo");
+        });
+
+        it("should call the merge() strategy for two keys when called", () => {
+            schema = new ObjectSchema({
+                foo: {
+                    merge() {
+                        return "bar";
+                    },
+                    validate() { }
+                },
+                bar: {
+                    merge() {
+                        return "baz";
+                    },
+                    validate() {}
+                }
+            });
+            
+            const result = schema.merge({ foo: true, bar: 1 }, { foo: true, bar: 2 });
+            assert.propertyVal(result, "foo", "bar");
+            assert.propertyVal(result, "bar", "baz");
+        });
+
+        it("should call the merge() strategy for two keys when called on three objects", () => {
+            schema = new ObjectSchema({
+                foo: {
+                    merge() {
+                        return "bar";
+                    },
+                    validate() { }
+                },
+                bar: {
+                    merge() {
+                        return "baz";
+                    },
+                    validate() { }
+                }
+            });
+            
+            const result = schema.merge(
+                { foo: true, bar: 1 },
+                { foo: true, bar: 3 },
+                { foo: false, bar: 2 }
+            );
+            assert.propertyVal(result, "foo", "bar");
+            assert.propertyVal(result, "bar", "baz");
+        });
+
+        it("should call the merge() strategy when defined as 'overwrite'", () => {
+            schema = new ObjectSchema({
+                foo: {
+                    merge: "overwrite",
+                    validate() { }
+                }
+            });
+            
+            const result = schema.merge(
+                { foo: true },
+                { foo: false }
+            );
+            assert.propertyVal(result, "foo", false);
+        });
+
+        it("should call the merge() strategy when defined as 'assign'", () => {
+            schema = new ObjectSchema({
+                foo: {
+                    merge: "assign",
+                    validate() { }
+                }
+            });
+            
+            const result = schema.merge(
+                { foo: { bar: true } },
+                { foo: { baz: false } }
+            );
+
+            assert.strictEqual(result.foo.bar, true);
+            assert.strictEqual(result.foo.baz, false);
+        });
+
+        it("should call the merge strategy when there's a subschema", () => {
+
+            schema = new ObjectSchema({
+                name: {
+                    schema: {
+                        first: {
+                            merge: "replace",
+                            validate: "string"
+                        },
+                        last: {
+                            merge: "replace",
+                            validate: "string"
+                        }
+                    }
+                }
+            });
+
+            const result = schema.merge({
+                name: {
+                    first: "n",
+                    last: "z"
+                }
+            }, {
+                name: {
+                    first: "g"
+                }
+            });
+
+            assert.strictEqual(result.name.first, "g");
+            assert.strictEqual(result.name.last, "z");
+        });
+
+        it("should return separate objects when using subschema", () => {
+
+            schema = new ObjectSchema({
+                age: {
+                    merge: "replace",
+                    validate: "number"
+                },
+                address: {
+                    schema: {
+                        street: {
+                            schema: {
+                                number: {
+                                    merge: "replace",
+                                    validate: "number"
+                                },
+                                streetName: {
+                                    merge: "replace",
+                                    validate: "string"
+                                }
+                            }
+                        },
+                        state: {
+                            merge: "replace",
+                            validate: "string"
+                        }
+                    }
+                }
+            });
+
+            const baseObject = {
+                address: {
+                    street: {
+                        number: 100,
+                        streetName: "Foo St"
+                    },
+                    state: "HA"
+                }
+            };
+
+            const result = schema.merge(baseObject, {
+                age: 29
+            });
+
+            assert.notStrictEqual(result.address.street, baseObject.address.street);
+            assert.deepStrictEqual(result.address, baseObject.address);
+        });
+
+        it("should not error when calling the merge strategy when there's a subschema and no matching key in second object", () => {
+
+            schema = new ObjectSchema({
+                name: {
+                    schema: {
+                        first: {
+                            merge: "replace",
+                            validate: "string"
+                        },
+                        last: {
+                            merge: "replace",
+                            validate: "string"
+                        }
+                    }
+                }
+            });
+
+            const result = schema.merge({
+                name: {
+                    first: "n",
+                    last: "z"
+                }
+            }, {
+            });
+
+            assert.strictEqual(result.name.first, "n");
+            assert.strictEqual(result.name.last, "z");
+        });
+
+        it("should not error when calling the merge strategy when there's multiple subschemas and no matching key in second object", () => {
+
+            schema = new ObjectSchema({
+                user: {
+                    schema: {
+                        name: {
+                            schema: {
+                                first: {
+                                    merge: "replace",
+                                    validate: "string"
+                                },
+                                last: {
+                                    merge: "replace",
+                                    validate: "string"
+                                }
+                            }
+                        }
+
+                    }
+                }
+            });
+
+            const result = schema.merge({
+                user: {
+                    name: {
+                        first: "n",
+                        last: "z"
+                    }
+                }
+            }, {
+            });
+
+            assert.strictEqual(result.user.name.first, "n");
+            assert.strictEqual(result.user.name.last, "z");
+        });
+
+
+    });
+
+    describe("validate()", () => {
+
+        it("should throw an error when an unexpected key is found", () => {
+            let schema = new ObjectSchema({});
+            assert.throws(() => {
+                schema.validate({ foo: true });
+            }, /Unexpected key "foo"/);
+        });
+
+        it("should not throw an error when an expected key is found", () => {
+            schema = new ObjectSchema({
+                foo: {
+                    merge() {
+                        return "bar";
+                    },
+                    validate() {}
+                }
+            });
+            
+            schema.validate({ foo: true });
+        });
+
+        it("should pass the property value into validate() when key is found", () => {
+            schema = new ObjectSchema({
+                foo: {
+                    merge() {
+                        return "bar";
+                    },
+                    validate(value) {
+                        assert.isTrue(value);
+                    }
+                }
+            });
+            
+            schema.validate({ foo: true });
+        });
+
+        it("should not throw an error when expected keys are found", () => {
+            schema = new ObjectSchema({
+                foo: {
+                    merge() {
+                        return "bar";
+                    },
+                    validate() {}
+                },
+                bar: {
+                    merge() {
+                        return "baz";
+                    },
+                    validate() {}
+                }
+            });
+            
+            schema.validate({ foo: true, bar: true });
+        });
+
+        it("should not throw an error when expected keys are found with required keys", () => {
+            schema = new ObjectSchema({
+                foo: {
+                    merge() {
+                        return "bar";
+                    },
+                    validate() { }
+                },
+                bar: {
+                    requires: ["foo"],
+                    merge() {
+                        return "baz";
+                    },
+                    validate() { }
+                }
+            });
+            
+            schema.validate({ foo: true, bar: true });
+        });
+
+        it("should throw an error when expected keys are found without required keys", () => {
+            schema = new ObjectSchema({
+                foo: {
+                    merge() {
+                        return "bar";
+                    },
+                    validate() { }
+                },
+                baz: {
+                    merge() {
+                        return "baz";
+                    },
+                    validate() { }
+                },
+                bar: {
+                    name: "bar",
+                    requires: ["foo", "baz"],
+                    merge() { },
+                    validate() { }
+                }
+            });
+
+            assert.throws(() => {
+                schema.validate({ bar: true });
+            }, /Key "bar" requires keys "foo", "baz"./);
+        });
+
+
+        it("should throw an error when an expected key is found but is invalid", () => {
+
+            schema = new ObjectSchema({
+                foo: {
+                    merge() {
+                        return "bar";
+                    },
+                    validate() {
+                        throw new Error("Invalid key.");
+                    }
+                }
+            });
+
+            assert.throws(() => {
+                schema.validate({ foo: true });
+            }, /Key "foo": Invalid key/);
+        });
+
+        it("should throw an error when an expected key is found but is invalid with a string validator", () => {
+
+            schema = new ObjectSchema({
+                foo: {
+                    merge() {
+                        return "bar";
+                    },
+                    validate: "string"
+                }
+            });
+
+            assert.throws(() => {
+                schema.validate({ foo: true });
+            }, /Key "foo": Expected a string/);
+        });
+
+        it("should throw an error when an expected key is found but is invalid with a number validator", () => {
+
+            schema = new ObjectSchema({
+                foo: {
+                    merge() {
+                        return "bar";
+                    },
+                    validate: "number"
+                }
+            });
+
+            assert.throws(() => {
+                schema.validate({ foo: true });
+            }, /Key "foo": Expected a number/);
+        });
+
+        it("should throw an error when a required key is missing", () => {
+
+            schema = new ObjectSchema({
+                foo: {
+                    required: true,
+                    merge() {
+                        return "bar";
+                    },
+                    validate() {}
+                }
+            });
+
+            assert.throws(() => {
+                schema.validate({});
+            }, /Missing required key "foo"/);
+        });
+
+        it("should throw an error when a subschema is provided and the value doesn't validate", () => {
+
+            schema = new ObjectSchema({
+                name: {
+                    schema: {
+                        first: {
+                            merge: "replace",
+                            validate: "string"
+                        },
+                        last: {
+                            merge: "replace",
+                            validate: "string"
+                        }
+                    }
+                }
+            });
+
+            assert.throws(() => {
+                schema.validate({
+                    name: {
+                        first: 123,
+                        last: "z"
+                    }
+                });
+                        
+            }, /Key "name": Key "first": Expected a string/);
+        });
+
+        it("should not throw an error when a subschema is provided and the value validates", () => {
+
+            schema = new ObjectSchema({
+                name: {
+                    schema: {
+                        first: {
+                            merge: "replace",
+                            validate: "string"
+                        },
+                        last: {
+                            merge: "replace",
+                            validate: "string"
+                        }
+                    }
+                }
+            });
+
+            schema.validate({
+                name: {
+                    first: "n",
+                    last: "z"
+                }
+            });
+                    
+        });
+
+    });
+
+});

node_modules/@humanwhocodes/object-schema/tests/validation-strategy.js

+/**
+ * @filedescription Merge Strategy Tests
+ */
+/* global it, describe, beforeEach */
+
+"use strict";
+
+//-----------------------------------------------------------------------------
+// Requirements
+//-----------------------------------------------------------------------------
+
+const assert = require("chai").assert;
+const { ValidationStrategy } = require("../src/");
+
+//-----------------------------------------------------------------------------
+// Class
+//-----------------------------------------------------------------------------
+
+describe("ValidationStrategy", () => {
+
+    describe("boolean", () => {
+        it("should not throw an error when the value is a boolean", () => {
+            ValidationStrategy.boolean(true);
+        });
+
+        it("should throw an error when the value is null", () => {
+            assert.throws(() => {
+                ValidationStrategy.boolean(null);
+            }, /Expected a Boolean/);
+        });
+
+        it("should throw an error when the value is a string", () => {
+            assert.throws(() => {
+                ValidationStrategy.boolean("foo");
+            }, /Expected a Boolean/);
+        });
+
+        it("should throw an error when the value is a number", () => {
+            assert.throws(() => {
+                ValidationStrategy.boolean(123);
+            }, /Expected a Boolean/);
+        });
+
+        it("should throw an error when the value is an object", () => {
+            assert.throws(() => {
+                ValidationStrategy.boolean({});
+            }, /Expected a Boolean/);
+        });
+    });
+
+    describe("number", () => {
+        it("should not throw an error when the value is a number", () => {
+            ValidationStrategy.number(25);
+        });
+
+        it("should throw an error when the value is null", () => {
+            assert.throws(() => {
+                ValidationStrategy.number(null);
+            }, /Expected a number/);
+        });
+
+        it("should throw an error when the value is a string", () => {
+            assert.throws(() => {
+                ValidationStrategy.number("foo");
+            }, /Expected a number/);
+        });
+
+        it("should throw an error when the value is a boolean", () => {
+            assert.throws(() => {
+                ValidationStrategy.number(true);
+            }, /Expected a number/);
+        });
+
+        it("should throw an error when the value is an object", () => {
+            assert.throws(() => {
+                ValidationStrategy.number({});
+            }, /Expected a number/);
+        });
+    });
+
+    describe("object", () => {
+        it("should not throw an error when the value is an object", () => {
+            ValidationStrategy.object({});
+        });
+
+        it("should throw an error when the value is null", () => {
+            assert.throws(() => {
+                ValidationStrategy.object(null);
+            }, /Expected an object/);
+        });
+
+        it("should throw an error when the value is a string", () => {
+            assert.throws(() => {
+                ValidationStrategy.object("");
+            }, /Expected an object/);
+        });
+    });
+
+    describe("array", () => {
+        it("should not throw an error when the value is an array", () => {
+            ValidationStrategy.array([]);
+        });
+
+        it("should throw an error when the value is null", () => {
+            assert.throws(() => {
+                ValidationStrategy.array(null);
+            }, /Expected an array/);
+        });
+
+        it("should throw an error when the value is a string", () => {
+            assert.throws(() => {
+                ValidationStrategy.array("");
+            }, /Expected an array/);
+        });
+
+        it("should throw an error when the value is an object", () => {
+            assert.throws(() => {
+                ValidationStrategy.array({});
+            }, /Expected an array/);
+        });
+    });
+
+    describe("object?", () => {
+        it("should not throw an error when the value is an object", () => {
+            ValidationStrategy["object?"]({});
+        });
+
+        it("should not throw an error when the value is null", () => {
+            ValidationStrategy["object?"](null);
+        });
+
+        it("should throw an error when the value is a string", () => {
+            assert.throws(() => {
+                ValidationStrategy["object?"]("");
+            }, /Expected an object/);
+        });
+    });
+
+    describe("string", () => {
+        it("should not throw an error when the value is a string", () => {
+            ValidationStrategy.string("foo");
+        });
+
+        it("should not throw an error when the value is an empty string", () => {
+            ValidationStrategy.string("");
+        });
+
+        it("should throw an error when the value is null", () => {
+            assert.throws(() => {
+                ValidationStrategy.string(null);
+            }, /Expected a string/);
+        });
+
+        it("should throw an error when the value is an object", () => {
+            assert.throws(() => {
+                ValidationStrategy.string({});
+            }, /Expected a string/);
+        });
+    });
+
+    describe("string!", () => {
+        it("should not throw an error when the value is an string", () => {
+            ValidationStrategy["string!"]("foo");
+        });
+
+        it("should throw an error when the value is an empty string", () => {
+            assert.throws(() => {
+                ValidationStrategy["string!"]("");
+            }, /Expected a non-empty string/);
+        });
+
+        it("should throw an error when the value is null", () => {
+            assert.throws(() => {
+                ValidationStrategy["string!"](null);
+            }, /Expected a non-empty string/);
+        });
+
+        it("should throw an error when the value is an object", () => {
+            assert.throws(() => {
+                ValidationStrategy["string!"]({});
+            }, /Expected a non-empty string/);
+        });
+    });
+
+
+});

node_modules/accepts/HISTORY.md

+1.3.8 / 2022-02-02
+==================
+
+  * deps: mime-types@~2.1.34
+    - deps: mime-db@~1.51.0
+  * deps: negotiator@0.6.3
+
 1.3.7 / 2019-04-29
 ==================
 

node_modules/accepts/README.md

@@ -3,7 +3,7 @@
 [![NPM Version][npm-version-image]][npm-url]
 [![NPM Downloads][npm-downloads-image]][npm-url]
 [![Node.js Version][node-version-image]][node-version-url]
-[![Build Status][travis-image]][travis-url]
+[![Build Status][github-actions-ci-image]][github-actions-ci-url]
 [![Test Coverage][coveralls-image]][coveralls-url]
 
 Higher level content negotiation based on [negotiator](https://www.npmjs.com/package/negotiator).
@@ -29,8 +29,6 @@ $ npm install accepts
 
 ## API
 
-<!-- eslint-disable no-unused-vars -->
-
 ```js
 var accepts = require('accepts')
 ```
@@ -133,10 +131,10 @@ curl -I -H'Accept: text/html' http://localhost:3000/
 
 [coveralls-image]: https://badgen.net/coveralls/c/github/jshttp/accepts/master
 [coveralls-url]: https://coveralls.io/r/jshttp/accepts?branch=master
+[github-actions-ci-image]: https://badgen.net/github/checks/jshttp/accepts/master?label=ci
+[github-actions-ci-url]: https://github.com/jshttp/accepts/actions/workflows/ci.yml
 [node-version-image]: https://badgen.net/npm/node/accepts
 [node-version-url]: https://nodejs.org/en/download
 [npm-downloads-image]: https://badgen.net/npm/dm/accepts
 [npm-url]: https://npmjs.org/package/accepts
 [npm-version-image]: https://badgen.net/npm/v/accepts
-[travis-image]: https://badgen.net/travis/jshttp/accepts/master
-[travis-url]: https://travis-ci.org/jshttp/accepts

node_modules/accepts/package.json

 {
   "name": "accepts",
   "description": "Higher-level content negotiation",
-  "version": "1.3.7",
+  "version": "1.3.8",
   "contributors": [
     "Douglas Christopher Wilson <doug@somethingdoug.com>",
     "Jonathan Ong <me@jongleberry.com> (http://jongleberry.com)"
@@ -9,20 +9,20 @@
   "license": "MIT",
   "repository": "jshttp/accepts",
   "dependencies": {
-    "mime-types": "~2.1.24",
-    "negotiator": "0.6.2"
+    "mime-types": "~2.1.34",
+    "negotiator": "0.6.3"
   },
   "devDependencies": {
     "deep-equal": "1.0.1",
-    "eslint": "5.16.0",
-    "eslint-config-standard": "12.0.0",
-    "eslint-plugin-import": "2.17.2",
-    "eslint-plugin-markdown": "1.0.0",
-    "eslint-plugin-node": "8.0.1",
-    "eslint-plugin-promise": "4.1.1",
-    "eslint-plugin-standard": "4.0.0",
-    "mocha": "6.1.4",
-    "nyc": "14.0.0"
+    "eslint": "7.32.0",
+    "eslint-config-standard": "14.1.1",
+    "eslint-plugin-import": "2.25.4",
+    "eslint-plugin-markdown": "2.2.1",
+    "eslint-plugin-node": "11.1.0",
+    "eslint-plugin-promise": "4.3.1",
+    "eslint-plugin-standard": "4.1.0",
+    "mocha": "9.2.0",
+    "nyc": "15.1.0"
   },
   "files": [
     "LICENSE",
@@ -33,10 +33,10 @@
     "node": ">= 0.6"
   },
   "scripts": {
-    "lint": "eslint --plugin markdown --ext js,md .",
+    "lint": "eslint .",
     "test": "mocha --reporter spec --check-leaks --bail test/",
-    "test-cov": "nyc --reporter=html --reporter=text npm test",
-    "test-travis": "nyc --reporter=text npm test"
+    "test-ci": "nyc --reporter=lcov --reporter=text npm test",
+    "test-cov": "nyc --reporter=html --reporter=text npm test"
   },
   "keywords": [
     "content",

node_modules/acorn-jsx/LICENSE

+Copyright (C) 2012-2017 by Ingvar Stepanyan
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

node_modules/acorn-jsx/README.md

+# Acorn-JSX
+
+[![Build Status](https://travis-ci.org/acornjs/acorn-jsx.svg?branch=master)](https://travis-ci.org/acornjs/acorn-jsx)
+[![NPM version](https://img.shields.io/npm/v/acorn-jsx.svg)](https://www.npmjs.org/package/acorn-jsx)
+
+This is plugin for [Acorn](http://marijnhaverbeke.nl/acorn/) - a tiny, fast JavaScript parser, written completely in JavaScript.
+
+It was created as an experimental alternative, faster [React.js JSX](http://facebook.github.io/react/docs/jsx-in-depth.html) parser. Later, it replaced the [official parser](https://github.com/facebookarchive/esprima) and these days is used by many prominent development tools.
+
+## Transpiler
+
+Please note that this tool only parses source code to JSX AST, which is useful for various language tools and services. If you want to transpile your code to regular ES5-compliant JavaScript with source map, check out [Babel](https://babeljs.io/) and [Buble](https://buble.surge.sh/) transpilers which use `acorn-jsx` under the hood.
+
+## Usage
+
+Requiring this module provides you with an Acorn plugin that you can use like this:
+
+```javascript
+var acorn = require("acorn");
+var jsx = require("acorn-jsx");
+acorn.Parser.extend(jsx()).parse("my(<jsx/>, 'code');");
+```
+
+Note that official spec doesn't support mix of XML namespaces and object-style access in tag names (#27) like in `<namespace:Object.Property />`, so it was deprecated in `acorn-jsx@3.0`. If you still want to opt-in to support of such constructions, you can pass the following option:
+
+```javascript
+acorn.Parser.extend(jsx({ allowNamespacedObjects: true }))
+```
+
+Also, since most apps use pure React transformer, a new option was introduced that allows to prohibit namespaces completely:
+
+```javascript
+acorn.Parser.extend(jsx({ allowNamespaces: false }))
+```
+
+Note that by default `allowNamespaces` is enabled for spec compliancy.
+
+## License
+
+This plugin is issued under the [MIT license](./LICENSE).

node_modules/acorn-jsx/index.d.ts

+import { Parser } from 'acorn' 
+
+declare const jsx: (options?: jsx.Options) => (BaseParser: typeof Parser) => typeof Parser;
+
+declare namespace jsx {
+  interface Options {
+    allowNamespacedObjects?: boolean;
+    allowNamespaces?: boolean;
+  }
+}
+
+export = jsx;

node_modules/acorn-jsx/index.js

+'use strict';
+
+const XHTMLEntities = require('./xhtml');
+
+const hexNumber = /^[\da-fA-F]+$/;
+const decimalNumber = /^\d+$/;
+
+// The map to `acorn-jsx` tokens from `acorn` namespace objects.
+const acornJsxMap = new WeakMap();
+
+// Get the original tokens for the given `acorn` namespace object.
+function getJsxTokens(acorn) {
+  acorn = acorn.Parser.acorn || acorn;
+  let acornJsx = acornJsxMap.get(acorn);
+  if (!acornJsx) {
+    const tt = acorn.tokTypes;
+    const TokContext = acorn.TokContext;
+    const TokenType = acorn.TokenType;
+    const tc_oTag = new TokContext('<tag', false);
+    const tc_cTag = new TokContext('</tag', false);
+    const tc_expr = new TokContext('<tag>...</tag>', true, true);
+    const tokContexts = {
+      tc_oTag: tc_oTag,
+      tc_cTag: tc_cTag,
+      tc_expr: tc_expr
+    };
+    const tokTypes = {
+      jsxName: new TokenType('jsxName'),
+      jsxText: new TokenType('jsxText', {beforeExpr: true}),
+      jsxTagStart: new TokenType('jsxTagStart', {startsExpr: true}),
+      jsxTagEnd: new TokenType('jsxTagEnd')
+    };
+
+    tokTypes.jsxTagStart.updateContext = function() {
+      this.context.push(tc_expr); // treat as beginning of JSX expression
+      this.context.push(tc_oTag); // start opening tag context
+      this.exprAllowed = false;
+    };
+    tokTypes.jsxTagEnd.updateContext = function(prevType) {
+      let out = this.context.pop();
+      if (out === tc_oTag && prevType === tt.slash || out === tc_cTag) {
+        this.context.pop();
+        this.exprAllowed = this.curContext() === tc_expr;
+      } else {
+        this.exprAllowed = true;
+      }
+    };
+
+    acornJsx = { tokContexts: tokContexts, tokTypes: tokTypes };
+    acornJsxMap.set(acorn, acornJsx);
+  }
+
+  return acornJsx;
+}
+
+// Transforms JSX element name to string.
+
+function getQualifiedJSXName(object) {
+  if (!object)
+    return object;
+
+  if (object.type === 'JSXIdentifier')
+    return object.name;
+
+  if (object.type === 'JSXNamespacedName')
+    return object.namespace.name + ':' + object.name.name;
+
+  if (object.type === 'JSXMemberExpression')
+    return getQualifiedJSXName(object.object) + '.' +
+    getQualifiedJSXName(object.property);
+}
+
+module.exports = function(options) {
+  options = options || {};
+  return function(Parser) {
+    return plugin({
+      allowNamespaces: options.allowNamespaces !== false,
+      allowNamespacedObjects: !!options.allowNamespacedObjects
+    }, Parser);
+  };
+};
+
+// This is `tokTypes` of the peer dep.
+// This can be different instances from the actual `tokTypes` this plugin uses.
+Object.defineProperty(module.exports, "tokTypes", {
+  get: function get_tokTypes() {
+    return getJsxTokens(require("acorn")).tokTypes;
+  },
+  configurable: true,
+  enumerable: true
+});
+
+function plugin(options, Parser) {
+  const acorn = Parser.acorn || require("acorn");
+  const acornJsx = getJsxTokens(acorn);
+  const tt = acorn.tokTypes;
+  const tok = acornJsx.tokTypes;
+  const tokContexts = acorn.tokContexts;
+  const tc_oTag = acornJsx.tokContexts.tc_oTag;
+  const tc_cTag = acornJsx.tokContexts.tc_cTag;
+  const tc_expr = acornJsx.tokContexts.tc_expr;
+  const isNewLine = acorn.isNewLine;
+  const isIdentifierStart = acorn.isIdentifierStart;
+  const isIdentifierChar = acorn.isIdentifierChar;
+
+  return class extends Parser {
+    // Expose actual `tokTypes` and `tokContexts` to other plugins.
+    static get acornJsx() {
+      return acornJsx;
+    }
+
+    // Reads inline JSX contents token.
+    jsx_readToken() {
+      let out = '', chunkStart = this.pos;
+      for (;;) {
+        if (this.pos >= this.input.length)
+          this.raise(this.start, 'Unterminated JSX contents');
+        let ch = this.input.charCodeAt(this.pos);
+
+        switch (ch) {
+        case 60: // '<'
+        case 123: // '{'
+          if (this.pos === this.start) {
+            if (ch === 60 && this.exprAllowed) {
+              ++this.pos;
+              return this.finishToken(tok.jsxTagStart);
+            }
+            return this.getTokenFromCode(ch);
+          }
+          out += this.input.slice(chunkStart, this.pos);
+          return this.finishToken(tok.jsxText, out);
+
+        case 38: // '&'
+          out += this.input.slice(chunkStart, this.pos);
+          out += this.jsx_readEntity();
+          chunkStart = this.pos;
+          break;
+
+        case 62: // '>'
+        case 125: // '}'
+          this.raise(
+            this.pos,
+            "Unexpected token `" + this.input[this.pos] + "`. Did you mean `" +
+              (ch === 62 ? "&gt;" : "&rbrace;") + "` or " + "`{\"" + this.input[this.pos] + "\"}" + "`?"
+          );
+
+        default:
+          if (isNewLine(ch)) {
+            out += this.input.slice(chunkStart, this.pos);
+            out += this.jsx_readNewLine(true);
+            chunkStart = this.pos;
+          } else {
+            ++this.pos;
+          }
+        }
+      }
+    }
+
+    jsx_readNewLine(normalizeCRLF) {
+      let ch = this.input.charCodeAt(this.pos);
+      let out;
+      ++this.pos;
+      if (ch === 13 && this.input.charCodeAt(this.pos) === 10) {
+        ++this.pos;
+        out = normalizeCRLF ? '\n' : '\r\n';
+      } else {
+        out = String.fromCharCode(ch);
+      }
+      if (this.options.locations) {
+        ++this.curLine;
+        this.lineStart = this.pos;
+      }
+
+      return out;
+    }
+
+    jsx_readString(quote) {
+      let out = '', chunkStart = ++this.pos;
+      for (;;) {
+        if (this.pos >= this.input.length)
+          this.raise(this.start, 'Unterminated string constant');
+        let ch = this.input.charCodeAt(this.pos);
+        if (ch === quote) break;
+        if (ch === 38) { // '&'
+          out += this.input.slice(chunkStart, this.pos);
+          out += this.jsx_readEntity();
+          chunkStart = this.pos;
+        } else if (isNewLine(ch)) {
+          out += this.input.slice(chunkStart, this.pos);
+          out += this.jsx_readNewLine(false);
+          chunkStart = this.pos;
+        } else {
+          ++this.pos;
+        }
+      }
+      out += this.input.slice(chunkStart, this.pos++);
+      return this.finishToken(tt.string, out);
+    }
+
+    jsx_readEntity() {
+      let str = '', count = 0, entity;
+      let ch = this.input[this.pos];
+      if (ch !== '&')
+        this.raise(this.pos, 'Entity must start with an ampersand');
+      let startPos = ++this.pos;
+      while (this.pos < this.input.length && count++ < 10) {
+        ch = this.input[this.pos++];
+        if (ch === ';') {
+          if (str[0] === '#') {
+            if (str[1] === 'x') {
+              str = str.substr(2);
+              if (hexNumber.test(str))
+                entity = String.fromCharCode(parseInt(str, 16));
+            } else {
+              str = str.substr(1);
+              if (decimalNumber.test(str))
+                entity = String.fromCharCode(parseInt(str, 10));
+            }
+          } else {
+            entity = XHTMLEntities[str];
+          }
+          break;
+        }
+        str += ch;
+      }
+      if (!entity) {
+        this.pos = startPos;
+        return '&';
+      }
+      return entity;
+    }
+
+    // Read a JSX identifier (valid tag or attribute name).
+    //
+    // Optimized version since JSX identifiers can't contain
+    // escape characters and so can be read as single slice.
+    // Also assumes that first character was already checked
+    // by isIdentifierStart in readToken.
+
+    jsx_readWord() {
+      let ch, start = this.pos;
+      do {
+        ch = this.input.charCodeAt(++this.pos);
+      } while (isIdentifierChar(ch) || ch === 45); // '-'
+      return this.finishToken(tok.jsxName, this.input.slice(start, this.pos));
+    }
+
+    // Parse next token as JSX identifier
+
+    jsx_parseIdentifier() {
+      let node = this.startNode();
+      if (this.type === tok.jsxName)
+        node.name = this.value;
+      else if (this.type.keyword)
+        node.name = this.type.keyword;
+      else
+        this.unexpected();
+      this.next();
+      return this.finishNode(node, 'JSXIdentifier');
+    }
+
+    // Parse namespaced identifier.
+
+    jsx_parseNamespacedName() {
+      let startPos = this.start, startLoc = this.startLoc;
+      let name = this.jsx_parseIdentifier();
+      if (!options.allowNamespaces || !this.eat(tt.colon)) return name;
+      var node = this.startNodeAt(startPos, startLoc);
+      node.namespace = name;
+      node.name = this.jsx_parseIdentifier();
+      return this.finishNode(node, 'JSXNamespacedName');
+    }
+
+    // Parses element name in any form - namespaced, member
+    // or single identifier.
+
+    jsx_parseElementName() {
+      if (this.type === tok.jsxTagEnd) return '';
+      let startPos = this.start, startLoc = this.startLoc;
+      let node = this.jsx_parseNamespacedName();
+      if (this.type === tt.dot && node.type === 'JSXNamespacedName' && !options.allowNamespacedObjects) {
+        this.unexpected();
+      }
+      while (this.eat(tt.dot)) {
+        let newNode = this.startNodeAt(startPos, startLoc);
+        newNode.object = node;
+        newNode.property = this.jsx_parseIdentifier();
+        node = this.finishNode(newNode, 'JSXMemberExpression');
+      }
+      return node;
+    }
+
+    // Parses any type of JSX attribute value.
+
+    jsx_parseAttributeValue() {
+      switch (this.type) {
+      case tt.braceL:
+        let node = this.jsx_parseExpressionContainer();
+        if (node.expression.type === 'JSXEmptyExpression')
+          this.raise(node.start, 'JSX attributes must only be assigned a non-empty expression');
+        return node;
+
+      case tok.jsxTagStart:
+      case tt.string:
+        return this.parseExprAtom();
+
+      default:
+        this.raise(this.start, 'JSX value should be either an expression or a quoted JSX text');
+      }
+    }
+
+    // JSXEmptyExpression is unique type since it doesn't actually parse anything,
+    // and so it should start at the end of last read token (left brace) and finish
+    // at the beginning of the next one (right brace).
+
+    jsx_parseEmptyExpression() {
+      let node = this.startNodeAt(this.lastTokEnd, this.lastTokEndLoc);
+      return this.finishNodeAt(node, 'JSXEmptyExpression', this.start, this.startLoc);
+    }
+
+    // Parses JSX expression enclosed into curly brackets.
+
+    jsx_parseExpressionContainer() {
+      let node = this.startNode();
+      this.next();
+      node.expression = this.type === tt.braceR
+        ? this.jsx_parseEmptyExpression()
+        : this.parseExpression();
+      this.expect(tt.braceR);
+      return this.finishNode(node, 'JSXExpressionContainer');
+    }
+
+    // Parses following JSX attribute name-value pair.
+
+    jsx_parseAttribute() {
+      let node = this.startNode();
+      if (this.eat(tt.braceL)) {
+        this.expect(tt.ellipsis);
+        node.argument = this.parseMaybeAssign();
+        this.expect(tt.braceR);
+        return this.finishNode(node, 'JSXSpreadAttribute');
+      }
+      node.name = this.jsx_parseNamespacedName();
+      node.value = this.eat(tt.eq) ? this.jsx_parseAttributeValue() : null;
+      return this.finishNode(node, 'JSXAttribute');
+    }
+
+    // Parses JSX opening tag starting after '<'.
+
+    jsx_parseOpeningElementAt(startPos, startLoc) {
+      let node = this.startNodeAt(startPos, startLoc);
+      node.attributes = [];
+      let nodeName = this.jsx_parseElementName();
+      if (nodeName) node.name = nodeName;
+      while (this.type !== tt.slash && this.type !== tok.jsxTagEnd)
+        node.attributes.push(this.jsx_parseAttribute());
+      node.selfClosing = this.eat(tt.slash);
+      this.expect(tok.jsxTagEnd);
+      return this.finishNode(node, nodeName ? 'JSXOpeningElement' : 'JSXOpeningFragment');
+    }
+
+    // Parses JSX closing tag starting after '</'.
+
+    jsx_parseClosingElementAt(startPos, startLoc) {
+      let node = this.startNodeAt(startPos, startLoc);
+      let nodeName = this.jsx_parseElementName();
+      if (nodeName) node.name = nodeName;
+      this.expect(tok.jsxTagEnd);
+      return this.finishNode(node, nodeName ? 'JSXClosingElement' : 'JSXClosingFragment');
+    }
+
+    // Parses entire JSX element, including it's opening tag
+    // (starting after '<'), attributes, contents and closing tag.
+
+    jsx_parseElementAt(startPos, startLoc) {
+      let node = this.startNodeAt(startPos, startLoc);
+      let children = [];
+      let openingElement = this.jsx_parseOpeningElementAt(startPos, startLoc);
+      let closingElement = null;
+
+      if (!openingElement.selfClosing) {
+        contents: for (;;) {
+          switch (this.type) {
+          case tok.jsxTagStart:
+            startPos = this.start; startLoc = this.startLoc;
+            this.next();
+            if (this.eat(tt.slash)) {
+              closingElement = this.jsx_parseClosingElementAt(startPos, startLoc);
+              break contents;
+            }
+            children.push(this.jsx_parseElementAt(startPos, startLoc));
+            break;
+
+          case tok.jsxText:
+            children.push(this.parseExprAtom());
+            break;
+
+          case tt.braceL:
+            children.push(this.jsx_parseExpressionContainer());
+            break;
+
+          default:
+            this.unexpected();
+          }
+        }
+        if (getQualifiedJSXName(closingElement.name) !== getQualifiedJSXName(openingElement.name)) {
+          this.raise(
+            closingElement.start,
+            'Expected corresponding JSX closing tag for <' + getQualifiedJSXName(openingElement.name) + '>');
+        }
+      }
+      let fragmentOrElement = openingElement.name ? 'Element' : 'Fragment';
+
+      node['opening' + fragmentOrElement] = openingElement;
+      node['closing' + fragmentOrElement] = closingElement;
+      node.children = children;
+      if (this.type === tt.relational && this.value === "<") {
+        this.raise(this.start, "Adjacent JSX elements must be wrapped in an enclosing tag");
+      }
+      return this.finishNode(node, 'JSX' + fragmentOrElement);
+    }
+
+    // Parse JSX text
+
+    jsx_parseText() {
+      let node = this.parseLiteral(this.value);
+      node.type = "JSXText";
+      return node;
+    }
+
+    // Parses entire JSX element from current position.
+
+    jsx_parseElement() {
+      let startPos = this.start, startLoc = this.startLoc;
+      this.next();
+      return this.jsx_parseElementAt(startPos, startLoc);
+    }
+
+    parseExprAtom(refShortHandDefaultPos) {
+      if (this.type === tok.jsxText)
+        return this.jsx_parseText();
+      else if (this.type === tok.jsxTagStart)
+        return this.jsx_parseElement();
+      else
+        return super.parseExprAtom(refShortHandDefaultPos);
+    }
+
+    readToken(code) {
+      let context = this.curContext();
+
+      if (context === tc_expr) return this.jsx_readToken();
+
+      if (context === tc_oTag || context === tc_cTag) {
+        if (isIdentifierStart(code)) return this.jsx_readWord();
+
+        if (code == 62) {
+          ++this.pos;
+          return this.finishToken(tok.jsxTagEnd);
+        }
+
+        if ((code === 34 || code === 39) && context == tc_oTag)
+          return this.jsx_readString(code);
+      }
+
+      if (code === 60 && this.exprAllowed && this.input.charCodeAt(this.pos + 1) !== 33) {
+        ++this.pos;
+        return this.finishToken(tok.jsxTagStart);
+      }
+      return super.readToken(code);
+    }
+
+    updateContext(prevType) {
+      if (this.type == tt.braceL) {
+        var curContext = this.curContext();
+        if (curContext == tc_oTag) this.context.push(tokContexts.b_expr);
+        else if (curContext == tc_expr) this.context.push(tokContexts.b_tmpl);
+        else super.updateContext(prevType);
+        this.exprAllowed = true;
+      } else if (this.type === tt.slash && prevType === tok.jsxTagStart) {
+        this.context.length -= 2; // do not consider JSX expr -> JSX open tag -> ... anymore
+        this.context.push(tc_cTag); // reconsider as closing tag context
+        this.exprAllowed = false;
+      } else {
+        return super.updateContext(prevType);
+      }
+    }
+  };
+}

node_modules/acorn-jsx/package.json

+{
+  "name": "acorn-jsx",
+  "description": "Modern, fast React.js JSX parser",
+  "homepage": "https://github.com/acornjs/acorn-jsx",
+  "version": "5.3.2",
+  "maintainers": [
+    {
+      "name": "Ingvar Stepanyan",
+      "email": "me@rreverser.com",
+      "web": "http://rreverser.com/"
+    }
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/acornjs/acorn-jsx"
+  },
+  "license": "MIT",
+  "scripts": {
+    "test": "node test/run.js"
+  },
+  "peerDependencies": {
+    "acorn": "^6.0.0 || ^7.0.0 || ^8.0.0"
+  },
+  "devDependencies": {
+    "acorn": "^8.0.1"
+  }
+}

node_modules/acorn-jsx/xhtml.js

+module.exports = {
+  quot: '\u0022',
+  amp: '&',
+  apos: '\u0027',
+  lt: '<',
+  gt: '>',
+  nbsp: '\u00A0',
+  iexcl: '\u00A1',
+  cent: '\u00A2',
+  pound: '\u00A3',
+  curren: '\u00A4',
+  yen: '\u00A5',
+  brvbar: '\u00A6',
+  sect: '\u00A7',
+  uml: '\u00A8',
+  copy: '\u00A9',
+  ordf: '\u00AA',
+  laquo: '\u00AB',
+  not: '\u00AC',
+  shy: '\u00AD',
+  reg: '\u00AE',
+  macr: '\u00AF',
+  deg: '\u00B0',
+  plusmn: '\u00B1',
+  sup2: '\u00B2',
+  sup3: '\u00B3',
+  acute: '\u00B4',
+  micro: '\u00B5',
+  para: '\u00B6',
+  middot: '\u00B7',
+  cedil: '\u00B8',
+  sup1: '\u00B9',
+  ordm: '\u00BA',
+  raquo: '\u00BB',
+  frac14: '\u00BC',
+  frac12: '\u00BD',
+  frac34: '\u00BE',
+  iquest: '\u00BF',
+  Agrave: '\u00C0',
+  Aacute: '\u00C1',
+  Acirc: '\u00C2',
+  Atilde: '\u00C3',
+  Auml: '\u00C4',
+  Aring: '\u00C5',
+  AElig: '\u00C6',
+  Ccedil: '\u00C7',
+  Egrave: '\u00C8',
+  Eacute: '\u00C9',
+  Ecirc: '\u00CA',
+  Euml: '\u00CB',
+  Igrave: '\u00CC',
+  Iacute: '\u00CD',
+  Icirc: '\u00CE',
+  Iuml: '\u00CF',
+  ETH: '\u00D0',
+  Ntilde: '\u00D1',
+  Ograve: '\u00D2',
+  Oacute: '\u00D3',
+  Ocirc: '\u00D4',
+  Otilde: '\u00D5',
+  Ouml: '\u00D6',
+  times: '\u00D7',
+  Oslash: '\u00D8',
+  Ugrave: '\u00D9',
+  Uacute: '\u00DA',
+  Ucirc: '\u00DB',
+  Uuml: '\u00DC',
+  Yacute: '\u00DD',
+  THORN: '\u00DE',
+  szlig: '\u00DF',
+  agrave: '\u00E0',
+  aacute: '\u00E1',
+  acirc: '\u00E2',
+  atilde: '\u00E3',
+  auml: '\u00E4',
+  aring: '\u00E5',
+  aelig: '\u00E6',
+  ccedil: '\u00E7',
+  egrave: '\u00E8',
+  eacute: '\u00E9',
+  ecirc: '\u00EA',
+  euml: '\u00EB',
+  igrave: '\u00EC',
+  iacute: '\u00ED',
+  icirc: '\u00EE',
+  iuml: '\u00EF',
+  eth: '\u00F0',
+  ntilde: '\u00F1',
+  ograve: '\u00F2',
+  oacute: '\u00F3',
+  ocirc: '\u00F4',
+  otilde: '\u00F5',
+  ouml: '\u00F6',
+  divide: '\u00F7',
+  oslash: '\u00F8',
+  ugrave: '\u00F9',
+  uacute: '\u00FA',
+  ucirc: '\u00FB',
+  uuml: '\u00FC',
+  yacute: '\u00FD',
+  thorn: '\u00FE',
+  yuml: '\u00FF',
+  OElig: '\u0152',
+  oelig: '\u0153',
+  Scaron: '\u0160',
+  scaron: '\u0161',
+  Yuml: '\u0178',
+  fnof: '\u0192',
+  circ: '\u02C6',
+  tilde: '\u02DC',
+  Alpha: '\u0391',
+  Beta: '\u0392',
+  Gamma: '\u0393',
+  Delta: '\u0394',
+  Epsilon: '\u0395',
+  Zeta: '\u0396',
+  Eta: '\u0397',
+  Theta: '\u0398',
+  Iota: '\u0399',
+  Kappa: '\u039A',
+  Lambda: '\u039B',
+  Mu: '\u039C',
+  Nu: '\u039D',
+  Xi: '\u039E',
+  Omicron: '\u039F',
+  Pi: '\u03A0',
+  Rho: '\u03A1',
+  Sigma: '\u03A3',
+  Tau: '\u03A4',
+  Upsilon: '\u03A5',
+  Phi: '\u03A6',
+  Chi: '\u03A7',
+  Psi: '\u03A8',
+  Omega: '\u03A9',
+  alpha: '\u03B1',
+  beta: '\u03B2',
+  gamma: '\u03B3',
+  delta: '\u03B4',
+  epsilon: '\u03B5',
+  zeta: '\u03B6',
+  eta: '\u03B7',
+  theta: '\u03B8',
+  iota: '\u03B9',
+  kappa: '\u03BA',
+  lambda: '\u03BB',
+  mu: '\u03BC',
+  nu: '\u03BD',
+  xi: '\u03BE',
+  omicron: '\u03BF',
+  pi: '\u03C0',
+  rho: '\u03C1',
+  sigmaf: '\u03C2',
+  sigma: '\u03C3',
+  tau: '\u03C4',
+  upsilon: '\u03C5',
+  phi: '\u03C6',
+  chi: '\u03C7',
+  psi: '\u03C8',
+  omega: '\u03C9',
+  thetasym: '\u03D1',
+  upsih: '\u03D2',
+  piv: '\u03D6',
+  ensp: '\u2002',
+  emsp: '\u2003',
+  thinsp: '\u2009',
+  zwnj: '\u200C',
+  zwj: '\u200D',
+  lrm: '\u200E',
+  rlm: '\u200F',
+  ndash: '\u2013',
+  mdash: '\u2014',
+  lsquo: '\u2018',
+  rsquo: '\u2019',
+  sbquo: '\u201A',
+  ldquo: '\u201C',
+  rdquo: '\u201D',
+  bdquo: '\u201E',
+  dagger: '\u2020',
+  Dagger: '\u2021',
+  bull: '\u2022',
+  hellip: '\u2026',
+  permil: '\u2030',
+  prime: '\u2032',
+  Prime: '\u2033',
+  lsaquo: '\u2039',
+  rsaquo: '\u203A',
+  oline: '\u203E',
+  frasl: '\u2044',
+  euro: '\u20AC',
+  image: '\u2111',
+  weierp: '\u2118',
+  real: '\u211C',
+  trade: '\u2122',
+  alefsym: '\u2135',
+  larr: '\u2190',
+  uarr: '\u2191',
+  rarr: '\u2192',
+  darr: '\u2193',
+  harr: '\u2194',
+  crarr: '\u21B5',
+  lArr: '\u21D0',
+  uArr: '\u21D1',
+  rArr: '\u21D2',
+  dArr: '\u21D3',
+  hArr: '\u21D4',
+  forall: '\u2200',
+  part: '\u2202',
+  exist: '\u2203',
+  empty: '\u2205',
+  nabla: '\u2207',
+  isin: '\u2208',
+  notin: '\u2209',
+  ni: '\u220B',
+  prod: '\u220F',
+  sum: '\u2211',
+  minus: '\u2212',
+  lowast: '\u2217',
+  radic: '\u221A',
+  prop: '\u221D',
+  infin: '\u221E',
+  ang: '\u2220',
+  and: '\u2227',
+  or: '\u2228',
+  cap: '\u2229',
+  cup: '\u222A',
+  'int': '\u222B',
+  there4: '\u2234',
+  sim: '\u223C',
+  cong: '\u2245',
+  asymp: '\u2248',
+  ne: '\u2260',
+  equiv: '\u2261',
+  le: '\u2264',
+  ge: '\u2265',
+  sub: '\u2282',
+  sup: '\u2283',
+  nsub: '\u2284',
+  sube: '\u2286',
+  supe: '\u2287',
+  oplus: '\u2295',
+  otimes: '\u2297',
+  perp: '\u22A5',
+  sdot: '\u22C5',
+  lceil: '\u2308',
+  rceil: '\u2309',
+  lfloor: '\u230A',
+  rfloor: '\u230B',
+  lang: '\u2329',
+  rang: '\u232A',
+  loz: '\u25CA',
+  spades: '\u2660',
+  clubs: '\u2663',
+  hearts: '\u2665',
+  diams: '\u2666'
+};