Regenerating node_modules

node_modules/.bin/eslint

@@ -0,0 +1 @@
+../eslint/bin/eslint.js

node_modules/.bin/eslint-config-prettier-check

@@ -0,0 +1 @@
+../eslint-config-prettier/bin/cli.js

node_modules/.bin/eslint-ignore-errors

@@ -0,0 +1 @@
+../eslint-plugin-github/bin/eslint-ignore-errors.js

node_modules/.bin/json5

@@ -0,0 +1 @@
+../json5/lib/cli.js

node_modules/.bin/prettier

@@ -0,0 +1 @@
+../prettier/bin-prettier.js

node_modules/.bin/tslint

@@ -1 +0,0 @@
-../tslint/bin/tslint

node_modules/@eslint/eslintrc/CHANGELOG.md

@@ -0,0 +1,4 @@
+v0.1.3 - September 1, 2020
+
+* [`8647a61`](https://github.com/eslint/eslintrc/commit/8647a61991fe121f923d33e96232475209b78210) Fix: version number and eslint-release version (refs #6) (Nicholas C. Zakas)
+

node_modules/@eslint/eslintrc/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2020 ESLint
+
+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/@eslint/eslintrc/README.md

@@ -0,0 +1,21 @@
+# ESLintRC Library
+
+This repository contains the legacy ESLintRC configuration file format for ESLint.
+
+**Note:** This package is not intended for use outside of the ESLint ecosystem. It is ESLint-specific and not intended for use in other programs.
+
+## Usage
+
+You can install the package as follows:
+
+```
+npm install @eslint/eslintrc --save-dev
+
+# or
+
+yarn add @eslint/eslintrc -D
+```
+
+## License
+
+MIT License

node_modules/@eslint/eslintrc/conf/category-list.json

@@ -0,0 +1,39 @@
+{
+    "categories": [
+        { "name": "Possible Errors", "description": "These rules relate to possible syntax or logic errors in JavaScript code:" },
+        { "name": "Best Practices", "description": "These rules relate to better ways of doing things to help you avoid problems:" },
+        { "name": "Strict Mode", "description": "These rules relate to strict mode directives:" },
+        { "name": "Variables", "description": "These rules relate to variable declarations:" },
+        { "name": "Stylistic Issues", "description": "These rules relate to style guidelines, and are therefore quite subjective:" },
+        { "name": "ECMAScript 6", "description": "These rules relate to ES6, also known as ES2015:" }
+    ],
+    "deprecated": {
+        "name": "Deprecated",
+        "description": "These rules have been deprecated in accordance with the <a href=\"/docs/user-guide/rule-deprecation\">deprecation policy</a>, and replaced by newer rules:",
+        "rules": []
+    },
+    "removed": {
+        "name": "Removed",
+        "description": "These rules from older versions of ESLint (before the <a href=\"/docs/user-guide/rule-deprecation\">deprecation policy</a> existed) have been replaced by newer rules:",
+        "rules": [
+            { "removed": "generator-star", "replacedBy": ["generator-star-spacing"] },
+            { "removed": "global-strict", "replacedBy": ["strict"] },
+            { "removed": "no-arrow-condition", "replacedBy": ["no-confusing-arrow", "no-constant-condition"] },
+            { "removed": "no-comma-dangle", "replacedBy": ["comma-dangle"] },
+            { "removed": "no-empty-class", "replacedBy": ["no-empty-character-class"] },
+            { "removed": "no-empty-label", "replacedBy": ["no-labels"] },
+            { "removed": "no-extra-strict", "replacedBy": ["strict"] },
+            { "removed": "no-reserved-keys", "replacedBy": ["quote-props"] },
+            { "removed": "no-space-before-semi", "replacedBy": ["semi-spacing"] },
+            { "removed": "no-wrap-func", "replacedBy": ["no-extra-parens"] },
+            { "removed": "space-after-function-name", "replacedBy": ["space-before-function-paren"] },
+            { "removed": "space-after-keywords", "replacedBy": ["keyword-spacing"] },
+            { "removed": "space-before-function-parentheses", "replacedBy": ["space-before-function-paren"] },
+            { "removed": "space-before-keywords", "replacedBy": ["keyword-spacing"] },
+            { "removed": "space-in-brackets", "replacedBy": ["object-curly-spacing", "array-bracket-spacing"] },
+            { "removed": "space-return-throw-case", "replacedBy": ["keyword-spacing"] },
+            { "removed": "space-unary-word-ops", "replacedBy": ["space-unary-ops"] },
+            { "removed": "spaced-line-comment", "replacedBy": ["spaced-comment"] }
+        ]
+    }
+}

node_modules/@eslint/eslintrc/conf/config-schema.js

@@ -0,0 +1,81 @@
+/**
+ * @fileoverview Defines a schema for configs.
+ * @author Sylvan Mably
+ */
+
+"use strict";
+
+const baseConfigProperties = {
+    $schema: { type: "string" },
+    env: { type: "object" },
+    extends: { $ref: "#/definitions/stringOrStrings" },
+    globals: { type: "object" },
+    overrides: {
+        type: "array",
+        items: { $ref: "#/definitions/overrideConfig" },
+        additionalItems: false
+    },
+    parser: { type: ["string", "null"] },
+    parserOptions: { type: "object" },
+    plugins: { type: "array" },
+    processor: { type: "string" },
+    rules: { type: "object" },
+    settings: { type: "object" },
+    noInlineConfig: { type: "boolean" },
+    reportUnusedDisableDirectives: { type: "boolean" },
+
+    ecmaFeatures: { type: "object" } // deprecated; logs a warning when used
+};
+
+const configSchema = {
+    definitions: {
+        stringOrStrings: {
+            oneOf: [
+                { type: "string" },
+                {
+                    type: "array",
+                    items: { type: "string" },
+                    additionalItems: false
+                }
+            ]
+        },
+        stringOrStringsRequired: {
+            oneOf: [
+                { type: "string" },
+                {
+                    type: "array",
+                    items: { type: "string" },
+                    additionalItems: false,
+                    minItems: 1
+                }
+            ]
+        },
+
+        // Config at top-level.
+        objectConfig: {
+            type: "object",
+            properties: {
+                root: { type: "boolean" },
+                ignorePatterns: { $ref: "#/definitions/stringOrStrings" },
+                ...baseConfigProperties
+            },
+            additionalProperties: false
+        },
+
+        // Config in `overrides`.
+        overrideConfig: {
+            type: "object",
+            properties: {
+                excludedFiles: { $ref: "#/definitions/stringOrStrings" },
+                files: { $ref: "#/definitions/stringOrStringsRequired" },
+                ...baseConfigProperties
+            },
+            required: ["files"],
+            additionalProperties: false
+        }
+    },
+
+    $ref: "#/definitions/objectConfig"
+};
+
+module.exports = configSchema;

node_modules/@eslint/eslintrc/conf/default-cli-options.js

@@ -0,0 +1,31 @@
+/**
+ * @fileoverview Default CLIEngineOptions.
+ * @author Ian VanSchooten
+ */
+
+"use strict";
+
+module.exports = {
+    configFile: null,
+    baseConfig: false,
+    rulePaths: [],
+    useEslintrc: true,
+    envs: [],
+    globals: [],
+    extensions: null,
+    ignore: true,
+    ignorePath: void 0,
+    cache: false,
+
+    /*
+     * in order to honor the cacheFile option if specified
+     * this option should not have a default value otherwise
+     * it will always be used
+     */
+    cacheLocation: "",
+    cacheFile: ".eslintcache",
+    fix: false,
+    allowInlineConfig: true,
+    reportUnusedDisableDirectives: void 0,
+    globInputPaths: true
+};

node_modules/@eslint/eslintrc/conf/environments.js

@@ -0,0 +1,179 @@
+/**
+ * @fileoverview Defines environment settings and globals.
+ * @author Elan Shanker
+ */
+"use strict";
+
+//------------------------------------------------------------------------------
+// Requirements
+//------------------------------------------------------------------------------
+
+const globals = require("globals");
+
+//------------------------------------------------------------------------------
+// Helpers
+//------------------------------------------------------------------------------
+
+/**
+ * Get the object that has difference.
+ * @param {Record<string,boolean>} current The newer object.
+ * @param {Record<string,boolean>} prev The older object.
+ * @returns {Record<string,boolean>} The difference object.
+ */
+function getDiff(current, prev) {
+    const retv = {};
+
+    for (const [key, value] of Object.entries(current)) {
+        if (!Object.hasOwnProperty.call(prev, key)) {
+            retv[key] = value;
+        }
+    }
+
+    return retv;
+}
+
+const newGlobals2015 = getDiff(globals.es2015, globals.es5); // 19 variables such as Promise, Map, ...
+const newGlobals2017 = {
+    Atomics: false,
+    SharedArrayBuffer: false
+};
+const newGlobals2020 = {
+    BigInt: false,
+    BigInt64Array: false,
+    BigUint64Array: false,
+    globalThis: false
+};
+
+const newGlobals2021 = {
+    FinalizationRegistry: false,
+    WeakRef: false
+};
+
+//------------------------------------------------------------------------------
+// Public Interface
+//------------------------------------------------------------------------------
+
+/** @type {Map<string, import("../lib/shared/types").Environment>} */
+module.exports = new Map(Object.entries({
+
+    // Language
+    builtin: {
+        globals: globals.es5
+    },
+    es6: {
+        globals: newGlobals2015,
+        parserOptions: {
+            ecmaVersion: 6
+        }
+    },
+    es2015: {
+        globals: newGlobals2015,
+        parserOptions: {
+            ecmaVersion: 6
+        }
+    },
+    es2017: {
+        globals: { ...newGlobals2015, ...newGlobals2017 },
+        parserOptions: {
+            ecmaVersion: 8
+        }
+    },
+    es2020: {
+        globals: { ...newGlobals2015, ...newGlobals2017, ...newGlobals2020 },
+        parserOptions: {
+            ecmaVersion: 11
+        }
+    },
+    es2021: {
+        globals: { ...newGlobals2015, ...newGlobals2017, ...newGlobals2020, ...newGlobals2021 },
+        parserOptions: {
+            ecmaVersion: 12
+        }
+    },
+
+    // Platforms
+    browser: {
+        globals: globals.browser
+    },
+    node: {
+        globals: globals.node,
+        parserOptions: {
+            ecmaFeatures: {
+                globalReturn: true
+            }
+        }
+    },
+    "shared-node-browser": {
+        globals: globals["shared-node-browser"]
+    },
+    worker: {
+        globals: globals.worker
+    },
+    serviceworker: {
+        globals: globals.serviceworker
+    },
+
+    // Frameworks
+    commonjs: {
+        globals: globals.commonjs,
+        parserOptions: {
+            ecmaFeatures: {
+                globalReturn: true
+            }
+        }
+    },
+    amd: {
+        globals: globals.amd
+    },
+    mocha: {
+        globals: globals.mocha
+    },
+    jasmine: {
+        globals: globals.jasmine
+    },
+    jest: {
+        globals: globals.jest
+    },
+    phantomjs: {
+        globals: globals.phantomjs
+    },
+    jquery: {
+        globals: globals.jquery
+    },
+    qunit: {
+        globals: globals.qunit
+    },
+    prototypejs: {
+        globals: globals.prototypejs
+    },
+    shelljs: {
+        globals: globals.shelljs
+    },
+    meteor: {
+        globals: globals.meteor
+    },
+    mongo: {
+        globals: globals.mongo
+    },
+    protractor: {
+        globals: globals.protractor
+    },
+    applescript: {
+        globals: globals.applescript
+    },
+    nashorn: {
+        globals: globals.nashorn
+    },
+    atomtest: {
+        globals: globals.atomtest
+    },
+    embertest: {
+        globals: globals.embertest
+    },
+    webextensions: {
+        globals: globals.webextensions
+    },
+    greasemonkey: {
+        globals: globals.greasemonkey
+    }
+}));

node_modules/@eslint/eslintrc/conf/eslint-all.js

@@ -0,0 +1,32 @@
+/**
+ * @fileoverview Config to enable all rules.
+ * @author Robert Fletcher
+ */
+
+"use strict";
+
+//------------------------------------------------------------------------------
+// Requirements
+//------------------------------------------------------------------------------
+
+// FIXME: "../lib/rules" doesn't exist in this package
+const builtInRules = require("../lib/rules");
+
+//------------------------------------------------------------------------------
+// Helpers
+//------------------------------------------------------------------------------
+
+const allRules = {};
+
+for (const [ruleId, rule] of builtInRules) {
+    if (!rule.meta.deprecated) {
+        allRules[ruleId] = "error";
+    }
+}
+
+//------------------------------------------------------------------------------
+// Public Interface
+//------------------------------------------------------------------------------
+
+/** @type {import("../lib/shared/types").ConfigData} */
+module.exports = { rules: allRules };

node_modules/@eslint/eslintrc/conf/eslint-recommended.js

@@ -0,0 +1,72 @@
+/**
+ * @fileoverview Configuration applied when a user configuration extends from
+ * eslint:recommended.
+ * @author Nicholas C. Zakas
+ */
+
+"use strict";
+
+/* eslint sort-keys: ["error", "asc"] */
+
+/** @type {import("../lib/shared/types").ConfigData} */
+module.exports = {
+    rules: {
+        "constructor-super": "error",
+        "for-direction": "error",
+        "getter-return": "error",
+        "no-async-promise-executor": "error",
+        "no-case-declarations": "error",
+        "no-class-assign": "error",
+        "no-compare-neg-zero": "error",
+        "no-cond-assign": "error",
+        "no-const-assign": "error",
+        "no-constant-condition": "error",
+        "no-control-regex": "error",
+        "no-debugger": "error",
+        "no-delete-var": "error",
+        "no-dupe-args": "error",
+        "no-dupe-class-members": "error",
+        "no-dupe-else-if": "error",
+        "no-dupe-keys": "error",
+        "no-duplicate-case": "error",
+        "no-empty": "error",
+        "no-empty-character-class": "error",
+        "no-empty-pattern": "error",
+        "no-ex-assign": "error",
+        "no-extra-boolean-cast": "error",
+        "no-extra-semi": "error",
+        "no-fallthrough": "error",
+        "no-func-assign": "error",
+        "no-global-assign": "error",
+        "no-import-assign": "error",
+        "no-inner-declarations": "error",
+        "no-invalid-regexp": "error",
+        "no-irregular-whitespace": "error",
+        "no-misleading-character-class": "error",
+        "no-mixed-spaces-and-tabs": "error",
+        "no-new-symbol": "error",
+        "no-obj-calls": "error",
+        "no-octal": "error",
+        "no-prototype-builtins": "error",
+        "no-redeclare": "error",
+        "no-regex-spaces": "error",
+        "no-self-assign": "error",
+        "no-setter-return": "error",
+        "no-shadow-restricted-names": "error",
+        "no-sparse-arrays": "error",
+        "no-this-before-super": "error",
+        "no-undef": "error",
+        "no-unexpected-multiline": "error",
+        "no-unreachable": "error",
+        "no-unsafe-finally": "error",
+        "no-unsafe-negation": "error",
+        "no-unused-labels": "error",
+        "no-unused-vars": "error",
+        "no-useless-catch": "error",
+        "no-useless-escape": "error",
+        "no-with": "error",
+        "require-yield": "error",
+        "use-isnan": "error",
+        "valid-typeof": "error"
+    }
+};

node_modules/@eslint/eslintrc/conf/replacements.json

@@ -0,0 +1,22 @@
+{
+    "rules": {
+        "generator-star": ["generator-star-spacing"],
+        "global-strict": ["strict"],
+        "no-arrow-condition": ["no-confusing-arrow", "no-constant-condition"],
+        "no-comma-dangle": ["comma-dangle"],
+        "no-empty-class": ["no-empty-character-class"],
+        "no-empty-label": ["no-labels"],
+        "no-extra-strict": ["strict"],
+        "no-reserved-keys": ["quote-props"],
+        "no-space-before-semi": ["semi-spacing"],
+        "no-wrap-func": ["no-extra-parens"],
+        "space-after-function-name": ["space-before-function-paren"],
+        "space-after-keywords": ["keyword-spacing"],
+        "space-before-function-parentheses": ["space-before-function-paren"],
+        "space-before-keywords": ["keyword-spacing"],
+        "space-in-brackets": ["object-curly-spacing", "array-bracket-spacing", "computed-property-spacing"],
+        "space-return-throw-case": ["keyword-spacing"],
+        "space-unary-word-ops": ["space-unary-ops"],
+        "spaced-line-comment": ["spaced-comment"]
+    }
+}

node_modules/@eslint/eslintrc/lib/cascading-config-array-factory.js

@@ -0,0 +1,501 @@
+/**
+ * @fileoverview `CascadingConfigArrayFactory` class.
+ *
+ * `CascadingConfigArrayFactory` class has a responsibility:
+ *
+ * 1. Handles cascading of config files.
+ *
+ * It provides two methods:
+ *
+ * - `getConfigArrayForFile(filePath)`
+ *     Get the corresponded configuration of a given file. This method doesn't
+ *     throw even if the given file didn't exist.
+ * - `clearCache()`
+ *     Clear the internal cache. You have to call this method when
+ *     `additionalPluginPool` was updated if `baseConfig` or `cliConfig` depends
+ *     on the additional plugins. (`CLIEngine#addPlugin()` method calls this.)
+ *
+ * @author Toru Nagashima <https://github.com/mysticatea>
+ */
+"use strict";
+
+//------------------------------------------------------------------------------
+// Requirements
+//------------------------------------------------------------------------------
+
+const os = require("os");
+const path = require("path");
+const ConfigValidator = require("./shared/config-validator");
+const { emitDeprecationWarning } = require("./shared/deprecation-warnings");
+const { ConfigArrayFactory } = require("./config-array-factory");
+const { ConfigArray, ConfigDependency, IgnorePattern } = require("./config-array");
+const debug = require("debug")("eslintrc:cascading-config-array-factory");
+
+//------------------------------------------------------------------------------
+// Helpers
+//------------------------------------------------------------------------------
+
+// Define types for VSCode IntelliSense.
+/** @typedef {import("../shared/types").ConfigData} ConfigData */
+/** @typedef {import("../shared/types").Parser} Parser */
+/** @typedef {import("../shared/types").Plugin} Plugin */
+/** @typedef {ReturnType<ConfigArrayFactory["create"]>} ConfigArray */
+
+/**
+ * @typedef {Object} CascadingConfigArrayFactoryOptions
+ * @property {Map<string,Plugin>} [additionalPluginPool] The map for additional plugins.
+ * @property {ConfigData} [baseConfig] The config by `baseConfig` option.
+ * @property {ConfigData} [cliConfig] The config by CLI options (`--env`, `--global`, `--ignore-pattern`, `--parser`, `--parser-options`, `--plugin`, and `--rule`). CLI options overwrite the setting in config files.
+ * @property {string} [cwd] The base directory to start lookup.
+ * @property {string} [ignorePath] The path to the alternative file of `.eslintignore`.
+ * @property {string[]} [rulePaths] The value of `--rulesdir` option.
+ * @property {string} [specificConfigPath] The value of `--config` option.
+ * @property {boolean} [useEslintrc] if `false` then it doesn't load config files.
+ */
+
+/**
+ * @typedef {Object} CascadingConfigArrayFactoryInternalSlots
+ * @property {ConfigArray} baseConfigArray The config array of `baseConfig` option.
+ * @property {ConfigData} baseConfigData The config data of `baseConfig` option. This is used to reset `baseConfigArray`.
+ * @property {ConfigArray} cliConfigArray The config array of CLI options.
+ * @property {ConfigData} cliConfigData The config data of CLI options. This is used to reset `cliConfigArray`.
+ * @property {ConfigArrayFactory} configArrayFactory The factory for config arrays.
+ * @property {Map<string, ConfigArray>} configCache The cache from directory paths to config arrays.
+ * @property {string} cwd The base directory to start lookup.
+ * @property {WeakMap<ConfigArray, ConfigArray>} finalizeCache The cache from config arrays to finalized config arrays.
+ * @property {string} [ignorePath] The path to the alternative file of `.eslintignore`.
+ * @property {string[]|null} rulePaths The value of `--rulesdir` option. This is used to reset `baseConfigArray`.
+ * @property {string|null} specificConfigPath The value of `--config` option. This is used to reset `cliConfigArray`.
+ * @property {boolean} useEslintrc if `false` then it doesn't load config files.
+ */
+
+/** @type {WeakMap<CascadingConfigArrayFactory, CascadingConfigArrayFactoryInternalSlots>} */
+const internalSlotsMap = new WeakMap();
+
+/**
+ * Create the config array from `baseConfig` and `rulePaths`.
+ * @param {CascadingConfigArrayFactoryInternalSlots} slots The slots.
+ * @returns {ConfigArray} The config array of the base configs.
+ */
+function createBaseConfigArray({
+    configArrayFactory,
+    baseConfigData,
+    rulePaths,
+    cwd,
+    loadRules
+}) {
+    const baseConfigArray = configArrayFactory.create(
+        baseConfigData,
+        { name: "BaseConfig" }
+    );
+
+    /*
+     * Create the config array element for the default ignore patterns.
+     * This element has `ignorePattern` property that ignores the default
+     * patterns in the current working directory.
+     */
+    baseConfigArray.unshift(configArrayFactory.create(
+        { ignorePatterns: IgnorePattern.DefaultPatterns },
+        { name: "DefaultIgnorePattern" }
+    )[0]);
+
+    /*
+     * Load rules `--rulesdir` option as a pseudo plugin.
+     * Use a pseudo plugin to define rules of `--rulesdir`, so we can validate
+     * the rule's options with only information in the config array.
+     */
+    if (rulePaths && rulePaths.length > 0) {
+        baseConfigArray.push({
+            type: "config",
+            name: "--rulesdir",
+            filePath: "",
+            plugins: {
+                "": new ConfigDependency({
+                    definition: {
+                        rules: rulePaths.reduce(
+                            (map, rulesPath) => Object.assign(
+                                map,
+                                loadRules(rulesPath, cwd)
+                            ),
+                            {}
+                        )
+                    },
+                    filePath: "",
+                    id: "",
+                    importerName: "--rulesdir",
+                    importerPath: ""
+                })
+            }
+        });
+    }
+
+    return baseConfigArray;
+}
+
+/**
+ * Create the config array from CLI options.
+ * @param {CascadingConfigArrayFactoryInternalSlots} slots The slots.
+ * @returns {ConfigArray} The config array of the base configs.
+ */
+function createCLIConfigArray({
+    cliConfigData,
+    configArrayFactory,
+    cwd,
+    ignorePath,
+    specificConfigPath
+}) {
+    const cliConfigArray = configArrayFactory.create(
+        cliConfigData,
+        { name: "CLIOptions" }
+    );
+
+    cliConfigArray.unshift(
+        ...(ignorePath
+            ? configArrayFactory.loadESLintIgnore(ignorePath)
+            : configArrayFactory.loadDefaultESLintIgnore())
+    );
+
+    if (specificConfigPath) {
+        cliConfigArray.unshift(
+            ...configArrayFactory.loadFile(
+                specificConfigPath,
+                { name: "--config", basePath: cwd }
+            )
+        );
+    }
+
+    return cliConfigArray;
+}
+
+/**
+ * The error type when there are files matched by a glob, but all of them have been ignored.
+ */
+class ConfigurationNotFoundError extends Error {
+
+    // eslint-disable-next-line jsdoc/require-description
+    /**
+     * @param {string} directoryPath The directory path.
+     */
+    constructor(directoryPath) {
+        super(`No ESLint configuration found in ${directoryPath}.`);
+        this.messageTemplate = "no-config-found";
+        this.messageData = { directoryPath };
+    }
+}
+
+/**
+ * This class provides the functionality that enumerates every file which is
+ * matched by given glob patterns and that configuration.
+ */
+class CascadingConfigArrayFactory {
+
+    /**
+     * Initialize this enumerator.
+     * @param {CascadingConfigArrayFactoryOptions} options The options.
+     */
+    constructor({
+        additionalPluginPool = new Map(),
+        baseConfig: baseConfigData = null,
+        cliConfig: cliConfigData = null,
+        cwd = process.cwd(),
+        ignorePath,
+        resolvePluginsRelativeTo,
+        rulePaths = [],
+        specificConfigPath = null,
+        useEslintrc = true,
+        builtInRules = new Map(),
+        loadRules,
+        resolver
+    } = {}) {
+        const configArrayFactory = new ConfigArrayFactory({
+            additionalPluginPool,
+            cwd,
+            resolvePluginsRelativeTo,
+            builtInRules,
+            resolver
+        });
+
+        internalSlotsMap.set(this, {
+            baseConfigArray: createBaseConfigArray({
+                baseConfigData,
+                configArrayFactory,
+                cwd,
+                rulePaths,
+                loadRules,
+                resolver
+            }),
+            baseConfigData,
+            cliConfigArray: createCLIConfigArray({
+                cliConfigData,
+                configArrayFactory,
+                cwd,
+                ignorePath,
+                specificConfigPath
+            }),
+            cliConfigData,
+            configArrayFactory,
+            configCache: new Map(),
+            cwd,
+            finalizeCache: new WeakMap(),
+            ignorePath,
+            rulePaths,
+            specificConfigPath,
+            useEslintrc
+        });
+    }
+
+    /**
+     * The path to the current working directory.
+     * This is used by tests.
+     * @type {string}
+     */
+    get cwd() {
+        const { cwd } = internalSlotsMap.get(this);
+
+        return cwd;
+    }
+
+    /**
+     * Get the config array of a given file.
+     * If `filePath` was not given, it returns the config which contains only
+     * `baseConfigData` and `cliConfigData`.
+     * @param {string} [filePath] The file path to a file.
+     * @param {Object} [options] The options.
+     * @param {boolean} [options.ignoreNotFoundError] If `true` then it doesn't throw `ConfigurationNotFoundError`.
+     * @returns {ConfigArray} The config array of the file.
+     */
+    getConfigArrayForFile(filePath, { ignoreNotFoundError = false } = {}) {
+        const {
+            baseConfigArray,
+            cliConfigArray,
+            cwd
+        } = internalSlotsMap.get(this);
+
+        if (!filePath) {
+            return new ConfigArray(...baseConfigArray, ...cliConfigArray);
+        }
+
+        const directoryPath = path.dirname(path.resolve(cwd, filePath));
+
+        debug(`Load config files for ${directoryPath}.`);
+
+        return this._finalizeConfigArray(
+            this._loadConfigInAncestors(directoryPath),
+            directoryPath,
+            ignoreNotFoundError
+        );
+    }
+
+    /**
+     * Set the config data to override all configs.
+     * Require to call `clearCache()` method after this method is called.
+     * @param {ConfigData} configData The config data to override all configs.
+     * @returns {void}
+     */
+    setOverrideConfig(configData) {
+        const slots = internalSlotsMap.get(this);
+
+        slots.cliConfigData = configData;
+    }
+
+    /**
+     * Clear config cache.
+     * @returns {void}
+     */
+    clearCache() {
+        const slots = internalSlotsMap.get(this);
+
+        slots.baseConfigArray = createBaseConfigArray(slots);
+        slots.cliConfigArray = createCLIConfigArray(slots);
+        slots.configCache.clear();
+    }
+
+    /**
+     * Load and normalize config files from the ancestor directories.
+     * @param {string} directoryPath The path to a leaf directory.
+     * @param {boolean} configsExistInSubdirs `true` if configurations exist in subdirectories.
+     * @returns {ConfigArray} The loaded config.
+     * @private
+     */
+    _loadConfigInAncestors(directoryPath, configsExistInSubdirs = false) {
+        const {
+            baseConfigArray,
+            configArrayFactory,
+            configCache,
+            cwd,
+            useEslintrc
+        } = internalSlotsMap.get(this);
+
+        if (!useEslintrc) {
+            return baseConfigArray;
+        }
+
+        let configArray = configCache.get(directoryPath);
+
+        // Hit cache.
+        if (configArray) {
+            debug(`Cache hit: ${directoryPath}.`);
+            return configArray;
+        }
+        debug(`No cache found: ${directoryPath}.`);
+
+        const homePath = os.homedir();
+
+        // Consider this is root.
+        if (directoryPath === homePath && cwd !== homePath) {
+            debug("Stop traversing because of considered root.");
+            if (configsExistInSubdirs) {
+                const filePath = ConfigArrayFactory.getPathToConfigFileInDirectory(directoryPath);
+
+                if (filePath) {
+                    emitDeprecationWarning(
+                        filePath,
+                        "ESLINT_PERSONAL_CONFIG_SUPPRESS"
+                    );
+                }
+            }
+            return this._cacheConfig(directoryPath, baseConfigArray);
+        }
+
+        // Load the config on this directory.
+        try {
+            configArray = configArrayFactory.loadInDirectory(directoryPath);
+        } catch (error) {
+            /* istanbul ignore next */
+            if (error.code === "EACCES") {
+                debug("Stop traversing because of 'EACCES' error.");
+                return this._cacheConfig(directoryPath, baseConfigArray);
+            }
+            throw error;
+        }
+
+        if (configArray.length > 0 && configArray.isRoot()) {
+            debug("Stop traversing because of 'root:true'.");
+            configArray.unshift(...baseConfigArray);
+            return this._cacheConfig(directoryPath, configArray);
+        }
+
+        // Load from the ancestors and merge it.
+        const parentPath = path.dirname(directoryPath);
+        const parentConfigArray = parentPath && parentPath !== directoryPath
+            ? this._loadConfigInAncestors(
+                parentPath,
+                configsExistInSubdirs || configArray.length > 0
+            )
+            : baseConfigArray;
+
+        if (configArray.length > 0) {
+            configArray.unshift(...parentConfigArray);
+        } else {
+            configArray = parentConfigArray;
+        }
+
+        // Cache and return.
+        return this._cacheConfig(directoryPath, configArray);
+    }
+
+    /**
+     * Freeze and cache a given config.
+     * @param {string} directoryPath The path to a directory as a cache key.
+     * @param {ConfigArray} configArray The config array as a cache value.
+     * @returns {ConfigArray} The `configArray` (frozen).
+     */
+    _cacheConfig(directoryPath, configArray) {
+        const { configCache } = internalSlotsMap.get(this);
+
+        Object.freeze(configArray);
+        configCache.set(directoryPath, configArray);
+
+        return configArray;
+    }
+
+    /**
+     * Finalize a given config array.
+     * Concatenate `--config` and other CLI options.
+     * @param {ConfigArray} configArray The parent config array.
+     * @param {string} directoryPath The path to the leaf directory to find config files.
+     * @param {boolean} ignoreNotFoundError If `true` then it doesn't throw `ConfigurationNotFoundError`.
+     * @returns {ConfigArray} The loaded config.
+     * @private
+     */
+    _finalizeConfigArray(configArray, directoryPath, ignoreNotFoundError) {
+        const {
+            cliConfigArray,
+            configArrayFactory,
+            finalizeCache,
+            useEslintrc
+        } = internalSlotsMap.get(this);
+
+        let finalConfigArray = finalizeCache.get(configArray);
+
+        if (!finalConfigArray) {
+            finalConfigArray = configArray;
+
+            // Load the personal config if there are no regular config files.
+            if (
+                useEslintrc &&
+                configArray.every(c => !c.filePath) &&
+                cliConfigArray.every(c => !c.filePath) // `--config` option can be a file.
+            ) {
+                const homePath = os.homedir();
+
+                debug("Loading the config file of the home directory:", homePath);
+
+                const personalConfigArray = configArrayFactory.loadInDirectory(
+                    homePath,
+                    { name: "PersonalConfig" }
+                );
+
+                if (
+                    personalConfigArray.length > 0 &&
+                    !directoryPath.startsWith(homePath)
+                ) {
+                    const lastElement =
+                        personalConfigArray[personalConfigArray.length - 1];
+
+                    emitDeprecationWarning(
+                        lastElement.filePath,
+                        "ESLINT_PERSONAL_CONFIG_LOAD"
+                    );
+                }
+
+                finalConfigArray = finalConfigArray.concat(personalConfigArray);
+            }
+
+            // Apply CLI options.
+            if (cliConfigArray.length > 0) {
+                finalConfigArray = finalConfigArray.concat(cliConfigArray);
+            }
+
+            // Validate rule settings and environments.
+            const validator = new ConfigValidator({
+                builtInRules: configArrayFactory.builtInRules
+            });
+
+            validator.validateConfigArray(finalConfigArray);
+
+            // Cache it.
+            Object.freeze(finalConfigArray);
+            finalizeCache.set(configArray, finalConfigArray);
+
+            debug(
+                "Configuration was determined: %o on %s",
+                finalConfigArray,
+                directoryPath
+            );
+        }
+
+        // At least one element (the default ignore patterns) exists.
+        if (!ignoreNotFoundError && useEslintrc && finalConfigArray.length <= 1) {
+            throw new ConfigurationNotFoundError(directoryPath);
+        }
+
+        return finalConfigArray;
+    }
+}
+
+//------------------------------------------------------------------------------
+// Public Interface
+//------------------------------------------------------------------------------
+
+module.exports = { CascadingConfigArrayFactory };

node_modules/@eslint/eslintrc/lib/config-array/config-array.js

@@ -0,0 +1,524 @@
+/**
+ * @fileoverview `ConfigArray` class.
+ *
+ * `ConfigArray` class expresses the full of a configuration. It has the entry
+ * config file, base config files that were extended, loaded parsers, and loaded
+ * plugins.
+ *
+ * `ConfigArray` class provides three properties and two methods.
+ *
+ * - `pluginEnvironments`
+ * - `pluginProcessors`
+ * - `pluginRules`
+ *      The `Map` objects that contain the members of all plugins that this
+ *      config array contains. Those map objects don't have mutation methods.
+ *      Those keys are the member ID such as `pluginId/memberName`.
+ * - `isRoot()`
+ *      If `true` then this configuration has `root:true` property.
+ * - `extractConfig(filePath)`
+ *      Extract the final configuration for a given file. This means merging
+ *      every config array element which that `criteria` property matched. The
+ *      `filePath` argument must be an absolute path.
+ *
+ * `ConfigArrayFactory` provides the loading logic of config files.
+ *
+ * @author Toru Nagashima <https://github.com/mysticatea>
+ */
+"use strict";
+
+//------------------------------------------------------------------------------
+// Requirements
+//------------------------------------------------------------------------------
+
+const { ExtractedConfig } = require("./extracted-config");
+const { IgnorePattern } = require("./ignore-pattern");
+
+//------------------------------------------------------------------------------
+// Helpers
+//------------------------------------------------------------------------------
+
+// Define types for VSCode IntelliSense.
+/** @typedef {import("../../shared/types").Environment} Environment */
+/** @typedef {import("../../shared/types").GlobalConf} GlobalConf */
+/** @typedef {import("../../shared/types").RuleConf} RuleConf */
+/** @typedef {import("../../shared/types").Rule} Rule */
+/** @typedef {import("../../shared/types").Plugin} Plugin */
+/** @typedef {import("../../shared/types").Processor} Processor */
+/** @typedef {import("./config-dependency").DependentParser} DependentParser */
+/** @typedef {import("./config-dependency").DependentPlugin} DependentPlugin */
+/** @typedef {import("./override-tester")["OverrideTester"]} OverrideTester */
+
+/**
+ * @typedef {Object} ConfigArrayElement
+ * @property {string} name The name of this config element.
+ * @property {string} filePath The path to the source file of this config element.
+ * @property {InstanceType<OverrideTester>|null} criteria The tester for the `files` and `excludedFiles` of this config element.
+ * @property {Record<string, boolean>|undefined} env The environment settings.
+ * @property {Record<string, GlobalConf>|undefined} globals The global variable settings.
+ * @property {IgnorePattern|undefined} ignorePattern The ignore patterns.
+ * @property {boolean|undefined} noInlineConfig The flag that disables directive comments.
+ * @property {DependentParser|undefined} parser The parser loader.
+ * @property {Object|undefined} parserOptions The parser options.
+ * @property {Record<string, DependentPlugin>|undefined} plugins The plugin loaders.
+ * @property {string|undefined} processor The processor name to refer plugin's processor.
+ * @property {boolean|undefined} reportUnusedDisableDirectives The flag to report unused `eslint-disable` comments.
+ * @property {boolean|undefined} root The flag to express root.
+ * @property {Record<string, RuleConf>|undefined} rules The rule settings
+ * @property {Object|undefined} settings The shared settings.
+ * @property {"config" | "ignore" | "implicit-processor"} type The element type.
+ */
+
+/**
+ * @typedef {Object} ConfigArrayInternalSlots
+ * @property {Map<string, ExtractedConfig>} cache The cache to extract configs.
+ * @property {ReadonlyMap<string, Environment>|null} envMap The map from environment ID to environment definition.
+ * @property {ReadonlyMap<string, Processor>|null} processorMap The map from processor ID to environment definition.
+ * @property {ReadonlyMap<string, Rule>|null} ruleMap The map from rule ID to rule definition.
+ */
+
+/** @type {WeakMap<ConfigArray, ConfigArrayInternalSlots>} */
+const internalSlotsMap = new class extends WeakMap {
+    get(key) {
+        let value = super.get(key);
+
+        if (!value) {
+            value = {
+                cache: new Map(),
+                envMap: null,
+                processorMap: null,
+                ruleMap: null
+            };
+            super.set(key, value);
+        }
+
+        return value;
+    }
+}();
+
+/**
+ * Get the indices which are matched to a given file.
+ * @param {ConfigArrayElement[]} elements The elements.
+ * @param {string} filePath The path to a target file.
+ * @returns {number[]} The indices.
+ */
+function getMatchedIndices(elements, filePath) {
+    const indices = [];
+
+    for (let i = elements.length - 1; i >= 0; --i) {
+        const element = elements[i];
+
+        if (!element.criteria || (filePath && element.criteria.test(filePath))) {
+            indices.push(i);
+        }
+    }
+
+    return indices;
+}
+
+/**
+ * Check if a value is a non-null object.
+ * @param {any} x The value to check.
+ * @returns {boolean} `true` if the value is a non-null object.
+ */
+function isNonNullObject(x) {
+    return typeof x === "object" && x !== null;
+}
+
+/**
+ * Merge two objects.
+ *
+ * Assign every property values of `y` to `x` if `x` doesn't have the property.
+ * If `x`'s property value is an object, it does recursive.
+ * @param {Object} target The destination to merge
+ * @param {Object|undefined} source The source to merge.
+ * @returns {void}
+ */
+function mergeWithoutOverwrite(target, source) {
+    if (!isNonNullObject(source)) {
+        return;
+    }
+
+    for (const key of Object.keys(source)) {
+        if (key === "__proto__") {
+            continue;
+        }
+
+        if (isNonNullObject(target[key])) {
+            mergeWithoutOverwrite(target[key], source[key]);
+        } else if (target[key] === void 0) {
+            if (isNonNullObject(source[key])) {
+                target[key] = Array.isArray(source[key]) ? [] : {};
+                mergeWithoutOverwrite(target[key], source[key]);
+            } else if (source[key] !== void 0) {
+                target[key] = source[key];
+            }
+        }
+    }
+}
+
+/**
+ * The error for plugin conflicts.
+ */
+class PluginConflictError extends Error {
+
+    /**
+     * Initialize this error object.
+     * @param {string} pluginId The plugin ID.
+     * @param {{filePath:string, importerName:string}[]} plugins The resolved plugins.
+     */
+    constructor(pluginId, plugins) {
+        super(`Plugin "${pluginId}" was conflicted between ${plugins.map(p => `"${p.importerName}"`).join(" and ")}.`);
+        this.messageTemplate = "plugin-conflict";
+        this.messageData = { pluginId, plugins };
+    }
+}
+
+/**
+ * Merge plugins.
+ * `target`'s definition is prior to `source`'s.
+ * @param {Record<string, DependentPlugin>} target The destination to merge
+ * @param {Record<string, DependentPlugin>|undefined} source The source to merge.
+ * @returns {void}
+ */
+function mergePlugins(target, source) {
+    if (!isNonNullObject(source)) {
+        return;
+    }
+
+    for (const key of Object.keys(source)) {
+        if (key === "__proto__") {
+            continue;
+        }
+        const targetValue = target[key];
+        const sourceValue = source[key];
+
+        // Adopt the plugin which was found at first.
+        if (targetValue === void 0) {
+            if (sourceValue.error) {
+                throw sourceValue.error;
+            }
+            target[key] = sourceValue;
+        } else if (sourceValue.filePath !== targetValue.filePath) {
+            throw new PluginConflictError(key, [
+                {
+                    filePath: targetValue.filePath,
+                    importerName: targetValue.importerName
+                },
+                {
+                    filePath: sourceValue.filePath,
+                    importerName: sourceValue.importerName
+                }
+            ]);
+        }
+    }
+}
+
+/**
+ * Merge rule configs.
+ * `target`'s definition is prior to `source`'s.
+ * @param {Record<string, Array>} target The destination to merge
+ * @param {Record<string, RuleConf>|undefined} source The source to merge.
+ * @returns {void}
+ */
+function mergeRuleConfigs(target, source) {
+    if (!isNonNullObject(source)) {
+        return;
+    }
+
+    for (const key of Object.keys(source)) {
+        if (key === "__proto__") {
+            continue;
+        }
+        const targetDef = target[key];
+        const sourceDef = source[key];
+
+        // Adopt the rule config which was found at first.
+        if (targetDef === void 0) {
+            if (Array.isArray(sourceDef)) {
+                target[key] = [...sourceDef];
+            } else {
+                target[key] = [sourceDef];
+            }
+
+        /*
+         * If the first found rule config is severity only and the current rule
+         * config has options, merge the severity and the options.
+         */
+        } else if (
+            targetDef.length === 1 &&
+            Array.isArray(sourceDef) &&
+            sourceDef.length >= 2
+        ) {
+            targetDef.push(...sourceDef.slice(1));
+        }
+    }
+}
+
+/**
+ * Create the extracted config.
+ * @param {ConfigArray} instance The config elements.
+ * @param {number[]} indices The indices to use.
+ * @returns {ExtractedConfig} The extracted config.
+ */
+function createConfig(instance, indices) {
+    const config = new ExtractedConfig();
+    const ignorePatterns = [];
+
+    // Merge elements.
+    for (const index of indices) {
+        const element = instance[index];
+
+        // Adopt the parser which was found at first.
+        if (!config.parser && element.parser) {
+            if (element.parser.error) {
+                throw element.parser.error;
+            }
+            config.parser = element.parser;
+        }
+
+        // Adopt the processor which was found at first.
+        if (!config.processor && element.processor) {
+            config.processor = element.processor;
+        }
+
+        // Adopt the noInlineConfig which was found at first.
+        if (config.noInlineConfig === void 0 && element.noInlineConfig !== void 0) {
+            config.noInlineConfig = element.noInlineConfig;
+            config.configNameOfNoInlineConfig = element.name;
+        }
+
+        // Adopt the reportUnusedDisableDirectives which was found at first.
+        if (config.reportUnusedDisableDirectives === void 0 && element.reportUnusedDisableDirectives !== void 0) {
+            config.reportUnusedDisableDirectives = element.reportUnusedDisableDirectives;
+        }
+
+        // Collect ignorePatterns
+        if (element.ignorePattern) {
+            ignorePatterns.push(element.ignorePattern);
+        }
+
+        // Merge others.
+        mergeWithoutOverwrite(config.env, element.env);
+        mergeWithoutOverwrite(config.globals, element.globals);
+        mergeWithoutOverwrite(config.parserOptions, element.parserOptions);
+        mergeWithoutOverwrite(config.settings, element.settings);
+        mergePlugins(config.plugins, element.plugins);
+        mergeRuleConfigs(config.rules, element.rules);
+    }
+
+    // Create the predicate function for ignore patterns.
+    if (ignorePatterns.length > 0) {
+        config.ignores = IgnorePattern.createIgnore(ignorePatterns.reverse());
+    }
+
+    return config;
+}
+
+/**
+ * Collect definitions.
+ * @template T, U
+ * @param {string} pluginId The plugin ID for prefix.
+ * @param {Record<string,T>} defs The definitions to collect.
+ * @param {Map<string, U>} map The map to output.
+ * @param {function(T): U} [normalize] The normalize function for each value.
+ * @returns {void}
+ */
+function collect(pluginId, defs, map, normalize) {
+    if (defs) {
+        const prefix = pluginId && `${pluginId}/`;
+
+        for (const [key, value] of Object.entries(defs)) {
+            map.set(
+                `${prefix}${key}`,
+                normalize ? normalize(value) : value
+            );
+        }
+    }
+}
+
+/**
+ * Normalize a rule definition.
+ * @param {Function|Rule} rule The rule definition to normalize.
+ * @returns {Rule} The normalized rule definition.
+ */
+function normalizePluginRule(rule) {
+    return typeof rule === "function" ? { create: rule } : rule;
+}
+
+/**
+ * Delete the mutation methods from a given map.
+ * @param {Map<any, any>} map The map object to delete.
+ * @returns {void}
+ */
+function deleteMutationMethods(map) {
+    Object.defineProperties(map, {
+        clear: { configurable: true, value: void 0 },
+        delete: { configurable: true, value: void 0 },
+        set: { configurable: true, value: void 0 }
+    });
+}
+
+/**
+ * Create `envMap`, `processorMap`, `ruleMap` with the plugins in the config array.
+ * @param {ConfigArrayElement[]} elements The config elements.
+ * @param {ConfigArrayInternalSlots} slots The internal slots.
+ * @returns {void}
+ */
+function initPluginMemberMaps(elements, slots) {
+    const processed = new Set();
+
+    slots.envMap = new Map();
+    slots.processorMap = new Map();
+    slots.ruleMap = new Map();
+
+    for (const element of elements) {
+        if (!element.plugins) {
+            continue;
+        }
+
+        for (const [pluginId, value] of Object.entries(element.plugins)) {
+            const plugin = value.definition;
+
+            if (!plugin || processed.has(pluginId)) {
+                continue;
+            }
+            processed.add(pluginId);
+
+            collect(pluginId, plugin.environments, slots.envMap);
+            collect(pluginId, plugin.processors, slots.processorMap);
+            collect(pluginId, plugin.rules, slots.ruleMap, normalizePluginRule);
+        }
+    }
+
+    deleteMutationMethods(slots.envMap);
+    deleteMutationMethods(slots.processorMap);
+    deleteMutationMethods(slots.ruleMap);
+}
+
+/**
+ * Create `envMap`, `processorMap`, `ruleMap` with the plugins in the config array.
+ * @param {ConfigArray} instance The config elements.
+ * @returns {ConfigArrayInternalSlots} The extracted config.
+ */
+function ensurePluginMemberMaps(instance) {
+    const slots = internalSlotsMap.get(instance);
+
+    if (!slots.ruleMap) {
+        initPluginMemberMaps(instance, slots);
+    }
+
+    return slots;
+}
+
+//------------------------------------------------------------------------------
+// Public Interface
+//------------------------------------------------------------------------------
+
+/**
+ * The Config Array.
+ *
+ * `ConfigArray` instance contains all settings, parsers, and plugins.
+ * You need to call `ConfigArray#extractConfig(filePath)` method in order to
+ * extract, merge and get only the config data which is related to an arbitrary
+ * file.
+ * @extends {Array<ConfigArrayElement>}
+ */
+class ConfigArray extends Array {
+
+    /**
+     * Get the plugin environments.
+     * The returned map cannot be mutated.
+     * @type {ReadonlyMap<string, Environment>} The plugin environments.
+     */
+    get pluginEnvironments() {
+        return ensurePluginMemberMaps(this).envMap;
+    }
+
+    /**
+     * Get the plugin processors.
+     * The returned map cannot be mutated.
+     * @type {ReadonlyMap<string, Processor>} The plugin processors.
+     */
+    get pluginProcessors() {
+        return ensurePluginMemberMaps(this).processorMap;
+    }
+
+    /**
+     * Get the plugin rules.
+     * The returned map cannot be mutated.
+     * @returns {ReadonlyMap<string, Rule>} The plugin rules.
+     */
+    get pluginRules() {
+        return ensurePluginMemberMaps(this).ruleMap;
+    }
+
+    /**
+     * Check if this config has `root` flag.
+     * @returns {boolean} `true` if this config array is root.
+     */
+    isRoot() {
+        for (let i = this.length - 1; i >= 0; --i) {
+            const root = this[i].root;
+
+            if (typeof root === "boolean") {
+                return root;
+            }
+        }
+        return false;
+    }
+
+    /**
+     * Extract the config data which is related to a given file.
+     * @param {string} filePath The absolute path to the target file.
+     * @returns {ExtractedConfig} The extracted config data.
+     */
+    extractConfig(filePath) {
+        const { cache } = internalSlotsMap.get(this);
+        const indices = getMatchedIndices(this, filePath);
+        const cacheKey = indices.join(",");
+
+        if (!cache.has(cacheKey)) {
+            cache.set(cacheKey, createConfig(this, indices));
+        }
+
+        return cache.get(cacheKey);
+    }
+
+    /**
+     * Check if a given path is an additional lint target.
+     * @param {string} filePath The absolute path to the target file.
+     * @returns {boolean} `true` if the file is an additional lint target.
+     */
+    isAdditionalTargetPath(filePath) {
+        for (const { criteria, type } of this) {
+            if (
+                type === "config" &&
+                criteria &&
+                !criteria.endsWithWildcard &&
+                criteria.test(filePath)
+            ) {
+                return true;
+            }
+        }
+        return false;
+    }
+}
+
+const exportObject = {
+    ConfigArray,
+
+    /**
+     * Get the used extracted configs.
+     * CLIEngine will use this method to collect used deprecated rules.
+     * @param {ConfigArray} instance The config array object to get.
+     * @returns {ExtractedConfig[]} The used extracted configs.
+     * @private
+     */
+    getUsedExtractedConfigs(instance) {
+        const { cache } = internalSlotsMap.get(instance);
+
+        return Array.from(cache.values());
+    }
+};
+
+module.exports = exportObject;

node_modules/@eslint/eslintrc/lib/config-array/config-dependency.js

@@ -0,0 +1,116 @@
+/**
+ * @fileoverview `ConfigDependency` class.
+ *
+ * `ConfigDependency` class expresses a loaded parser or plugin.
+ *
+ * If the parser or plugin was loaded successfully, it has `definition` property
+ * and `filePath` property. Otherwise, it has `error` property.
+ *
+ * When `JSON.stringify()` converted a `ConfigDependency` object to a JSON, it
+ * omits `definition` property.
+ *
+ * `ConfigArrayFactory` creates `ConfigDependency` objects when it loads parsers
+ * or plugins.
+ *
+ * @author Toru Nagashima <https://github.com/mysticatea>
+ */
+"use strict";
+
+const util = require("util");
+
+/**
+ * The class is to store parsers or plugins.
+ * This class hides the loaded object from `JSON.stringify()` and `console.log`.
+ * @template T
+ */
+class ConfigDependency {
+
+    /**
+     * Initialize this instance.
+     * @param {Object} data The dependency data.
+     * @param {T} [data.definition] The dependency if the loading succeeded.
+     * @param {Error} [data.error] The error object if the loading failed.
+     * @param {string} [data.filePath] The actual path to the dependency if the loading succeeded.
+     * @param {string} data.id The ID of this dependency.
+     * @param {string} data.importerName The name of the config file which loads this dependency.
+     * @param {string} data.importerPath The path to the config file which loads this dependency.
+     */
+    constructor({
+        definition = null,
+        error = null,
+        filePath = null,
+        id,
+        importerName,
+        importerPath
+    }) {
+
+        /**
+         * The loaded dependency if the loading succeeded.
+         * @type {T|null}
+         */
+        this.definition = definition;
+
+        /**
+         * The error object if the loading failed.
+         * @type {Error|null}
+         */
+        this.error = error;
+
+        /**
+         * The loaded dependency if the loading succeeded.
+         * @type {string|null}
+         */
+        this.filePath = filePath;
+
+        /**
+         * The ID of this dependency.
+         * @type {string}
+         */
+        this.id = id;
+
+        /**
+         * The name of the config file which loads this dependency.
+         * @type {string}
+         */
+        this.importerName = importerName;
+
+        /**
+         * The path to the config file which loads this dependency.
+         * @type {string}
+         */
+        this.importerPath = importerPath;
+    }
+
+    // eslint-disable-next-line jsdoc/require-description
+    /**
+     * @returns {Object} a JSON compatible object.
+     */
+    toJSON() {
+        const obj = this[util.inspect.custom]();
+
+        // Display `error.message` (`Error#message` is unenumerable).
+        if (obj.error instanceof Error) {
+            obj.error = { ...obj.error, message: obj.error.message };
+        }
+
+        return obj;
+    }
+
+    // eslint-disable-next-line jsdoc/require-description
+    /**
+     * @returns {Object} an object to display by `console.log()`.
+     */
+    [util.inspect.custom]() {
+        const {
+            definition: _ignore, // eslint-disable-line no-unused-vars
+            ...obj
+        } = this;
+
+        return obj;
+    }
+}
+
+/** @typedef {ConfigDependency<import("../../shared/types").Parser>} DependentParser */
+/** @typedef {ConfigDependency<import("../../shared/types").Plugin>} DependentPlugin */
+
+module.exports = { ConfigDependency };

node_modules/@eslint/eslintrc/lib/config-array/extracted-config.js

@@ -0,0 +1,146 @@
+/**
+ * @fileoverview `ExtractedConfig` class.
+ *
+ * `ExtractedConfig` class expresses a final configuration for a specific file.
+ *
+ * It provides one method.
+ *
+ * - `toCompatibleObjectAsConfigFileContent()`
+ *      Convert this configuration to the compatible object as the content of
+ *      config files. It converts the loaded parser and plugins to strings.
+ *      `CLIEngine#getConfigForFile(filePath)` method uses this method.
+ *
+ * `ConfigArray#extractConfig(filePath)` creates a `ExtractedConfig` instance.
+ *
+ * @author Toru Nagashima <https://github.com/mysticatea>
+ */
+"use strict";
+
+const { IgnorePattern } = require("./ignore-pattern");
+
+// For VSCode intellisense
+/** @typedef {import("../../shared/types").ConfigData} ConfigData */
+/** @typedef {import("../../shared/types").GlobalConf} GlobalConf */
+/** @typedef {import("../../shared/types").SeverityConf} SeverityConf */
+/** @typedef {import("./config-dependency").DependentParser} DependentParser */
+/** @typedef {import("./config-dependency").DependentPlugin} DependentPlugin */
+
+/**
+ * Check if `xs` starts with `ys`.
+ * @template T
+ * @param {T[]} xs The array to check.
+ * @param {T[]} ys The array that may be the first part of `xs`.
+ * @returns {boolean} `true` if `xs` starts with `ys`.
+ */
+function startsWith(xs, ys) {
+    return xs.length >= ys.length && ys.every((y, i) => y === xs[i]);
+}
+
+/**
+ * The class for extracted config data.
+ */
+class ExtractedConfig {
+    constructor() {
+
+        /**
+         * The config name what `noInlineConfig` setting came from.
+         * @type {string}
+         */
+        this.configNameOfNoInlineConfig = "";
+
+        /**
+         * Environments.
+         * @type {Record<string, boolean>}
+         */
+        this.env = {};
+
+        /**
+         * Global variables.
+         * @type {Record<string, GlobalConf>}
+         */
+        this.globals = {};
+
+        /**
+         * The glob patterns that ignore to lint.
+         * @type {(((filePath:string, dot?:boolean) => boolean) & { basePath:string; patterns:string[] }) | undefined}
+         */
+        this.ignores = void 0;
+
+        /**
+         * The flag that disables directive comments.
+         * @type {boolean|undefined}
+         */
+        this.noInlineConfig = void 0;
+
+        /**
+         * Parser definition.
+         * @type {DependentParser|null}
+         */
+        this.parser = null;
+
+        /**
+         * Options for the parser.
+         * @type {Object}
+         */
+        this.parserOptions = {};
+
+        /**
+         * Plugin definitions.
+         * @type {Record<string, DependentPlugin>}
+         */
+        this.plugins = {};
+
+        /**
+         * Processor ID.
+         * @type {string|null}
+         */
+        this.processor = null;
+
+        /**
+         * The flag that reports unused `eslint-disable` directive comments.
+         * @type {boolean|undefined}
+         */
+        this.reportUnusedDisableDirectives = void 0;
+
+        /**
+         * Rule settings.
+         * @type {Record<string, [SeverityConf, ...any[]]>}
+         */
+        this.rules = {};
+
+        /**
+         * Shared settings.
+         * @type {Object}
+         */
+        this.settings = {};
+    }
+
+    /**
+     * Convert this config to the compatible object as a config file content.
+     * @returns {ConfigData} The converted object.
+     */
+    toCompatibleObjectAsConfigFileContent() {
+        const {
+            /* eslint-disable no-unused-vars */
+            configNameOfNoInlineConfig: _ignore1,
+            processor: _ignore2,
+            /* eslint-enable no-unused-vars */
+            ignores,
+            ...config
+        } = this;
+
+        config.parser = config.parser && config.parser.filePath;
+        config.plugins = Object.keys(config.plugins).filter(Boolean).reverse();
+        config.ignorePatterns = ignores ? ignores.patterns : [];
+
+        // Strip the default patterns from `ignorePatterns`.
+        if (startsWith(config.ignorePatterns, IgnorePattern.DefaultPatterns)) {
+            config.ignorePatterns =
+                config.ignorePatterns.slice(IgnorePattern.DefaultPatterns.length);
+        }
+
+        return config;
+    }
+}
+
+module.exports = { ExtractedConfig };

node_modules/@eslint/eslintrc/lib/config-array/ignore-pattern.js

@@ -0,0 +1,237 @@
+/**
+ * @fileoverview `IgnorePattern` class.
+ *
+ * `IgnorePattern` class has the set of glob patterns and the base path.
+ *
+ * It provides two static methods.
+ *
+ * - `IgnorePattern.createDefaultIgnore(cwd)`
+ *      Create the default predicate function.
+ * - `IgnorePattern.createIgnore(ignorePatterns)`
+ *      Create the predicate function from multiple `IgnorePattern` objects.
+ *
+ * It provides two properties and a method.
+ *
+ * - `patterns`
+ *      The glob patterns that ignore to lint.
+ * - `basePath`
+ *      The base path of the glob patterns. If absolute paths existed in the
+ *      glob patterns, those are handled as relative paths to the base path.
+ * - `getPatternsRelativeTo(basePath)`
+ *      Get `patterns` as modified for a given base path. It modifies the
+ *      absolute paths in the patterns as prepending the difference of two base
+ *      paths.
+ *
+ * `ConfigArrayFactory` creates `IgnorePattern` objects when it processes
+ * `ignorePatterns` properties.
+ *
+ * @author Toru Nagashima <https://github.com/mysticatea>
+ */
+"use strict";
+
+//------------------------------------------------------------------------------
+// Requirements
+//------------------------------------------------------------------------------
+
+const assert = require("assert");
+const path = require("path");
+const ignore = require("ignore");
+const debug = require("debug")("eslint:ignore-pattern");
+
+/** @typedef {ReturnType<import("ignore").default>} Ignore */
+
+//------------------------------------------------------------------------------
+// Helpers
+//------------------------------------------------------------------------------
+
+/**
+ * Get the path to the common ancestor directory of given paths.
+ * @param {string[]} sourcePaths The paths to calculate the common ancestor.
+ * @returns {string} The path to the common ancestor directory.
+ */
+function getCommonAncestorPath(sourcePaths) {
+    let result = sourcePaths[0];
+
+    for (let i = 1; i < sourcePaths.length; ++i) {
+        const a = result;
+        const b = sourcePaths[i];
+
+        // Set the shorter one (it's the common ancestor if one includes the other).
+        result = a.length < b.length ? a : b;
+
+        // Set the common ancestor.
+        for (let j = 0, lastSepPos = 0; j < a.length && j < b.length; ++j) {
+            if (a[j] !== b[j]) {
+                result = a.slice(0, lastSepPos);
+                break;
+            }
+            if (a[j] === path.sep) {
+                lastSepPos = j;
+            }
+        }
+    }
+
+    let resolvedResult = result || path.sep;
+
+    // if Windows common ancestor is root of drive must have trailing slash to be absolute.
+    if (resolvedResult && resolvedResult.endsWith(":") && process.platform === "win32") {
+        resolvedResult += path.sep;
+    }
+    return resolvedResult;
+}
+
+/**
+ * Make relative path.
+ * @param {string} from The source path to get relative path.
+ * @param {string} to The destination path to get relative path.
+ * @returns {string} The relative path.
+ */
+function relative(from, to) {
+    const relPath = path.relative(from, to);
+
+    if (path.sep === "/") {
+        return relPath;
+    }
+    return relPath.split(path.sep).join("/");
+}
+
+/**
+ * Get the trailing slash if existed.
+ * @param {string} filePath The path to check.
+ * @returns {string} The trailing slash if existed.
+ */
+function dirSuffix(filePath) {
+    const isDir = (
+        filePath.endsWith(path.sep) ||
+        (process.platform === "win32" && filePath.endsWith("/"))
+    );
+
+    return isDir ? "/" : "";
+}
+
+const DefaultPatterns = Object.freeze(["/**/node_modules/*"]);
+const DotPatterns = Object.freeze([".*", "!.eslintrc.*", "!../"]);
+
+//------------------------------------------------------------------------------
+// Public
+//------------------------------------------------------------------------------
+
+class IgnorePattern {
+
+    /**
+     * The default patterns.
+     * @type {string[]}
+     */
+    static get DefaultPatterns() {
+        return DefaultPatterns;
+    }
+
+    /**
+     * Create the default predicate function.
+     * @param {string} cwd The current working directory.
+     * @returns {((filePath:string, dot:boolean) => boolean) & {basePath:string; patterns:string[]}}
+     * The preficate function.
+     * The first argument is an absolute path that is checked.
+     * The second argument is the flag to not ignore dotfiles.
+     * If the predicate function returned `true`, it means the path should be ignored.
+     */
+    static createDefaultIgnore(cwd) {
+        return this.createIgnore([new IgnorePattern(DefaultPatterns, cwd)]);
+    }
+
+    /**
+     * Create the predicate function from multiple `IgnorePattern` objects.
+     * @param {IgnorePattern[]} ignorePatterns The list of ignore patterns.
+     * @returns {((filePath:string, dot?:boolean) => boolean) & {basePath:string; patterns:string[]}}
+     * The preficate function.
+     * The first argument is an absolute path that is checked.
+     * The second argument is the flag to not ignore dotfiles.
+     * If the predicate function returned `true`, it means the path should be ignored.
+     */
+    static createIgnore(ignorePatterns) {
+        debug("Create with: %o", ignorePatterns);
+
+        const basePath = getCommonAncestorPath(ignorePatterns.map(p => p.basePath));
+        const patterns = [].concat(
+            ...ignorePatterns.map(p => p.getPatternsRelativeTo(basePath))
+        );
+        const ig = ignore().add([...DotPatterns, ...patterns]);
+        const dotIg = ignore().add(patterns);
+
+        debug("  processed: %o", { basePath, patterns });
+
+        return Object.assign(
+            (filePath, dot = false) => {
+                assert(path.isAbsolute(filePath), "'filePath' should be an absolute path.");
+                const relPathRaw = relative(basePath, filePath);
+                const relPath = relPathRaw && (relPathRaw + dirSuffix(filePath));
+                const adoptedIg = dot ? dotIg : ig;
+                const result = relPath !== "" && adoptedIg.ignores(relPath);
+
+                debug("Check", { filePath, dot, relativePath: relPath, result });
+                return result;
+            },
+            { basePath, patterns }
+        );
+    }
+
+    /**
+     * Initialize a new `IgnorePattern` instance.
+     * @param {string[]} patterns The glob patterns that ignore to lint.
+     * @param {string} basePath The base path of `patterns`.
+     */
+    constructor(patterns, basePath) {
+        assert(path.isAbsolute(basePath), "'basePath' should be an absolute path.");
+
+        /**
+         * The glob patterns that ignore to lint.
+         * @type {string[]}
+         */
+        this.patterns = patterns;
+
+        /**
+         * The base path of `patterns`.
+         * @type {string}
+         */
+        this.basePath = basePath;
+
+        /**
+         * If `true` then patterns which don't start with `/` will match the paths to the outside of `basePath`. Defaults to `false`.
+         *
+         * It's set `true` for `.eslintignore`, `package.json`, and `--ignore-path` for backward compatibility.
+         * It's `false` as-is for `ignorePatterns` property in config files.
+         * @type {boolean}
+         */
+        this.loose = false;
+    }
+
+    /**
+     * Get `patterns` as modified for a given base path. It modifies the
+     * absolute paths in the patterns as prepending the difference of two base
+     * paths.
+     * @param {string} newBasePath The base path.
+     * @returns {string[]} Modifired patterns.
+     */
+    getPatternsRelativeTo(newBasePath) {
+        assert(path.isAbsolute(newBasePath), "'newBasePath' should be an absolute path.");
+        const { basePath, loose, patterns } = this;
+
+        if (newBasePath === basePath) {
+            return patterns;
+        }
+        const prefix = `/${relative(newBasePath, basePath)}`;
+
+        return patterns.map(pattern => {
+            const negative = pattern.startsWith("!");
+            const head = negative ? "!" : "";
+            const body = negative ? pattern.slice(1) : pattern;
+
+            if (body.startsWith("/") || body.startsWith("../")) {
+                return `${head}${prefix}${body}`;
+            }
+            return loose ? pattern : `${head}${prefix}/**/${body}`;
+        });
+    }
+}
+
+module.exports = { IgnorePattern };

node_modules/@eslint/eslintrc/lib/config-array/index.js

@@ -0,0 +1,20 @@
+/**
+ * @fileoverview `ConfigArray` class.
+ * @author Toru Nagashima <https://github.com/mysticatea>
+ */
+"use strict";
+
+const { ConfigArray, getUsedExtractedConfigs } = require("./config-array");
+const { ConfigDependency } = require("./config-dependency");
+const { ExtractedConfig } = require("./extracted-config");
+const { IgnorePattern } = require("./ignore-pattern");
+const { OverrideTester } = require("./override-tester");
+
+module.exports = {
+    ConfigArray,
+    ConfigDependency,
+    ExtractedConfig,
+    IgnorePattern,
+    OverrideTester,
+    getUsedExtractedConfigs
+};

node_modules/@eslint/eslintrc/lib/config-array/override-tester.js

@@ -0,0 +1,223 @@
+/**
+ * @fileoverview `OverrideTester` class.
+ *
+ * `OverrideTester` class handles `files` property and `excludedFiles` property
+ * of `overrides` config.
+ *
+ * It provides one method.
+ *
+ * - `test(filePath)`
+ *      Test if a file path matches the pair of `files` property and
+ *      `excludedFiles` property. The `filePath` argument must be an absolute
+ *      path.
+ *
+ * `ConfigArrayFactory` creates `OverrideTester` objects when it processes
+ * `overrides` properties.
+ *
+ * @author Toru Nagashima <https://github.com/mysticatea>
+ */
+"use strict";
+
+const assert = require("assert");
+const path = require("path");
+const util = require("util");
+const { Minimatch } = require("minimatch");
+const minimatchOpts = { dot: true, matchBase: true };
+
+/**
+ * @typedef {Object} Pattern
+ * @property {InstanceType<Minimatch>[] | null} includes The positive matchers.
+ * @property {InstanceType<Minimatch>[] | null} excludes The negative matchers.
+ */
+
+/**
+ * Normalize a given pattern to an array.
+ * @param {string|string[]|undefined} patterns A glob pattern or an array of glob patterns.
+ * @returns {string[]|null} Normalized patterns.
+ * @private
+ */
+function normalizePatterns(patterns) {
+    if (Array.isArray(patterns)) {
+        return patterns.filter(Boolean);
+    }
+    if (typeof patterns === "string" && patterns) {
+        return [patterns];
+    }
+    return [];
+}
+
+/**
+ * Create the matchers of given patterns.
+ * @param {string[]} patterns The patterns.
+ * @returns {InstanceType<Minimatch>[] | null} The matchers.
+ */
+function toMatcher(patterns) {
+    if (patterns.length === 0) {
+        return null;
+    }
+    return patterns.map(pattern => {
+        if (/^\.[/\\]/u.test(pattern)) {
+            return new Minimatch(
+                pattern.slice(2),
+
+                // `./*.js` should not match with `subdir/foo.js`
+                { ...minimatchOpts, matchBase: false }
+            );
+        }
+        return new Minimatch(pattern, minimatchOpts);
+    });
+}
+
+/**
+ * Convert a given matcher to string.
+ * @param {Pattern} matchers The matchers.
+ * @returns {string} The string expression of the matcher.
+ */
+function patternToJson({ includes, excludes }) {
+    return {
+        includes: includes && includes.map(m => m.pattern),
+        excludes: excludes && excludes.map(m => m.pattern)
+    };
+}
+
+/**
+ * The class to test given paths are matched by the patterns.
+ */
+class OverrideTester {
+
+    /**
+     * Create a tester with given criteria.
+     * If there are no criteria, returns `null`.
+     * @param {string|string[]} files The glob patterns for included files.
+     * @param {string|string[]} excludedFiles The glob patterns for excluded files.
+     * @param {string} basePath The path to the base directory to test paths.
+     * @returns {OverrideTester|null} The created instance or `null`.
+     */
+    static create(files, excludedFiles, basePath) {
+        const includePatterns = normalizePatterns(files);
+        const excludePatterns = normalizePatterns(excludedFiles);
+        let endsWithWildcard = false;
+
+        if (includePatterns.length === 0) {
+            return null;
+        }
+
+        // Rejects absolute paths or relative paths to parents.
+        for (const pattern of includePatterns) {
+            if (path.isAbsolute(pattern) || pattern.includes("..")) {
+                throw new Error(`Invalid override pattern (expected relative path not containing '..'): ${pattern}`);
+            }
+            if (pattern.endsWith("*")) {
+                endsWithWildcard = true;
+            }
+        }
+        for (const pattern of excludePatterns) {
+            if (path.isAbsolute(pattern) || pattern.includes("..")) {
+                throw new Error(`Invalid override pattern (expected relative path not containing '..'): ${pattern}`);
+            }
+        }
+
+        const includes = toMatcher(includePatterns);
+        const excludes = toMatcher(excludePatterns);
+
+        return new OverrideTester(
+            [{ includes, excludes }],
+            basePath,
+            endsWithWildcard
+        );
+    }
+
+    /**
+     * Combine two testers by logical and.
+     * If either of the testers was `null`, returns the other tester.
+     * The `basePath` property of the two must be the same value.
+     * @param {OverrideTester|null} a A tester.
+     * @param {OverrideTester|null} b Another tester.
+     * @returns {OverrideTester|null} Combined tester.
+     */
+    static and(a, b) {
+        if (!b) {
+            return a && new OverrideTester(
+                a.patterns,
+                a.basePath,
+                a.endsWithWildcard
+            );
+        }
+        if (!a) {
+            return new OverrideTester(
+                b.patterns,
+                b.basePath,
+                b.endsWithWildcard
+            );
+        }
+
+        assert.strictEqual(a.basePath, b.basePath);
+        return new OverrideTester(
+            a.patterns.concat(b.patterns),
+            a.basePath,
+            a.endsWithWildcard || b.endsWithWildcard
+        );
+    }
+
+    /**
+     * Initialize this instance.
+     * @param {Pattern[]} patterns The matchers.
+     * @param {string} basePath The base path.
+     * @param {boolean} endsWithWildcard If `true` then a pattern ends with `*`.
+     */
+    constructor(patterns, basePath, endsWithWildcard = false) {
+
+        /** @type {Pattern[]} */
+        this.patterns = patterns;
+
+        /** @type {string} */
+        this.basePath = basePath;
+
+        /** @type {boolean} */
+        this.endsWithWildcard = endsWithWildcard;
+    }
+
+    /**
+     * Test if a given path is matched or not.
+     * @param {string} filePath The absolute path to the target file.
+     * @returns {boolean} `true` if the path was matched.
+     */
+    test(filePath) {
+        if (typeof filePath !== "string" || !path.isAbsolute(filePath)) {
+            throw new Error(`'filePath' should be an absolute path, but got ${filePath}.`);
+        }
+        const relativePath = path.relative(this.basePath, filePath);
+
+        return this.patterns.every(({ includes, excludes }) => (
+            (!includes || includes.some(m => m.match(relativePath))) &&
+            (!excludes || !excludes.some(m => m.match(relativePath)))
+        ));
+    }
+
+    // eslint-disable-next-line jsdoc/require-description
+    /**
+     * @returns {Object} a JSON compatible object.
+     */
+    toJSON() {
+        if (this.patterns.length === 1) {
+            return {
+                ...patternToJson(this.patterns[0]),
+                basePath: this.basePath
+            };
+        }
+        return {
+            AND: this.patterns.map(patternToJson),
+            basePath: this.basePath
+        };
+    }
+
+    // eslint-disable-next-line jsdoc/require-description
+    /**
+     * @returns {Object} an object to display by `console.log()`.
+     */
+    [util.inspect.custom]() {
+        return this.toJSON();
+    }
+}
+
+module.exports = { OverrideTester };

node_modules/@eslint/eslintrc/lib/index.js

@@ -0,0 +1,51 @@
+/**
+ * @fileoverview Package exports for @eslint/eslintrc
+ * @author Nicholas C. Zakas
+ */
+"use strict";
+
+//------------------------------------------------------------------------------
+// Requirements
+//------------------------------------------------------------------------------
+
+const {
+    ConfigArrayFactory,
+    createContext: createConfigArrayFactoryContext
+} = require("./config-array-factory");
+
+const { CascadingConfigArrayFactory } = require("./cascading-config-array-factory");
+const { ModuleResolver } = require("./shared/relative-module-resolver");
+const { ConfigArray, getUsedExtractedConfigs } = require("./config-array");
+const { ConfigDependency } = require("./config-array/config-dependency");
+const { ExtractedConfig } = require("./config-array/extracted-config");
+const { IgnorePattern } = require("./config-array/ignore-pattern");
+const { OverrideTester } = require("./config-array/override-tester");
+const ConfigOps = require("./shared/config-ops");
+const ConfigValidator = require("./shared/config-validator");
+const naming = require("./shared/naming");
+
+//-----------------------------------------------------------------------------
+// Exports
+//-----------------------------------------------------------------------------
+
+module.exports = {
+
+    Legacy: {
+        ConfigArray,
+        createConfigArrayFactoryContext,
+        CascadingConfigArrayFactory,
+        ConfigArrayFactory,
+        ConfigDependency,
+        ExtractedConfig,
+        IgnorePattern,
+        OverrideTester,
+        getUsedExtractedConfigs,
+
+        // shared
+        ConfigOps,
+        ConfigValidator,
+        ModuleResolver,
+        naming
+    }
+
+};

node_modules/@eslint/eslintrc/lib/shared/ajv.js

@@ -0,0 +1,34 @@
+/**
+ * @fileoverview The instance of Ajv validator.
+ * @author Evgeny Poberezkin
+ */
+"use strict";
+
+//------------------------------------------------------------------------------
+// Requirements
+//------------------------------------------------------------------------------
+
+const Ajv = require("ajv"),
+    metaSchema = require("ajv/lib/refs/json-schema-draft-04.json");
+
+//------------------------------------------------------------------------------
+// Public Interface
+//------------------------------------------------------------------------------
+
+module.exports = (additionalOptions = {}) => {
+    const ajv = new Ajv({
+        meta: false,
+        useDefaults: true,
+        validateSchema: false,
+        missingRefs: "ignore",
+        verbose: true,
+        schemaId: "auto",
+        ...additionalOptions
+    });
+
+    ajv.addMetaSchema(metaSchema);
+    // eslint-disable-next-line no-underscore-dangle
+    ajv._opts.defaultMeta = metaSchema.id;
+
+    return ajv;
+};

node_modules/@eslint/eslintrc/lib/shared/config-ops.js

@@ -0,0 +1,130 @@
+/**
+ * @fileoverview Config file operations. This file must be usable in the browser,
+ * so no Node-specific code can be here.
+ * @author Nicholas C. Zakas
+ */
+"use strict";
+
+//------------------------------------------------------------------------------
+// Private
+//------------------------------------------------------------------------------
+
+const RULE_SEVERITY_STRINGS = ["off", "warn", "error"],
+    RULE_SEVERITY = RULE_SEVERITY_STRINGS.reduce((map, value, index) => {
+        map[value] = index;
+        return map;
+    }, {}),
+    VALID_SEVERITIES = [0, 1, 2, "off", "warn", "error"];
+
+//------------------------------------------------------------------------------
+// Public Interface
+//------------------------------------------------------------------------------
+
+module.exports = {
+
+    /**
+     * Normalizes the severity value of a rule's configuration to a number
+     * @param {(number|string|[number, ...*]|[string, ...*])} ruleConfig A rule's configuration value, generally
+     * received from the user. A valid config value is either 0, 1, 2, the string "off" (treated the same as 0),
+     * the string "warn" (treated the same as 1), the string "error" (treated the same as 2), or an array
+     * whose first element is one of the above values. Strings are matched case-insensitively.
+     * @returns {(0|1|2)} The numeric severity value if the config value was valid, otherwise 0.
+     */
+    getRuleSeverity(ruleConfig) {
+        const severityValue = Array.isArray(ruleConfig) ? ruleConfig[0] : ruleConfig;
+
+        if (severityValue === 0 || severityValue === 1 || severityValue === 2) {
+            return severityValue;
+        }
+
+        if (typeof severityValue === "string") {
+            return RULE_SEVERITY[severityValue.toLowerCase()] || 0;
+        }
+
+        return 0;
+    },
+
+    /**
+     * Converts old-style severity settings (0, 1, 2) into new-style
+     * severity settings (off, warn, error) for all rules. Assumption is that severity
+     * values have already been validated as correct.
+     * @param {Object} config The config object to normalize.
+     * @returns {void}
+     */
+    normalizeToStrings(config) {
+
+        if (config.rules) {
+            Object.keys(config.rules).forEach(ruleId => {
+                const ruleConfig = config.rules[ruleId];
+
+                if (typeof ruleConfig === "number") {
+                    config.rules[ruleId] = RULE_SEVERITY_STRINGS[ruleConfig] || RULE_SEVERITY_STRINGS[0];
+                } else if (Array.isArray(ruleConfig) && typeof ruleConfig[0] === "number") {
+                    ruleConfig[0] = RULE_SEVERITY_STRINGS[ruleConfig[0]] || RULE_SEVERITY_STRINGS[0];
+                }
+            });
+        }
+    },
+
+    /**
+     * Determines if the severity for the given rule configuration represents an error.
+     * @param {int|string|Array} ruleConfig The configuration for an individual rule.
+     * @returns {boolean} True if the rule represents an error, false if not.
+     */
+    isErrorSeverity(ruleConfig) {
+        return module.exports.getRuleSeverity(ruleConfig) === 2;
+    },
+
+    /**
+     * Checks whether a given config has valid severity or not.
+     * @param {number|string|Array} ruleConfig The configuration for an individual rule.
+     * @returns {boolean} `true` if the configuration has valid severity.
+     */
+    isValidSeverity(ruleConfig) {
+        let severity = Array.isArray(ruleConfig) ? ruleConfig[0] : ruleConfig;
+
+        if (typeof severity === "string") {
+            severity = severity.toLowerCase();
+        }
+        return VALID_SEVERITIES.indexOf(severity) !== -1;
+    },
+
+    /**
+     * Checks whether every rule of a given config has valid severity or not.
+     * @param {Object} config The configuration for rules.
+     * @returns {boolean} `true` if the configuration has valid severity.
+     */
+    isEverySeverityValid(config) {
+        return Object.keys(config).every(ruleId => this.isValidSeverity(config[ruleId]));
+    },
+
+    /**
+     * Normalizes a value for a global in a config
+     * @param {(boolean|string|null)} configuredValue The value given for a global in configuration or in
+     * a global directive comment
+     * @returns {("readable"|"writeable"|"off")} The value normalized as a string
+     * @throws Error if global value is invalid
+     */
+    normalizeConfigGlobal(configuredValue) {
+        switch (configuredValue) {
+            case "off":
+                return "off";
+
+            case true:
+            case "true":
+            case "writeable":
+            case "writable":
+                return "writable";
+
+            case null:
+            case false:
+            case "false":
+            case "readable":
+            case "readonly":
+                return "readonly";
+
+            default:
+                throw new Error(`'${configuredValue}' is not a valid configuration for a global (use 'readonly', 'writable', or 'off')`);
+        }
+    }
+};

node_modules/@eslint/eslintrc/lib/shared/config-validator.js

@@ -0,0 +1,324 @@
+/**
+ * @fileoverview Validates configs.
+ * @author Brandon Mills
+ */
+
+"use strict";
+
+//------------------------------------------------------------------------------
+// Requirements
+//------------------------------------------------------------------------------
+
+const
+    util = require("util"),
+    configSchema = require("../../conf/config-schema"),
+    BuiltInEnvironments = require("../../conf/environments"),
+    ConfigOps = require("./config-ops"),
+    { emitDeprecationWarning } = require("./deprecation-warnings");
+
+const ajv = require("./ajv")();
+const ruleValidators = new WeakMap();
+const noop = Function.prototype;
+
+//------------------------------------------------------------------------------
+// Private
+//------------------------------------------------------------------------------
+let validateSchema;
+const severityMap = {
+    error: 2,
+    warn: 1,
+    off: 0
+};
+
+const validated = new WeakSet();
+
+//-----------------------------------------------------------------------------
+// Exports
+//-----------------------------------------------------------------------------
+
+module.exports = class ConfigValidator {
+    constructor({ builtInRules = new Map() } = {}) {
+        this.builtInRules = builtInRules;
+    }
+
+    /**
+     * Gets a complete options schema for a rule.
+     * @param {{create: Function, schema: (Array|null)}} rule A new-style rule object
+     * @returns {Object} JSON Schema for the rule's options.
+     */
+    getRuleOptionsSchema(rule) {
+        if (!rule) {
+            return null;
+        }
+
+        const schema = rule.schema || rule.meta && rule.meta.schema;
+
+        // Given a tuple of schemas, insert warning level at the beginning
+        if (Array.isArray(schema)) {
+            if (schema.length) {
+                return {
+                    type: "array",
+                    items: schema,
+                    minItems: 0,
+                    maxItems: schema.length
+                };
+            }
+            return {
+                type: "array",
+                minItems: 0,
+                maxItems: 0
+            };
+
+        }
+
+        // Given a full schema, leave it alone
+        return schema || null;
+    }
+
+    /**
+     * Validates a rule's severity and returns the severity value. Throws an error if the severity is invalid.
+     * @param {options} options The given options for the rule.
+     * @returns {number|string} The rule's severity value
+     */
+    validateRuleSeverity(options) {
+        const severity = Array.isArray(options) ? options[0] : options;
+        const normSeverity = typeof severity === "string" ? severityMap[severity.toLowerCase()] : severity;
+
+        if (normSeverity === 0 || normSeverity === 1 || normSeverity === 2) {
+            return normSeverity;
+        }
+
+        throw new Error(`\tSeverity should be one of the following: 0 = off, 1 = warn, 2 = error (you passed '${util.inspect(severity).replace(/'/gu, "\"").replace(/\n/gu, "")}').\n`);
+
+    }
+
+    /**
+     * Validates the non-severity options passed to a rule, based on its schema.
+     * @param {{create: Function}} rule The rule to validate
+     * @param {Array} localOptions The options for the rule, excluding severity
+     * @returns {void}
+     */
+    validateRuleSchema(rule, localOptions) {
+        if (!ruleValidators.has(rule)) {
+            const schema = this.getRuleOptionsSchema(rule);
+
+            if (schema) {
+                ruleValidators.set(rule, ajv.compile(schema));
+            }
+        }
+
+        const validateRule = ruleValidators.get(rule);
+
+        if (validateRule) {
+            validateRule(localOptions);
+            if (validateRule.errors) {
+                throw new Error(validateRule.errors.map(
+                    error => `\tValue ${JSON.stringify(error.data)} ${error.message}.\n`
+                ).join(""));
+            }
+        }
+    }
+
+    /**
+     * Validates a rule's options against its schema.
+     * @param {{create: Function}|null} rule The rule that the config is being validated for
+     * @param {string} ruleId The rule's unique name.
+     * @param {Array|number} options The given options for the rule.
+     * @param {string|null} source The name of the configuration source to report in any errors. If null or undefined,
+     * no source is prepended to the message.
+     * @returns {void}
+     */
+    validateRuleOptions(rule, ruleId, options, source = null) {
+        try {
+            const severity = this.validateRuleSeverity(options);
+
+            if (severity !== 0) {
+                this.validateRuleSchema(rule, Array.isArray(options) ? options.slice(1) : []);
+            }
+        } catch (err) {
+            const enhancedMessage = `Configuration for rule "${ruleId}" is invalid:\n${err.message}`;
+
+            if (typeof source === "string") {
+                throw new Error(`${source}:\n\t${enhancedMessage}`);
+            } else {
+                throw new Error(enhancedMessage);
+            }
+        }
+    }
+
+    /**
+     * Validates an environment object
+     * @param {Object} environment The environment config object to validate.
+     * @param {string} source The name of the configuration source to report in any errors.
+     * @param {function(envId:string): Object} [getAdditionalEnv] A map from strings to loaded environments.
+     * @returns {void}
+     */
+    validateEnvironment(
+        environment,
+        source,
+        getAdditionalEnv = noop
+    ) {
+
+        // not having an environment is ok
+        if (!environment) {
+            return;
+        }
+
+        Object.keys(environment).forEach(id => {
+            const env = getAdditionalEnv(id) || BuiltInEnvironments.get(id) || null;
+
+            if (!env) {
+                const message = `${source}:\n\tEnvironment key "${id}" is unknown\n`;
+
+                throw new Error(message);
+            }
+        });
+    }
+
+    /**
+     * Validates a rules config object
+     * @param {Object} rulesConfig The rules config object to validate.
+     * @param {string} source The name of the configuration source to report in any errors.
+     * @param {function(ruleId:string): Object} getAdditionalRule A map from strings to loaded rules
+     * @returns {void}
+     */
+    validateRules(
+        rulesConfig,
+        source,
+        getAdditionalRule = noop
+    ) {
+        if (!rulesConfig) {
+            return;
+        }
+
+        Object.keys(rulesConfig).forEach(id => {
+            const rule = getAdditionalRule(id) || this.builtInRules.get(id) || null;
+
+            this.validateRuleOptions(rule, id, rulesConfig[id], source);
+        });
+    }
+
+    /**
+     * Validates a `globals` section of a config file
+     * @param {Object} globalsConfig The `globals` section
+     * @param {string|null} source The name of the configuration source to report in the event of an error.
+     * @returns {void}
+     */
+    validateGlobals(globalsConfig, source = null) {
+        if (!globalsConfig) {
+            return;
+        }
+
+        Object.entries(globalsConfig)
+            .forEach(([configuredGlobal, configuredValue]) => {
+                try {
+                    ConfigOps.normalizeConfigGlobal(configuredValue);
+                } catch (err) {
+                    throw new Error(`ESLint configuration of global '${configuredGlobal}' in ${source} is invalid:\n${err.message}`);
+                }
+            });
+    }
+
+    /**
+     * Validate `processor` configuration.
+     * @param {string|undefined} processorName The processor name.
+     * @param {string} source The name of config file.
+     * @param {function(id:string): Processor} getProcessor The getter of defined processors.
+     * @returns {void}
+     */
+    validateProcessor(processorName, source, getProcessor) {
+        if (processorName && !getProcessor(processorName)) {
+            throw new Error(`ESLint configuration of processor in '${source}' is invalid: '${processorName}' was not found.`);
+        }
+    }
+
+    /**
+     * Formats an array of schema validation errors.
+     * @param {Array} errors An array of error messages to format.
+     * @returns {string} Formatted error message
+     */
+    formatErrors(errors) {
+        return errors.map(error => {
+            if (error.keyword === "additionalProperties") {
+                const formattedPropertyPath = error.dataPath.length ? `${error.dataPath.slice(1)}.${error.params.additionalProperty}` : error.params.additionalProperty;
+
+                return `Unexpected top-level property "${formattedPropertyPath}"`;
+            }
+            if (error.keyword === "type") {
+                const formattedField = error.dataPath.slice(1);
+                const formattedExpectedType = Array.isArray(error.schema) ? error.schema.join("/") : error.schema;
+                const formattedValue = JSON.stringify(error.data);
+
+                return `Property "${formattedField}" is the wrong type (expected ${formattedExpectedType} but got \`${formattedValue}\`)`;
+            }
+
+            const field = error.dataPath[0] === "." ? error.dataPath.slice(1) : error.dataPath;
+
+            return `"${field}" ${error.message}. Value: ${JSON.stringify(error.data)}`;
+        }).map(message => `\t- ${message}.\n`).join("");
+    }
+
+    /**
+     * Validates the top level properties of the config object.
+     * @param {Object} config The config object to validate.
+     * @param {string} source The name of the configuration source to report in any errors.
+     * @returns {void}
+     */
+    validateConfigSchema(config, source = null) {
+        validateSchema = this.validateSchema || ajv.compile(configSchema);
+
+        if (!validateSchema(config)) {
+            throw new Error(`ESLint configuration in ${source} is invalid:\n${this.formatErrors(validateSchema.errors)}`);
+        }
+
+        if (Object.hasOwnProperty.call(config, "ecmaFeatures")) {
+            emitDeprecationWarning(source, "ESLINT_LEGACY_ECMAFEATURES");
+        }
+    }
+
+    /**
+     * Validates an entire config object.
+     * @param {Object} config The config object to validate.
+     * @param {string} source The name of the configuration source to report in any errors.
+     * @param {function(ruleId:string): Object} [getAdditionalRule] A map from strings to loaded rules.
+     * @param {function(envId:string): Object} [getAdditionalEnv] A map from strings to loaded envs.
+     * @returns {void}
+     */
+    validate(config, source, getAdditionalRule, getAdditionalEnv) {
+        this.validateConfigSchema(config, source);
+        this.validateRules(config.rules, source, getAdditionalRule);
+        this.validateEnvironment(config.env, source, getAdditionalEnv);
+        this.validateGlobals(config.globals, source);
+
+        for (const override of config.overrides || []) {
+            this.validateRules(override.rules, source, getAdditionalRule);
+            this.validateEnvironment(override.env, source, getAdditionalEnv);
+            this.validateGlobals(config.globals, source);
+        }
+    }
+
+    /**
+     * Validate config array object.
+     * @param {ConfigArray} configArray The config array to validate.
+     * @returns {void}
+     */
+    validateConfigArray(configArray) {
+        const getPluginEnv = Map.prototype.get.bind(configArray.pluginEnvironments);
+        const getPluginProcessor = Map.prototype.get.bind(configArray.pluginProcessors);
+        const getPluginRule = Map.prototype.get.bind(configArray.pluginRules);
+
+        // Validate.
+        for (const element of configArray) {
+            if (validated.has(element)) {
+                continue;
+            }
+            validated.add(element);
+
+            this.validateEnvironment(element.env, element.name, getPluginEnv);
+            this.validateGlobals(element.globals, element.name);
+            this.validateProcessor(element.processor, element.name, getPluginProcessor);
+            this.validateRules(element.rules, element.name, getPluginRule);
+        }
+    }
+
+};

node_modules/@eslint/eslintrc/lib/shared/deprecation-warnings.js

@@ -0,0 +1,56 @@
+/**
+ * @fileoverview Provide the function that emits deprecation warnings.
+ * @author Toru Nagashima <http://github.com/mysticatea>
+ */
+"use strict";
+
+//------------------------------------------------------------------------------
+// Requirements
+//------------------------------------------------------------------------------
+
+const path = require("path");
+const lodash = require("lodash");
+
+//------------------------------------------------------------------------------
+// Private
+//------------------------------------------------------------------------------
+
+// Defitions for deprecation warnings.
+const deprecationWarningMessages = {
+    ESLINT_LEGACY_ECMAFEATURES:
+        "The 'ecmaFeatures' config file property is deprecated and has no effect.",
+    ESLINT_PERSONAL_CONFIG_LOAD:
+        "'~/.eslintrc.*' config files have been deprecated. " +
+        "Please use a config file per project or the '--config' option.",
+    ESLINT_PERSONAL_CONFIG_SUPPRESS:
+        "'~/.eslintrc.*' config files have been deprecated. " +
+        "Please remove it or add 'root:true' to the config files in your " +
+        "projects in order to avoid loading '~/.eslintrc.*' accidentally."
+};
+
+/**
+ * Emits a deprecation warning containing a given filepath. A new deprecation warning is emitted
+ * for each unique file path, but repeated invocations with the same file path have no effect.
+ * No warnings are emitted if the `--no-deprecation` or `--no-warnings` Node runtime flags are active.
+ * @param {string} source The name of the configuration source to report the warning for.
+ * @param {string} errorCode The warning message to show.
+ * @returns {void}
+ */
+const emitDeprecationWarning = lodash.memoize((source, errorCode) => {
+    const rel = path.relative(process.cwd(), source);
+    const message = deprecationWarningMessages[errorCode];
+
+    process.emitWarning(
+        `${message} (found in "${rel}")`,
+        "DeprecationWarning",
+        errorCode
+    );
+}, (...args) => JSON.stringify(args));
+
+//------------------------------------------------------------------------------
+// Public Interface
+//------------------------------------------------------------------------------
+
+module.exports = {
+    emitDeprecationWarning
+};

node_modules/@eslint/eslintrc/lib/shared/naming.js

@@ -0,0 +1,97 @@
+/**
+ * @fileoverview Common helpers for naming of plugins, formatters and configs
+ */
+"use strict";
+
+const NAMESPACE_REGEX = /^@.*\//iu;
+
+/**
+ * Brings package name to correct format based on prefix
+ * @param {string} name The name of the package.
+ * @param {string} prefix Can be either "eslint-plugin", "eslint-config" or "eslint-formatter"
+ * @returns {string} Normalized name of the package
+ * @private
+ */
+function normalizePackageName(name, prefix) {
+    let normalizedName = name;
+
+    /**
+     * On Windows, name can come in with Windows slashes instead of Unix slashes.
+     * Normalize to Unix first to avoid errors later on.
+     * https://github.com/eslint/eslint/issues/5644
+     */
+    if (normalizedName.includes("\\")) {
+        normalizedName = normalizedName.replace(/\\/gu, "/");
+    }
+
+    if (normalizedName.charAt(0) === "@") {
+
+        /**
+         * it's a scoped package
+         * package name is the prefix, or just a username
+         */
+        const scopedPackageShortcutRegex = new RegExp(`^(@[^/]+)(?:/(?:${prefix})?)?$`, "u"),
+            scopedPackageNameRegex = new RegExp(`^${prefix}(-|$)`, "u");
+
+        if (scopedPackageShortcutRegex.test(normalizedName)) {
+            normalizedName = normalizedName.replace(scopedPackageShortcutRegex, `$1/${prefix}`);
+        } else if (!scopedPackageNameRegex.test(normalizedName.split("/")[1])) {
+
+            /**
+             * for scoped packages, insert the prefix after the first / unless
+             * the path is already @scope/eslint or @scope/eslint-xxx-yyy
+             */
+            normalizedName = normalizedName.replace(/^@([^/]+)\/(.*)$/u, `@$1/${prefix}-$2`);
+        }
+    } else if (!normalizedName.startsWith(`${prefix}-`)) {
+        normalizedName = `${prefix}-${normalizedName}`;
+    }
+
+    return normalizedName;
+}
+
+/**
+ * Removes the prefix from a fullname.
+ * @param {string} fullname The term which may have the prefix.
+ * @param {string} prefix The prefix to remove.
+ * @returns {string} The term without prefix.
+ */
+function getShorthandName(fullname, prefix) {
+    if (fullname[0] === "@") {
+        let matchResult = new RegExp(`^(@[^/]+)/${prefix}$`, "u").exec(fullname);
+
+        if (matchResult) {
+            return matchResult[1];
+        }
+
+        matchResult = new RegExp(`^(@[^/]+)/${prefix}-(.+)$`, "u").exec(fullname);
+        if (matchResult) {
+            return `${matchResult[1]}/${matchResult[2]}`;
+        }
+    } else if (fullname.startsWith(`${prefix}-`)) {
+        return fullname.slice(prefix.length + 1);
+    }
+
+    return fullname;
+}
+
+/**
+ * Gets the scope (namespace) of a term.
+ * @param {string} term The term which may have the namespace.
+ * @returns {string} The namespace of the term if it has one.
+ */
+function getNamespaceFromTerm(term) {
+    const match = term.match(NAMESPACE_REGEX);
+
+    return match ? match[0] : "";
+}
+
+//------------------------------------------------------------------------------
+// Public Interface
+//------------------------------------------------------------------------------
+
+module.exports = {
+    normalizePackageName,
+    getShorthandName,
+    getNamespaceFromTerm
+};

node_modules/@eslint/eslintrc/lib/shared/relative-module-resolver.js

@@ -0,0 +1,44 @@
+/**
+ * Utility for resolving a module relative to another module
+ * @author Teddy Katz
+ */
+
+"use strict";
+
+const Module = require("module");
+
+/*
+ * `Module.createRequire` is added in v12.2.0. It supports URL as well.
+ * We only support the case where the argument is a filepath, not a URL.
+ */
+// eslint-disable-next-line node/no-unsupported-features/node-builtins, node/no-deprecated-api
+const createRequire = Module.createRequire || Module.createRequireFromPath;
+
+module.exports = {
+
+    /**
+     * Resolves a Node module relative to another module
+     * @param {string} moduleName The name of a Node module, or a path to a Node module.
+     * @param {string} relativeToPath An absolute path indicating the module that `moduleName` should be resolved relative to. This must be
+     * a file rather than a directory, but the file need not actually exist.
+     * @returns {string} The absolute path that would result from calling `require.resolve(moduleName)` in a file located at `relativeToPath`
+     */
+    resolve(moduleName, relativeToPath) {
+        try {
+            return createRequire(relativeToPath).resolve(moduleName);
+        } catch (error) {
+
+            // This `if` block is for older Node.js than 12.0.0. We can remove this block in the future.
+            if (
+                typeof error === "object" &&
+                error !== null &&
+                error.code === "MODULE_NOT_FOUND" &&
+                !error.requireStack &&
+                error.message.includes(moduleName)
+            ) {
+                error.message += `\nRequire stack:\n- ${relativeToPath}`;
+            }
+            throw error;
+        }
+    }
+};

node_modules/@eslint/eslintrc/node_modules/ignore/CHANGELOG.md

@@ -0,0 +1,19 @@
+# `node-ignore` 4 ChangeLog
+
+# 4.x
+
+## 2018-06-22, Version 4.0.0
+
+- **SEMVER-MAJOR**: Drop support for node < 6 by default.
+- **FEATURE**: supports the missing character ranges and sets, such as `*.[a-z]` and `*.[jJ][pP][gG]`
+- **FEATURE**: new option: `ignorecase` to make `ignore` case sensitive.
+- **FEATURE**: supports question mark which matches a single character.
+- **PATCH**: fixes typescript declaration.
+
+## ~ 2018-08-09, Version 4.0.1 - 4.0.5
+
+- **PATCH**: updates README.md about frequent asked quesions from github issues.
+
+## 2018-08-12, Version 4.0.6
+
+- **PATCH**: `Object.prototype` methods will not ruin the result any more.

node_modules/@eslint/eslintrc/node_modules/ignore/LICENSE-MIT

@@ -0,0 +1,21 @@
+Copyright (c) 2013 Kael Zhang <i@kael.me>, contributors
+http://kael.me/
+
+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/@eslint/eslintrc/node_modules/ignore/README.md

@@ -0,0 +1,307 @@
+<table><thead>
+  <tr>
+    <th>Linux</th>
+    <th>OS X</th>
+    <th>Windows</th>
+    <th>Coverage</th>
+    <th>Downloads</th>
+  </tr>
+</thead><tbody><tr>
+  <td colspan="2" align="center">
+    <a href="https://travis-ci.org/kaelzhang/node-ignore">
+    <img
+      src="https://travis-ci.org/kaelzhang/node-ignore.svg?branch=master"
+      alt="Build Status" /></a>
+  </td>
+  <td align="center">
+    <a href="https://ci.appveyor.com/project/kaelzhang/node-ignore">
+    <img
+      src="https://ci.appveyor.com/api/projects/status/github/kaelzhang/node-ignore?branch=master&svg=true"
+      alt="Windows Build Status" /></a>
+  </td>
+  <td align="center">
+    <a href="https://codecov.io/gh/kaelzhang/node-ignore">
+    <img
+      src="https://codecov.io/gh/kaelzhang/node-ignore/branch/master/graph/badge.svg"
+      alt="Coverage Status" /></a>
+  </td>
+  <td align="center">
+    <a href="https://www.npmjs.org/package/ignore">
+    <img
+      src="http://img.shields.io/npm/dm/ignore.svg"
+      alt="npm module downloads per month" /></a>
+  </td>
+</tr></tbody></table>
+
+# ignore
+
+`ignore` is a manager, filter and parser which implemented in pure JavaScript according to the .gitignore [spec](http://git-scm.com/docs/gitignore).
+
+Pay attention that [`minimatch`](https://www.npmjs.org/package/minimatch) does not work in the gitignore way. To filter filenames according to .gitignore file, I recommend this module.
+
+##### Tested on
+
+- Linux + Node: `0.8` - `7.x`
+- Windows + Node: `0.10` - `7.x`, node < `0.10` is not tested due to the lack of support of appveyor.
+
+Actually, `ignore` does not rely on any versions of node specially.
+
+Since `4.0.0`, ignore will no longer support `node < 6` by default, to use in node < 6, `require('ignore/legacy')`. For details, see [CHANGELOG](https://github.com/kaelzhang/node-ignore/blob/master/CHANGELOG.md).
+
+## Table Of Main Contents
+
+- [Usage](#usage)
+- [`Pathname` Conventions](#pathname-conventions)
+- [Guide for 2.x -> 3.x](#upgrade-2x---3x)
+- [Guide for 3.x -> 4.x](#upgrade-3x---4x)
+- See Also:
+  - [`glob-gitignore`](https://www.npmjs.com/package/glob-gitignore) matches files using patterns and filters them according to gitignore rules.
+
+## Usage
+
+```js
+import ignore from 'ignore'
+const ig = ignore().add(['.abc/*', '!.abc/d/'])
+```
+
+### Filter the given paths
+
+```js
+const paths = [
+  '.abc/a.js',    // filtered out
+  '.abc/d/e.js'   // included
+]
+
+ig.filter(paths)        // ['.abc/d/e.js']
+ig.ignores('.abc/a.js') // true
+```
+
+### As the filter function
+
+```js
+paths.filter(ig.createFilter()); // ['.abc/d/e.js']
+```
+
+### Win32 paths will be handled
+
+```js
+ig.filter(['.abc\\a.js', '.abc\\d\\e.js'])
+// if the code above runs on windows, the result will be
+// ['.abc\\d\\e.js']
+```
+
+## Why another ignore?
+
+- `ignore` is a standalone module, and is much simpler so that it could easy work with other programs, unlike [isaacs](https://npmjs.org/~isaacs)'s [fstream-ignore](https://npmjs.org/package/fstream-ignore) which must work with the modules of the fstream family.
+
+- `ignore` only contains utility methods to filter paths according to the specified ignore rules, so
+  - `ignore` never try to find out ignore rules by traversing directories or fetching from git configurations.
+  - `ignore` don't cares about sub-modules of git projects.
+
+- Exactly according to [gitignore man page](http://git-scm.com/docs/gitignore), fixes some known matching issues of fstream-ignore, such as:
+  - '`/*.js`' should only match '`a.js`', but not '`abc/a.js`'.
+  - '`**/foo`' should match '`foo`' anywhere.
+  - Prevent re-including a file if a parent directory of that file is excluded.
+  - Handle trailing whitespaces:
+    - `'a '`(one space) should not match `'a  '`(two spaces).
+    - `'a \ '` matches `'a  '`
+  - All test cases are verified with the result of `git check-ignore`.
+
+# Methods
+
+## .add(pattern: string | Ignore): this
+## .add(patterns: Array<string | Ignore>): this
+
+- **pattern** `String | Ignore` An ignore pattern string, or the `Ignore` instance
+- **patterns** `Array<String | Ignore>` Array of ignore patterns.
+
+Adds a rule or several rules to the current manager.
+
+Returns `this`
+
+Notice that a line starting with `'#'`(hash) is treated as a comment. Put a backslash (`'\'`) in front of the first hash for patterns that begin with a hash, if you want to ignore a file with a hash at the beginning of the filename.
+
+```js
+ignore().add('#abc').ignores('#abc')    // false
+ignore().add('\#abc').ignores('#abc')   // true
+```
+
+`pattern` could either be a line of ignore pattern or a string of multiple ignore patterns, which means we could just `ignore().add()` the content of a ignore file:
+
+```js
+ignore()
+.add(fs.readFileSync(filenameOfGitignore).toString())
+.filter(filenames)
+```
+
+`pattern` could also be an `ignore` instance, so that we could easily inherit the rules of another `Ignore` instance.
+
+## <strike>.addIgnoreFile(path)</strike>
+
+REMOVED in `3.x` for now.
+
+To upgrade `ignore@2.x` up to `3.x`, use
+
+```js
+import fs from 'fs'
+
+if (fs.existsSync(filename)) {
+  ignore().add(fs.readFileSync(filename).toString())
+}
+```
+
+instead.
+
+## .filter(paths: Array<Pathname>): Array<Pathname>
+
+```ts
+type Pathname = string
+```
+
+Filters the given array of pathnames, and returns the filtered array.
+
+- **paths** `Array.<Pathname>` The array of `pathname`s to be filtered.
+
+### `Pathname` Conventions:
+
+#### 1. `Pathname` should be a `path.relative()`d pathname
+
+`Pathname` should be a string that have been `path.join()`ed, or the return value of `path.relative()` to the current directory.
+
+```js
+// WRONG
+ig.ignores('./abc')
+
+// WRONG, for it will never happen.
+// If the gitignore rule locates at the root directory,
+// `'/abc'` should be changed to `'abc'`.
+// ```
+// path.relative('/', '/abc')  -> 'abc'
+// ```
+ig.ignores('/abc')
+
+// Right
+ig.ignores('abc')
+
+// Right
+ig.ignores(path.join('./abc'))  // path.join('./abc') -> 'abc'
+```
+
+In other words, each `Pathname` here should be a relative path to the directory of the gitignore rules.
+
+Suppose the dir structure is:
+
+```
+/path/to/your/repo
+    |-- a
+    |   |-- a.js
+    |
+    |-- .b
+    |
+    |-- .c
+         |-- .DS_store
+```
+
+Then the `paths` might be like this:
+
+```js
+[
+  'a/a.js'
+  '.b',
+  '.c/.DS_store'
+]
+```
+
+Usually, you could use [`glob`](http://npmjs.org/package/glob) with `option.mark = true` to fetch the structure of the current directory:
+
+```js
+import glob from 'glob'
+
+glob('**', {
+  // Adds a / character to directory matches.
+  mark: true
+}, (err, files) => {
+  if (err) {
+    return console.error(err)
+  }
+
+  let filtered = ignore().add(patterns).filter(files)
+  console.log(filtered)
+})
+```
+
+#### 2. filenames and dirnames
+
+`node-ignore` does NO `fs.stat` during path matching, so for the example below:
+
+```js
+ig.add('config/')
+
+// `ig` does NOT know if 'config' is a normal file, directory or something
+ig.ignores('config')    // And it returns `false`
+
+ig.ignores('config/')   // returns `true`
+```
+
+Specially for people who develop some library based on `node-ignore`, it is important to understand that.
+
+## .ignores(pathname: Pathname): boolean
+
+> new in 3.2.0
+
+Returns `Boolean` whether `pathname` should be ignored.
+
+```js
+ig.ignores('.abc/a.js')    // true
+```
+
+## .createFilter()
+
+Creates a filter function which could filter an array of paths with `Array.prototype.filter`.
+
+Returns `function(path)` the filter function.
+
+## `options.ignorecase` since 4.0.0
+
+Similar as the `core.ignorecase` option of [git-config](https://git-scm.com/docs/git-config), `node-ignore` will be case insensitive if `options.ignorecase` is set to `true` (default value), otherwise case sensitive.
+
+```js
+const ig = ignore({
+  ignorecase: false
+})
+
+ig.add('*.png')
+
+ig.ignores('*.PNG')  // false
+```
+
+****
+
+# Upgrade Guide
+
+## Upgrade 2.x -> 3.x
+
+- All `options` of 2.x are unnecessary and removed, so just remove them.
+- `ignore()` instance is no longer an [`EventEmitter`](nodejs.org/api/events.html), and all events are unnecessary and removed.
+- `.addIgnoreFile()` is removed, see the [.addIgnoreFile](#addignorefilepath) section for details.
+
+## Upgrade 3.x -> 4.x
+
+Since `4.0.0`, `ignore` will no longer support node < 6, to use `ignore` in node < 6:
+
+```js
+var ignore = require('ignore/legacy')
+```
+
+****
+
+# Collaborators
+
+- [@whitecolor](https://github.com/whitecolor) *Alex*
+- [@SamyPesse](https://github.com/SamyPesse) *Samy Pessé*
+- [@azproduction](https://github.com/azproduction) *Mikhail Davydov*
+- [@TrySound](https://github.com/TrySound) *Bogdan Chadkin*
+- [@JanMattner](https://github.com/JanMattner) *Jan Mattner*
+- [@ntwb](https://github.com/ntwb) *Stephen Edgar*
+- [@kasperisager](https://github.com/kasperisager) *Kasper Isager*
+- [@sandersn](https://github.com/sandersn) *Nathan Shively-Sanders*

node_modules/@eslint/eslintrc/node_modules/ignore/index.d.ts

@@ -0,0 +1,45 @@
+interface Ignore {
+  /**
+   * Adds a rule rules to the current manager.
+   * @param  {string | Ignore} pattern
+   * @returns IgnoreBase
+   */
+  add(pattern: string | Ignore): Ignore
+  /**
+   * Adds several rules to the current manager.
+   * @param  {string[]} patterns
+   * @returns IgnoreBase
+   */
+  add(patterns: (string | Ignore)[]): Ignore
+
+  /**
+   * Filters the given array of pathnames, and returns the filtered array.
+   * NOTICE that each path here should be a relative path to the root of your repository.
+   * @param paths the array of paths to be filtered.
+   * @returns The filtered array of paths
+   */
+  filter(paths: string[]): string[]
+  /**
+   * Creates a filter function which could filter
+   * an array of paths with Array.prototype.filter.
+   */
+  createFilter(): (path: string) => boolean
+
+  /**
+   * Returns Boolean whether pathname should be ignored.
+   * @param  {string} pathname a path to check
+   * @returns boolean
+   */
+  ignores(pathname: string): boolean
+}
+
+interface Options {
+  ignorecase?: boolean
+}
+
+/**
+ * Creates new ignore manager.
+ */
+declare function ignore(options?: Options): Ignore
+
+export default ignore

node_modules/@eslint/eslintrc/node_modules/ignore/index.js

@@ -0,0 +1,463 @@
+// A simple implementation of make-array
+function make_array (subject) {
+  return Array.isArray(subject)
+    ? subject
+    : [subject]
+}
+
+const REGEX_BLANK_LINE = /^\s+$/
+const REGEX_LEADING_EXCAPED_EXCLAMATION = /^\\!/
+const REGEX_LEADING_EXCAPED_HASH = /^\\#/
+const SLASH = '/'
+const KEY_IGNORE = typeof Symbol !== 'undefined'
+  ? Symbol.for('node-ignore')
+  /* istanbul ignore next */
+  : 'node-ignore'
+
+const define = (object, key, value) =>
+  Object.defineProperty(object, key, {value})
+
+const REGEX_REGEXP_RANGE = /([0-z])-([0-z])/g
+
+// Sanitize the range of a regular expression
+// The cases are complicated, see test cases for details
+const sanitizeRange = range => range.replace(
+  REGEX_REGEXP_RANGE,
+  (match, from, to) => from.charCodeAt(0) <= to.charCodeAt(0)
+    ? match
+    // Invalid range (out of order) which is ok for gitignore rules but
+    //   fatal for JavaScript regular expression, so eliminate it.
+    : ''
+)
+
+// > If the pattern ends with a slash,
+// > it is removed for the purpose of the following description,
+// > but it would only find a match with a directory.
+// > In other words, foo/ will match a directory foo and paths underneath it,
+// > but will not match a regular file or a symbolic link foo
+// >  (this is consistent with the way how pathspec works in general in Git).
+// '`foo/`' will not match regular file '`foo`' or symbolic link '`foo`'
+// -> ignore-rules will not deal with it, because it costs extra `fs.stat` call
+//      you could use option `mark: true` with `glob`
+
+// '`foo/`' should not continue with the '`..`'
+const DEFAULT_REPLACER_PREFIX = [
+
+  // > Trailing spaces are ignored unless they are quoted with backslash ("\")
+  [
+    // (a\ ) -> (a )
+    // (a  ) -> (a)
+    // (a \ ) -> (a  )
+    /\\?\s+$/,
+    match => match.indexOf('\\') === 0
+      ? ' '
+      : ''
+  ],
+
+  // replace (\ ) with ' '
+  [
+    /\\\s/g,
+    () => ' '
+  ],
+
+  // Escape metacharacters
+  // which is written down by users but means special for regular expressions.
+
+  // > There are 12 characters with special meanings:
+  // > - the backslash \,
+  // > - the caret ^,
+  // > - the dollar sign $,
+  // > - the period or dot .,
+  // > - the vertical bar or pipe symbol |,
+  // > - the question mark ?,
+  // > - the asterisk or star *,
+  // > - the plus sign +,
+  // > - the opening parenthesis (,
+  // > - the closing parenthesis ),
+  // > - and the opening square bracket [,
+  // > - the opening curly brace {,
+  // > These special characters are often called "metacharacters".
+  [
+    /[\\^$.|*+(){]/g,
+    match => `\\${match}`
+  ],
+
+  [
+    // > [abc] matches any character inside the brackets
+    // >    (in this case a, b, or c);
+    /\[([^\]/]*)($|\])/g,
+    (match, p1, p2) => p2 === ']'
+      ? `[${sanitizeRange(p1)}]`
+      : `\\${match}`
+  ],
+
+  [
+    // > a question mark (?) matches a single character
+    /(?!\\)\?/g,
+    () => '[^/]'
+  ],
+
+  // leading slash
+  [
+
+    // > A leading slash matches the beginning of the pathname.
+    // > For example, "/*.c" matches "cat-file.c" but not "mozilla-sha1/sha1.c".
+    // A leading slash matches the beginning of the pathname
+    /^\//,
+    () => '^'
+  ],
+
+  // replace special metacharacter slash after the leading slash
+  [
+    /\//g,
+    () => '\\/'
+  ],
+
+  [
+    // > A leading "**" followed by a slash means match in all directories.
+    // > For example, "**/foo" matches file or directory "foo" anywhere,
+    // > the same as pattern "foo".
+    // > "**/foo/bar" matches file or directory "bar" anywhere that is directly
+    // >   under directory "foo".
+    // Notice that the '*'s have been replaced as '\\*'
+    /^\^*\\\*\\\*\\\//,
+
+    // '**/foo' <-> 'foo'
+    () => '^(?:.*\\/)?'
+  ]
+]
+
+const DEFAULT_REPLACER_SUFFIX = [
+  // starting
+  [
+    // there will be no leading '/'
+    //   (which has been replaced by section "leading slash")
+    // If starts with '**', adding a '^' to the regular expression also works
+    /^(?=[^^])/,
+    function startingReplacer () {
+      return !/\/(?!$)/.test(this)
+        // > If the pattern does not contain a slash /,
+        // >   Git treats it as a shell glob pattern
+        // Actually, if there is only a trailing slash,
+        //   git also treats it as a shell glob pattern
+        ? '(?:^|\\/)'
+
+        // > Otherwise, Git treats the pattern as a shell glob suitable for
+        // >   consumption by fnmatch(3)
+        : '^'
+    }
+  ],
+
+  // two globstars
+  [
+    // Use lookahead assertions so that we could match more than one `'/**'`
+    /\\\/\\\*\\\*(?=\\\/|$)/g,
+
+    // Zero, one or several directories
+    // should not use '*', or it will be replaced by the next replacer
+
+    // Check if it is not the last `'/**'`
+    (match, index, str) => index + 6 < str.length
+
+      // case: /**/
+      // > A slash followed by two consecutive asterisks then a slash matches
+      // >   zero or more directories.
+      // > For example, "a/**/b" matches "a/b", "a/x/b", "a/x/y/b" and so on.
+      // '/**/'
+      ? '(?:\\/[^\\/]+)*'
+
+      // case: /**
+      // > A trailing `"/**"` matches everything inside.
+
+      // #21: everything inside but it should not include the current folder
+      : '\\/.+'
+  ],
+
+  // intermediate wildcards
+  [
+    // Never replace escaped '*'
+    // ignore rule '\*' will match the path '*'
+
+    // 'abc.*/' -> go
+    // 'abc.*'  -> skip this rule
+    /(^|[^\\]+)\\\*(?=.+)/g,
+
+    // '*.js' matches '.js'
+    // '*.js' doesn't match 'abc'
+    (match, p1) => `${p1}[^\\/]*`
+  ],
+
+  // trailing wildcard
+  [
+    /(\^|\\\/)?\\\*$/,
+    (match, p1) => {
+      const prefix = p1
+        // '\^':
+        // '/*' does not match ''
+        // '/*' does not match everything
+
+        // '\\\/':
+        // 'abc/*' does not match 'abc/'
+        ? `${p1}[^/]+`
+
+        // 'a*' matches 'a'
+        // 'a*' matches 'aa'
+        : '[^/]*'
+
+      return `${prefix}(?=$|\\/$)`
+    }
+  ],
+
+  [
+    // unescape
+    /\\\\\\/g,
+    () => '\\'
+  ]
+]
+
+const POSITIVE_REPLACERS = [
+  ...DEFAULT_REPLACER_PREFIX,
+
+  // 'f'
+  // matches
+  // - /f(end)
+  // - /f/
+  // - (start)f(end)
+  // - (start)f/
+  // doesn't match
+  // - oof
+  // - foo
+  // pseudo:
+  // -> (^|/)f(/|$)
+
+  // ending
+  [
+    // 'js' will not match 'js.'
+    // 'ab' will not match 'abc'
+    /(?:[^*/])$/,
+
+    // 'js*' will not match 'a.js'
+    // 'js/' will not match 'a.js'
+    // 'js' will match 'a.js' and 'a.js/'
+    match => `${match}(?=$|\\/)`
+  ],
+
+  ...DEFAULT_REPLACER_SUFFIX
+]
+
+const NEGATIVE_REPLACERS = [
+  ...DEFAULT_REPLACER_PREFIX,
+
+  // #24, #38
+  // The MISSING rule of [gitignore docs](https://git-scm.com/docs/gitignore)
+  // A negative pattern without a trailing wildcard should not
+  // re-include the things inside that directory.
+
+  // eg:
+  // ['node_modules/*', '!node_modules']
+  // should ignore `node_modules/a.js`
+  [
+    /(?:[^*])$/,
+    match => `${match}(?=$|\\/$)`
+  ],
+
+  ...DEFAULT_REPLACER_SUFFIX
+]
+
+// A simple cache, because an ignore rule only has only one certain meaning
+const cache = Object.create(null)
+
+// @param {pattern}
+const make_regex = (pattern, negative, ignorecase) => {
+  const r = cache[pattern]
+  if (r) {
+    return r
+  }
+
+  const replacers = negative
+    ? NEGATIVE_REPLACERS
+    : POSITIVE_REPLACERS
+
+  const source = replacers.reduce(
+    (prev, current) => prev.replace(current[0], current[1].bind(pattern)),
+    pattern
+  )
+
+  return cache[pattern] = ignorecase
+    ? new RegExp(source, 'i')
+    : new RegExp(source)
+}
+
+// > A blank line matches no files, so it can serve as a separator for readability.
+const checkPattern = pattern => pattern
+  && typeof pattern === 'string'
+  && !REGEX_BLANK_LINE.test(pattern)
+
+  // > A line starting with # serves as a comment.
+  && pattern.indexOf('#') !== 0
+
+const createRule = (pattern, ignorecase) => {
+  const origin = pattern
+  let negative = false
+
+  // > An optional prefix "!" which negates the pattern;
+  if (pattern.indexOf('!') === 0) {
+    negative = true
+    pattern = pattern.substr(1)
+  }
+
+  pattern = pattern
+  // > Put a backslash ("\") in front of the first "!" for patterns that
+  // >   begin with a literal "!", for example, `"\!important!.txt"`.
+  .replace(REGEX_LEADING_EXCAPED_EXCLAMATION, '!')
+  // > Put a backslash ("\") in front of the first hash for patterns that
+  // >   begin with a hash.
+  .replace(REGEX_LEADING_EXCAPED_HASH, '#')
+
+  const regex = make_regex(pattern, negative, ignorecase)
+
+  return {
+    origin,
+    pattern,
+    negative,
+    regex
+  }
+}
+
+class IgnoreBase {
+  constructor ({
+    ignorecase = true
+  } = {}) {
+    this._rules = []
+    this._ignorecase = ignorecase
+    define(this, KEY_IGNORE, true)
+    this._initCache()
+  }
+
+  _initCache () {
+    this._cache = Object.create(null)
+  }
+
+  // @param {Array.<string>|string|Ignore} pattern
+  add (pattern) {
+    this._added = false
+
+    if (typeof pattern === 'string') {
+      pattern = pattern.split(/\r?\n/g)
+    }
+
+    make_array(pattern).forEach(this._addPattern, this)
+
+    // Some rules have just added to the ignore,
+    // making the behavior changed.
+    if (this._added) {
+      this._initCache()
+    }
+
+    return this
+  }
+
+  // legacy
+  addPattern (pattern) {
+    return this.add(pattern)
+  }
+
+  _addPattern (pattern) {
+    // #32
+    if (pattern && pattern[KEY_IGNORE]) {
+      this._rules = this._rules.concat(pattern._rules)
+      this._added = true
+      return
+    }
+
+    if (checkPattern(pattern)) {
+      const rule = createRule(pattern, this._ignorecase)
+      this._added = true
+      this._rules.push(rule)
+    }
+  }
+
+  filter (paths) {
+    return make_array(paths).filter(path => this._filter(path))
+  }
+
+  createFilter () {
+    return path => this._filter(path)
+  }
+
+  ignores (path) {
+    return !this._filter(path)
+  }
+
+  // @returns `Boolean` true if the `path` is NOT ignored
+  _filter (path, slices) {
+    if (!path) {
+      return false
+    }
+
+    if (path in this._cache) {
+      return this._cache[path]
+    }
+
+    if (!slices) {
+      // path/to/a.js
+      // ['path', 'to', 'a.js']
+      slices = path.split(SLASH)
+    }
+
+    slices.pop()
+
+    return this._cache[path] = slices.length
+      // > It is not possible to re-include a file if a parent directory of
+      // >   that file is excluded.
+      // If the path contains a parent directory, check the parent first
+      ? this._filter(slices.join(SLASH) + SLASH, slices)
+        && this._test(path)
+
+      // Or only test the path
+      : this._test(path)
+  }
+
+  // @returns {Boolean} true if a file is NOT ignored
+  _test (path) {
+    // Explicitly define variable type by setting matched to `0`
+    let matched = 0
+
+    this._rules.forEach(rule => {
+      // if matched = true, then we only test negative rules
+      // if matched = false, then we test non-negative rules
+      if (!(matched ^ rule.negative)) {
+        matched = rule.negative ^ rule.regex.test(path)
+      }
+    })
+
+    return !matched
+  }
+}
+
+// Windows
+// --------------------------------------------------------------
+/* istanbul ignore if  */
+if (
+  // Detect `process` so that it can run in browsers.
+  typeof process !== 'undefined'
+  && (
+    process.env && process.env.IGNORE_TEST_WIN32
+    || process.platform === 'win32'
+  )
+) {
+  const filter = IgnoreBase.prototype._filter
+
+  /* eslint no-control-regex: "off" */
+  const make_posix = str => /^\\\\\?\\/.test(str)
+  || /[^\x00-\x80]+/.test(str)
+    ? str
+    : str.replace(/\\/g, '/')
+
+  IgnoreBase.prototype._filter = function filterWin32 (path, slices) {
+    path = make_posix(path)
+    return filter.call(this, path, slices)
+  }
+}
+
+module.exports = options => new IgnoreBase(options)

node_modules/@eslint/eslintrc/node_modules/ignore/legacy.js

@@ -0,0 +1,466 @@
+'use strict';
+
+var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
+
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+// A simple implementation of make-array
+function make_array(subject) {
+  return Array.isArray(subject) ? subject : [subject];
+}
+
+var REGEX_BLANK_LINE = /^\s+$/;
+var REGEX_LEADING_EXCAPED_EXCLAMATION = /^\\!/;
+var REGEX_LEADING_EXCAPED_HASH = /^\\#/;
+var SLASH = '/';
+var KEY_IGNORE = typeof Symbol !== 'undefined' ? Symbol.for('node-ignore')
+/* istanbul ignore next */
+: 'node-ignore';
+
+var define = function define(object, key, value) {
+  return Object.defineProperty(object, key, { value });
+};
+
+var REGEX_REGEXP_RANGE = /([0-z])-([0-z])/g;
+
+// Sanitize the range of a regular expression
+// The cases are complicated, see test cases for details
+var sanitizeRange = function sanitizeRange(range) {
+  return range.replace(REGEX_REGEXP_RANGE, function (match, from, to) {
+    return from.charCodeAt(0) <= to.charCodeAt(0) ? match
+    // Invalid range (out of order) which is ok for gitignore rules but
+    //   fatal for JavaScript regular expression, so eliminate it.
+    : '';
+  });
+};
+
+// > If the pattern ends with a slash,
+// > it is removed for the purpose of the following description,
+// > but it would only find a match with a directory.
+// > In other words, foo/ will match a directory foo and paths underneath it,
+// > but will not match a regular file or a symbolic link foo
+// >  (this is consistent with the way how pathspec works in general in Git).
+// '`foo/`' will not match regular file '`foo`' or symbolic link '`foo`'
+// -> ignore-rules will not deal with it, because it costs extra `fs.stat` call
+//      you could use option `mark: true` with `glob`
+
+// '`foo/`' should not continue with the '`..`'
+var DEFAULT_REPLACER_PREFIX = [
+
+// > Trailing spaces are ignored unless they are quoted with backslash ("\")
+[
+// (a\ ) -> (a )
+// (a  ) -> (a)
+// (a \ ) -> (a  )
+/\\?\s+$/, function (match) {
+  return match.indexOf('\\') === 0 ? ' ' : '';
+}],
+
+// replace (\ ) with ' '
+[/\\\s/g, function () {
+  return ' ';
+}],
+
+// Escape metacharacters
+// which is written down by users but means special for regular expressions.
+
+// > There are 12 characters with special meanings:
+// > - the backslash \,
+// > - the caret ^,
+// > - the dollar sign $,
+// > - the period or dot .,
+// > - the vertical bar or pipe symbol |,
+// > - the question mark ?,
+// > - the asterisk or star *,
+// > - the plus sign +,
+// > - the opening parenthesis (,
+// > - the closing parenthesis ),
+// > - and the opening square bracket [,
+// > - the opening curly brace {,
+// > These special characters are often called "metacharacters".
+[/[\\^$.|*+(){]/g, function (match) {
+  return `\\${match}`;
+}], [
+// > [abc] matches any character inside the brackets
+// >    (in this case a, b, or c);
+/\[([^\]/]*)($|\])/g, function (match, p1, p2) {
+  return p2 === ']' ? `[${sanitizeRange(p1)}]` : `\\${match}`;
+}], [
+// > a question mark (?) matches a single character
+/(?!\\)\?/g, function () {
+  return '[^/]';
+}],
+
+// leading slash
+[
+
+// > A leading slash matches the beginning of the pathname.
+// > For example, "/*.c" matches "cat-file.c" but not "mozilla-sha1/sha1.c".
+// A leading slash matches the beginning of the pathname
+/^\//, function () {
+  return '^';
+}],
+
+// replace special metacharacter slash after the leading slash
+[/\//g, function () {
+  return '\\/';
+}], [
+// > A leading "**" followed by a slash means match in all directories.
+// > For example, "**/foo" matches file or directory "foo" anywhere,
+// > the same as pattern "foo".
+// > "**/foo/bar" matches file or directory "bar" anywhere that is directly
+// >   under directory "foo".
+// Notice that the '*'s have been replaced as '\\*'
+/^\^*\\\*\\\*\\\//,
+
+// '**/foo' <-> 'foo'
+function () {
+  return '^(?:.*\\/)?';
+}]];
+
+var DEFAULT_REPLACER_SUFFIX = [
+// starting
+[
+// there will be no leading '/'
+//   (which has been replaced by section "leading slash")
+// If starts with '**', adding a '^' to the regular expression also works
+/^(?=[^^])/, function startingReplacer() {
+  return !/\/(?!$)/.test(this)
+  // > If the pattern does not contain a slash /,
+  // >   Git treats it as a shell glob pattern
+  // Actually, if there is only a trailing slash,
+  //   git also treats it as a shell glob pattern
+  ? '(?:^|\\/)'
+
+  // > Otherwise, Git treats the pattern as a shell glob suitable for
+  // >   consumption by fnmatch(3)
+  : '^';
+}],
+
+// two globstars
+[
+// Use lookahead assertions so that we could match more than one `'/**'`
+/\\\/\\\*\\\*(?=\\\/|$)/g,
+
+// Zero, one or several directories
+// should not use '*', or it will be replaced by the next replacer
+
+// Check if it is not the last `'/**'`
+function (match, index, str) {
+  return index + 6 < str.length
+
+  // case: /**/
+  // > A slash followed by two consecutive asterisks then a slash matches
+  // >   zero or more directories.
+  // > For example, "a/**/b" matches "a/b", "a/x/b", "a/x/y/b" and so on.
+  // '/**/'
+  ? '(?:\\/[^\\/]+)*'
+
+  // case: /**
+  // > A trailing `"/**"` matches everything inside.
+
+  // #21: everything inside but it should not include the current folder
+  : '\\/.+';
+}],
+
+// intermediate wildcards
+[
+// Never replace escaped '*'
+// ignore rule '\*' will match the path '*'
+
+// 'abc.*/' -> go
+// 'abc.*'  -> skip this rule
+/(^|[^\\]+)\\\*(?=.+)/g,
+
+// '*.js' matches '.js'
+// '*.js' doesn't match 'abc'
+function (match, p1) {
+  return `${p1}[^\\/]*`;
+}],
+
+// trailing wildcard
+[/(\^|\\\/)?\\\*$/, function (match, p1) {
+  var prefix = p1
+  // '\^':
+  // '/*' does not match ''
+  // '/*' does not match everything
+
+  // '\\\/':
+  // 'abc/*' does not match 'abc/'
+  ? `${p1}[^/]+`
+
+  // 'a*' matches 'a'
+  // 'a*' matches 'aa'
+  : '[^/]*';
+
+  return `${prefix}(?=$|\\/$)`;
+}], [
+// unescape
+/\\\\\\/g, function () {
+  return '\\';
+}]];
+
+var POSITIVE_REPLACERS = [].concat(DEFAULT_REPLACER_PREFIX, [
+
+// 'f'
+// matches
+// - /f(end)
+// - /f/
+// - (start)f(end)
+// - (start)f/
+// doesn't match
+// - oof
+// - foo
+// pseudo:
+// -> (^|/)f(/|$)
+
+// ending
+[
+// 'js' will not match 'js.'
+// 'ab' will not match 'abc'
+/(?:[^*/])$/,
+
+// 'js*' will not match 'a.js'
+// 'js/' will not match 'a.js'
+// 'js' will match 'a.js' and 'a.js/'
+function (match) {
+  return `${match}(?=$|\\/)`;
+}]], DEFAULT_REPLACER_SUFFIX);
+
+var NEGATIVE_REPLACERS = [].concat(DEFAULT_REPLACER_PREFIX, [
+
+// #24, #38
+// The MISSING rule of [gitignore docs](https://git-scm.com/docs/gitignore)
+// A negative pattern without a trailing wildcard should not
+// re-include the things inside that directory.
+
+// eg:
+// ['node_modules/*', '!node_modules']
+// should ignore `node_modules/a.js`
+[/(?:[^*])$/, function (match) {
+  return `${match}(?=$|\\/$)`;
+}]], DEFAULT_REPLACER_SUFFIX);
+
+// A simple cache, because an ignore rule only has only one certain meaning
+var cache = Object.create(null);
+
+// @param {pattern}
+var make_regex = function make_regex(pattern, negative, ignorecase) {
+  var r = cache[pattern];
+  if (r) {
+    return r;
+  }
+
+  var replacers = negative ? NEGATIVE_REPLACERS : POSITIVE_REPLACERS;
+
+  var source = replacers.reduce(function (prev, current) {
+    return prev.replace(current[0], current[1].bind(pattern));
+  }, pattern);
+
+  return cache[pattern] = ignorecase ? new RegExp(source, 'i') : new RegExp(source);
+};
+
+// > A blank line matches no files, so it can serve as a separator for readability.
+var checkPattern = function checkPattern(pattern) {
+  return pattern && typeof pattern === 'string' && !REGEX_BLANK_LINE.test(pattern)
+
+  // > A line starting with # serves as a comment.
+  && pattern.indexOf('#') !== 0;
+};
+
+var createRule = function createRule(pattern, ignorecase) {
+  var origin = pattern;
+  var negative = false;
+
+  // > An optional prefix "!" which negates the pattern;
+  if (pattern.indexOf('!') === 0) {
+    negative = true;
+    pattern = pattern.substr(1);
+  }
+
+  pattern = pattern
+  // > Put a backslash ("\") in front of the first "!" for patterns that
+  // >   begin with a literal "!", for example, `"\!important!.txt"`.
+  .replace(REGEX_LEADING_EXCAPED_EXCLAMATION, '!')
+  // > Put a backslash ("\") in front of the first hash for patterns that
+  // >   begin with a hash.
+  .replace(REGEX_LEADING_EXCAPED_HASH, '#');
+
+  var regex = make_regex(pattern, negative, ignorecase);
+
+  return {
+    origin,
+    pattern,
+    negative,
+    regex
+  };
+};
+
+var IgnoreBase = function () {
+  function IgnoreBase() {
+    var _ref = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {},
+        _ref$ignorecase = _ref.ignorecase,
+        ignorecase = _ref$ignorecase === undefined ? true : _ref$ignorecase;
+
+    _classCallCheck(this, IgnoreBase);
+
+    this._rules = [];
+    this._ignorecase = ignorecase;
+    define(this, KEY_IGNORE, true);
+    this._initCache();
+  }
+
+  _createClass(IgnoreBase, [{
+    key: '_initCache',
+    value: function _initCache() {
+      this._cache = Object.create(null);
+    }
+
+    // @param {Array.<string>|string|Ignore} pattern
+
+  }, {
+    key: 'add',
+    value: function add(pattern) {
+      this._added = false;
+
+      if (typeof pattern === 'string') {
+        pattern = pattern.split(/\r?\n/g);
+      }
+
+      make_array(pattern).forEach(this._addPattern, this);
+
+      // Some rules have just added to the ignore,
+      // making the behavior changed.
+      if (this._added) {
+        this._initCache();
+      }
+
+      return this;
+    }
+
+    // legacy
+
+  }, {
+    key: 'addPattern',
+    value: function addPattern(pattern) {
+      return this.add(pattern);
+    }
+  }, {
+    key: '_addPattern',
+    value: function _addPattern(pattern) {
+      // #32
+      if (pattern && pattern[KEY_IGNORE]) {
+        this._rules = this._rules.concat(pattern._rules);
+        this._added = true;
+        return;
+      }
+
+      if (checkPattern(pattern)) {
+        var rule = createRule(pattern, this._ignorecase);
+        this._added = true;
+        this._rules.push(rule);
+      }
+    }
+  }, {
+    key: 'filter',
+    value: function filter(paths) {
+      var _this = this;
+
+      return make_array(paths).filter(function (path) {
+        return _this._filter(path);
+      });
+    }
+  }, {
+    key: 'createFilter',
+    value: function createFilter() {
+      var _this2 = this;
+
+      return function (path) {
+        return _this2._filter(path);
+      };
+    }
+  }, {
+    key: 'ignores',
+    value: function ignores(path) {
+      return !this._filter(path);
+    }
+
+    // @returns `Boolean` true if the `path` is NOT ignored
+
+  }, {
+    key: '_filter',
+    value: function _filter(path, slices) {
+      if (!path) {
+        return false;
+      }
+
+      if (path in this._cache) {
+        return this._cache[path];
+      }
+
+      if (!slices) {
+        // path/to/a.js
+        // ['path', 'to', 'a.js']
+        slices = path.split(SLASH);
+      }
+
+      slices.pop();
+
+      return this._cache[path] = slices.length
+      // > It is not possible to re-include a file if a parent directory of
+      // >   that file is excluded.
+      // If the path contains a parent directory, check the parent first
+      ? this._filter(slices.join(SLASH) + SLASH, slices) && this._test(path)
+
+      // Or only test the path
+      : this._test(path);
+    }
+
+    // @returns {Boolean} true if a file is NOT ignored
+
+  }, {
+    key: '_test',
+    value: function _test(path) {
+      // Explicitly define variable type by setting matched to `0`
+      var matched = 0;
+
+      this._rules.forEach(function (rule) {
+        // if matched = true, then we only test negative rules
+        // if matched = false, then we test non-negative rules
+        if (!(matched ^ rule.negative)) {
+          matched = rule.negative ^ rule.regex.test(path);
+        }
+      });
+
+      return !matched;
+    }
+  }]);
+
+  return IgnoreBase;
+}();
+
+// Windows
+// --------------------------------------------------------------
+/* istanbul ignore if  */
+
+
+if (
+// Detect `process` so that it can run in browsers.
+typeof process !== 'undefined' && (process.env && process.env.IGNORE_TEST_WIN32 || process.platform === 'win32')) {
+  var filter = IgnoreBase.prototype._filter;
+
+  /* eslint no-control-regex: "off" */
+  var make_posix = function make_posix(str) {
+    return (/^\\\\\?\\/.test(str) || /[^\x00-\x80]+/.test(str) ? str : str.replace(/\\/g, '/')
+    );
+  };
+
+  IgnoreBase.prototype._filter = function filterWin32(path, slices) {
+    path = make_posix(path);
+    return filter.call(this, path, slices);
+  };
+}
+
+module.exports = function (options) {
+  return new IgnoreBase(options);
+};

node_modules/@eslint/eslintrc/node_modules/ignore/package.json

@@ -0,0 +1,64 @@
+{
+  "name": "ignore",
+  "version": "4.0.6",
+  "description": "Ignore is a manager and filter for .gitignore rules.",
+  "files": [
+    "legacy.js",
+    "index.js",
+    "index.d.ts",
+    "LICENSE-MIT"
+  ],
+  "scripts": {
+    "prepublish": "npm run build",
+    "build": "babel -o legacy.js index.js",
+    "test:lint": "eslint .",
+    "test:tsc": "tsc ./test/ts/simple.ts",
+    "test:git": "tap test/git-check-ignore.js",
+    "test:ignore": "tap test/ignore.js --coverage",
+    "test-no-cov": "npm run test:lint && npm run test:tsc && tap test/*.js --coverage",
+    "test": "npm run test-no-cov",
+    "posttest": "tap --coverage-report=html && codecov"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git@github.com:kaelzhang/node-ignore.git"
+  },
+  "keywords": [
+    "ignore",
+    ".gitignore",
+    "gitignore",
+    "npmignore",
+    "rules",
+    "manager",
+    "filter",
+    "regexp",
+    "regex",
+    "fnmatch",
+    "glob",
+    "asterisks",
+    "regular-expression"
+  ],
+  "author": "kael",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/kaelzhang/node-ignore/issues"
+  },
+  "devDependencies": {
+    "babel-cli": "^6.26.0",
+    "babel-preset-env": "^1.7.0",
+    "codecov": "^3.0.4",
+    "eslint": "^5.3.0",
+    "eslint-config-ostai": "^1.3.2",
+    "eslint-plugin-import": "^2.13.0",
+    "mkdirp": "^0.5.1",
+    "pre-suf": "^1.1.0",
+    "rimraf": "^2.6.2",
+    "spawn-sync": "^2.0.0",
+    "tap": "^12.0.1",
+    "tmp": "0.0.33",
+    "typescript": "^3.0.1"
+  },
+  "engines": {
+    "node": ">= 4"
+  }
+}

node_modules/@eslint/eslintrc/node_modules/strip-json-comments/index.d.ts

@@ -0,0 +1,36 @@
+declare namespace stripJsonComments {
+	interface Options {
+		/**
+		Replace comments with whitespace instead of stripping them entirely.
+
+		@default true
+		*/
+		readonly whitespace?: boolean;
+	}
+}
+
+/**
+Strip comments from JSON. Lets you use comments in your JSON files!
+
+It will replace single-line comments `//` and multi-line comments `/**\/` with whitespace. This allows JSON error positions to remain as close as possible to the original source.
+
+@param jsonString - Accepts a string with JSON.
+@returns A JSON string without comments.
+
+@example
+```
+const json = `{
+	// Rainbows
+	"unicorn": "cake"
+}`;
+
+JSON.parse(stripJsonComments(json));
+//=> {unicorn: 'cake'}
+```
+*/
+declare function stripJsonComments(
+	jsonString: string,
+	options?: stripJsonComments.Options
+): string;
+
+export = stripJsonComments;

node_modules/@eslint/eslintrc/node_modules/strip-json-comments/index.js

@@ -0,0 +1,77 @@
+'use strict';
+const singleComment = Symbol('singleComment');
+const multiComment = Symbol('multiComment');
+const stripWithoutWhitespace = () => '';
+const stripWithWhitespace = (string, start, end) => string.slice(start, end).replace(/\S/g, ' ');
+
+const isEscaped = (jsonString, quotePosition) => {
+	let index = quotePosition - 1;
+	let backslashCount = 0;
+
+	while (jsonString[index] === '\\') {
+		index -= 1;
+		backslashCount += 1;
+	}
+
+	return Boolean(backslashCount % 2);
+};
+
+module.exports = (jsonString, options = {}) => {
+	if (typeof jsonString !== 'string') {
+		throw new TypeError(`Expected argument \`jsonString\` to be a \`string\`, got \`${typeof jsonString}\``);
+	}
+
+	const strip = options.whitespace === false ? stripWithoutWhitespace : stripWithWhitespace;
+
+	let insideString = false;
+	let insideComment = false;
+	let offset = 0;
+	let result = '';
+
+	for (let i = 0; i < jsonString.length; i++) {
+		const currentCharacter = jsonString[i];
+		const nextCharacter = jsonString[i + 1];
+
+		if (!insideComment && currentCharacter === '"') {
+			const escaped = isEscaped(jsonString, i);
+			if (!escaped) {
+				insideString = !insideString;
+			}
+		}
+
+		if (insideString) {
+			continue;
+		}
+
+		if (!insideComment && currentCharacter + nextCharacter === '//') {
+			result += jsonString.slice(offset, i);
+			offset = i;
+			insideComment = singleComment;
+			i++;
+		} else if (insideComment === singleComment && currentCharacter + nextCharacter === '\r\n') {
+			i++;
+			insideComment = false;
+			result += strip(jsonString, offset, i);
+			offset = i;
+			continue;
+		} else if (insideComment === singleComment && currentCharacter === '\n') {
+			insideComment = false;
+			result += strip(jsonString, offset, i);
+			offset = i;
+		} else if (!insideComment && currentCharacter + nextCharacter === '/*') {
+			result += jsonString.slice(offset, i);
+			offset = i;
+			insideComment = multiComment;
+			i++;
+			continue;
+		} else if (insideComment === multiComment && currentCharacter + nextCharacter === '*/') {
+			i++;
+			insideComment = false;
+			result += strip(jsonString, offset, i + 1);
+			offset = i + 1;
+			continue;
+		}
+	}
+
+	return result + (insideComment ? strip(jsonString.slice(offset)) : jsonString.slice(offset));
+};

node_modules/@eslint/eslintrc/node_modules/strip-json-comments/license

@@ -0,0 +1,9 @@
+MIT License
+
+Copyright (c) Sindre Sorhus <sindresorhus@gmail.com> (https://sindresorhus.com)
+
+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/@eslint/eslintrc/node_modules/strip-json-comments/package.json

@@ -0,0 +1,47 @@
+{
+  "name": "strip-json-comments",
+  "version": "3.1.1",
+  "description": "Strip comments from JSON. Lets you use comments in your JSON files!",
+  "license": "MIT",
+  "repository": "sindresorhus/strip-json-comments",
+  "funding": "https://github.com/sponsors/sindresorhus",
+  "author": {
+    "name": "Sindre Sorhus",
+    "email": "sindresorhus@gmail.com",
+    "url": "https://sindresorhus.com"
+  },
+  "engines": {
+    "node": ">=8"
+  },
+  "scripts": {
+    "test": "xo && ava && tsd",
+    "bench": "matcha benchmark.js"
+  },
+  "files": [
+    "index.js",
+    "index.d.ts"
+  ],
+  "keywords": [
+    "json",
+    "strip",
+    "comments",
+    "remove",
+    "delete",
+    "trim",
+    "multiline",
+    "parse",
+    "config",
+    "configuration",
+    "settings",
+    "util",
+    "env",
+    "environment",
+    "jsonc"
+  ],
+  "devDependencies": {
+    "ava": "^1.4.1",
+    "matcha": "^0.7.0",
+    "tsd": "^0.7.2",
+    "xo": "^0.24.0"
+  }
+}

node_modules/@eslint/eslintrc/node_modules/strip-json-comments/readme.md

@@ -0,0 +1,78 @@
+# strip-json-comments [![Build Status](https://travis-ci.com/sindresorhus/strip-json-comments.svg?branch=master)](https://travis-ci.com/github/sindresorhus/strip-json-comments)
+
+> Strip comments from JSON. Lets you use comments in your JSON files!
+
+This is now possible:
+
+```js
+{
+	// Rainbows
+	"unicorn": /* ❤ */ "cake"
+}
+```
+
+It will replace single-line comments `//` and multi-line comments `/**/` with whitespace. This allows JSON error positions to remain as close as possible to the original source.
+
+Also available as a [Gulp](https://github.com/sindresorhus/gulp-strip-json-comments)/[Grunt](https://github.com/sindresorhus/grunt-strip-json-comments)/[Broccoli](https://github.com/sindresorhus/broccoli-strip-json-comments) plugin.
+
+## Install
+
+```
+$ npm install strip-json-comments
+```
+
+## Usage
+
+```js
+const json = `{
+	// Rainbows
+	"unicorn": /* ❤ */ "cake"
+}`;
+
+JSON.parse(stripJsonComments(json));
+//=> {unicorn: 'cake'}
+```
+
+## API
+
+### stripJsonComments(jsonString, options?)
+
+#### jsonString
+
+Type: `string`
+
+Accepts a string with JSON and returns a string without comments.
+
+#### options
+
+Type: `object`
+
+##### whitespace
+
+Type: `boolean`\
+Default: `true`
+
+Replace comments with whitespace instead of stripping them entirely.
+
+## Benchmark
+
+```
+$ npm run bench
+```
+
+## Related
+
+- [strip-json-comments-cli](https://github.com/sindresorhus/strip-json-comments-cli) - CLI for this module
+- [strip-css-comments](https://github.com/sindresorhus/strip-css-comments) - Strip comments from CSS
+
+---
+
+<div align="center">
+	<b>
+		<a href="https://tidelift.com/subscription/pkg/npm-strip-json-comments?utm_source=npm-strip-json-comments&utm_medium=referral&utm_campaign=readme">Get professional support for this package with a Tidelift subscription</a>
+	</b>
+	<br>
+	<sub>
+		Tidelift helps make open source sustainable for maintainers while giving companies<br>assurances about security, maintenance, and licensing for their dependencies.
+	</sub>
+</div>

node_modules/@eslint/eslintrc/package.json

@@ -0,0 +1,59 @@
+{
+  "name": "@eslint/eslintrc",
+  "version": "0.1.3",
+  "description": "The legacy ESLintRC config file format for ESLint",
+  "main": "lib/index.js",
+  "files": [
+    "lib",
+    "conf",
+    "LICENSE"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "lint": "eslint .",
+    "test": "mocha tests/lib/shared",
+    "generate-release": "eslint-generate-release",
+    "generate-alpharelease": "eslint-generate-prerelease alpha",
+    "generate-betarelease": "eslint-generate-prerelease beta",
+    "generate-rcrelease": "eslint-generate-prerelease rc",
+    "publish-release": "eslint-publish-release"
+  },
+  "repository": "eslint/eslintrc",
+  "keywords": [
+    "ESLint",
+    "ESLintRC",
+    "Configuration"
+  ],
+  "author": "Nicholas C. Zakas",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/eslint/eslintrc/issues"
+  },
+  "homepage": "https://github.com/eslint/eslintrc#readme",
+  "devDependencies": {
+    "chai": "^4.2.0",
+    "eslint": "^7.7.0",
+    "eslint-config-eslint": "^6.0.0",
+    "eslint-plugin-jsdoc": "^22.1.0",
+    "eslint-plugin-node": "^11.1.0",
+    "eslint-release": "^3.1.2",
+    "mocha": "^8.1.1"
+  },
+  "dependencies": {
+    "ajv": "^6.12.4",
+    "debug": "^4.1.1",
+    "espree": "^7.3.0",
+    "globals": "^12.1.0",
+    "ignore": "^4.0.6",
+    "import-fresh": "^3.2.1",
+    "js-yaml": "^3.13.1",
+    "lodash": "^4.17.19",
+    "minimatch": "^3.0.4",
+    "strip-json-comments": "^3.1.1"
+  },
+  "engines": {
+    "node": "^10.12.0 || >=12.0.0"
+  }
+}

node_modules/@types/json-schema/LICENSE

@@ -0,0 +1,21 @@
+    MIT License
+
+    Copyright (c) Microsoft Corporation.
+
+    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/@types/json-schema/README.md

@@ -0,0 +1,16 @@
+# Installation
+> `npm install --save @types/json-schema`
+
+# Summary
+This package contains type definitions for json-schema 4.0, 6.0 and (https://github.com/kriszyp/json-schema).
+
+# Details
+Files were exported from https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/json-schema.
+
+### Additional Details
+ * Last updated: Mon, 31 Aug 2020 21:41:49 GMT
+ * Dependencies: none
+ * Global values: none
+
+# Credits
+These definitions were written by [Boris Cherny](https://github.com/bcherny), [Cyrille Tuzi](https://github.com/cyrilletuzi), [Lucian Buzzo](https://github.com/lucianbuzzo), [Roland Groza](https://github.com/rolandjitsu), and [Jason Kwok](https://github.com/JasonHK).

node_modules/@types/json-schema/index.d.ts

@@ -0,0 +1,747 @@
+// Type definitions for json-schema 4.0, 6.0 and 7.0
+// Project: https://github.com/kriszyp/json-schema
+// Definitions by: Boris Cherny <https://github.com/bcherny>
+//                 Cyrille Tuzi <https://github.com/cyrilletuzi>
+//                 Lucian Buzzo <https://github.com/lucianbuzzo>
+//                 Roland Groza <https://github.com/rolandjitsu>
+//                 Jason Kwok <https://github.com/JasonHK>
+// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.2
+
+//==================================================================================================
+// JSON Schema Draft 04
+//==================================================================================================
+
+/**
+ * @see https://tools.ietf.org/html/draft-zyp-json-schema-03#section-5.1
+ */
+export type JSONSchema4TypeName =
+    | 'string'
+    | 'number'
+    | 'integer'
+    | 'boolean'
+    | 'object'
+    | 'array'
+    | 'null'
+    | 'any';
+
+/**
+ * @see https://tools.ietf.org/html/draft-zyp-json-schema-04#section-3.5
+ */
+export type JSONSchema4Type =
+    | string
+    | number
+    | boolean
+    | JSONSchema4Object
+    | JSONSchema4Array
+    | null;
+
+// Workaround for infinite type recursion
+export interface JSONSchema4Object {
+    [key: string]: JSONSchema4Type;
+}
+
+// Workaround for infinite type recursion
+// https://github.com/Microsoft/TypeScript/issues/3496#issuecomment-128553540
+export interface JSONSchema4Array extends Array<JSONSchema4Type> {}
+
+/**
+ * Meta schema
+ *
+ * Recommended values:
+ * - 'http://json-schema.org/schema#'
+ * - 'http://json-schema.org/hyper-schema#'
+ * - 'http://json-schema.org/draft-04/schema#'
+ * - 'http://json-schema.org/draft-04/hyper-schema#'
+ * - 'http://json-schema.org/draft-03/schema#'
+ * - 'http://json-schema.org/draft-03/hyper-schema#'
+ *
+ * @see https://tools.ietf.org/html/draft-handrews-json-schema-validation-01#section-5
+ */
+export type JSONSchema4Version = string;
+
+/**
+ * JSON Schema V4
+ * @see https://tools.ietf.org/html/draft-zyp-json-schema-04
+ */
+export interface JSONSchema4 {
+    id?: string
+    $ref?: string
+    $schema?: JSONSchema4Version
+
+    /**
+     * This attribute is a string that provides a short description of the
+     * instance property.
+     *
+     * @see https://tools.ietf.org/html/draft-zyp-json-schema-03#section-5.21
+     */
+    title?: string
+
+    /**
+     * This attribute is a string that provides a full description of the of
+     * purpose the instance property.
+     *
+     * @see https://tools.ietf.org/html/draft-zyp-json-schema-03#section-5.22
+     */
+    description?: string
+
+    default?: JSONSchema4Type
+    multipleOf?: number
+    maximum?: number
+    exclusiveMaximum?: boolean
+    minimum?: number
+    exclusiveMinimum?: boolean
+    maxLength?: number
+    minLength?: number
+    pattern?: string
+
+    /**
+     * May only be defined when "items" is defined, and is a tuple of JSONSchemas.
+     *
+     * This provides a definition for additional items in an array instance
+     * when tuple definitions of the items is provided.  This can be false
+     * to indicate additional items in the array are not allowed, or it can
+     * be a schema that defines the schema of the additional items.
+     *
+     * @see https://tools.ietf.org/html/draft-zyp-json-schema-03#section-5.6
+     */
+    additionalItems?: boolean | JSONSchema4
+
+    /**
+     * This attribute defines the allowed items in an instance array, and
+     * MUST be a schema or an array of schemas.  The default value is an
+     * empty schema which allows any value for items in the instance array.
+     *
+     * When this attribute value is a schema and the instance value is an
+     * array, then all the items in the array MUST be valid according to the
+     * schema.
+     *
+     * When this attribute value is an array of schemas and the instance
+     * value is an array, each position in the instance array MUST conform
+     * to the schema in the corresponding position for this array.  This
+     * called tuple typing.  When tuple typing is used, additional items are
+     * allowed, disallowed, or constrained by the "additionalItems"
+     * (Section 5.6) attribute using the same rules as
+     * "additionalProperties" (Section 5.4) for objects.
+     *
+     * @see https://tools.ietf.org/html/draft-zyp-json-schema-03#section-5.5
+     */
+    items?: JSONSchema4 | JSONSchema4[]
+
+    maxItems?: number
+    minItems?: number
+    uniqueItems?: boolean
+    maxProperties?: number
+    minProperties?: number
+
+    /**
+     * This attribute indicates if the instance must have a value, and not
+     * be undefined. This is false by default, making the instance
+     * optional.
+     *
+     * @see https://tools.ietf.org/html/draft-zyp-json-schema-03#section-5.7
+     */
+    required?: false | string[]
+
+    /**
+     * This attribute defines a schema for all properties that are not
+     * explicitly defined in an object type definition. If specified, the
+     * value MUST be a schema or a boolean. If false is provided, no
+     * additional properties are allowed beyond the properties defined in
+     * the schema. The default value is an empty schema which allows any
+     * value for additional properties.
+     *
+     * @see https://tools.ietf.org/html/draft-zyp-json-schema-03#section-5.4
+     */
+    additionalProperties?: boolean | JSONSchema4
+
+    definitions?: {
+        [k: string]: JSONSchema4
+    }
+
+    /**
+     * This attribute is an object with property definitions that define the
+     * valid values of instance object property values. When the instance
+     * value is an object, the property values of the instance object MUST
+     * conform to the property definitions in this object. In this object,
+     * each property definition's value MUST be a schema, and the property's
+     * name MUST be the name of the instance property that it defines.  The
+     * instance property value MUST be valid according to the schema from
+     * the property definition. Properties are considered unordered, the
+     * order of the instance properties MAY be in any order.
+     *
+     * @see https://tools.ietf.org/html/draft-zyp-json-schema-03#section-5.2
+     */
+    properties?: {
+        [k: string]: JSONSchema4
+    }
+
+    /**
+     * This attribute is an object that defines the schema for a set of
+     * property names of an object instance. The name of each property of
+     * this attribute's object is a regular expression pattern in the ECMA
+     * 262/Perl 5 format, while the value is a schema. If the pattern
+     * matches the name of a property on the instance object, the value of
+     * the instance's property MUST be valid against the pattern name's
+     * schema value.
+     *
+     * @see https://tools.ietf.org/html/draft-zyp-json-schema-03#section-5.3
+     */
+    patternProperties?: {
+        [k: string]: JSONSchema4
+    }
+    dependencies?: {
+        [k: string]: JSONSchema4 | string[]
+    }
+
+    /**
+     * This provides an enumeration of all possible values that are valid
+     * for the instance property. This MUST be an array, and each item in
+     * the array represents a possible value for the instance value. If
+     * this attribute is defined, the instance value MUST be one of the
+     * values in the array in order for the schema to be valid.
+     *
+     * @see https://tools.ietf.org/html/draft-zyp-json-schema-03#section-5.19
+     */
+    enum?: JSONSchema4Type[]
+
+    /**
+     * A single type, or a union of simple types
+     */
+    type?: JSONSchema4TypeName | JSONSchema4TypeName[]
+
+    allOf?: JSONSchema4[]
+    anyOf?: JSONSchema4[]
+    oneOf?: JSONSchema4[]
+    not?: JSONSchema4
+
+    /**
+     * The value of this property MUST be another schema which will provide
+     * a base schema which the current schema will inherit from.  The
+     * inheritance rules are such that any instance that is valid according
+     * to the current schema MUST be valid according to the referenced
+     * schema.  This MAY also be an array, in which case, the instance MUST
+     * be valid for all the schemas in the array.  A schema that extends
+     * another schema MAY define additional attributes, constrain existing
+     * attributes, or add other constraints.
+     *
+     * Conceptually, the behavior of extends can be seen as validating an
+     * instance against all constraints in the extending schema as well as
+     * the extended schema(s).
+     *
+     * @see https://tools.ietf.org/html/draft-zyp-json-schema-03#section-5.26
+     */
+    extends?: string | string[]
+
+    /**
+     * @see https://tools.ietf.org/html/draft-zyp-json-schema-04#section-5.6
+     */
+    [k: string]: any
+
+    format?: string
+}
+
+//==================================================================================================
+// JSON Schema Draft 06
+//==================================================================================================
+
+export type JSONSchema6TypeName =
+    | 'string'
+    | 'number'
+    | 'integer'
+    | 'boolean'
+    | 'object'
+    | 'array'
+    | 'null'
+    | 'any';
+
+export type JSONSchema6Type =
+    | string
+    | number
+    | boolean
+    | JSONSchema6Object
+    | JSONSchema6Array
+    | null;
+
+// Workaround for infinite type recursion
+export interface JSONSchema6Object {
+    [key: string]: JSONSchema6Type;
+}
+
+// Workaround for infinite type recursion
+// https://github.com/Microsoft/TypeScript/issues/3496#issuecomment-128553540
+export interface JSONSchema6Array extends Array<JSONSchema6Type> {}
+
+/**
+ * Meta schema
+ *
+ * Recommended values:
+ * - 'http://json-schema.org/schema#'
+ * - 'http://json-schema.org/hyper-schema#'
+ * - 'http://json-schema.org/draft-06/schema#'
+ * - 'http://json-schema.org/draft-06/hyper-schema#'
+ *
+ * @see https://tools.ietf.org/html/draft-handrews-json-schema-validation-01#section-5
+ */
+export type JSONSchema6Version = string;
+
+/**
+ * JSON Schema V6
+ * @see https://tools.ietf.org/html/draft-wright-json-schema-validation-01
+ */
+export type JSONSchema6Definition = JSONSchema6 | boolean;
+export interface JSONSchema6 {
+    $id?: string
+    $ref?: string
+    $schema?: JSONSchema6Version
+
+    /**
+     * Must be strictly greater than 0.
+     * A numeric instance is valid only if division by this keyword's value results in an integer.
+     * @see https://tools.ietf.org/html/draft-wright-json-schema-validation-01#section-6.1
+     */
+    multipleOf?: number
+
+    /**
+     * Representing an inclusive upper limit for a numeric instance.
+     * This keyword validates only if the instance is less than or exactly equal to "maximum".
+     * @see https://tools.ietf.org/html/draft-wright-json-schema-validation-01#section-6.2
+     */
+    maximum?: number
+
+    /**
+     * Representing an exclusive upper limit for a numeric instance.
+     * This keyword validates only if the instance is strictly less than (not equal to) to "exclusiveMaximum".
+     * @see https://tools.ietf.org/html/draft-wright-json-schema-validation-01#section-6.3
+     */
+    exclusiveMaximum?: number
+
+    /**
+     * Representing an inclusive lower limit for a numeric instance.
+     * This keyword validates only if the instance is greater than or exactly equal to "minimum".
+     * @see https://tools.ietf.org/html/draft-wright-json-schema-validation-01#section-6.4
+     */
+    minimum?: number
+
+    /**
+     * Representing an exclusive lower limit for a numeric instance.
+     * This keyword validates only if the instance is strictly greater than (not equal to) to "exclusiveMinimum".
+     * @see https://tools.ietf.org/html/draft-wright-json-schema-validation-01#section-6.5
+     */
+    exclusiveMinimum?: number
+
+    /**
+     * Must be a non-negative integer.
+     * A string instance is valid against this keyword if its length is less than, or equal to, the value of this keyword.
+     * @see https://tools.ietf.org/html/draft-wright-json-schema-validation-01#section-6.6
+     */
+    maxLength?: number
+
+    /**
+     * Must be a non-negative integer.
+     * A string instance is valid against this keyword if its length is greater than, or equal to, the value of this keyword.
+     * Omitting this keyword has the same behavior as a value of 0.
+     * @see https://tools.ietf.org/html/draft-wright-json-schema-validation-01#section-6.7
+     */
+    minLength?: number
+
+    /**
+     * Should be a valid regular expression, according to the ECMA 262 regular expression dialect.
+     * @see https://tools.ietf.org/html/draft-wright-json-schema-validation-01#section-6.8
+     */
+    pattern?: string
+
+    /**
+     * This keyword determines how child instances validate for arrays, and does not directly validate the immediate instance itself.
+     * Omitting this keyword has the same behavior as an empty schema.
+     * @see https://tools.ietf.org/html/draft-wright-json-schema-validation-01#section-6.9
+     */
+    items?: JSONSchema6Definition | JSONSchema6Definition[]
+
+    /**
+     * This keyword determines how child instances validate for arrays, and does not directly validate the immediate instance itself.
+     * If "items" is an array of schemas, validation succeeds if every instance element
+     * at a position greater than the size of "items" validates against "additionalItems".
+     * Otherwise, "additionalItems" MUST be ignored, as the "items" schema
+     * (possibly the default value of an empty schema) is applied to all elements.
+     * Omitting this keyword has the same behavior as an empty schema.
+     * @see https://tools.ietf.org/html/draft-wright-json-schema-validation-01#section-6.10
+     */
+    additionalItems?: JSONSchema6Definition
+
+    /**
+     * Must be a non-negative integer.
+     * An array instance is valid against "maxItems" if its size is less than, or equal to, the value of this keyword.
+     * @see https://tools.ietf.org/html/draft-wright-json-schema-validation-01#section-6.11
+     */
+    maxItems?: number
+
+    /**
+     * Must be a non-negative integer.
+     * An array instance is valid against "maxItems" if its size is greater than, or equal to, the value of this keyword.
+     * Omitting this keyword has the same behavior as a value of 0.
+     * @see https://tools.ietf.org/html/draft-wright-json-schema-validation-01#section-6.12
+     */
+    minItems?: number
+
+    /**
+     * If this keyword has boolean value false, the instance validates successfully.
+     * If it has boolean value true, the instance validates successfully if all of its elements are unique.
+     * Omitting this keyword has the same behavior as a value of false.
+     * @see https://tools.ietf.org/html/draft-wright-json-schema-validation-01#section-6.13
+     */
+    uniqueItems?: boolean
+
+    /**
+     * An array instance is valid against "contains" if at least one of its elements is valid against the given schema.
+     * @see https://tools.ietf.org/html/draft-wright-json-schema-validation-01#section-6.14
+     */
+    contains?: JSONSchema6Definition
+
+    /**
+     * Must be a non-negative integer.
+     * An object instance is valid against "maxProperties" if its number of properties is less than, or equal to, the value of this keyword.
+     * @see https://tools.ietf.org/html/draft-wright-json-schema-validation-01#section-6.15
+     */
+    maxProperties?: number
+
+    /**
+     * Must be a non-negative integer.
+     * An object instance is valid against "maxProperties" if its number of properties is greater than,
+     * or equal to, the value of this keyword.
+     * Omitting this keyword has the same behavior as a value of 0.
+     * @see https://tools.ietf.org/html/draft-wright-json-schema-validation-01#section-6.16
+     */
+    minProperties?: number
+
+    /**
+     * Elements of this array must be unique.
+     * An object instance is valid against this keyword if every item in the array is the name of a property in the instance.
+     * Omitting this keyword has the same behavior as an empty array.
+     *
+     * @see https://tools.ietf.org/html/draft-wright-json-schema-validation-01#section-6.17
+     */
+    required?: string[]
+
+    /**
+     * This keyword determines how child instances validate for objects, and does not directly validate the immediate instance itself.
+     * Validation succeeds if, for each name that appears in both the instance and as a name within this keyword's value,
+     * the child instance for that name successfully validates against the corresponding schema.
+     * Omitting this keyword has the same behavior as an empty object.
+     * @see https://tools.ietf.org/html/draft-wright-json-schema-validation-01#section-6.18
+     */
+    properties?: {
+        [k: string]: JSONSchema6Definition
+    }
+
+    /**
+     * This attribute is an object that defines the schema for a set of property names of an object instance.
+     * The name of each property of this attribute's object is a regular expression pattern in the ECMA 262, while the value is a schema.
+     * If the pattern matches the name of a property on the instance object, the value of the instance's property
+     * MUST be valid against the pattern name's schema value.
+     * Omitting this keyword has the same behavior as an empty object.
+     * @see https://tools.ietf.org/html/draft-wright-json-schema-validation-01#section-6.19
+     */
+    patternProperties?: {
+        [k: string]: JSONSchema6Definition
+    }
+
+    /**
+     * This attribute defines a schema for all properties that are not explicitly defined in an object type definition.
+     * If specified, the value MUST be a schema or a boolean.
+     * If false is provided, no additional properties are allowed beyond the properties defined in the schema.
+     * The default value is an empty schema which allows any value for additional properties.
+     * @see https://tools.ietf.org/html/draft-wright-json-schema-validation-01#section-6.20
+     */
+    additionalProperties?: JSONSchema6Definition
+
+    /**
+     * This keyword specifies rules that are evaluated if the instance is an object and contains a certain property.
+     * Each property specifies a dependency.
+     * If the dependency value is an array, each element in the array must be unique.
+     * Omitting this keyword has the same behavior as an empty object.
+     * @see https://tools.ietf.org/html/draft-wright-json-schema-validation-01#section-6.21
+     */
+    dependencies?: {
+        [k: string]: JSONSchema6Definition | string[]
+    }
+
+    /**
+     * Takes a schema which validates the names of all properties rather than their values.
+     * Note the property name that the schema is testing will always be a string.
+     * Omitting this keyword has the same behavior as an empty schema.
+     * @see https://tools.ietf.org/html/draft-wright-json-schema-validation-01#section-6.22
+     */
+    propertyNames?: JSONSchema6Definition
+
+    /**
+     * This provides an enumeration of all possible values that are valid
+     * for the instance property. This MUST be an array, and each item in
+     * the array represents a possible value for the instance value. If
+     * this attribute is defined, the instance value MUST be one of the
+     * values in the array in order for the schema to be valid.
+     *
+     * @see https://tools.ietf.org/html/draft-wright-json-schema-validation-01#section-6.23
+     */
+    enum?: JSONSchema6Type[]
+
+    /**
+     * More readable form of a one-element "enum"
+     * @see https://tools.ietf.org/html/draft-wright-json-schema-validation-01#section-6.24
+     */
+    const?: JSONSchema6Type
+
+    /**
+     * A single type, or a union of simple types
+     * @see https://tools.ietf.org/html/draft-wright-json-schema-validation-01#section-6.25
+     */
+    type?: JSONSchema6TypeName | JSONSchema6TypeName[]
+
+    /**
+     * @see https://tools.ietf.org/html/draft-wright-json-schema-validation-01#section-6.26
+     */
+    allOf?: JSONSchema6Definition[]
+
+    /**
+     * @see https://tools.ietf.org/html/draft-wright-json-schema-validation-01#section-6.27
+     */
+    anyOf?: JSONSchema6Definition[]
+
+    /**
+     * @see https://tools.ietf.org/html/draft-wright-json-schema-validation-01#section-6.28
+     */
+    oneOf?: JSONSchema6Definition[]
+
+    /**
+     * @see https://tools.ietf.org/html/draft-wright-json-schema-validation-01#section-6.29
+     */
+    not?: JSONSchema6Definition
+
+    /**
+     * @see https://tools.ietf.org/html/draft-wright-json-schema-validation-01#section-7.1
+     */
+    definitions?: {
+        [k: string]: JSONSchema6Definition
+    }
+
+    /**
+     * This attribute is a string that provides a short description of the instance property.
+     *
+     * @see https://tools.ietf.org/html/draft-wright-json-schema-validation-01#section-7.2
+     */
+    title?: string
+
+    /**
+     * This attribute is a string that provides a full description of the of purpose the instance property.
+     *
+     * @see https://tools.ietf.org/html/draft-wright-json-schema-validation-01#section-7.2
+     */
+    description?: string
+
+    /**
+     * This keyword can be used to supply a default JSON value associated with a particular schema.
+     * It is RECOMMENDED that a default value be valid against the associated schema.
+     * @see https://tools.ietf.org/html/draft-wright-json-schema-validation-01#section-7.3
+     */
+    default?: JSONSchema6Type
+
+    /**
+     * Array of examples with no validation effect the value of "default" is usable as an example without repeating it under this keyword
+     * @see https://tools.ietf.org/html/draft-wright-json-schema-validation-01#section-7.4
+     */
+    examples?: JSONSchema6Type[]
+
+    /**
+     * @see https://tools.ietf.org/html/draft-wright-json-schema-validation-01#section-8
+     */
+    format?: string
+}
+
+//==================================================================================================
+// JSON Schema Draft 07
+//==================================================================================================
+// https://tools.ietf.org/html/draft-handrews-json-schema-validation-01
+//--------------------------------------------------------------------------------------------------
+
+/**
+ * Primitive type
+ * @see https://tools.ietf.org/html/draft-handrews-json-schema-validation-01#section-6.1.1
+ */
+export type JSONSchema7TypeName =
+    | 'string'
+    | 'number'
+    | 'integer'
+    | 'boolean'
+    | 'object'
+    | 'array'
+    | 'null';
+
+/**
+ * Primitive type
+ * @see https://tools.ietf.org/html/draft-handrews-json-schema-validation-01#section-6.1.1
+ */
+export type JSONSchema7Type =
+    | string
+    | number
+    | boolean
+    | JSONSchema7Object
+    | JSONSchema7Array
+    | null;
+
+// Workaround for infinite type recursion
+export interface JSONSchema7Object {
+    [key: string]: JSONSchema7Type;
+}
+
+// Workaround for infinite type recursion
+// https://github.com/Microsoft/TypeScript/issues/3496#issuecomment-128553540
+export interface JSONSchema7Array extends Array<JSONSchema7Type> {}
+
+/**
+ * Meta schema
+ *
+ * Recommended values:
+ * - 'http://json-schema.org/schema#'
+ * - 'http://json-schema.org/hyper-schema#'
+ * - 'http://json-schema.org/draft-07/schema#'
+ * - 'http://json-schema.org/draft-07/hyper-schema#'
+ *
+ * @see https://tools.ietf.org/html/draft-handrews-json-schema-validation-01#section-5
+ */
+export type JSONSchema7Version = string;
+
+/**
+ * JSON Schema v7
+ * @see https://tools.ietf.org/html/draft-handrews-json-schema-validation-01
+ */
+export type JSONSchema7Definition = JSONSchema7 | boolean;
+export interface JSONSchema7 {
+    $id?: string;
+    $ref?: string;
+    $schema?: JSONSchema7Version;
+    $comment?: string;
+
+    /**
+     * @see https://tools.ietf.org/html/draft-handrews-json-schema-validation-01#section-6.1
+     */
+    type?: JSONSchema7TypeName | JSONSchema7TypeName[];
+    enum?: JSONSchema7Type[];
+    const?: JSONSchema7Type;
+
+    /**
+     * @see https://tools.ietf.org/html/draft-handrews-json-schema-validation-01#section-6.2
+     */
+    multipleOf?: number;
+    maximum?: number;
+    exclusiveMaximum?: number;
+    minimum?: number;
+    exclusiveMinimum?: number;
+
+    /**
+     * @see https://tools.ietf.org/html/draft-handrews-json-schema-validation-01#section-6.3
+     */
+    maxLength?: number;
+    minLength?: number;
+    pattern?: string;
+
+    /**
+     * @see https://tools.ietf.org/html/draft-handrews-json-schema-validation-01#section-6.4
+     */
+    items?: JSONSchema7Definition | JSONSchema7Definition[];
+    additionalItems?: JSONSchema7Definition;
+    maxItems?: number;
+    minItems?: number;
+    uniqueItems?: boolean;
+    contains?: JSONSchema7;
+
+    /**
+     * @see https://tools.ietf.org/html/draft-handrews-json-schema-validation-01#section-6.5
+     */
+    maxProperties?: number;
+    minProperties?: number;
+    required?: string[];
+    properties?: {
+        [key: string]: JSONSchema7Definition;
+    };
+    patternProperties?: {
+        [key: string]: JSONSchema7Definition;
+    };
+    additionalProperties?: JSONSchema7Definition;
+    dependencies?: {
+        [key: string]: JSONSchema7Definition | string[];
+    };
+    propertyNames?: JSONSchema7Definition;
+
+    /**
+     * @see https://tools.ietf.org/html/draft-handrews-json-schema-validation-01#section-6.6
+     */
+    if?: JSONSchema7Definition;
+    then?: JSONSchema7Definition;
+    else?: JSONSchema7Definition;
+
+    /**
+     * @see https://tools.ietf.org/html/draft-handrews-json-schema-validation-01#section-6.7
+     */
+    allOf?: JSONSchema7Definition[];
+    anyOf?: JSONSchema7Definition[];
+    oneOf?: JSONSchema7Definition[];
+    not?: JSONSchema7Definition;
+
+    /**
+     * @see https://tools.ietf.org/html/draft-handrews-json-schema-validation-01#section-7
+     */
+    format?: string;
+
+    /**
+     * @see https://tools.ietf.org/html/draft-handrews-json-schema-validation-01#section-8
+     */
+    contentMediaType?: string;
+    contentEncoding?: string;
+
+    /**
+     * @see https://tools.ietf.org/html/draft-handrews-json-schema-validation-01#section-9
+     */
+    definitions?: {
+        [key: string]: JSONSchema7Definition;
+    };
+
+    /**
+     * @see https://tools.ietf.org/html/draft-handrews-json-schema-validation-01#section-10
+     */
+    title?: string;
+    description?: string;
+    default?: JSONSchema7Type;
+    readOnly?: boolean;
+    writeOnly?: boolean;
+    examples?: JSONSchema7Type;
+}
+
+export interface ValidationResult {
+    valid: boolean;
+    errors: ValidationError[];
+}
+
+export interface ValidationError {
+    property: string;
+    message: string;
+}
+
+/**
+ * To use the validator call JSONSchema.validate with an instance object and an optional schema object.
+ * If a schema is provided, it will be used to validate. If the instance object refers to a schema (self-validating),
+ * that schema will be used to validate and the schema parameter is not necessary (if both exist,
+ * both validations will occur).
+ */
+export function validate(instance: {}, schema: JSONSchema4 | JSONSchema6 | JSONSchema7): ValidationResult;
+
+/**
+ * The checkPropertyChange method will check to see if an value can legally be in property with the given schema
+ * This is slightly different than the validate method in that it will fail if the schema is readonly and it will
+ * not check for self-validation, it is assumed that the passed in value is already internally valid.
+ */
+export function checkPropertyChange(value: any, schema: JSONSchema4 | JSONSchema6 | JSONSchema7, property: string): ValidationResult;
+
+/**
+ * This checks to ensure that the result is valid and will throw an appropriate error message if it is not.
+ */
+export function mustBeValid(result: ValidationResult): void;

node_modules/@types/json-schema/package.json

@@ -0,0 +1,44 @@
+{
+  "name": "@types/json-schema",
+  "version": "7.0.6",
+  "description": "TypeScript definitions for json-schema 4.0, 6.0 and",
+  "license": "MIT",
+  "contributors": [
+    {
+      "name": "Boris Cherny",
+      "url": "https://github.com/bcherny",
+      "githubUsername": "bcherny"
+    },
+    {
+      "name": "Cyrille Tuzi",
+      "url": "https://github.com/cyrilletuzi",
+      "githubUsername": "cyrilletuzi"
+    },
+    {
+      "name": "Lucian Buzzo",
+      "url": "https://github.com/lucianbuzzo",
+      "githubUsername": "lucianbuzzo"
+    },
+    {
+      "name": "Roland Groza",
+      "url": "https://github.com/rolandjitsu",
+      "githubUsername": "rolandjitsu"
+    },
+    {
+      "name": "Jason Kwok",
+      "url": "https://github.com/JasonHK",
+      "githubUsername": "JasonHK"
+    }
+  ],
+  "main": "",
+  "types": "index.d.ts",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/DefinitelyTyped/DefinitelyTyped.git",
+    "directory": "types/json-schema"
+  },
+  "scripts": {},
+  "dependencies": {},
+  "typesPublisherContentHash": "bb4b22e70ee94bf7b787307444fcee2f57a8869f012a460ed8f15b5b6985ed70",
+  "typeScriptVersion": "3.1"
+}

node_modules/@types/json5/README.md

@@ -0,0 +1,18 @@
+# Installation
+> `npm install --save @types/json5`
+
+# Summary
+This package contains type definitions for JSON5 (http://json5.org/).
+
+# Details
+Files were exported from https://www.github.com/DefinitelyTyped/DefinitelyTyped/tree/types-2.0/json5
+
+Additional Details
+ * Last updated: Mon, 19 Sep 2016 17:28:59 GMT
+ * File structure: ProperModule
+ * Library Dependencies: none
+ * Module Dependencies: none
+ * Global values: json5
+
+# Credits
+These definitions were written by Jason Swearingen <https://jasonswearingen.github.io>.

node_modules/@types/json5/index.d.ts

@@ -0,0 +1,44 @@
+// Type definitions for JSON5
+// Project: http://json5.org/
+// Definitions by: Jason Swearingen <https://jasonswearingen.github.io>
+// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+
+
+//commonjs loader
+
+/** 
+ * The following is the exact list of additions to JSON's syntax introduced by JSON5. All of these are optional, and all of these come from ES5.
+
+Objects
+
+Object keys can be unquoted if they're valid identifiers. Yes, even reserved keywords (like default) are valid unquoted keys in ES5 [§11.1.5, §7.6]. (More info)
+
+(TODO: Unicode characters and escape sequences aren’t yet supported in this implementation.)
+
+Objects can have trailing commas.
+
+Arrays
+
+Arrays can have trailing commas.
+Strings
+
+Strings can be single-quoted.
+
+Strings can be split across multiple lines; just prefix each newline with a backslash. [ES5 §7.8.4]
+
+Numbers
+
+Numbers can be hexadecimal (base 16).
+
+Numbers can begin or end with a (leading or trailing) decimal point.
+
+Numbers can include Infinity, -Infinity, NaN, and -NaN.
+
+Numbers can begin with an explicit plus sign.
+
+Comments
+
+Both inline (single-line) and block (multi-line) comments are allowed.
+  */
+declare var json5: JSON;
+export = json5;

node_modules/@types/json5/package.json

@@ -0,0 +1,16 @@
+{
+  "name": "@types/json5",
+  "version": "0.0.29",
+  "description": "TypeScript definitions for JSON5",
+  "license": "MIT",
+  "author": "Jason Swearingen <https://jasonswearingen.github.io>",
+  "main": "",
+  "repository": {
+    "type": "git",
+    "url": "https://www.github.com/DefinitelyTyped/DefinitelyTyped.git"
+  },
+  "scripts": {},
+  "dependencies": {},
+  "typings": "index.d.ts",
+  "typesPublisherContentHash": "1ed77f2bfd59d290798abf89db281c36565f4a78d97d4e9caab25319d54c6331"
+}

node_modules/@types/json5/types-metadata.json

@@ -0,0 +1,25 @@
+{
+    "authors": "Jason Swearingen <https://jasonswearingen.github.io>",
+    "definitionFilename": "index.d.ts",
+    "libraryDependencies": [],
+    "moduleDependencies": [],
+    "libraryMajorVersion": "0",
+    "libraryMinorVersion": "0",
+    "libraryName": "JSON5",
+    "typingsPackageName": "json5",
+    "projectName": "http://json5.org/",
+    "sourceRepoURL": "https://www.github.com/DefinitelyTyped/DefinitelyTyped",
+    "sourceBranch": "types-2.0",
+    "kind": "ProperModule",
+    "globals": [
+        "json5"
+    ],
+    "declaredModules": [
+        "json5"
+    ],
+    "files": [
+        "index.d.ts"
+    ],
+    "hasPackageJson": false,
+    "contentHash": "1ed77f2bfd59d290798abf89db281c36565f4a78d97d4e9caab25319d54c6331"
+}

node_modules/@typescript-eslint/eslint-plugin/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2019 TypeScript ESLint and other contributors
+
+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/@typescript-eslint/eslint-plugin/README.md

@@ -0,0 +1,224 @@
+<h1 align="center">ESLint Plugin TypeScript</h1>
+
+<p align="center">An ESLint plugin which provides lint rules for TypeScript codebases.</p>
+
+<p align="center">
+    <img src="https://github.com/typescript-eslint/typescript-eslint/workflows/CI/badge.svg" alt="CI" />
+    <a href="https://www.npmjs.com/package/@typescript-eslint/eslint-plugin"><img src="https://img.shields.io/npm/v/@typescript-eslint/eslint-plugin.svg?style=flat-square" alt="NPM Version" /></a>
+    <a href="https://www.npmjs.com/package/@typescript-eslint/eslint-plugin"><img src="https://img.shields.io/npm/dm/@typescript-eslint/eslint-plugin.svg?style=flat-square" alt="NPM Downloads" /></a>
+</p>
+
+## Getting Started
+
+- **[You can find our Getting Started docs here](../../docs/getting-started/linting/README.md)**
+- **[You can find our FAQ / Troubleshooting docs here](../../docs/getting-started/linting/FAQ.md)**
+
+These docs walk you through setting up ESLint, this plugin, and our parser. If you know what you're doing and just want to quick start, read on...
+
+## Quick-start
+
+### Installation
+
+Make sure you have TypeScript and [`@typescript-eslint/parser`](../parser) installed:
+
+```bash
+$ yarn add -D typescript @typescript-eslint/parser
+$ npm i --save-dev typescript @typescript-eslint/parser
+```
+
+Then install the plugin:
+
+```bash
+$ yarn add -D @typescript-eslint/eslint-plugin
+$ npm i --save-dev @typescript-eslint/eslint-plugin
+```
+
+It is important that you use the same version number for `@typescript-eslint/parser` and `@typescript-eslint/eslint-plugin`.
+
+**Note:** If you installed ESLint globally (using the `-g` flag) then you must also install `@typescript-eslint/eslint-plugin` globally.
+
+### Usage
+
+Add `@typescript-eslint/parser` to the `parser` field and `@typescript-eslint` to the plugins section of your `.eslintrc` configuration file, then configure the rules you want to use under the rules section.
+
+```json
+{
+  "parser": "@typescript-eslint/parser",
+  "plugins": ["@typescript-eslint"],
+  "rules": {
+    "@typescript-eslint/rule-name": "error"
+  }
+}
+```
+
+You can also enable all the recommended rules for our plugin. Add `plugin:@typescript-eslint/recommended` in extends:
+
+```json
+{
+  "extends": ["plugin:@typescript-eslint/recommended"]
+}
+```
+
+**Note: Make sure to use `eslint --ext .js,.ts` since by [default](https://eslint.org/docs/user-guide/command-line-interface#--ext) `eslint` will only search for `.js` files.**
+
+### Recommended Configs
+
+You can also use [`eslint:recommended`](https://eslint.org/docs/rules/) (the set of rules which are recommended for all projects by the ESLint Team) with this plugin:
+
+```json
+{
+  "extends": ["eslint:recommended", "plugin:@typescript-eslint/recommended"]
+}
+```
+
+As of version 2 of this plugin, _by design_, none of the rules in the main `recommended` config require type-checking in order to run. This means that they are more lightweight and faster to run.
+
+Some highly valuable rules simply require type-checking in order to be implemented correctly, however, so we provide an additional config you can extend from called `recommended-requiring-type-checking`. You would apply this _in addition_ to the recommended configs previously mentioned, e.g.:
+
+```json
+{
+  "extends": [
+    "eslint:recommended",
+    "plugin:@typescript-eslint/recommended",
+    "plugin:@typescript-eslint/recommended-requiring-type-checking"
+  ]
+}
+```
+
+Pro Tip: For larger codebases you may want to consider splitting our linting into two separate stages: 1. fast feedback rules which operate purely based on syntax (no type-checking), 2. rules which are based on semantics (type-checking).
+
+**[You can read more about linting with type information here](../../docs/getting-started/linting/TYPED_LINTING.md)**
+
+## Supported Rules
+
+<!-- begin base rule list -->
+
+**Key**: :heavy_check_mark: = recommended, :wrench: = fixable, :thought_balloon: = requires type information
+
+| Name                                                                                                                  | Description                                                                                                             | :heavy_check_mark: | :wrench: | :thought_balloon: |
+| --------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------- | ------------------ | -------- | ----------------- |
+| [`@typescript-eslint/adjacent-overload-signatures`](./docs/rules/adjacent-overload-signatures.md)                     | Require that member overloads be consecutive                                                                            | :heavy_check_mark: |          |                   |
+| [`@typescript-eslint/array-type`](./docs/rules/array-type.md)                                                         | Requires using either `T[]` or `Array<T>` for arrays                                                                    |                    | :wrench: |                   |
+| [`@typescript-eslint/await-thenable`](./docs/rules/await-thenable.md)                                                 | Disallows awaiting a value that is not a Thenable                                                                       | :heavy_check_mark: |          | :thought_balloon: |
+| [`@typescript-eslint/ban-ts-comment`](./docs/rules/ban-ts-comment.md)                                                 | Bans `// @ts-<directive>` comments from being used or requires descriptions after directive                             | :heavy_check_mark: |          |                   |
+| [`@typescript-eslint/ban-tslint-comment`](./docs/rules/ban-tslint-comment.md)                                         | Bans `// tslint:<rule-flag>` comments from being used                                                                   |                    | :wrench: |                   |
+| [`@typescript-eslint/ban-types`](./docs/rules/ban-types.md)                                                           | Bans specific types from being used                                                                                     | :heavy_check_mark: | :wrench: |                   |
+| [`@typescript-eslint/class-literal-property-style`](./docs/rules/class-literal-property-style.md)                     | Ensures that literals on classes are exposed in a consistent style                                                      |                    | :wrench: |                   |
+| [`@typescript-eslint/consistent-type-assertions`](./docs/rules/consistent-type-assertions.md)                         | Enforces consistent usage of type assertions                                                                            |                    |          |                   |
+| [`@typescript-eslint/consistent-type-definitions`](./docs/rules/consistent-type-definitions.md)                       | Consistent with type definition either `interface` or `type`                                                            |                    | :wrench: |                   |
+| [`@typescript-eslint/consistent-type-imports`](./docs/rules/consistent-type-imports.md)                               | Enforces consistent usage of type imports                                                                               |                    | :wrench: |                   |
+| [`@typescript-eslint/explicit-function-return-type`](./docs/rules/explicit-function-return-type.md)                   | Require explicit return types on functions and class methods                                                            |                    |          |                   |
+| [`@typescript-eslint/explicit-member-accessibility`](./docs/rules/explicit-member-accessibility.md)                   | Require explicit accessibility modifiers on class properties and methods                                                |                    | :wrench: |                   |
+| [`@typescript-eslint/explicit-module-boundary-types`](./docs/rules/explicit-module-boundary-types.md)                 | Require explicit return and argument types on exported functions' and classes' public class methods                     | :heavy_check_mark: |          |                   |
+| [`@typescript-eslint/member-delimiter-style`](./docs/rules/member-delimiter-style.md)                                 | Require a specific member delimiter style for interfaces and type literals                                              |                    | :wrench: |                   |
+| [`@typescript-eslint/member-ordering`](./docs/rules/member-ordering.md)                                               | Require a consistent member declaration order                                                                           |                    |          |                   |
+| [`@typescript-eslint/method-signature-style`](./docs/rules/method-signature-style.md)                                 | Enforces using a particular method signature syntax.                                                                    |                    | :wrench: |                   |
+| [`@typescript-eslint/naming-convention`](./docs/rules/naming-convention.md)                                           | Enforces naming conventions for everything across a codebase                                                            |                    |          | :thought_balloon: |
+| [`@typescript-eslint/no-base-to-string`](./docs/rules/no-base-to-string.md)                                           | Requires that `.toString()` is only called on objects which provide useful information when stringified                 |                    |          | :thought_balloon: |
+| [`@typescript-eslint/no-confusing-non-null-assertion`](./docs/rules/no-confusing-non-null-assertion.md)               | Disallow non-null assertion in locations that may be confusing                                                          |                    | :wrench: |                   |
+| [`@typescript-eslint/no-dynamic-delete`](./docs/rules/no-dynamic-delete.md)                                           | Disallow the delete operator with computed key expressions                                                              |                    | :wrench: |                   |
+| [`@typescript-eslint/no-empty-interface`](./docs/rules/no-empty-interface.md)                                         | Disallow the declaration of empty interfaces                                                                            | :heavy_check_mark: | :wrench: |                   |
+| [`@typescript-eslint/no-explicit-any`](./docs/rules/no-explicit-any.md)                                               | Disallow usage of the `any` type                                                                                        | :heavy_check_mark: | :wrench: |                   |
+| [`@typescript-eslint/no-extra-non-null-assertion`](./docs/rules/no-extra-non-null-assertion.md)                       | Disallow extra non-null assertion                                                                                       | :heavy_check_mark: | :wrench: |                   |
+| [`@typescript-eslint/no-extraneous-class`](./docs/rules/no-extraneous-class.md)                                       | Forbids the use of classes as namespaces                                                                                |                    |          |                   |
+| [`@typescript-eslint/no-floating-promises`](./docs/rules/no-floating-promises.md)                                     | Requires Promise-like values to be handled appropriately                                                                | :heavy_check_mark: |          | :thought_balloon: |
+| [`@typescript-eslint/no-for-in-array`](./docs/rules/no-for-in-array.md)                                               | Disallow iterating over an array with a for-in loop                                                                     | :heavy_check_mark: |          | :thought_balloon: |
+| [`@typescript-eslint/no-implicit-any-catch`](./docs/rules/no-implicit-any-catch.md)                                   | Disallow usage of the implicit `any` type in catch clauses                                                              |                    | :wrench: |                   |
+| [`@typescript-eslint/no-implied-eval`](./docs/rules/no-implied-eval.md)                                               | Disallow the use of `eval()`-like methods                                                                               | :heavy_check_mark: |          | :thought_balloon: |
+| [`@typescript-eslint/no-inferrable-types`](./docs/rules/no-inferrable-types.md)                                       | Disallows explicit type declarations for variables or parameters initialized to a number, string, or boolean            | :heavy_check_mark: | :wrench: |                   |
+| [`@typescript-eslint/no-invalid-void-type`](./docs/rules/no-invalid-void-type.md)                                     | Disallows usage of `void` type outside of generic or return types                                                       |                    |          |                   |
+| [`@typescript-eslint/no-misused-new`](./docs/rules/no-misused-new.md)                                                 | Enforce valid definition of `new` and `constructor`                                                                     | :heavy_check_mark: |          |                   |
+| [`@typescript-eslint/no-misused-promises`](./docs/rules/no-misused-promises.md)                                       | Avoid using promises in places not designed to handle them                                                              | :heavy_check_mark: |          | :thought_balloon: |
+| [`@typescript-eslint/no-namespace`](./docs/rules/no-namespace.md)                                                     | Disallow the use of custom TypeScript modules and namespaces                                                            | :heavy_check_mark: |          |                   |
+| [`@typescript-eslint/no-non-null-asserted-optional-chain`](./docs/rules/no-non-null-asserted-optional-chain.md)       | Disallows using a non-null assertion after an optional chain expression                                                 | :heavy_check_mark: |          |                   |
+| [`@typescript-eslint/no-non-null-assertion`](./docs/rules/no-non-null-assertion.md)                                   | Disallows non-null assertions using the `!` postfix operator                                                            | :heavy_check_mark: |          |                   |
+| [`@typescript-eslint/no-parameter-properties`](./docs/rules/no-parameter-properties.md)                               | Disallow the use of parameter properties in class constructors                                                          |                    |          |                   |
+| [`@typescript-eslint/no-require-imports`](./docs/rules/no-require-imports.md)                                         | Disallows invocation of `require()`                                                                                     |                    |          |                   |
+| [`@typescript-eslint/no-this-alias`](./docs/rules/no-this-alias.md)                                                   | Disallow aliasing `this`                                                                                                | :heavy_check_mark: |          |                   |
+| [`@typescript-eslint/no-throw-literal`](./docs/rules/no-throw-literal.md)                                             | Disallow throwing literals as exceptions                                                                                |                    |          | :thought_balloon: |
+| [`@typescript-eslint/no-type-alias`](./docs/rules/no-type-alias.md)                                                   | Disallow the use of type aliases                                                                                        |                    |          |                   |
+| [`@typescript-eslint/no-unnecessary-boolean-literal-compare`](./docs/rules/no-unnecessary-boolean-literal-compare.md) | Flags unnecessary equality comparisons against boolean literals                                                         |                    | :wrench: | :thought_balloon: |
+| [`@typescript-eslint/no-unnecessary-condition`](./docs/rules/no-unnecessary-condition.md)                             | Prevents conditionals where the type is always truthy or always falsy                                                   |                    | :wrench: | :thought_balloon: |
+| [`@typescript-eslint/no-unnecessary-qualifier`](./docs/rules/no-unnecessary-qualifier.md)                             | Warns when a namespace qualifier is unnecessary                                                                         |                    | :wrench: | :thought_balloon: |
+| [`@typescript-eslint/no-unnecessary-type-arguments`](./docs/rules/no-unnecessary-type-arguments.md)                   | Enforces that type arguments will not be used if not required                                                           |                    | :wrench: | :thought_balloon: |
+| [`@typescript-eslint/no-unnecessary-type-assertion`](./docs/rules/no-unnecessary-type-assertion.md)                   | Warns if a type assertion does not change the type of an expression                                                     | :heavy_check_mark: | :wrench: | :thought_balloon: |
+| [`@typescript-eslint/no-unsafe-assignment`](./docs/rules/no-unsafe-assignment.md)                                     | Disallows assigning any to variables and properties                                                                     | :heavy_check_mark: |          | :thought_balloon: |
+| [`@typescript-eslint/no-unsafe-call`](./docs/rules/no-unsafe-call.md)                                                 | Disallows calling an any type value                                                                                     | :heavy_check_mark: |          | :thought_balloon: |
+| [`@typescript-eslint/no-unsafe-member-access`](./docs/rules/no-unsafe-member-access.md)                               | Disallows member access on any typed variables                                                                          | :heavy_check_mark: |          | :thought_balloon: |
+| [`@typescript-eslint/no-unsafe-return`](./docs/rules/no-unsafe-return.md)                                             | Disallows returning any from a function                                                                                 | :heavy_check_mark: |          | :thought_balloon: |
+| [`@typescript-eslint/no-var-requires`](./docs/rules/no-var-requires.md)                                               | Disallows the use of require statements except in import statements                                                     | :heavy_check_mark: |          |                   |
+| [`@typescript-eslint/prefer-as-const`](./docs/rules/prefer-as-const.md)                                               | Prefer usage of `as const` over literal type                                                                            | :heavy_check_mark: | :wrench: |                   |
+| [`@typescript-eslint/prefer-enum-initializers`](./docs/rules/prefer-enum-initializers.md)                             | Prefer initializing each enums member value                                                                             |                    |          |                   |
+| [`@typescript-eslint/prefer-for-of`](./docs/rules/prefer-for-of.md)                                                   | Prefer a ‘for-of’ loop over a standard ‘for’ loop if the index is only used to access the array being iterated          |                    |          |                   |
+| [`@typescript-eslint/prefer-function-type`](./docs/rules/prefer-function-type.md)                                     | Use function types instead of interfaces with call signatures                                                           |                    | :wrench: |                   |
+| [`@typescript-eslint/prefer-includes`](./docs/rules/prefer-includes.md)                                               | Enforce `includes` method over `indexOf` method                                                                         |                    | :wrench: | :thought_balloon: |
+| [`@typescript-eslint/prefer-literal-enum-member`](./docs/rules/prefer-literal-enum-member.md)                         | Require that all enum members be literal values to prevent unintended enum member name shadow issues                    |                    |          |                   |
+| [`@typescript-eslint/prefer-namespace-keyword`](./docs/rules/prefer-namespace-keyword.md)                             | Require the use of the `namespace` keyword instead of the `module` keyword to declare custom TypeScript modules         | :heavy_check_mark: | :wrench: |                   |
+| [`@typescript-eslint/prefer-nullish-coalescing`](./docs/rules/prefer-nullish-coalescing.md)                           | Enforce the usage of the nullish coalescing operator instead of logical chaining                                        |                    |          | :thought_balloon: |
+| [`@typescript-eslint/prefer-optional-chain`](./docs/rules/prefer-optional-chain.md)                                   | Prefer using concise optional chain expressions instead of chained logical ands                                         |                    |          |                   |
+| [`@typescript-eslint/prefer-readonly`](./docs/rules/prefer-readonly.md)                                               | Requires that private members are marked as `readonly` if they're never modified outside of the constructor             |                    | :wrench: | :thought_balloon: |
+| [`@typescript-eslint/prefer-readonly-parameter-types`](./docs/rules/prefer-readonly-parameter-types.md)               | Requires that function parameters are typed as readonly to prevent accidental mutation of inputs                        |                    |          | :thought_balloon: |
+| [`@typescript-eslint/prefer-reduce-type-parameter`](./docs/rules/prefer-reduce-type-parameter.md)                     | Prefer using type parameter when calling `Array#reduce` instead of casting                                              |                    | :wrench: | :thought_balloon: |
+| [`@typescript-eslint/prefer-regexp-exec`](./docs/rules/prefer-regexp-exec.md)                                         | Enforce that `RegExp#exec` is used instead of `String#match` if no global flag is provided                              | :heavy_check_mark: |          | :thought_balloon: |
+| [`@typescript-eslint/prefer-string-starts-ends-with`](./docs/rules/prefer-string-starts-ends-with.md)                 | Enforce the use of `String#startsWith` and `String#endsWith` instead of other equivalent methods of checking substrings |                    | :wrench: | :thought_balloon: |
+| [`@typescript-eslint/prefer-ts-expect-error`](./docs/rules/prefer-ts-expect-error.md)                                 | Recommends using `// @ts-expect-error` over `// @ts-ignore`                                                             |                    | :wrench: |                   |
+| [`@typescript-eslint/promise-function-async`](./docs/rules/promise-function-async.md)                                 | Requires any function or method that returns a Promise to be marked async                                               |                    |          | :thought_balloon: |
+| [`@typescript-eslint/require-array-sort-compare`](./docs/rules/require-array-sort-compare.md)                         | Requires `Array#sort` calls to always provide a `compareFunction`                                                       |                    |          | :thought_balloon: |
+| [`@typescript-eslint/restrict-plus-operands`](./docs/rules/restrict-plus-operands.md)                                 | When adding two variables, operands must both be of type number or of type string                                       | :heavy_check_mark: |          | :thought_balloon: |
+| [`@typescript-eslint/restrict-template-expressions`](./docs/rules/restrict-template-expressions.md)                   | Enforce template literal expressions to be of string type                                                               | :heavy_check_mark: |          | :thought_balloon: |
+| [`@typescript-eslint/strict-boolean-expressions`](./docs/rules/strict-boolean-expressions.md)                         | Restricts the types allowed in boolean expressions                                                                      |                    |          | :thought_balloon: |
+| [`@typescript-eslint/switch-exhaustiveness-check`](./docs/rules/switch-exhaustiveness-check.md)                       | Exhaustiveness checking in switch with union type                                                                       |                    |          | :thought_balloon: |
+| [`@typescript-eslint/triple-slash-reference`](./docs/rules/triple-slash-reference.md)                                 | Sets preference level for triple slash directives versus ES6-style import declarations                                  | :heavy_check_mark: |          |                   |
+| [`@typescript-eslint/type-annotation-spacing`](./docs/rules/type-annotation-spacing.md)                               | Require consistent spacing around type annotations                                                                      |                    | :wrench: |                   |
+| [`@typescript-eslint/typedef`](./docs/rules/typedef.md)                                                               | Requires type annotations to exist                                                                                      |                    |          |                   |
+| [`@typescript-eslint/unbound-method`](./docs/rules/unbound-method.md)                                                 | Enforces unbound methods are called with their expected scope                                                           | :heavy_check_mark: |          | :thought_balloon: |
+| [`@typescript-eslint/unified-signatures`](./docs/rules/unified-signatures.md)                                         | Warns for any two overloads that could be unified into one by using a union or an optional/rest parameter               |                    |          |                   |
+
+<!-- end base rule list -->
+
+### Extension Rules
+
+In some cases, ESLint provides a rule itself, but it doesn't support TypeScript syntax; either it crashes, or it ignores the syntax, or it falsely reports against it.
+In these cases, we create what we call an extension rule; a rule within our plugin that has the same functionality, but also supports TypeScript.
+
+<!-- begin extension rule list -->
+
+**Key**: :heavy_check_mark: = recommended, :wrench: = fixable, :thought_balloon: = requires type information
+
+| Name                                                                                            | Description                                                                          | :heavy_check_mark: | :wrench: | :thought_balloon: |
+| ----------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------ | ------------------ | -------- | ----------------- |
+| [`@typescript-eslint/brace-style`](./docs/rules/brace-style.md)                                 | Enforce consistent brace style for blocks                                            |                    | :wrench: |                   |
+| [`@typescript-eslint/comma-spacing`](./docs/rules/comma-spacing.md)                             | Enforces consistent spacing before and after commas                                  |                    | :wrench: |                   |
+| [`@typescript-eslint/default-param-last`](./docs/rules/default-param-last.md)                   | Enforce default parameters to be last                                                |                    |          |                   |
+| [`@typescript-eslint/dot-notation`](./docs/rules/dot-notation.md)                               | enforce dot notation whenever possible                                               |                    | :wrench: | :thought_balloon: |
+| [`@typescript-eslint/func-call-spacing`](./docs/rules/func-call-spacing.md)                     | Require or disallow spacing between function identifiers and their invocations       |                    | :wrench: |                   |
+| [`@typescript-eslint/indent`](./docs/rules/indent.md)                                           | Enforce consistent indentation                                                       |                    | :wrench: |                   |
+| [`@typescript-eslint/init-declarations`](./docs/rules/init-declarations.md)                     | require or disallow initialization in variable declarations                          |                    |          |                   |
+| [`@typescript-eslint/keyword-spacing`](./docs/rules/keyword-spacing.md)                         | Enforce consistent spacing before and after keywords                                 |                    | :wrench: |                   |
+| [`@typescript-eslint/lines-between-class-members`](./docs/rules/lines-between-class-members.md) | Require or disallow an empty line between class members                              |                    | :wrench: |                   |
+| [`@typescript-eslint/no-array-constructor`](./docs/rules/no-array-constructor.md)               | Disallow generic `Array` constructors                                                | :heavy_check_mark: | :wrench: |                   |
+| [`@typescript-eslint/no-dupe-class-members`](./docs/rules/no-dupe-class-members.md)             | Disallow duplicate class members                                                     |                    |          |                   |
+| [`@typescript-eslint/no-empty-function`](./docs/rules/no-empty-function.md)                     | Disallow empty functions                                                             | :heavy_check_mark: |          |                   |
+| [`@typescript-eslint/no-extra-parens`](./docs/rules/no-extra-parens.md)                         | Disallow unnecessary parentheses                                                     |                    | :wrench: |                   |
+| [`@typescript-eslint/no-extra-semi`](./docs/rules/no-extra-semi.md)                             | Disallow unnecessary semicolons                                                      | :heavy_check_mark: | :wrench: |                   |
+| [`@typescript-eslint/no-invalid-this`](./docs/rules/no-invalid-this.md)                         | disallow `this` keywords outside of classes or class-like objects                    |                    |          |                   |
+| [`@typescript-eslint/no-loop-func`](./docs/rules/no-loop-func.md)                               | Disallow function declarations that contain unsafe references inside loop statements |                    |          |                   |
+| [`@typescript-eslint/no-loss-of-precision`](./docs/rules/no-loss-of-precision.md)               | Disallow literal numbers that lose precision                                         |                    |          |                   |
+| [`@typescript-eslint/no-magic-numbers`](./docs/rules/no-magic-numbers.md)                       | Disallow magic numbers                                                               |                    |          |                   |
+| [`@typescript-eslint/no-redeclare`](./docs/rules/no-redeclare.md)                               | Disallow variable redeclaration                                                      |                    |          |                   |
+| [`@typescript-eslint/no-shadow`](./docs/rules/no-shadow.md)                                     | Disallow variable declarations from shadowing variables declared in the outer scope  |                    |          |                   |
+| [`@typescript-eslint/no-unused-expressions`](./docs/rules/no-unused-expressions.md)             | Disallow unused expressions                                                          |                    |          |                   |
+| [`@typescript-eslint/no-unused-vars`](./docs/rules/no-unused-vars.md)                           | Disallow unused variables                                                            | :heavy_check_mark: |          |                   |
+| [`@typescript-eslint/no-use-before-define`](./docs/rules/no-use-before-define.md)               | Disallow the use of variables before they are defined                                |                    |          |                   |
+| [`@typescript-eslint/no-useless-constructor`](./docs/rules/no-useless-constructor.md)           | Disallow unnecessary constructors                                                    |                    |          |                   |
+| [`@typescript-eslint/quotes`](./docs/rules/quotes.md)                                           | Enforce the consistent use of either backticks, double, or single quotes             |                    | :wrench: |                   |
+| [`@typescript-eslint/require-await`](./docs/rules/require-await.md)                             | Disallow async functions which have no `await` expression                            | :heavy_check_mark: |          | :thought_balloon: |
+| [`@typescript-eslint/return-await`](./docs/rules/return-await.md)                               | Enforces consistent returning of awaited values                                      |                    | :wrench: | :thought_balloon: |
+| [`@typescript-eslint/semi`](./docs/rules/semi.md)                                               | Require or disallow semicolons instead of ASI                                        |                    | :wrench: |                   |
+| [`@typescript-eslint/space-before-function-paren`](./docs/rules/space-before-function-paren.md) | Enforces consistent spacing before function parenthesis                              |                    | :wrench: |                   |
+
+<!-- end extension rule list -->
+
+## Contributing
+
+[See the contributing guide here](../../CONTRIBUTING.md).

node_modules/@typescript-eslint/eslint-plugin/dist/configs/all.js

@@ -0,0 +1,144 @@
+"use strict";
+// THIS CODE WAS AUTOMATICALLY GENERATED
+// DO NOT EDIT THIS CODE BY HAND
+// YOU CAN REGENERATE IT USING yarn generate:configs
+module.exports = {
+    extends: ['./configs/base', './configs/eslint-recommended'],
+    rules: {
+        '@typescript-eslint/adjacent-overload-signatures': 'error',
+        '@typescript-eslint/array-type': 'error',
+        '@typescript-eslint/await-thenable': 'error',
+        '@typescript-eslint/ban-ts-comment': 'error',
+        '@typescript-eslint/ban-tslint-comment': 'error',
+        '@typescript-eslint/ban-types': 'error',
+        'brace-style': 'off',
+        '@typescript-eslint/brace-style': 'error',
+        '@typescript-eslint/class-literal-property-style': 'error',
+        'comma-spacing': 'off',
+        '@typescript-eslint/comma-spacing': 'error',
+        '@typescript-eslint/consistent-type-assertions': 'error',
+        '@typescript-eslint/consistent-type-definitions': 'error',
+        '@typescript-eslint/consistent-type-imports': 'error',
+        'default-param-last': 'off',
+        '@typescript-eslint/default-param-last': 'error',
+        'dot-notation': 'off',
+        '@typescript-eslint/dot-notation': 'error',
+        '@typescript-eslint/explicit-function-return-type': 'error',
+        '@typescript-eslint/explicit-member-accessibility': 'error',
+        '@typescript-eslint/explicit-module-boundary-types': 'error',
+        'func-call-spacing': 'off',
+        '@typescript-eslint/func-call-spacing': 'error',
+        indent: 'off',
+        '@typescript-eslint/indent': 'error',
+        'init-declarations': 'off',
+        '@typescript-eslint/init-declarations': 'error',
+        'keyword-spacing': 'off',
+        '@typescript-eslint/keyword-spacing': 'error',
+        'lines-between-class-members': 'off',
+        '@typescript-eslint/lines-between-class-members': 'error',
+        '@typescript-eslint/member-delimiter-style': 'error',
+        '@typescript-eslint/member-ordering': 'error',
+        '@typescript-eslint/method-signature-style': 'error',
+        '@typescript-eslint/naming-convention': 'error',
+        'no-array-constructor': 'off',
+        '@typescript-eslint/no-array-constructor': 'error',
+        '@typescript-eslint/no-base-to-string': 'error',
+        '@typescript-eslint/no-confusing-non-null-assertion': 'error',
+        'no-dupe-class-members': 'off',
+        '@typescript-eslint/no-dupe-class-members': 'error',
+        '@typescript-eslint/no-dynamic-delete': 'error',
+        'no-empty-function': 'off',
+        '@typescript-eslint/no-empty-function': 'error',
+        '@typescript-eslint/no-empty-interface': 'error',
+        '@typescript-eslint/no-explicit-any': 'error',
+        '@typescript-eslint/no-extra-non-null-assertion': 'error',
+        'no-extra-parens': 'off',
+        '@typescript-eslint/no-extra-parens': 'error',
+        'no-extra-semi': 'off',
+        '@typescript-eslint/no-extra-semi': 'error',
+        '@typescript-eslint/no-extraneous-class': 'error',
+        '@typescript-eslint/no-floating-promises': 'error',
+        '@typescript-eslint/no-for-in-array': 'error',
+        '@typescript-eslint/no-implicit-any-catch': 'error',
+        '@typescript-eslint/no-implied-eval': 'error',
+        '@typescript-eslint/no-inferrable-types': 'error',
+        'no-invalid-this': 'off',
+        '@typescript-eslint/no-invalid-this': 'error',
+        '@typescript-eslint/no-invalid-void-type': 'error',
+        'no-loop-func': 'off',
+        '@typescript-eslint/no-loop-func': 'error',
+        'no-loss-of-precision': 'off',
+        '@typescript-eslint/no-loss-of-precision': 'error',
+        'no-magic-numbers': 'off',
+        '@typescript-eslint/no-magic-numbers': 'error',
+        '@typescript-eslint/no-misused-new': 'error',
+        '@typescript-eslint/no-misused-promises': 'error',
+        '@typescript-eslint/no-namespace': 'error',
+        '@typescript-eslint/no-non-null-asserted-optional-chain': 'error',
+        '@typescript-eslint/no-non-null-assertion': 'error',
+        '@typescript-eslint/no-parameter-properties': 'error',
+        'no-redeclare': 'off',
+        '@typescript-eslint/no-redeclare': 'error',
+        '@typescript-eslint/no-require-imports': 'error',
+        'no-shadow': 'off',
+        '@typescript-eslint/no-shadow': 'error',
+        '@typescript-eslint/no-this-alias': 'error',
+        '@typescript-eslint/no-throw-literal': 'error',
+        '@typescript-eslint/no-type-alias': 'error',
+        '@typescript-eslint/no-unnecessary-boolean-literal-compare': 'error',
+        '@typescript-eslint/no-unnecessary-condition': 'error',
+        '@typescript-eslint/no-unnecessary-qualifier': 'error',
+        '@typescript-eslint/no-unnecessary-type-arguments': 'error',
+        '@typescript-eslint/no-unnecessary-type-assertion': 'error',
+        '@typescript-eslint/no-unsafe-assignment': 'error',
+        '@typescript-eslint/no-unsafe-call': 'error',
+        '@typescript-eslint/no-unsafe-member-access': 'error',
+        '@typescript-eslint/no-unsafe-return': 'error',
+        'no-unused-expressions': 'off',
+        '@typescript-eslint/no-unused-expressions': 'error',
+        'no-unused-vars': 'off',
+        '@typescript-eslint/no-unused-vars': 'error',
+        'no-use-before-define': 'off',
+        '@typescript-eslint/no-use-before-define': 'error',
+        'no-useless-constructor': 'off',
+        '@typescript-eslint/no-useless-constructor': 'error',
+        '@typescript-eslint/no-var-requires': 'error',
+        '@typescript-eslint/prefer-as-const': 'error',
+        '@typescript-eslint/prefer-enum-initializers': 'error',
+        '@typescript-eslint/prefer-for-of': 'error',
+        '@typescript-eslint/prefer-function-type': 'error',
+        '@typescript-eslint/prefer-includes': 'error',
+        '@typescript-eslint/prefer-literal-enum-member': 'error',
+        '@typescript-eslint/prefer-namespace-keyword': 'error',
+        '@typescript-eslint/prefer-nullish-coalescing': 'error',
+        '@typescript-eslint/prefer-optional-chain': 'error',
+        '@typescript-eslint/prefer-readonly': 'error',
+        '@typescript-eslint/prefer-readonly-parameter-types': 'error',
+        '@typescript-eslint/prefer-reduce-type-parameter': 'error',
+        '@typescript-eslint/prefer-regexp-exec': 'error',
+        '@typescript-eslint/prefer-string-starts-ends-with': 'error',
+        '@typescript-eslint/prefer-ts-expect-error': 'error',
+        '@typescript-eslint/promise-function-async': 'error',
+        quotes: 'off',
+        '@typescript-eslint/quotes': 'error',
+        '@typescript-eslint/require-array-sort-compare': 'error',
+        'require-await': 'off',
+        '@typescript-eslint/require-await': 'error',
+        '@typescript-eslint/restrict-plus-operands': 'error',
+        '@typescript-eslint/restrict-template-expressions': 'error',
+        'no-return-await': 'off',
+        '@typescript-eslint/return-await': 'error',
+        semi: 'off',
+        '@typescript-eslint/semi': 'error',
+        'space-before-function-paren': 'off',
+        '@typescript-eslint/space-before-function-paren': 'error',
+        '@typescript-eslint/strict-boolean-expressions': 'error',
+        '@typescript-eslint/switch-exhaustiveness-check': 'error',
+        '@typescript-eslint/triple-slash-reference': 'error',
+        '@typescript-eslint/type-annotation-spacing': 'error',
+        '@typescript-eslint/typedef': 'error',
+        '@typescript-eslint/unbound-method': 'error',
+        '@typescript-eslint/unified-signatures': 'error',
+    },
+};
+//# sourceMappingURL=all.js.map

node_modules/@typescript-eslint/eslint-plugin/dist/configs/all.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"all.js","sourceRoot":"","sources":["../../src/configs/all.ts"],"names":[],"mappings":"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"}

node_modules/@typescript-eslint/eslint-plugin/dist/configs/base.js

@@ -0,0 +1,10 @@
+"use strict";
+// THIS CODE WAS AUTOMATICALLY GENERATED
+// DO NOT EDIT THIS CODE BY HAND
+// YOU CAN REGENERATE IT USING yarn generate:configs
+module.exports = {
+    parser: '@typescript-eslint/parser',
+    parserOptions: { sourceType: 'module' },
+    plugins: ['@typescript-eslint'],
+};
+//# sourceMappingURL=base.js.map

node_modules/@typescript-eslint/eslint-plugin/dist/configs/base.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"base.js","sourceRoot":"","sources":["../../src/configs/base.ts"],"names":[],"mappings":";AAAA,wCAAwC;AACxC,gCAAgC;AAChC,oDAAoD;AAEpD,iBAAS;IACP,MAAM,EAAE,2BAA2B;IACnC,aAAa,EAAE,EAAE,UAAU,EAAE,QAAQ,EAAE;IACvC,OAAO,EAAE,CAAC,oBAAoB,CAAC;CAChC,CAAC"}

node_modules/@typescript-eslint/eslint-plugin/dist/configs/eslint-recommended.js

@@ -0,0 +1,32 @@
+"use strict";
+module.exports = {
+    overrides: [
+        {
+            files: ['*.ts', '*.tsx'],
+            rules: {
+                'constructor-super': 'off',
+                'getter-return': 'off',
+                'no-const-assign': 'off',
+                'no-dupe-args': 'off',
+                'no-dupe-class-members': 'off',
+                'no-dupe-keys': 'off',
+                'no-func-assign': 'off',
+                'no-import-assign': 'off',
+                'no-new-symbol': 'off',
+                'no-obj-calls': 'off',
+                'no-redeclare': 'off',
+                'no-setter-return': 'off',
+                'no-this-before-super': 'off',
+                'no-undef': 'off',
+                'no-unreachable': 'off',
+                'no-unsafe-negation': 'off',
+                'no-var': 'error',
+                'prefer-const': 'error',
+                'prefer-rest-params': 'error',
+                'prefer-spread': 'error',
+                'valid-typeof': 'off',
+            },
+        },
+    ],
+};
+//# sourceMappingURL=eslint-recommended.js.map

node_modules/@typescript-eslint/eslint-plugin/dist/configs/eslint-recommended.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"eslint-recommended.js","sourceRoot":"","sources":["../../src/configs/eslint-recommended.ts"],"names":[],"mappings":";AAKA,iBAAS;IACP,SAAS,EAAE;QACT;YACE,KAAK,EAAE,CAAC,MAAM,EAAE,OAAO,CAAC;YACxB,KAAK,EAAE;gBACL,mBAAmB,EAAE,KAAK;gBAC1B,eAAe,EAAE,KAAK;gBACtB,iBAAiB,EAAE,KAAK;gBACxB,cAAc,EAAE,KAAK;gBACrB,uBAAuB,EAAE,KAAK;gBAC9B,cAAc,EAAE,KAAK;gBACrB,gBAAgB,EAAE,KAAK;gBACvB,kBAAkB,EAAE,KAAK;gBACzB,eAAe,EAAE,KAAK;gBACtB,cAAc,EAAE,KAAK;gBACrB,cAAc,EAAE,KAAK;gBACrB,kBAAkB,EAAE,KAAK;gBACzB,sBAAsB,EAAE,KAAK;gBAC7B,UAAU,EAAE,KAAK;gBACjB,gBAAgB,EAAE,KAAK;gBACvB,oBAAoB,EAAE,KAAK;gBAC3B,QAAQ,EAAE,OAAO;gBACjB,cAAc,EAAE,OAAO;gBACvB,oBAAoB,EAAE,OAAO;gBAC7B,eAAe,EAAE,OAAO;gBACxB,cAAc,EAAE,KAAK;aACtB;SACF;KACF;CACF,CAAC"}

node_modules/@typescript-eslint/eslint-plugin/dist/configs/recommended-requiring-type-checking.js

@@ -0,0 +1,26 @@
+"use strict";
+// THIS CODE WAS AUTOMATICALLY GENERATED
+// DO NOT EDIT THIS CODE BY HAND
+// YOU CAN REGENERATE IT USING yarn generate:configs
+module.exports = {
+    extends: ['./configs/base', './configs/eslint-recommended'],
+    rules: {
+        '@typescript-eslint/await-thenable': 'error',
+        '@typescript-eslint/no-floating-promises': 'error',
+        '@typescript-eslint/no-for-in-array': 'error',
+        '@typescript-eslint/no-implied-eval': 'error',
+        '@typescript-eslint/no-misused-promises': 'error',
+        '@typescript-eslint/no-unnecessary-type-assertion': 'error',
+        '@typescript-eslint/no-unsafe-assignment': 'error',
+        '@typescript-eslint/no-unsafe-call': 'error',
+        '@typescript-eslint/no-unsafe-member-access': 'error',
+        '@typescript-eslint/no-unsafe-return': 'error',
+        '@typescript-eslint/prefer-regexp-exec': 'error',
+        'require-await': 'off',
+        '@typescript-eslint/require-await': 'error',
+        '@typescript-eslint/restrict-plus-operands': 'error',
+        '@typescript-eslint/restrict-template-expressions': 'error',
+        '@typescript-eslint/unbound-method': 'error',
+    },
+};
+//# sourceMappingURL=recommended-requiring-type-checking.js.map

node_modules/@typescript-eslint/eslint-plugin/dist/configs/recommended-requiring-type-checking.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"recommended-requiring-type-checking.js","sourceRoot":"","sources":["../../src/configs/recommended-requiring-type-checking.ts"],"names":[],"mappings":";AAAA,wCAAwC;AACxC,gCAAgC;AAChC,oDAAoD;AAEpD,iBAAS;IACP,OAAO,EAAE,CAAC,gBAAgB,EAAE,8BAA8B,CAAC;IAC3D,KAAK,EAAE;QACL,mCAAmC,EAAE,OAAO;QAC5C,yCAAyC,EAAE,OAAO;QAClD,oCAAoC,EAAE,OAAO;QAC7C,oCAAoC,EAAE,OAAO;QAC7C,wCAAwC,EAAE,OAAO;QACjD,kDAAkD,EAAE,OAAO;QAC3D,yCAAyC,EAAE,OAAO;QAClD,mCAAmC,EAAE,OAAO;QAC5C,4CAA4C,EAAE,OAAO;QACrD,qCAAqC,EAAE,OAAO;QAC9C,uCAAuC,EAAE,OAAO;QAChD,eAAe,EAAE,KAAK;QACtB,kCAAkC,EAAE,OAAO;QAC3C,2CAA2C,EAAE,OAAO;QACpD,kDAAkD,EAAE,OAAO;QAC3D,mCAAmC,EAAE,OAAO;KAC7C;CACF,CAAC"}

node_modules/@typescript-eslint/eslint-plugin/dist/configs/recommended.js

@@ -0,0 +1,35 @@
+"use strict";
+// THIS CODE WAS AUTOMATICALLY GENERATED
+// DO NOT EDIT THIS CODE BY HAND
+// YOU CAN REGENERATE IT USING yarn generate:configs
+module.exports = {
+    extends: ['./configs/base', './configs/eslint-recommended'],
+    rules: {
+        '@typescript-eslint/adjacent-overload-signatures': 'error',
+        '@typescript-eslint/ban-ts-comment': 'error',
+        '@typescript-eslint/ban-types': 'error',
+        '@typescript-eslint/explicit-module-boundary-types': 'warn',
+        'no-array-constructor': 'off',
+        '@typescript-eslint/no-array-constructor': 'error',
+        'no-empty-function': 'off',
+        '@typescript-eslint/no-empty-function': 'error',
+        '@typescript-eslint/no-empty-interface': 'error',
+        '@typescript-eslint/no-explicit-any': 'warn',
+        '@typescript-eslint/no-extra-non-null-assertion': 'error',
+        'no-extra-semi': 'off',
+        '@typescript-eslint/no-extra-semi': 'error',
+        '@typescript-eslint/no-inferrable-types': 'error',
+        '@typescript-eslint/no-misused-new': 'error',
+        '@typescript-eslint/no-namespace': 'error',
+        '@typescript-eslint/no-non-null-asserted-optional-chain': 'error',
+        '@typescript-eslint/no-non-null-assertion': 'warn',
+        '@typescript-eslint/no-this-alias': 'error',
+        'no-unused-vars': 'off',
+        '@typescript-eslint/no-unused-vars': 'warn',
+        '@typescript-eslint/no-var-requires': 'error',
+        '@typescript-eslint/prefer-as-const': 'error',
+        '@typescript-eslint/prefer-namespace-keyword': 'error',
+        '@typescript-eslint/triple-slash-reference': 'error',
+    },
+};
+//# sourceMappingURL=recommended.js.map

node_modules/@typescript-eslint/eslint-plugin/dist/configs/recommended.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"recommended.js","sourceRoot":"","sources":["../../src/configs/recommended.ts"],"names":[],"mappings":";AAAA,wCAAwC;AACxC,gCAAgC;AAChC,oDAAoD;AAEpD,iBAAS;IACP,OAAO,EAAE,CAAC,gBAAgB,EAAE,8BAA8B,CAAC;IAC3D,KAAK,EAAE;QACL,iDAAiD,EAAE,OAAO;QAC1D,mCAAmC,EAAE,OAAO;QAC5C,8BAA8B,EAAE,OAAO;QACvC,mDAAmD,EAAE,MAAM;QAC3D,sBAAsB,EAAE,KAAK;QAC7B,yCAAyC,EAAE,OAAO;QAClD,mBAAmB,EAAE,KAAK;QAC1B,sCAAsC,EAAE,OAAO;QAC/C,uCAAuC,EAAE,OAAO;QAChD,oCAAoC,EAAE,MAAM;QAC5C,gDAAgD,EAAE,OAAO;QACzD,eAAe,EAAE,KAAK;QACtB,kCAAkC,EAAE,OAAO;QAC3C,wCAAwC,EAAE,OAAO;QACjD,mCAAmC,EAAE,OAAO;QAC5C,iCAAiC,EAAE,OAAO;QAC1C,wDAAwD,EAAE,OAAO;QACjE,0CAA0C,EAAE,MAAM;QAClD,kCAAkC,EAAE,OAAO;QAC3C,gBAAgB,EAAE,KAAK;QACvB,mCAAmC,EAAE,MAAM;QAC3C,oCAAoC,EAAE,OAAO;QAC7C,oCAAoC,EAAE,OAAO;QAC7C,6CAA6C,EAAE,OAAO;QACtD,2CAA2C,EAAE,OAAO;KACrD;CACF,CAAC"}

node_modules/@typescript-eslint/eslint-plugin/dist/index.js

@@ -0,0 +1,21 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+const rules_1 = __importDefault(require("./rules"));
+const all_1 = __importDefault(require("./configs/all"));
+const base_1 = __importDefault(require("./configs/base"));
+const recommended_1 = __importDefault(require("./configs/recommended"));
+const recommended_requiring_type_checking_1 = __importDefault(require("./configs/recommended-requiring-type-checking"));
+const eslint_recommended_1 = __importDefault(require("./configs/eslint-recommended"));
+module.exports = {
+    rules: rules_1.default,
+    configs: {
+        all: all_1.default,
+        base: base_1.default,
+        recommended: recommended_1.default,
+        'eslint-recommended': eslint_recommended_1.default,
+        'recommended-requiring-type-checking': recommended_requiring_type_checking_1.default,
+    },
+};
+//# sourceMappingURL=index.js.map

node_modules/@typescript-eslint/eslint-plugin/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";;;;AAAA,oDAA4B;AAE5B,wDAAgC;AAChC,0DAAkC;AAClC,wEAAgD;AAChD,wHAA6F;AAC7F,sFAA6D;AAE7D,iBAAS;IACP,KAAK,EAAL,eAAK;IACL,OAAO,EAAE;QACP,GAAG,EAAH,aAAG;QACH,IAAI,EAAJ,cAAI;QACJ,WAAW,EAAX,qBAAW;QACX,oBAAoB,EAAE,4BAAiB;QACvC,qCAAqC,EAAE,6CAAgC;KACxE;CACF,CAAC"}

node_modules/@typescript-eslint/eslint-plugin/dist/rules/adjacent-overload-signatures.js

@@ -0,0 +1,159 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const experimental_utils_1 = require("@typescript-eslint/experimental-utils");
+const util = __importStar(require("../util"));
+exports.default = util.createRule({
+    name: 'adjacent-overload-signatures',
+    meta: {
+        type: 'suggestion',
+        docs: {
+            description: 'Require that member overloads be consecutive',
+            category: 'Best Practices',
+            recommended: 'error',
+        },
+        schema: [],
+        messages: {
+            adjacentSignature: "All '{{name}}' signatures should be adjacent.",
+        },
+    },
+    defaultOptions: [],
+    create(context) {
+        const sourceCode = context.getSourceCode();
+        /**
+         * Gets the name and attribute of the member being processed.
+         * @param member the member being processed.
+         * @returns the name and attribute of the member or null if it's a member not relevant to the rule.
+         */
+        function getMemberMethod(member) {
+            var _a, _b;
+            if (!member) {
+                return null;
+            }
+            const isStatic = 'static' in member && !!member.static;
+            switch (member.type) {
+                case experimental_utils_1.AST_NODE_TYPES.ExportDefaultDeclaration:
+                case experimental_utils_1.AST_NODE_TYPES.ExportNamedDeclaration: {
+                    // export statements (e.g. export { a };)
+                    // have no declarations, so ignore them
+                    if (!member.declaration) {
+                        return null;
+                    }
+                    return getMemberMethod(member.declaration);
+                }
+                case experimental_utils_1.AST_NODE_TYPES.TSDeclareFunction:
+                case experimental_utils_1.AST_NODE_TYPES.FunctionDeclaration: {
+                    const name = (_b = (_a = member.id) === null || _a === void 0 ? void 0 : _a.name) !== null && _b !== void 0 ? _b : null;
+                    if (name === null) {
+                        return null;
+                    }
+                    return {
+                        name,
+                        static: isStatic,
+                        callSignature: false,
+                    };
+                }
+                case experimental_utils_1.AST_NODE_TYPES.TSMethodSignature:
+                    return {
+                        name: util.getNameFromMember(member, sourceCode),
+                        static: isStatic,
+                        callSignature: false,
+                    };
+                case experimental_utils_1.AST_NODE_TYPES.TSCallSignatureDeclaration:
+                    return {
+                        name: 'call',
+                        static: isStatic,
+                        callSignature: true,
+                    };
+                case experimental_utils_1.AST_NODE_TYPES.TSConstructSignatureDeclaration:
+                    return {
+                        name: 'new',
+                        static: isStatic,
+                        callSignature: false,
+                    };
+                case experimental_utils_1.AST_NODE_TYPES.MethodDefinition:
+                    return {
+                        name: util.getNameFromMember(member, sourceCode),
+                        static: isStatic,
+                        callSignature: false,
+                    };
+            }
+            return null;
+        }
+        function isSameMethod(method1, method2) {
+            return (!!method2 &&
+                method1.name === method2.name &&
+                method1.static === method2.static &&
+                method1.callSignature === method2.callSignature);
+        }
+        function getMembers(node) {
+            switch (node.type) {
+                case experimental_utils_1.AST_NODE_TYPES.ClassBody:
+                case experimental_utils_1.AST_NODE_TYPES.Program:
+                case experimental_utils_1.AST_NODE_TYPES.TSModuleBlock:
+                case experimental_utils_1.AST_NODE_TYPES.TSInterfaceBody:
+                    return node.body;
+                case experimental_utils_1.AST_NODE_TYPES.TSTypeLiteral:
+                    return node.members;
+            }
+        }
+        /**
+         * Check the body for overload methods.
+         * @param {ASTNode} node the body to be inspected.
+         */
+        function checkBodyForOverloadMethods(node) {
+            const members = getMembers(node);
+            if (members) {
+                let lastMethod = null;
+                const seenMethods = [];
+                members.forEach(member => {
+                    const method = getMemberMethod(member);
+                    if (method === null) {
+                        lastMethod = null;
+                        return;
+                    }
+                    const index = seenMethods.findIndex(seenMethod => isSameMethod(method, seenMethod));
+                    if (index > -1 && !isSameMethod(method, lastMethod)) {
+                        context.report({
+                            node: member,
+                            messageId: 'adjacentSignature',
+                            data: {
+                                name: (method.static ? 'static ' : '') + method.name,
+                            },
+                        });
+                    }
+                    else if (index === -1) {
+                        seenMethods.push(method);
+                    }
+                    lastMethod = method;
+                });
+            }
+        }
+        return {
+            ClassBody: checkBodyForOverloadMethods,
+            Program: checkBodyForOverloadMethods,
+            TSModuleBlock: checkBodyForOverloadMethods,
+            TSTypeLiteral: checkBodyForOverloadMethods,
+            TSInterfaceBody: checkBodyForOverloadMethods,
+        };
+    },
+});
+//# sourceMappingURL=adjacent-overload-signatures.js.map

node_modules/@typescript-eslint/eslint-plugin/dist/rules/adjacent-overload-signatures.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"adjacent-overload-signatures.js","sourceRoot":"","sources":["../../src/rules/adjacent-overload-signatures.ts"],"names":[],"mappings":"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"}

node_modules/@typescript-eslint/eslint-plugin/dist/rules/array-type.js

@@ -0,0 +1,275 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const experimental_utils_1 = require("@typescript-eslint/experimental-utils");
+const util = __importStar(require("../util"));
+/**
+ * Check whatever node can be considered as simple
+ * @param node the node to be evaluated.
+ */
+function isSimpleType(node) {
+    switch (node.type) {
+        case experimental_utils_1.AST_NODE_TYPES.Identifier:
+        case experimental_utils_1.AST_NODE_TYPES.TSAnyKeyword:
+        case experimental_utils_1.AST_NODE_TYPES.TSBooleanKeyword:
+        case experimental_utils_1.AST_NODE_TYPES.TSNeverKeyword:
+        case experimental_utils_1.AST_NODE_TYPES.TSNumberKeyword:
+        case experimental_utils_1.AST_NODE_TYPES.TSObjectKeyword:
+        case experimental_utils_1.AST_NODE_TYPES.TSStringKeyword:
+        case experimental_utils_1.AST_NODE_TYPES.TSSymbolKeyword:
+        case experimental_utils_1.AST_NODE_TYPES.TSUnknownKeyword:
+        case experimental_utils_1.AST_NODE_TYPES.TSVoidKeyword:
+        case experimental_utils_1.AST_NODE_TYPES.TSNullKeyword:
+        case experimental_utils_1.AST_NODE_TYPES.TSArrayType:
+        case experimental_utils_1.AST_NODE_TYPES.TSUndefinedKeyword:
+        case experimental_utils_1.AST_NODE_TYPES.TSThisType:
+        case experimental_utils_1.AST_NODE_TYPES.TSQualifiedName:
+            return true;
+        case experimental_utils_1.AST_NODE_TYPES.TSTypeReference:
+            if (node.typeName &&
+                node.typeName.type === experimental_utils_1.AST_NODE_TYPES.Identifier &&
+                node.typeName.name === 'Array') {
+                if (!node.typeParameters) {
+                    return true;
+                }
+                if (node.typeParameters.params.length === 1) {
+                    return isSimpleType(node.typeParameters.params[0]);
+                }
+            }
+            else {
+                if (node.typeParameters) {
+                    return false;
+                }
+                return isSimpleType(node.typeName);
+            }
+            return false;
+        default:
+            return false;
+    }
+}
+/**
+ * Check if node needs parentheses
+ * @param node the node to be evaluated.
+ */
+function typeNeedsParentheses(node) {
+    switch (node.type) {
+        case experimental_utils_1.AST_NODE_TYPES.TSTypeReference:
+            return typeNeedsParentheses(node.typeName);
+        case experimental_utils_1.AST_NODE_TYPES.TSUnionType:
+        case experimental_utils_1.AST_NODE_TYPES.TSFunctionType:
+        case experimental_utils_1.AST_NODE_TYPES.TSIntersectionType:
+        case experimental_utils_1.AST_NODE_TYPES.TSTypeOperator:
+        case experimental_utils_1.AST_NODE_TYPES.TSInferType:
+            return true;
+        case experimental_utils_1.AST_NODE_TYPES.Identifier:
+            return node.name === 'ReadonlyArray';
+        default:
+            return false;
+    }
+}
+const arrayOption = { enum: ['array', 'generic', 'array-simple'] };
+exports.default = util.createRule({
+    name: 'array-type',
+    meta: {
+        type: 'suggestion',
+        docs: {
+            description: 'Requires using either `T[]` or `Array<T>` for arrays',
+            category: 'Stylistic Issues',
+            // too opinionated to be recommended
+            recommended: false,
+        },
+        fixable: 'code',
+        messages: {
+            errorStringGeneric: "Array type using '{{type}}[]' is forbidden. Use 'Array<{{type}}>' instead.",
+            errorStringGenericSimple: "Array type using '{{type}}[]' is forbidden for non-simple types. Use 'Array<{{type}}>' instead.",
+            errorStringArray: "Array type using 'Array<{{type}}>' is forbidden. Use '{{type}}[]' instead.",
+            errorStringArraySimple: "Array type using 'Array<{{type}}>' is forbidden for simple types. Use '{{type}}[]' instead.",
+        },
+        schema: [
+            {
+                type: 'object',
+                properties: {
+                    default: arrayOption,
+                    readonly: arrayOption,
+                },
+            },
+        ],
+    },
+    defaultOptions: [
+        {
+            default: 'array',
+        },
+    ],
+    create(context, [options]) {
+        var _a;
+        const sourceCode = context.getSourceCode();
+        const defaultOption = options.default;
+        const readonlyOption = (_a = options.readonly) !== null && _a !== void 0 ? _a : defaultOption;
+        const isArraySimpleOption = defaultOption === 'array-simple' && readonlyOption === 'array-simple';
+        const isArrayOption = defaultOption === 'array' && readonlyOption === 'array';
+        const isGenericOption = defaultOption === 'generic' && readonlyOption === 'generic';
+        /**
+         * Check if whitespace is needed before this node
+         * @param node the node to be evaluated.
+         */
+        function requireWhitespaceBefore(node) {
+            const prevToken = sourceCode.getTokenBefore(node);
+            if (!prevToken) {
+                return false;
+            }
+            const nextToken = sourceCode.getTokenAfter(prevToken);
+            if (nextToken && sourceCode.isSpaceBetweenTokens(prevToken, nextToken)) {
+                return false;
+            }
+            return prevToken.type === experimental_utils_1.AST_TOKEN_TYPES.Identifier;
+        }
+        /**
+         * @param node the node to be evaluated.
+         */
+        function getMessageType(node) {
+            if (node) {
+                if (node.type === experimental_utils_1.AST_NODE_TYPES.TSParenthesizedType) {
+                    return getMessageType(node.typeAnnotation);
+                }
+                if (isSimpleType(node)) {
+                    return sourceCode.getText(node);
+                }
+            }
+            return 'T';
+        }
+        /**
+         * @param node the node to be evaluated
+         */
+        function getTypeOpNodeRange(node) {
+            if (!node) {
+                return undefined;
+            }
+            const firstToken = sourceCode.getFirstToken(node);
+            const nextToken = sourceCode.getTokenAfter(firstToken);
+            return [firstToken.range[0], nextToken.range[0]];
+        }
+        return {
+            TSArrayType(node) {
+                if (isArrayOption ||
+                    (isArraySimpleOption && isSimpleType(node.elementType))) {
+                    return;
+                }
+                const isReadonly = node.parent &&
+                    node.parent.type === experimental_utils_1.AST_NODE_TYPES.TSTypeOperator &&
+                    node.parent.operator === 'readonly';
+                const isReadonlyGeneric = readonlyOption === 'generic' && defaultOption !== 'generic';
+                const isReadonlyArray = readonlyOption !== 'generic' && defaultOption === 'generic';
+                if ((isReadonlyGeneric && !isReadonly) ||
+                    (isReadonlyArray && isReadonly)) {
+                    return;
+                }
+                const messageId = defaultOption === 'generic'
+                    ? 'errorStringGeneric'
+                    : 'errorStringGenericSimple';
+                const typeOpNode = isReadonly ? node.parent : null;
+                context.report({
+                    node: isReadonly ? node.parent : node,
+                    messageId,
+                    data: {
+                        type: getMessageType(node.elementType),
+                    },
+                    fix(fixer) {
+                        const toFix = [
+                            fixer.replaceTextRange([node.range[1] - 2, node.range[1]], '>'),
+                        ];
+                        const startText = requireWhitespaceBefore(node);
+                        const typeOpNodeRange = getTypeOpNodeRange(typeOpNode);
+                        if (typeOpNodeRange) {
+                            toFix.unshift(fixer.removeRange(typeOpNodeRange));
+                        }
+                        else {
+                            toFix.push(fixer.insertTextBefore(node, `${startText ? ' ' : ''}`));
+                        }
+                        toFix.push(fixer.insertTextBefore(node, `${isReadonly ? 'Readonly' : ''}Array<`));
+                        if (node.elementType.type === experimental_utils_1.AST_NODE_TYPES.TSParenthesizedType) {
+                            const first = sourceCode.getFirstToken(node.elementType);
+                            const last = sourceCode.getLastToken(node.elementType);
+                            if (!first || !last) {
+                                return null;
+                            }
+                            toFix.push(fixer.remove(first));
+                            toFix.push(fixer.remove(last));
+                        }
+                        return toFix;
+                    },
+                });
+            },
+            TSTypeReference(node) {
+                var _a;
+                if (isGenericOption ||
+                    node.typeName.type !== experimental_utils_1.AST_NODE_TYPES.Identifier) {
+                    return;
+                }
+                const isReadonlyArrayType = node.typeName.name === 'ReadonlyArray';
+                const isArrayType = node.typeName.name === 'Array';
+                if (!(isArrayType || isReadonlyArrayType) ||
+                    (readonlyOption === 'generic' && isReadonlyArrayType) ||
+                    (defaultOption === 'generic' && !isReadonlyArrayType)) {
+                    return;
+                }
+                const readonlyPrefix = isReadonlyArrayType ? 'readonly ' : '';
+                const typeParams = (_a = node.typeParameters) === null || _a === void 0 ? void 0 : _a.params;
+                const messageId = defaultOption === 'array'
+                    ? 'errorStringArray'
+                    : 'errorStringArraySimple';
+                if (!typeParams || typeParams.length === 0) {
+                    // Create an 'any' array
+                    context.report({
+                        node,
+                        messageId,
+                        data: {
+                            type: 'any',
+                        },
+                        fix(fixer) {
+                            return fixer.replaceText(node, `${readonlyPrefix}any[]`);
+                        },
+                    });
+                    return;
+                }
+                if (typeParams.length !== 1 ||
+                    (defaultOption === 'array-simple' && !isSimpleType(typeParams[0]))) {
+                    return;
+                }
+                const type = typeParams[0];
+                const parens = typeNeedsParentheses(type);
+                context.report({
+                    node,
+                    messageId,
+                    data: {
+                        type: getMessageType(type),
+                    },
+                    fix(fixer) {
+                        return [
+                            fixer.replaceTextRange([node.range[0], type.range[0]], `${readonlyPrefix}${parens ? '(' : ''}`),
+                            fixer.replaceTextRange([type.range[1], node.range[1]], parens ? ')[]' : '[]'),
+                        ];
+                    },
+                });
+            },
+        };
+    },
+});
+//# sourceMappingURL=array-type.js.map

node_modules/@typescript-eslint/eslint-plugin/dist/rules/await-thenable.js

@@ -0,0 +1,59 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const tsutils = __importStar(require("tsutils"));
+const util = __importStar(require("../util"));
+exports.default = util.createRule({
+    name: 'await-thenable',
+    meta: {
+        docs: {
+            description: 'Disallows awaiting a value that is not a Thenable',
+            category: 'Best Practices',
+            recommended: 'error',
+            requiresTypeChecking: true,
+        },
+        messages: {
+            await: 'Unexpected `await` of a non-Promise (non-"Thenable") value.',
+        },
+        schema: [],
+        type: 'problem',
+    },
+    defaultOptions: [],
+    create(context) {
+        const parserServices = util.getParserServices(context);
+        const checker = parserServices.program.getTypeChecker();
+        return {
+            AwaitExpression(node) {
+                const originalNode = parserServices.esTreeNodeToTSNodeMap.get(node);
+                const type = checker.getTypeAtLocation(originalNode.expression);
+                if (!util.isTypeAnyType(type) &&
+                    !util.isTypeUnknownType(type) &&
+                    !tsutils.isThenableType(checker, originalNode.expression, type)) {
+                    context.report({
+                        messageId: 'await',
+                        node,
+                    });
+                }
+            },
+        };
+    },
+});
+//# sourceMappingURL=await-thenable.js.map

node_modules/@typescript-eslint/eslint-plugin/dist/rules/await-thenable.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"await-thenable.js","sourceRoot":"","sources":["../../src/rules/await-thenable.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;AAAA,iDAAmC;AAEnC,8CAAgC;AAEhC,kBAAe,IAAI,CAAC,UAAU,CAAC;IAC7B,IAAI,EAAE,gBAAgB;IACtB,IAAI,EAAE;QACJ,IAAI,EAAE;YACJ,WAAW,EAAE,mDAAmD;YAChE,QAAQ,EAAE,gBAAgB;YAC1B,WAAW,EAAE,OAAO;YACpB,oBAAoB,EAAE,IAAI;SAC3B;QACD,QAAQ,EAAE;YACR,KAAK,EAAE,6DAA6D;SACrE;QACD,MAAM,EAAE,EAAE;QACV,IAAI,EAAE,SAAS;KAChB;IACD,cAAc,EAAE,EAAE;IAElB,MAAM,CAAC,OAAO;QACZ,MAAM,cAAc,GAAG,IAAI,CAAC,iBAAiB,CAAC,OAAO,CAAC,CAAC;QACvD,MAAM,OAAO,GAAG,cAAc,CAAC,OAAO,CAAC,cAAc,EAAE,CAAC;QAExD,OAAO;YACL,eAAe,CAAC,IAAI;gBAClB,MAAM,YAAY,GAAG,cAAc,CAAC,qBAAqB,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;gBACpE,MAAM,IAAI,GAAG,OAAO,CAAC,iBAAiB,CAAC,YAAY,CAAC,UAAU,CAAC,CAAC;gBAEhE,IACE,CAAC,IAAI,CAAC,aAAa,CAAC,IAAI,CAAC;oBACzB,CAAC,IAAI,CAAC,iBAAiB,CAAC,IAAI,CAAC;oBAC7B,CAAC,OAAO,CAAC,cAAc,CAAC,OAAO,EAAE,YAAY,CAAC,UAAU,EAAE,IAAI,CAAC,EAC/D;oBACA,OAAO,CAAC,MAAM,CAAC;wBACb,SAAS,EAAE,OAAO;wBAClB,IAAI;qBACL,CAAC,CAAC;iBACJ;YACH,CAAC;SACF,CAAC;IACJ,CAAC;CACF,CAAC,CAAC"}

node_modules/@typescript-eslint/eslint-plugin/dist/rules/ban-ts-comment.js

@@ -0,0 +1,141 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defaultMinimumDescriptionLength = void 0;
+const experimental_utils_1 = require("@typescript-eslint/experimental-utils");
+const util = __importStar(require("../util"));
+exports.defaultMinimumDescriptionLength = 3;
+exports.default = util.createRule({
+    name: 'ban-ts-comment',
+    meta: {
+        type: 'problem',
+        docs: {
+            description: 'Bans `// @ts-<directive>` comments from being used or requires descriptions after directive',
+            category: 'Best Practices',
+            recommended: 'error',
+        },
+        messages: {
+            tsDirectiveComment: 'Do not use "// @ts-{{directive}}" because it alters compilation errors.',
+            tsDirectiveCommentRequiresDescription: 'Include a description after the "// @ts-{{directive}}" directive to explain why the @ts-{{directive}} is necessary. The description must be {{minimumDescriptionLength}} characters or longer.',
+        },
+        schema: [
+            {
+                type: 'object',
+                properties: {
+                    'ts-expect-error': {
+                        oneOf: [
+                            {
+                                type: 'boolean',
+                                default: true,
+                            },
+                            {
+                                enum: ['allow-with-description'],
+                            },
+                        ],
+                    },
+                    'ts-ignore': {
+                        oneOf: [
+                            {
+                                type: 'boolean',
+                                default: true,
+                            },
+                            {
+                                enum: ['allow-with-description'],
+                            },
+                        ],
+                    },
+                    'ts-nocheck': {
+                        oneOf: [
+                            {
+                                type: 'boolean',
+                                default: true,
+                            },
+                            {
+                                enum: ['allow-with-description'],
+                            },
+                        ],
+                    },
+                    'ts-check': {
+                        oneOf: [
+                            {
+                                type: 'boolean',
+                                default: true,
+                            },
+                            {
+                                enum: ['allow-with-description'],
+                            },
+                        ],
+                    },
+                    minimumDescriptionLength: {
+                        type: 'number',
+                        default: exports.defaultMinimumDescriptionLength,
+                    },
+                },
+                additionalProperties: false,
+            },
+        ],
+    },
+    defaultOptions: [
+        {
+            'ts-expect-error': 'allow-with-description',
+            'ts-ignore': true,
+            'ts-nocheck': true,
+            'ts-check': false,
+            minimumDescriptionLength: exports.defaultMinimumDescriptionLength,
+        },
+    ],
+    create(context, [options]) {
+        const tsCommentRegExp = /^\/*\s*@ts-(expect-error|ignore|check|nocheck)(.*)/;
+        const sourceCode = context.getSourceCode();
+        return {
+            Program() {
+                const comments = sourceCode.getAllComments();
+                comments.forEach(comment => {
+                    var _a;
+                    if (comment.type !== experimental_utils_1.AST_TOKEN_TYPES.Line) {
+                        return;
+                    }
+                    const [, directive, description] = (_a = tsCommentRegExp.exec(comment.value)) !== null && _a !== void 0 ? _a : [];
+                    const fullDirective = `ts-${directive}`;
+                    const option = options[fullDirective];
+                    if (option === true) {
+                        context.report({
+                            data: { directive },
+                            node: comment,
+                            messageId: 'tsDirectiveComment',
+                        });
+                    }
+                    if (option === 'allow-with-description') {
+                        const { minimumDescriptionLength = exports.defaultMinimumDescriptionLength, } = options;
+                        if (description.trim().length < minimumDescriptionLength) {
+                            context.report({
+                                data: { directive, minimumDescriptionLength },
+                                node: comment,
+                                messageId: 'tsDirectiveCommentRequiresDescription',
+                            });
+                        }
+                    }
+                });
+            },
+        };
+    },
+});
+//# sourceMappingURL=ban-ts-comment.js.map

node_modules/@typescript-eslint/eslint-plugin/dist/rules/ban-ts-comment.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ban-ts-comment.js","sourceRoot":"","sources":["../../src/rules/ban-ts-comment.ts"],"names":[],"mappings":"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"}

node_modules/@typescript-eslint/eslint-plugin/dist/rules/ban-tslint-comment.js

@@ -0,0 +1,75 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const experimental_utils_1 = require("@typescript-eslint/experimental-utils");
+const util = __importStar(require("../util"));
+// tslint regex
+// https://github.com/palantir/tslint/blob/95d9d958833fd9dc0002d18cbe34db20d0fbf437/src/enableDisableRules.ts#L32
+const ENABLE_DISABLE_REGEX = /^\s*tslint:(enable|disable)(?:-(line|next-line))?(:|\s|$)/;
+const toText = (text, type) => type === experimental_utils_1.AST_TOKEN_TYPES.Line
+    ? ['//', text.trim()].join(' ')
+    : ['/*', text.trim(), '*/'].join(' ');
+exports.default = util.createRule({
+    name: 'ban-tslint-comment',
+    meta: {
+        type: 'suggestion',
+        docs: {
+            description: 'Bans `// tslint:<rule-flag>` comments from being used',
+            category: 'Stylistic Issues',
+            recommended: false,
+        },
+        messages: {
+            commentDetected: 'tslint comment detected: "{{ text }}"',
+        },
+        schema: [],
+        fixable: 'code',
+    },
+    defaultOptions: [],
+    create: context => {
+        const sourceCode = context.getSourceCode();
+        return {
+            Program() {
+                const comments = sourceCode.getAllComments();
+                comments.forEach(c => {
+                    if (ENABLE_DISABLE_REGEX.test(c.value)) {
+                        context.report({
+                            data: { text: toText(c.value, c.type) },
+                            node: c,
+                            messageId: 'commentDetected',
+                            fix(fixer) {
+                                const rangeStart = sourceCode.getIndexFromLoc({
+                                    column: c.loc.start.column > 0 ? c.loc.start.column - 1 : 0,
+                                    line: c.loc.start.line,
+                                });
+                                const rangeEnd = sourceCode.getIndexFromLoc({
+                                    column: c.loc.end.column,
+                                    line: c.loc.end.line,
+                                });
+                                return fixer.removeRange([rangeStart, rangeEnd + 1]);
+                            },
+                        });
+                    }
+                });
+            },
+        };
+    },
+});
+//# sourceMappingURL=ban-tslint-comment.js.map

node_modules/@typescript-eslint/eslint-plugin/dist/rules/ban-tslint-comment.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ban-tslint-comment.js","sourceRoot":"","sources":["../../src/rules/ban-tslint-comment.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;AAAA,8EAAwE;AACxE,8CAAgC;AAEhC,eAAe;AACf,iHAAiH;AACjH,MAAM,oBAAoB,GAAG,2DAA2D,CAAC;AAEzF,MAAM,MAAM,GAAG,CACb,IAAY,EACZ,IAAkD,EAC1C,EAAE,CACV,IAAI,KAAK,oCAAe,CAAC,IAAI;IAC3B,CAAC,CAAC,CAAC,IAAI,EAAE,IAAI,CAAC,IAAI,EAAE,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC;IAC/B,CAAC,CAAC,CAAC,IAAI,EAAE,IAAI,CAAC,IAAI,EAAE,EAAE,IAAI,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;AAE1C,kBAAe,IAAI,CAAC,UAAU,CAAC;IAC7B,IAAI,EAAE,oBAAoB;IAC1B,IAAI,EAAE;QACJ,IAAI,EAAE,YAAY;QAClB,IAAI,EAAE;YACJ,WAAW,EAAE,uDAAuD;YACpE,QAAQ,EAAE,kBAAkB;YAC5B,WAAW,EAAE,KAAK;SACnB;QACD,QAAQ,EAAE;YACR,eAAe,EAAE,uCAAuC;SACzD;QACD,MAAM,EAAE,EAAE;QACV,OAAO,EAAE,MAAM;KAChB;IACD,cAAc,EAAE,EAAE;IAClB,MAAM,EAAE,OAAO,CAAC,EAAE;QAChB,MAAM,UAAU,GAAG,OAAO,CAAC,aAAa,EAAE,CAAC;QAC3C,OAAO;YACL,OAAO;gBACL,MAAM,QAAQ,GAAG,UAAU,CAAC,cAAc,EAAE,CAAC;gBAC7C,QAAQ,CAAC,OAAO,CAAC,CAAC,CAAC,EAAE;oBACnB,IAAI,oBAAoB,CAAC,IAAI,CAAC,CAAC,CAAC,KAAK,CAAC,EAAE;wBACtC,OAAO,CAAC,MAAM,CAAC;4BACb,IAAI,EAAE,EAAE,IAAI,EAAE,MAAM,CAAC,CAAC,CAAC,KAAK,EAAE,CAAC,CAAC,IAAI,CAAC,EAAE;4BACvC,IAAI,EAAE,CAAC;4BACP,SAAS,EAAE,iBAAiB;4BAC5B,GAAG,CAAC,KAAK;gCACP,MAAM,UAAU,GAAG,UAAU,CAAC,eAAe,CAAC;oCAC5C,MAAM,EAAE,CAAC,CAAC,GAAG,CAAC,KAAK,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,KAAK,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC;oCAC3D,IAAI,EAAE,CAAC,CAAC,GAAG,CAAC,KAAK,CAAC,IAAI;iCACvB,CAAC,CAAC;gCACH,MAAM,QAAQ,GAAG,UAAU,CAAC,eAAe,CAAC;oCAC1C,MAAM,EAAE,CAAC,CAAC,GAAG,CAAC,GAAG,CAAC,MAAM;oCACxB,IAAI,EAAE,CAAC,CAAC,GAAG,CAAC,GAAG,CAAC,IAAI;iCACrB,CAAC,CAAC;gCACH,OAAO,KAAK,CAAC,WAAW,CAAC,CAAC,UAAU,EAAE,QAAQ,GAAG,CAAC,CAAC,CAAC,CAAC;4BACvD,CAAC;yBACF,CAAC,CAAC;qBACJ;gBACH,CAAC,CAAC,CAAC;YACL,CAAC;SACF,CAAC;IACJ,CAAC;CACF,CAAC,CAAC"}

node_modules/@typescript-eslint/eslint-plugin/dist/rules/ban-types.js

@@ -0,0 +1,189 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TYPE_KEYWORDS = void 0;
+const experimental_utils_1 = require("@typescript-eslint/experimental-utils");
+const util = __importStar(require("../util"));
+function removeSpaces(str) {
+    return str.replace(/ /g, '');
+}
+function stringifyTypeName(node, sourceCode) {
+    return removeSpaces(sourceCode.getText(node));
+}
+function getCustomMessage(bannedType) {
+    if (bannedType === null) {
+        return '';
+    }
+    if (typeof bannedType === 'string') {
+        return ` ${bannedType}`;
+    }
+    if (bannedType.message) {
+        return ` ${bannedType.message}`;
+    }
+    return '';
+}
+const defaultTypes = {
+    String: {
+        message: 'Use string instead',
+        fixWith: 'string',
+    },
+    Boolean: {
+        message: 'Use boolean instead',
+        fixWith: 'boolean',
+    },
+    Number: {
+        message: 'Use number instead',
+        fixWith: 'number',
+    },
+    Symbol: {
+        message: 'Use symbol instead',
+        fixWith: 'symbol',
+    },
+    Function: {
+        message: [
+            'The `Function` type accepts any function-like value.',
+            'It provides no type safety when calling the function, which can be a common source of bugs.',
+            'It also accepts things like class declarations, which will throw at runtime as they will not be called with `new`.',
+            'If you are expecting the function to accept certain arguments, you should explicitly define the function shape.',
+        ].join('\n'),
+    },
+    // object typing
+    Object: {
+        message: [
+            'The `Object` type actually means "any non-nullish value", so it is marginally better than `unknown`.',
+            '- If you want a type meaning "any object", you probably want `Record<string, unknown>` instead.',
+            '- If you want a type meaning "any value", you probably want `unknown` instead.',
+        ].join('\n'),
+    },
+    '{}': {
+        message: [
+            '`{}` actually means "any non-nullish value".',
+            '- If you want a type meaning "any object", you probably want `Record<string, unknown>` instead.',
+            '- If you want a type meaning "any value", you probably want `unknown` instead.',
+        ].join('\n'),
+    },
+    object: {
+        message: [
+            'The `object` type is currently hard to use ([see this issue](https://github.com/microsoft/TypeScript/issues/21732)).',
+            'Consider using `Record<string, unknown>` instead, as it allows you to more easily inspect and use the keys.',
+        ].join('\n'),
+    },
+};
+exports.TYPE_KEYWORDS = {
+    bigint: experimental_utils_1.AST_NODE_TYPES.TSBigIntKeyword,
+    boolean: experimental_utils_1.AST_NODE_TYPES.TSBooleanKeyword,
+    never: experimental_utils_1.AST_NODE_TYPES.TSNeverKeyword,
+    null: experimental_utils_1.AST_NODE_TYPES.TSNullKeyword,
+    number: experimental_utils_1.AST_NODE_TYPES.TSNumberKeyword,
+    object: experimental_utils_1.AST_NODE_TYPES.TSObjectKeyword,
+    string: experimental_utils_1.AST_NODE_TYPES.TSStringKeyword,
+    symbol: experimental_utils_1.AST_NODE_TYPES.TSSymbolKeyword,
+    undefined: experimental_utils_1.AST_NODE_TYPES.TSUndefinedKeyword,
+    unknown: experimental_utils_1.AST_NODE_TYPES.TSUnknownKeyword,
+    void: experimental_utils_1.AST_NODE_TYPES.TSVoidKeyword,
+};
+exports.default = util.createRule({
+    name: 'ban-types',
+    meta: {
+        type: 'suggestion',
+        docs: {
+            description: 'Bans specific types from being used',
+            category: 'Best Practices',
+            recommended: 'error',
+        },
+        fixable: 'code',
+        messages: {
+            bannedTypeMessage: "Don't use `{{name}}` as a type.{{customMessage}}",
+        },
+        schema: [
+            {
+                type: 'object',
+                properties: {
+                    types: {
+                        type: 'object',
+                        additionalProperties: {
+                            oneOf: [
+                                { type: 'null' },
+                                { type: 'boolean' },
+                                { type: 'string' },
+                                {
+                                    type: 'object',
+                                    properties: {
+                                        message: { type: 'string' },
+                                        fixWith: { type: 'string' },
+                                    },
+                                    additionalProperties: false,
+                                },
+                            ],
+                        },
+                    },
+                    extendDefaults: {
+                        type: 'boolean',
+                    },
+                },
+                additionalProperties: false,
+            },
+        ],
+    },
+    defaultOptions: [{}],
+    create(context, [options]) {
+        var _a, _b;
+        const extendDefaults = (_a = options.extendDefaults) !== null && _a !== void 0 ? _a : true;
+        const customTypes = (_b = options.types) !== null && _b !== void 0 ? _b : {};
+        const types = Object.assign({}, extendDefaults ? defaultTypes : {}, customTypes);
+        const bannedTypes = new Map(Object.entries(types).map(([type, data]) => [removeSpaces(type), data]));
+        function checkBannedTypes(typeNode, name = stringifyTypeName(typeNode, context.getSourceCode())) {
+            const bannedType = bannedTypes.get(name);
+            if (bannedType === undefined || bannedType === false) {
+                return;
+            }
+            const customMessage = getCustomMessage(bannedType);
+            const fixWith = bannedType && typeof bannedType === 'object' && bannedType.fixWith;
+            context.report({
+                node: typeNode,
+                messageId: 'bannedTypeMessage',
+                data: {
+                    name,
+                    customMessage,
+                },
+                fix: fixWith
+                    ? (fixer) => fixer.replaceText(typeNode, fixWith)
+                    : null,
+            });
+        }
+        const keywordSelectors = util.objectReduceKey(exports.TYPE_KEYWORDS, (acc, keyword) => {
+            if (bannedTypes.has(keyword)) {
+                acc[exports.TYPE_KEYWORDS[keyword]] = (node) => checkBannedTypes(node, keyword);
+            }
+            return acc;
+        }, {});
+        return Object.assign(Object.assign({}, keywordSelectors), { TSTypeLiteral(node) {
+                if (node.members.length) {
+                    return;
+                }
+                checkBannedTypes(node);
+            },
+            TSTypeReference({ typeName }) {
+                checkBannedTypes(typeName);
+            } });
+    },
+});
+//# sourceMappingURL=ban-types.js.map

node_modules/@typescript-eslint/eslint-plugin/dist/rules/ban-types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ban-types.js","sourceRoot":"","sources":["../../src/rules/ban-types.ts"],"names":[],"mappings":"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"}

node_modules/@typescript-eslint/eslint-plugin/dist/rules/brace-style.js

@@ -0,0 +1,94 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const brace_style_1 = __importDefault(require("eslint/lib/rules/brace-style"));
+const util_1 = require("../util");
+exports.default = util_1.createRule({
+    name: 'brace-style',
+    meta: {
+        type: 'layout',
+        docs: {
+            description: 'Enforce consistent brace style for blocks',
+            category: 'Stylistic Issues',
+            recommended: false,
+            extendsBaseRule: true,
+        },
+        messages: brace_style_1.default.meta.messages,
+        fixable: brace_style_1.default.meta.fixable,
+        schema: brace_style_1.default.meta.schema,
+    },
+    defaultOptions: ['1tbs'],
+    create(context) {
+        const [style, { allowSingleLine } = { allowSingleLine: false },] = context.options;
+        const isAllmanStyle = style === 'allman';
+        const sourceCode = context.getSourceCode();
+        const rules = brace_style_1.default.create(context);
+        /**
+         * Checks a pair of curly brackets based on the user's config
+         */
+        function validateCurlyPair(openingCurlyToken, closingCurlyToken) {
+            if (allowSingleLine &&
+                util_1.isTokenOnSameLine(openingCurlyToken, closingCurlyToken)) {
+                return;
+            }
+            const tokenBeforeOpeningCurly = sourceCode.getTokenBefore(openingCurlyToken);
+            const tokenBeforeClosingCurly = sourceCode.getTokenBefore(closingCurlyToken);
+            const tokenAfterOpeningCurly = sourceCode.getTokenAfter(openingCurlyToken);
+            if (!isAllmanStyle &&
+                !util_1.isTokenOnSameLine(tokenBeforeOpeningCurly, openingCurlyToken)) {
+                context.report({
+                    node: openingCurlyToken,
+                    messageId: 'nextLineOpen',
+                    fix: fixer => {
+                        const textRange = [
+                            tokenBeforeOpeningCurly.range[1],
+                            openingCurlyToken.range[0],
+                        ];
+                        const textBetween = sourceCode.text.slice(textRange[0], textRange[1]);
+                        if (textBetween.trim()) {
+                            return null;
+                        }
+                        return fixer.replaceTextRange(textRange, ' ');
+                    },
+                });
+            }
+            if (isAllmanStyle &&
+                util_1.isTokenOnSameLine(tokenBeforeOpeningCurly, openingCurlyToken)) {
+                context.report({
+                    node: openingCurlyToken,
+                    messageId: 'sameLineOpen',
+                    fix: fixer => fixer.insertTextBefore(openingCurlyToken, '\n'),
+                });
+            }
+            if (util_1.isTokenOnSameLine(openingCurlyToken, tokenAfterOpeningCurly) &&
+                tokenAfterOpeningCurly !== closingCurlyToken) {
+                context.report({
+                    node: openingCurlyToken,
+                    messageId: 'blockSameLine',
+                    fix: fixer => fixer.insertTextAfter(openingCurlyToken, '\n'),
+                });
+            }
+            if (util_1.isTokenOnSameLine(tokenBeforeClosingCurly, closingCurlyToken) &&
+                tokenBeforeClosingCurly !== openingCurlyToken) {
+                context.report({
+                    node: closingCurlyToken,
+                    messageId: 'singleLineClose',
+                    fix: fixer => fixer.insertTextBefore(closingCurlyToken, '\n'),
+                });
+            }
+        }
+        return Object.assign(Object.assign({}, rules), { 'TSInterfaceBody, TSModuleBlock'(node) {
+                const openingCurly = sourceCode.getFirstToken(node);
+                const closingCurly = sourceCode.getLastToken(node);
+                validateCurlyPair(openingCurly, closingCurly);
+            },
+            TSEnumDeclaration(node) {
+                const closingCurly = sourceCode.getLastToken(node);
+                const openingCurly = sourceCode.getTokenBefore(node.members.length ? node.members[0] : closingCurly);
+                validateCurlyPair(openingCurly, closingCurly);
+            } });
+    },
+});
+//# sourceMappingURL=brace-style.js.map

node_modules/@typescript-eslint/eslint-plugin/dist/rules/brace-style.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"brace-style.js","sourceRoot":"","sources":["../../src/rules/brace-style.ts"],"names":[],"mappings":"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"}

node_modules/@typescript-eslint/eslint-plugin/dist/rules/class-literal-property-style.js

@@ -0,0 +1,114 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const experimental_utils_1 = require("@typescript-eslint/experimental-utils");
+const util = __importStar(require("../util"));
+const printNodeModifiers = (node, final) => {
+    var _a;
+    return `${(_a = node.accessibility) !== null && _a !== void 0 ? _a : ''}${node.static ? ' static' : ''} ${final} `.trimLeft();
+};
+const isSupportedLiteral = (node) => {
+    if (node.type === experimental_utils_1.AST_NODE_TYPES.Literal) {
+        return true;
+    }
+    if (node.type === experimental_utils_1.AST_NODE_TYPES.TaggedTemplateExpression ||
+        node.type === experimental_utils_1.AST_NODE_TYPES.TemplateLiteral) {
+        return ('quasi' in node ? node.quasi.quasis : node.quasis).length === 1;
+    }
+    return false;
+};
+exports.default = util.createRule({
+    name: 'class-literal-property-style',
+    meta: {
+        type: 'problem',
+        docs: {
+            description: 'Ensures that literals on classes are exposed in a consistent style',
+            category: 'Best Practices',
+            recommended: false,
+        },
+        fixable: 'code',
+        messages: {
+            preferFieldStyle: 'Literals should be exposed using readonly fields.',
+            preferGetterStyle: 'Literals should be exposed using getters.',
+        },
+        schema: [{ enum: ['fields', 'getters'] }],
+    },
+    defaultOptions: ['fields'],
+    create(context, [style]) {
+        if (style === 'fields') {
+            return {
+                MethodDefinition(node) {
+                    if (node.kind !== 'get' ||
+                        !node.value.body ||
+                        !node.value.body.body.length) {
+                        return;
+                    }
+                    const [statement] = node.value.body.body;
+                    if (statement.type !== experimental_utils_1.AST_NODE_TYPES.ReturnStatement) {
+                        return;
+                    }
+                    const { argument } = statement;
+                    if (!argument || !isSupportedLiteral(argument)) {
+                        return;
+                    }
+                    context.report({
+                        node: node.key,
+                        messageId: 'preferFieldStyle',
+                        fix(fixer) {
+                            const sourceCode = context.getSourceCode();
+                            const name = sourceCode.getText(node.key);
+                            let text = '';
+                            text += printNodeModifiers(node, 'readonly');
+                            text += node.computed ? `[${name}]` : name;
+                            text += ` = ${sourceCode.getText(argument)};`;
+                            return fixer.replaceText(node, text);
+                        },
+                    });
+                },
+            };
+        }
+        return {
+            ClassProperty(node) {
+                if (!node.readonly || node.declare) {
+                    return;
+                }
+                const { value } = node;
+                if (!value || !isSupportedLiteral(value)) {
+                    return;
+                }
+                context.report({
+                    node: node.key,
+                    messageId: 'preferGetterStyle',
+                    fix(fixer) {
+                        const sourceCode = context.getSourceCode();
+                        const name = sourceCode.getText(node.key);
+                        let text = '';
+                        text += printNodeModifiers(node, 'get');
+                        text += node.computed ? `[${name}]` : name;
+                        text += `() { return ${sourceCode.getText(value)}; }`;
+                        return fixer.replaceText(node, text);
+                    },
+                });
+            },
+        };
+    },
+});
+//# sourceMappingURL=class-literal-property-style.js.map

node_modules/@typescript-eslint/eslint-plugin/dist/rules/class-literal-property-style.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"class-literal-property-style.js","sourceRoot":"","sources":["../../src/rules/class-literal-property-style.ts"],"names":[],"mappings":"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"}

node_modules/@typescript-eslint/eslint-plugin/dist/rules/comma-spacing.js

@@ -0,0 +1,141 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const experimental_utils_1 = require("@typescript-eslint/experimental-utils");
+const util_1 = require("../util");
+exports.default = util_1.createRule({
+    name: 'comma-spacing',
+    meta: {
+        type: 'suggestion',
+        docs: {
+            description: 'Enforces consistent spacing before and after commas',
+            category: 'Stylistic Issues',
+            recommended: false,
+            extendsBaseRule: true,
+        },
+        fixable: 'whitespace',
+        schema: [
+            {
+                type: 'object',
+                properties: {
+                    before: {
+                        type: 'boolean',
+                        default: false,
+                    },
+                    after: {
+                        type: 'boolean',
+                        default: true,
+                    },
+                },
+                additionalProperties: false,
+            },
+        ],
+        messages: {
+            unexpected: `There should be no space {{loc}} ','.`,
+            missing: `A space is required {{loc}} ','.`,
+        },
+    },
+    defaultOptions: [
+        {
+            before: false,
+            after: true,
+        },
+    ],
+    create(context, [{ before: spaceBefore, after: spaceAfter }]) {
+        const sourceCode = context.getSourceCode();
+        const tokensAndComments = sourceCode.tokensAndComments;
+        const ignoredTokens = new Set();
+        /**
+         * Adds null elements of the ArrayExpression or ArrayPattern node to the ignore list
+         * @param node node to evaluate
+         */
+        function addNullElementsToIgnoreList(node) {
+            let previousToken = sourceCode.getFirstToken(node);
+            for (const element of node.elements) {
+                let token;
+                if (element === null) {
+                    token = sourceCode.getTokenAfter(previousToken);
+                    if (token && util_1.isCommaToken(token)) {
+                        ignoredTokens.add(token);
+                    }
+                }
+                else {
+                    token = sourceCode.getTokenAfter(element);
+                }
+                previousToken = token;
+            }
+        }
+        /**
+         * Adds type parameters trailing comma token to the ignore list
+         * @param node node to evaluate
+         */
+        function addTypeParametersTrailingCommaToIgnoreList(node) {
+            const param = node.params[node.params.length - 1];
+            const afterToken = sourceCode.getTokenAfter(param);
+            if (afterToken && util_1.isCommaToken(afterToken)) {
+                ignoredTokens.add(afterToken);
+            }
+        }
+        /**
+         * Validates the spacing around a comma token.
+         * @param commaToken The token representing the comma
+         * @param prevToken The last token before the comma
+         * @param nextToken The first token after the comma
+         */
+        function validateCommaSpacing(commaToken, prevToken, nextToken) {
+            if (prevToken &&
+                util_1.isTokenOnSameLine(prevToken, commaToken) &&
+                spaceBefore !== sourceCode.isSpaceBetweenTokens(prevToken, commaToken)) {
+                context.report({
+                    node: commaToken,
+                    data: {
+                        loc: 'before',
+                    },
+                    messageId: spaceBefore ? 'missing' : 'unexpected',
+                    fix: fixer => spaceBefore
+                        ? fixer.insertTextBefore(commaToken, ' ')
+                        : fixer.replaceTextRange([prevToken.range[1], commaToken.range[0]], ''),
+                });
+            }
+            if (nextToken && util_1.isClosingParenToken(nextToken)) {
+                return;
+            }
+            if (!spaceAfter && nextToken && nextToken.type === experimental_utils_1.AST_TOKEN_TYPES.Line) {
+                return;
+            }
+            if (nextToken &&
+                util_1.isTokenOnSameLine(commaToken, nextToken) &&
+                spaceAfter !== sourceCode.isSpaceBetweenTokens(commaToken, nextToken)) {
+                context.report({
+                    node: commaToken,
+                    data: {
+                        loc: 'after',
+                    },
+                    messageId: spaceAfter ? 'missing' : 'unexpected',
+                    fix: fixer => spaceAfter
+                        ? fixer.insertTextAfter(commaToken, ' ')
+                        : fixer.replaceTextRange([commaToken.range[1], nextToken.range[0]], ''),
+                });
+            }
+        }
+        return {
+            TSTypeParameterDeclaration: addTypeParametersTrailingCommaToIgnoreList,
+            ArrayExpression: addNullElementsToIgnoreList,
+            ArrayPattern: addNullElementsToIgnoreList,
+            'Program:exit'() {
+                tokensAndComments.forEach((token, i) => {
+                    if (!util_1.isCommaToken(token)) {
+                        return;
+                    }
+                    const prevToken = tokensAndComments[i - 1];
+                    const nextToken = tokensAndComments[i + 1];
+                    validateCommaSpacing(token, util_1.isCommaToken(prevToken) || ignoredTokens.has(token)
+                        ? null
+                        : prevToken, util_1.isCommaToken(nextToken) || ignoredTokens.has(token)
+                        ? null
+                        : nextToken);
+                });
+            },
+        };
+    },
+});
+//# sourceMappingURL=comma-spacing.js.map

node_modules/@typescript-eslint/eslint-plugin/dist/rules/comma-spacing.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"comma-spacing.js","sourceRoot":"","sources":["../../src/rules/comma-spacing.ts"],"names":[],"mappings":"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"}

node_modules/@typescript-eslint/eslint-plugin/dist/rules/consistent-type-assertions.js

@@ -0,0 +1,153 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const util = __importStar(require("../util"));
+const experimental_utils_1 = require("@typescript-eslint/experimental-utils");
+exports.default = util.createRule({
+    name: 'consistent-type-assertions',
+    meta: {
+        type: 'suggestion',
+        docs: {
+            category: 'Best Practices',
+            description: 'Enforces consistent usage of type assertions',
+            recommended: false,
+        },
+        messages: {
+            as: "Use 'as {{cast}}' instead of '<{{cast}}>'.",
+            'angle-bracket': "Use '<{{cast}}>' instead of 'as {{cast}}'.",
+            never: 'Do not use any type assertions.',
+            unexpectedObjectTypeAssertion: 'Always prefer const x: T = { ... }.',
+        },
+        schema: [
+            {
+                oneOf: [
+                    {
+                        type: 'object',
+                        properties: {
+                            assertionStyle: {
+                                enum: ['never'],
+                            },
+                        },
+                        additionalProperties: false,
+                        required: ['assertionStyle'],
+                    },
+                    {
+                        type: 'object',
+                        properties: {
+                            assertionStyle: {
+                                enum: ['as', 'angle-bracket'],
+                            },
+                            objectLiteralTypeAssertions: {
+                                enum: ['allow', 'allow-as-parameter', 'never'],
+                            },
+                        },
+                        additionalProperties: false,
+                        required: ['assertionStyle'],
+                    },
+                ],
+            },
+        ],
+    },
+    defaultOptions: [
+        {
+            assertionStyle: 'as',
+            objectLiteralTypeAssertions: 'allow',
+        },
+    ],
+    create(context, [options]) {
+        const sourceCode = context.getSourceCode();
+        function isConst(node) {
+            if (node.type !== experimental_utils_1.AST_NODE_TYPES.TSTypeReference) {
+                return false;
+            }
+            return (node.typeName.type === experimental_utils_1.AST_NODE_TYPES.Identifier &&
+                node.typeName.name === 'const');
+        }
+        function reportIncorrectAssertionType(node) {
+            // If this node is `as const`, then don't report an error.
+            if (isConst(node.typeAnnotation)) {
+                return;
+            }
+            const messageId = options.assertionStyle;
+            context.report({
+                node,
+                messageId,
+                data: messageId !== 'never'
+                    ? { cast: sourceCode.getText(node.typeAnnotation) }
+                    : {},
+            });
+        }
+        function checkType(node) {
+            switch (node.type) {
+                case experimental_utils_1.AST_NODE_TYPES.TSAnyKeyword:
+                case experimental_utils_1.AST_NODE_TYPES.TSUnknownKeyword:
+                    return false;
+                case experimental_utils_1.AST_NODE_TYPES.TSTypeReference:
+                    return (
+                    // Ignore `as const` and `<const>`
+                    !isConst(node) ||
+                        // Allow qualified names which have dots between identifiers, `Foo.Bar`
+                        node.typeName.type === experimental_utils_1.AST_NODE_TYPES.TSQualifiedName);
+                default:
+                    return true;
+            }
+        }
+        function checkExpression(node) {
+            if (options.assertionStyle === 'never' ||
+                options.objectLiteralTypeAssertions === 'allow' ||
+                node.expression.type !== experimental_utils_1.AST_NODE_TYPES.ObjectExpression) {
+                return;
+            }
+            if (options.objectLiteralTypeAssertions === 'allow-as-parameter' &&
+                node.parent &&
+                (node.parent.type === experimental_utils_1.AST_NODE_TYPES.NewExpression ||
+                    node.parent.type === experimental_utils_1.AST_NODE_TYPES.CallExpression ||
+                    node.parent.type === experimental_utils_1.AST_NODE_TYPES.ThrowStatement ||
+                    node.parent.type === experimental_utils_1.AST_NODE_TYPES.AssignmentPattern)) {
+                return;
+            }
+            if (checkType(node.typeAnnotation) &&
+                node.expression.type === experimental_utils_1.AST_NODE_TYPES.ObjectExpression) {
+                context.report({
+                    node,
+                    messageId: 'unexpectedObjectTypeAssertion',
+                });
+            }
+        }
+        return {
+            TSTypeAssertion(node) {
+                if (options.assertionStyle !== 'angle-bracket') {
+                    reportIncorrectAssertionType(node);
+                    return;
+                }
+                checkExpression(node);
+            },
+            TSAsExpression(node) {
+                if (options.assertionStyle !== 'as') {
+                    reportIncorrectAssertionType(node);
+                    return;
+                }
+                checkExpression(node);
+            },
+        };
+    },
+});
+//# sourceMappingURL=consistent-type-assertions.js.map

node_modules/@typescript-eslint/eslint-plugin/dist/rules/consistent-type-assertions.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"consistent-type-assertions.js","sourceRoot":"","sources":["../../src/rules/consistent-type-assertions.ts"],"names":[],"mappings":"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"}

node_modules/@typescript-eslint/eslint-plugin/dist/rules/consistent-type-definitions.js

@@ -0,0 +1,102 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const experimental_utils_1 = require("@typescript-eslint/experimental-utils");
+const util = __importStar(require("../util"));
+exports.default = util.createRule({
+    name: 'consistent-type-definitions',
+    meta: {
+        type: 'suggestion',
+        docs: {
+            description: 'Consistent with type definition either `interface` or `type`',
+            category: 'Stylistic Issues',
+            // too opinionated to be recommended
+            recommended: false,
+        },
+        messages: {
+            interfaceOverType: 'Use an `interface` instead of a `type`.',
+            typeOverInterface: 'Use a `type` instead of an `interface`.',
+        },
+        schema: [
+            {
+                enum: ['interface', 'type'],
+            },
+        ],
+        fixable: 'code',
+    },
+    defaultOptions: ['interface'],
+    create(context, [option]) {
+        const sourceCode = context.getSourceCode();
+        return {
+            "TSTypeAliasDeclaration[typeAnnotation.type='TSTypeLiteral']"(node) {
+                if (option === 'interface') {
+                    context.report({
+                        node: node.id,
+                        messageId: 'interfaceOverType',
+                        fix(fixer) {
+                            var _a;
+                            const typeNode = (_a = node.typeParameters) !== null && _a !== void 0 ? _a : node.id;
+                            const fixes = [];
+                            const firstToken = sourceCode.getFirstToken(node);
+                            if (firstToken) {
+                                fixes.push(fixer.replaceText(firstToken, 'interface'));
+                                fixes.push(fixer.replaceTextRange([typeNode.range[1], node.typeAnnotation.range[0]], ' '));
+                            }
+                            const afterToken = sourceCode.getTokenAfter(node.typeAnnotation);
+                            if (afterToken &&
+                                afterToken.type === experimental_utils_1.AST_TOKEN_TYPES.Punctuator &&
+                                afterToken.value === ';') {
+                                fixes.push(fixer.remove(afterToken));
+                            }
+                            return fixes;
+                        },
+                    });
+                }
+            },
+            TSInterfaceDeclaration(node) {
+                if (option === 'type') {
+                    context.report({
+                        node: node.id,
+                        messageId: 'typeOverInterface',
+                        fix(fixer) {
+                            var _a;
+                            const typeNode = (_a = node.typeParameters) !== null && _a !== void 0 ? _a : node.id;
+                            const fixes = [];
+                            const firstToken = sourceCode.getFirstToken(node);
+                            if (firstToken) {
+                                fixes.push(fixer.replaceText(firstToken, 'type'));
+                                fixes.push(fixer.replaceTextRange([typeNode.range[1], node.body.range[0]], ' = '));
+                            }
+                            if (node.extends) {
+                                node.extends.forEach(heritage => {
+                                    const typeIdentifier = sourceCode.getText(heritage);
+                                    fixes.push(fixer.insertTextAfter(node.body, ` & ${typeIdentifier}`));
+                                });
+                            }
+                            return fixes;
+                        },
+                    });
+                }
+            },
+        };
+    },
+});
+//# sourceMappingURL=consistent-type-definitions.js.map

node_modules/@typescript-eslint/eslint-plugin/dist/rules/consistent-type-definitions.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"consistent-type-definitions.js","sourceRoot":"","sources":["../../src/rules/consistent-type-definitions.ts"],"names":[],"mappings":"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"}

node_modules/@typescript-eslint/eslint-plugin/dist/rules/consistent-type-imports.js

@@ -0,0 +1,392 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const experimental_utils_1 = require("@typescript-eslint/experimental-utils");
+const util = __importStar(require("../util"));
+function isImportToken(token) {
+    return token.type === experimental_utils_1.AST_TOKEN_TYPES.Keyword && token.value === 'import';
+}
+function isTypeToken(token) {
+    return token.type === experimental_utils_1.AST_TOKEN_TYPES.Identifier && token.value === 'type';
+}
+exports.default = util.createRule({
+    name: 'consistent-type-imports',
+    meta: {
+        type: 'suggestion',
+        docs: {
+            description: 'Enforces consistent usage of type imports',
+            category: 'Stylistic Issues',
+            recommended: false,
+        },
+        messages: {
+            typeOverValue: 'All imports in the declaration are only used as types. Use `import type`',
+            someImportsAreOnlyTypes: 'Imports {{typeImports}} are only used as types',
+            aImportIsOnlyTypes: 'Import {{typeImports}} is only used as types',
+            valueOverType: 'Use an `import` instead of an `import type`.',
+            noImportTypeAnnotations: '`import()` type annotations are forbidden.',
+        },
+        schema: [
+            {
+                type: 'object',
+                properties: {
+                    prefer: {
+                        enum: ['type-imports', 'no-type-imports'],
+                    },
+                    disallowTypeAnnotations: {
+                        type: 'boolean',
+                    },
+                },
+                additionalProperties: false,
+            },
+        ],
+        fixable: 'code',
+    },
+    defaultOptions: [
+        {
+            prefer: 'type-imports',
+            disallowTypeAnnotations: true,
+        },
+    ],
+    create(context, [option]) {
+        var _a;
+        const prefer = (_a = option.prefer) !== null && _a !== void 0 ? _a : 'type-imports';
+        const disallowTypeAnnotations = option.disallowTypeAnnotations !== false;
+        const sourceCode = context.getSourceCode();
+        const sourceImportsMap = {};
+        return Object.assign(Object.assign({}, (prefer === 'type-imports'
+            ? {
+                // prefer type imports
+                ImportDeclaration(node) {
+                    var _a;
+                    const source = node.source.value;
+                    const sourceImports = (_a = sourceImportsMap[source]) !== null && _a !== void 0 ? _a : (sourceImportsMap[source] = {
+                        source,
+                        reportValueImports: [],
+                        typeOnlyNamedImport: null,
+                    });
+                    if (node.importKind === 'type') {
+                        if (!sourceImports.typeOnlyNamedImport &&
+                            node.specifiers.every(specifier => specifier.type === experimental_utils_1.AST_NODE_TYPES.ImportSpecifier)) {
+                            sourceImports.typeOnlyNamedImport = node;
+                        }
+                        return;
+                    }
+                    // if importKind === 'value'
+                    const typeSpecifiers = [];
+                    const valueSpecifiers = [];
+                    const unusedSpecifiers = [];
+                    for (const specifier of node.specifiers) {
+                        const [variable] = context.getDeclaredVariables(specifier);
+                        if (variable.references.length === 0) {
+                            unusedSpecifiers.push(specifier);
+                        }
+                        else {
+                            const onlyHasTypeReferences = variable.references.every(ref => {
+                                if (ref.isValueReference) {
+                                    // `type T = typeof foo` will create a value reference because "foo" must be a value type
+                                    // however this value reference is safe to use with type-only imports
+                                    let parent = ref.identifier.parent;
+                                    while (parent) {
+                                        if (parent.type === experimental_utils_1.AST_NODE_TYPES.TSTypeQuery) {
+                                            return true;
+                                        }
+                                        // TSTypeQuery must have a TSESTree.EntityName as its child, so we can filter here and break early
+                                        if (parent.type !== experimental_utils_1.AST_NODE_TYPES.TSQualifiedName) {
+                                            break;
+                                        }
+                                        parent = parent.parent;
+                                    }
+                                    return false;
+                                }
+                                return ref.isTypeReference;
+                            });
+                            if (onlyHasTypeReferences) {
+                                typeSpecifiers.push(specifier);
+                            }
+                            else {
+                                valueSpecifiers.push(specifier);
+                            }
+                        }
+                    }
+                    if (typeSpecifiers.length) {
+                        sourceImports.reportValueImports.push({
+                            node,
+                            typeSpecifiers,
+                            valueSpecifiers,
+                            unusedSpecifiers,
+                        });
+                    }
+                },
+                'Program:exit'() {
+                    for (const sourceImports of Object.values(sourceImportsMap)) {
+                        if (sourceImports.reportValueImports.length === 0) {
+                            continue;
+                        }
+                        for (const report of sourceImports.reportValueImports) {
+                            if (report.valueSpecifiers.length === 0 &&
+                                report.unusedSpecifiers.length === 0) {
+                                // import is all type-only, convert the entire import to `import type`
+                                context.report({
+                                    node: report.node,
+                                    messageId: 'typeOverValue',
+                                    *fix(fixer) {
+                                        yield* fixToTypeImport(fixer, report, sourceImports);
+                                    },
+                                });
+                            }
+                            else {
+                                // we have a mixed type/value import, so we need to split them out into multiple exports
+                                const typeImportNames = report.typeSpecifiers.map(specifier => `"${specifier.local.name}"`);
+                                context.report({
+                                    node: report.node,
+                                    messageId: typeImportNames.length === 1
+                                        ? 'aImportIsOnlyTypes'
+                                        : 'someImportsAreOnlyTypes',
+                                    data: {
+                                        typeImports: typeImportNames.length === 1
+                                            ? typeImportNames[0]
+                                            : [
+                                                typeImportNames.slice(0, -1).join(', '),
+                                                typeImportNames.slice(-1)[0],
+                                            ].join(' and '),
+                                    },
+                                    *fix(fixer) {
+                                        yield* fixToTypeImport(fixer, report, sourceImports);
+                                    },
+                                });
+                            }
+                        }
+                    }
+                },
+            }
+            : {
+                // prefer no type imports
+                'ImportDeclaration[importKind = "type"]'(node) {
+                    context.report({
+                        node,
+                        messageId: 'valueOverType',
+                        fix(fixer) {
+                            return fixToValueImport(fixer, node);
+                        },
+                    });
+                },
+            })), (disallowTypeAnnotations
+            ? {
+                // disallow `import()` type
+                TSImportType(node) {
+                    context.report({
+                        node,
+                        messageId: 'noImportTypeAnnotations',
+                    });
+                },
+            }
+            : {}));
+        function* fixToTypeImport(fixer, report, sourceImports) {
+            const { node } = report;
+            const defaultSpecifier = node.specifiers[0].type === experimental_utils_1.AST_NODE_TYPES.ImportDefaultSpecifier
+                ? node.specifiers[0]
+                : null;
+            const namespaceSpecifier = node.specifiers[0].type === experimental_utils_1.AST_NODE_TYPES.ImportNamespaceSpecifier
+                ? node.specifiers[0]
+                : null;
+            const namedSpecifiers = node.specifiers.filter((specifier) => specifier.type === experimental_utils_1.AST_NODE_TYPES.ImportSpecifier);
+            if (namespaceSpecifier) {
+                // e.g.
+                // import * as types from 'foo'
+                yield* fixToTypeImportByInsertType(fixer, node, false);
+                return;
+            }
+            else if (defaultSpecifier) {
+                if (report.typeSpecifiers.includes(defaultSpecifier) &&
+                    namedSpecifiers.length === 0) {
+                    // e.g.
+                    // import Type from 'foo'
+                    yield* fixToTypeImportByInsertType(fixer, node, true);
+                    return;
+                }
+            }
+            else {
+                if (namedSpecifiers.every(specifier => report.typeSpecifiers.includes(specifier))) {
+                    // e.g.
+                    // import {Type1, Type2} from 'foo'
+                    yield* fixToTypeImportByInsertType(fixer, node, false);
+                    return;
+                }
+            }
+            const typeNamedSpecifiers = namedSpecifiers.filter(specifier => report.typeSpecifiers.includes(specifier));
+            const fixesNamedSpecifiers = getFixesNamedSpecifiers(typeNamedSpecifiers, namedSpecifiers);
+            const afterFixes = [];
+            if (typeNamedSpecifiers.length) {
+                if (sourceImports.typeOnlyNamedImport) {
+                    const closingBraceToken = util.nullThrows(sourceCode.getFirstTokenBetween(sourceCode.getFirstToken(sourceImports.typeOnlyNamedImport), sourceImports.typeOnlyNamedImport.source, util.isClosingBraceToken), util.NullThrowsReasons.MissingToken('}', sourceImports.typeOnlyNamedImport.type));
+                    let insertText = fixesNamedSpecifiers.typeNamedSpecifiersText;
+                    const before = sourceCode.getTokenBefore(closingBraceToken);
+                    if (!util.isCommaToken(before) && !util.isOpeningBraceToken(before)) {
+                        insertText = ',' + insertText;
+                    }
+                    // import type { Already, Type1, Type2 } from 'foo'
+                    //                       ^^^^^^^^^^^^^ insert
+                    const insertTypeNamedSpecifiers = fixer.insertTextBefore(closingBraceToken, insertText);
+                    if (sourceImports.typeOnlyNamedImport.range[1] <= node.range[0]) {
+                        yield insertTypeNamedSpecifiers;
+                    }
+                    else {
+                        afterFixes.push(insertTypeNamedSpecifiers);
+                    }
+                }
+                else {
+                    yield fixer.insertTextBefore(node, `import type {${fixesNamedSpecifiers.typeNamedSpecifiersText}} from ${sourceCode.getText(node.source)};\n`);
+                }
+            }
+            if (defaultSpecifier &&
+                report.typeSpecifiers.includes(defaultSpecifier)) {
+                if (typeNamedSpecifiers.length === namedSpecifiers.length) {
+                    const importToken = util.nullThrows(sourceCode.getFirstToken(node, isImportToken), util.NullThrowsReasons.MissingToken('import', node.type));
+                    // import type Type from 'foo'
+                    //        ^^^^ insert
+                    yield fixer.insertTextAfter(importToken, ' type');
+                }
+                else {
+                    yield fixer.insertTextBefore(node, `import type ${sourceCode.getText(defaultSpecifier)} from ${sourceCode.getText(node.source)};\n`);
+                    // import Type , {...} from 'foo'
+                    //        ^^^^^^ remove
+                    yield fixer.remove(defaultSpecifier);
+                    yield fixer.remove(sourceCode.getTokenAfter(defaultSpecifier));
+                }
+            }
+            yield* fixesNamedSpecifiers.removeTypeNamedSpecifiers;
+            yield* afterFixes;
+            /**
+             * Returns information for fixing named specifiers.
+             */
+            function getFixesNamedSpecifiers(typeNamedSpecifiers, allNamedSpecifiers) {
+                const typeNamedSpecifiersTexts = [];
+                const removeTypeNamedSpecifiers = [];
+                if (typeNamedSpecifiers.length === allNamedSpecifiers.length) {
+                    // e.g.
+                    // import Foo, {Type1, Type2} from 'foo'
+                    // import DefType, {Type1, Type2} from 'foo'
+                    const openingBraceToken = util.nullThrows(sourceCode.getTokenBefore(typeNamedSpecifiers[0], util.isOpeningBraceToken), util.NullThrowsReasons.MissingToken('{', node.type));
+                    const commaToken = util.nullThrows(sourceCode.getTokenBefore(openingBraceToken, util.isCommaToken), util.NullThrowsReasons.MissingToken(',', node.type));
+                    const closingBraceToken = util.nullThrows(sourceCode.getFirstTokenBetween(openingBraceToken, node.source, util.isClosingBraceToken), util.NullThrowsReasons.MissingToken('}', node.type));
+                    // import DefType, {...} from 'foo'
+                    //               ^^^^^^^ remove
+                    removeTypeNamedSpecifiers.push(fixer.removeRange([
+                        commaToken.range[0],
+                        closingBraceToken.range[1],
+                    ]));
+                    typeNamedSpecifiersTexts.push(sourceCode.text.slice(openingBraceToken.range[1], closingBraceToken.range[0]));
+                }
+                else {
+                    const typeNamedSpecifierGroups = [];
+                    let group = [];
+                    for (const namedSpecifier of allNamedSpecifiers) {
+                        if (typeNamedSpecifiers.includes(namedSpecifier)) {
+                            group.push(namedSpecifier);
+                        }
+                        else if (group.length) {
+                            typeNamedSpecifierGroups.push(group);
+                            group = [];
+                        }
+                    }
+                    if (group.length) {
+                        typeNamedSpecifierGroups.push(group);
+                    }
+                    for (const namedSpecifiers of typeNamedSpecifierGroups) {
+                        const { removeRange, textRange } = getNamedSpecifierRanges(namedSpecifiers, allNamedSpecifiers);
+                        removeTypeNamedSpecifiers.push(fixer.removeRange(removeRange));
+                        typeNamedSpecifiersTexts.push(sourceCode.text.slice(...textRange));
+                    }
+                }
+                return {
+                    typeNamedSpecifiersText: typeNamedSpecifiersTexts.join(','),
+                    removeTypeNamedSpecifiers,
+                };
+            }
+            /**
+             * Returns ranges for fixing named specifier.
+             */
+            function getNamedSpecifierRanges(namedSpecifierGroup, allNamedSpecifiers) {
+                const first = namedSpecifierGroup[0];
+                const last = namedSpecifierGroup[namedSpecifierGroup.length - 1];
+                const removeRange = [first.range[0], last.range[1]];
+                const textRange = [...removeRange];
+                const before = sourceCode.getTokenBefore(first);
+                textRange[0] = before.range[1];
+                if (util.isCommaToken(before)) {
+                    removeRange[0] = before.range[0];
+                }
+                else {
+                    removeRange[0] = before.range[1];
+                }
+                const isFirst = allNamedSpecifiers[0] === first;
+                const isLast = allNamedSpecifiers[allNamedSpecifiers.length - 1] === last;
+                const after = sourceCode.getTokenAfter(last);
+                textRange[1] = after.range[0];
+                if (isFirst || isLast) {
+                    if (util.isCommaToken(after)) {
+                        removeRange[1] = after.range[1];
+                    }
+                }
+                return {
+                    textRange,
+                    removeRange,
+                };
+            }
+        }
+        function* fixToTypeImportByInsertType(fixer, node, isDefaultImport) {
+            // import type Foo from 'foo'
+            //       ^^^^^ insert
+            const importToken = util.nullThrows(sourceCode.getFirstToken(node, isImportToken), util.NullThrowsReasons.MissingToken('import', node.type));
+            yield fixer.insertTextAfter(importToken, ' type');
+            if (isDefaultImport) {
+                // Has default import
+                const openingBraceToken = sourceCode.getFirstTokenBetween(importToken, node.source, util.isOpeningBraceToken);
+                if (openingBraceToken) {
+                    // Only braces. e.g. import Foo, {} from 'foo'
+                    const commaToken = util.nullThrows(sourceCode.getTokenBefore(openingBraceToken, util.isCommaToken), util.NullThrowsReasons.MissingToken(',', node.type));
+                    const closingBraceToken = util.nullThrows(sourceCode.getFirstTokenBetween(openingBraceToken, node.source, util.isClosingBraceToken), util.NullThrowsReasons.MissingToken('}', node.type));
+                    // import type Foo, {} from 'foo'
+                    //                  ^^ remove
+                    yield fixer.removeRange([
+                        commaToken.range[0],
+                        closingBraceToken.range[1],
+                    ]);
+                    const specifiersText = sourceCode.text.slice(commaToken.range[1], closingBraceToken.range[1]);
+                    if (node.specifiers.length > 1) {
+                        // import type Foo from 'foo'
+                        // import type {...} from 'foo' // <- insert
+                        yield fixer.insertTextAfter(node, `\nimport type${specifiersText} from ${sourceCode.getText(node.source)};`);
+                    }
+                }
+            }
+        }
+        function fixToValueImport(fixer, node) {
+            var _a, _b;
+            // import type Foo from 'foo'
+            //        ^^^^ remove
+            const importToken = util.nullThrows(sourceCode.getFirstToken(node, isImportToken), util.NullThrowsReasons.MissingToken('import', node.type));
+            const typeToken = util.nullThrows(sourceCode.getFirstTokenBetween(importToken, (_b = (_a = node.specifiers[0]) === null || _a === void 0 ? void 0 : _a.local) !== null && _b !== void 0 ? _b : node.source, isTypeToken), util.NullThrowsReasons.MissingToken('type', node.type));
+            return fixer.remove(typeToken);
+        }
+    },
+});
+//# sourceMappingURL=consistent-type-imports.js.map

node_modules/@typescript-eslint/eslint-plugin/dist/rules/default-param-last.js

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const util_1 = require("../util");
+const experimental_utils_1 = require("@typescript-eslint/experimental-utils");
+exports.default = util_1.createRule({
+    name: 'default-param-last',
+    meta: {
+        type: 'suggestion',
+        docs: {
+            description: 'Enforce default parameters to be last',
+            category: 'Best Practices',
+            recommended: false,
+            extendsBaseRule: true,
+        },
+        schema: [],
+        messages: {
+            shouldBeLast: 'Default parameters should be last.',
+        },
+    },
+    defaultOptions: [],
+    create(context) {
+        /**
+         * checks if node is optional parameter
+         * @param node the node to be evaluated
+         * @private
+         */
+        function isOptionalParam(node) {
+            return 'optional' in node && node.optional === true;
+        }
+        /**
+         * checks if node is plain parameter
+         * @param node the node to be evaluated
+         * @private
+         */
+        function isPlainParam(node) {
+            return !(node.type === experimental_utils_1.AST_NODE_TYPES.AssignmentPattern ||
+                node.type === experimental_utils_1.AST_NODE_TYPES.RestElement ||
+                isOptionalParam(node));
+        }
+        function checkDefaultParamLast(node) {
+            let hasSeenPlainParam = false;
+            for (let i = node.params.length - 1; i >= 0; i--) {
+                const current = node.params[i];
+                const param = current.type === experimental_utils_1.AST_NODE_TYPES.TSParameterProperty
+                    ? current.parameter
+                    : current;
+                if (isPlainParam(param)) {
+                    hasSeenPlainParam = true;
+                    continue;
+                }
+                if (hasSeenPlainParam &&
+                    (isOptionalParam(param) ||
+                        param.type === experimental_utils_1.AST_NODE_TYPES.AssignmentPattern)) {
+                    context.report({ node: current, messageId: 'shouldBeLast' });
+                }
+            }
+        }
+        return {
+            ArrowFunctionExpression: checkDefaultParamLast,
+            FunctionDeclaration: checkDefaultParamLast,
+            FunctionExpression: checkDefaultParamLast,
+        };
+    },
+});
+//# sourceMappingURL=default-param-last.js.map

node_modules/@typescript-eslint/eslint-plugin/dist/rules/default-param-last.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"default-param-last.js","sourceRoot":"","sources":["../../src/rules/default-param-last.ts"],"names":[],"mappings":";;AAAA,kCAAqC;AACrC,8EAG+C;AAE/C,kBAAe,iBAAU,CAAC;IACxB,IAAI,EAAE,oBAAoB;IAC1B,IAAI,EAAE;QACJ,IAAI,EAAE,YAAY;QAClB,IAAI,EAAE;YACJ,WAAW,EAAE,uCAAuC;YACpD,QAAQ,EAAE,gBAAgB;YAC1B,WAAW,EAAE,KAAK;YAClB,eAAe,EAAE,IAAI;SACtB;QACD,MAAM,EAAE,EAAE;QACV,QAAQ,EAAE;YACR,YAAY,EAAE,oCAAoC;SACnD;KACF;IACD,cAAc,EAAE,EAAE;IAClB,MAAM,CAAC,OAAO;QACZ;;;;WAIG;QACH,SAAS,eAAe,CAAC,IAAwB;YAC/C,OAAO,UAAU,IAAI,IAAI,IAAI,IAAI,CAAC,QAAQ,KAAK,IAAI,CAAC;QACtD,CAAC;QAED;;;;WAIG;QACH,SAAS,YAAY,CAAC,IAAwB;YAC5C,OAAO,CAAC,CACN,IAAI,CAAC,IAAI,KAAK,mCAAc,CAAC,iBAAiB;gBAC9C,IAAI,CAAC,IAAI,KAAK,mCAAc,CAAC,WAAW;gBACxC,eAAe,CAAC,IAAI,CAAC,CACtB,CAAC;QACJ,CAAC;QAED,SAAS,qBAAqB,CAC5B,IAG+B;YAE/B,IAAI,iBAAiB,GAAG,KAAK,CAAC;YAC9B,KAAK,IAAI,CAAC,GAAG,IAAI,CAAC,MAAM,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC,IAAI,CAAC,EAAE,CAAC,EAAE,EAAE;gBAChD,MAAM,OAAO,GAAG,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC;gBAC/B,MAAM,KAAK,GACT,OAAO,CAAC,IAAI,KAAK,mCAAc,CAAC,mBAAmB;oBACjD,CAAC,CAAC,OAAO,CAAC,SAAS;oBACnB,CAAC,CAAC,OAAO,CAAC;gBAEd,IAAI,YAAY,CAAC,KAAK,CAAC,EAAE;oBACvB,iBAAiB,GAAG,IAAI,CAAC;oBACzB,SAAS;iBACV;gBAED,IACE,iBAAiB;oBACjB,CAAC,eAAe,CAAC,KAAK,CAAC;wBACrB,KAAK,CAAC,IAAI,KAAK,mCAAc,CAAC,iBAAiB,CAAC,EAClD;oBACA,OAAO,CAAC,MAAM,CAAC,EAAE,IAAI,EAAE,OAAO,EAAE,SAAS,EAAE,cAAc,EAAE,CAAC,CAAC;iBAC9D;aACF;QACH,CAAC;QAED,OAAO;YACL,uBAAuB,EAAE,qBAAqB;YAC9C,mBAAmB,EAAE,qBAAqB;YAC1C,kBAAkB,EAAE,qBAAqB;SAC1C,CAAC;IACJ,CAAC;CACF,CAAC,CAAC"}

node_modules/@typescript-eslint/eslint-plugin/dist/rules/dot-notation.js

@@ -0,0 +1,90 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const ts = __importStar(require("typescript"));
+const dot_notation_1 = __importDefault(require("eslint/lib/rules/dot-notation"));
+const util_1 = require("../util");
+exports.default = util_1.createRule({
+    name: 'dot-notation',
+    meta: {
+        type: 'suggestion',
+        docs: {
+            description: 'enforce dot notation whenever possible',
+            category: 'Best Practices',
+            recommended: false,
+            extendsBaseRule: true,
+            requiresTypeChecking: true,
+        },
+        schema: [
+            {
+                type: 'object',
+                properties: {
+                    allowKeywords: {
+                        type: 'boolean',
+                        default: true,
+                    },
+                    allowPattern: {
+                        type: 'string',
+                        default: '',
+                    },
+                    allowPrivateClassPropertyAccess: {
+                        type: 'boolean',
+                        default: false,
+                    },
+                },
+                additionalProperties: false,
+            },
+        ],
+        fixable: dot_notation_1.default.meta.fixable,
+        messages: dot_notation_1.default.meta.messages,
+    },
+    defaultOptions: [
+        {
+            allowPrivateClassPropertyAccess: false,
+            allowKeywords: true,
+            allowPattern: '',
+        },
+    ],
+    create(context, [options]) {
+        const rules = dot_notation_1.default.create(context);
+        const allowPrivateClassPropertyAccess = options.allowPrivateClassPropertyAccess;
+        const parserServices = util_1.getParserServices(context);
+        const typeChecker = parserServices.program.getTypeChecker();
+        return {
+            MemberExpression(node) {
+                var _a, _b, _c;
+                if (allowPrivateClassPropertyAccess && node.computed) {
+                    // for perf reasons - only fetch the symbol if we have to
+                    const objectSymbol = typeChecker.getSymbolAtLocation(parserServices.esTreeNodeToTSNodeMap.get(node.property));
+                    if (((_c = (_b = (_a = objectSymbol === null || objectSymbol === void 0 ? void 0 : objectSymbol.getDeclarations()) === null || _a === void 0 ? void 0 : _a[0]) === null || _b === void 0 ? void 0 : _b.modifiers) === null || _c === void 0 ? void 0 : _c[0].kind) ===
+                        ts.SyntaxKind.PrivateKeyword) {
+                        return;
+                    }
+                }
+                rules.MemberExpression(node);
+            },
+        };
+    },
+});
+//# sourceMappingURL=dot-notation.js.map

node_modules/@typescript-eslint/eslint-plugin/dist/rules/dot-notation.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"dot-notation.js","sourceRoot":"","sources":["../../src/rules/dot-notation.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;AACA,+CAAiC;AACjC,iFAAqD;AACrD,kCAKiB;AAKjB,kBAAe,iBAAU,CAAsB;IAC7C,IAAI,EAAE,cAAc;IACpB,IAAI,EAAE;QACJ,IAAI,EAAE,YAAY;QAClB,IAAI,EAAE;YACJ,WAAW,EAAE,wCAAwC;YACrD,QAAQ,EAAE,gBAAgB;YAC1B,WAAW,EAAE,KAAK;YAClB,eAAe,EAAE,IAAI;YACrB,oBAAoB,EAAE,IAAI;SAC3B;QACD,MAAM,EAAE;YACN;gBACE,IAAI,EAAE,QAAQ;gBACd,UAAU,EAAE;oBACV,aAAa,EAAE;wBACb,IAAI,EAAE,SAAS;wBACf,OAAO,EAAE,IAAI;qBACd;oBACD,YAAY,EAAE;wBACZ,IAAI,EAAE,QAAQ;wBACd,OAAO,EAAE,EAAE;qBACZ;oBACD,+BAA+B,EAAE;wBAC/B,IAAI,EAAE,SAAS;wBACf,OAAO,EAAE,KAAK;qBACf;iBACF;gBACD,oBAAoB,EAAE,KAAK;aAC5B;SACF;QACD,OAAO,EAAE,sBAAQ,CAAC,IAAI,CAAC,OAAO;QAC9B,QAAQ,EAAE,sBAAQ,CAAC,IAAI,CAAC,QAAQ;KACjC;IACD,cAAc,EAAE;QACd;YACE,+BAA+B,EAAE,KAAK;YACtC,aAAa,EAAE,IAAI;YACnB,YAAY,EAAE,EAAE;SACjB;KACF;IACD,MAAM,CAAC,OAAO,EAAE,CAAC,OAAO,CAAC;QACvB,MAAM,KAAK,GAAG,sBAAQ,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC;QACvC,MAAM,+BAA+B,GACnC,OAAO,CAAC,+BAA+B,CAAC;QAE1C,MAAM,cAAc,GAAG,wBAAiB,CAAC,OAAO,CAAC,CAAC;QAClD,MAAM,WAAW,GAAG,cAAc,CAAC,OAAO,CAAC,cAAc,EAAE,CAAC;QAE5D,OAAO;YACL,gBAAgB,CAAC,IAA+B;;gBAC9C,IAAI,+BAA+B,IAAI,IAAI,CAAC,QAAQ,EAAE;oBACpD,yDAAyD;oBACzD,MAAM,YAAY,GAAG,WAAW,CAAC,mBAAmB,CAClD,cAAc,CAAC,qBAAqB,CAAC,GAAG,CAAC,IAAI,CAAC,QAAQ,CAAC,CACxD,CAAC;oBACF,IACE,mBAAA,YAAY,aAAZ,YAAY,uBAAZ,YAAY,CAAE,eAAe,4CAAK,CAAC,2CAAG,SAAS,0CAAG,CAAC,EAAE,IAAI;wBACzD,EAAE,CAAC,UAAU,CAAC,cAAc,EAC5B;wBACA,OAAO;qBACR;iBACF;gBACD,KAAK,CAAC,gBAAgB,CAAC,IAAI,CAAC,CAAC;YAC/B,CAAC;SACF,CAAC;IACJ,CAAC;CACF,CAAC,CAAC"}

node_modules/@typescript-eslint/eslint-plugin/dist/rules/explicit-function-return-type.js

@@ -0,0 +1,97 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const experimental_utils_1 = require("@typescript-eslint/experimental-utils");
+const util = __importStar(require("../util"));
+const explicitReturnTypeUtils_1 = require("../util/explicitReturnTypeUtils");
+exports.default = util.createRule({
+    name: 'explicit-function-return-type',
+    meta: {
+        type: 'problem',
+        docs: {
+            description: 'Require explicit return types on functions and class methods',
+            category: 'Stylistic Issues',
+            recommended: false,
+        },
+        messages: {
+            missingReturnType: 'Missing return type on function.',
+        },
+        schema: [
+            {
+                type: 'object',
+                properties: {
+                    allowExpressions: {
+                        type: 'boolean',
+                    },
+                    allowTypedFunctionExpressions: {
+                        type: 'boolean',
+                    },
+                    allowHigherOrderFunctions: {
+                        type: 'boolean',
+                    },
+                    allowDirectConstAssertionInArrowFunctions: {
+                        type: 'boolean',
+                    },
+                    allowConciseArrowFunctionExpressionsStartingWithVoid: {
+                        type: 'boolean',
+                    },
+                },
+                additionalProperties: false,
+            },
+        ],
+    },
+    defaultOptions: [
+        {
+            allowExpressions: false,
+            allowTypedFunctionExpressions: true,
+            allowHigherOrderFunctions: true,
+            allowDirectConstAssertionInArrowFunctions: true,
+            allowConciseArrowFunctionExpressionsStartingWithVoid: false,
+        },
+    ],
+    create(context, [options]) {
+        const sourceCode = context.getSourceCode();
+        return {
+            'ArrowFunctionExpression, FunctionExpression'(node) {
+                if (options.allowConciseArrowFunctionExpressionsStartingWithVoid &&
+                    node.type === experimental_utils_1.AST_NODE_TYPES.ArrowFunctionExpression &&
+                    node.expression &&
+                    node.body.type === experimental_utils_1.AST_NODE_TYPES.UnaryExpression &&
+                    node.body.operator === 'void') {
+                    return;
+                }
+                explicitReturnTypeUtils_1.checkFunctionExpressionReturnType(node, options, sourceCode, loc => context.report({
+                    node,
+                    loc,
+                    messageId: 'missingReturnType',
+                }));
+            },
+            FunctionDeclaration(node) {
+                explicitReturnTypeUtils_1.checkFunctionReturnType(node, options, sourceCode, loc => context.report({
+                    node,
+                    loc,
+                    messageId: 'missingReturnType',
+                }));
+            },
+        };
+    },
+});
+//# sourceMappingURL=explicit-function-return-type.js.map

node_modules/@typescript-eslint/eslint-plugin/dist/rules/explicit-function-return-type.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"explicit-function-return-type.js","sourceRoot":"","sources":["../../src/rules/explicit-function-return-type.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;AAAA,8EAG+C;AAC/C,8CAAgC;AAChC,6EAGyC;AAazC,kBAAe,IAAI,CAAC,UAAU,CAAsB;IAClD,IAAI,EAAE,+BAA+B;IACrC,IAAI,EAAE;QACJ,IAAI,EAAE,SAAS;QACf,IAAI,EAAE;YACJ,WAAW,EACT,8DAA8D;YAChE,QAAQ,EAAE,kBAAkB;YAC5B,WAAW,EAAE,KAAK;SACnB;QACD,QAAQ,EAAE;YACR,iBAAiB,EAAE,kCAAkC;SACtD;QACD,MAAM,EAAE;YACN;gBACE,IAAI,EAAE,QAAQ;gBACd,UAAU,EAAE;oBACV,gBAAgB,EAAE;wBAChB,IAAI,EAAE,SAAS;qBAChB;oBACD,6BAA6B,EAAE;wBAC7B,IAAI,EAAE,SAAS;qBAChB;oBACD,yBAAyB,EAAE;wBACzB,IAAI,EAAE,SAAS;qBAChB;oBACD,yCAAyC,EAAE;wBACzC,IAAI,EAAE,SAAS;qBAChB;oBACD,oDAAoD,EAAE;wBACpD,IAAI,EAAE,SAAS;qBAChB;iBACF;gBACD,oBAAoB,EAAE,KAAK;aAC5B;SACF;KACF;IACD,cAAc,EAAE;QACd;YACE,gBAAgB,EAAE,KAAK;YACvB,6BAA6B,EAAE,IAAI;YACnC,yBAAyB,EAAE,IAAI;YAC/B,yCAAyC,EAAE,IAAI;YAC/C,oDAAoD,EAAE,KAAK;SAC5D;KACF;IACD,MAAM,CAAC,OAAO,EAAE,CAAC,OAAO,CAAC;QACvB,MAAM,UAAU,GAAG,OAAO,CAAC,aAAa,EAAE,CAAC;QAE3C,OAAO;YACL,6CAA6C,CAC3C,IAAoE;gBAEpE,IACE,OAAO,CAAC,oDAAoD;oBAC5D,IAAI,CAAC,IAAI,KAAK,mCAAc,CAAC,uBAAuB;oBACpD,IAAI,CAAC,UAAU;oBACf,IAAI,CAAC,IAAI,CAAC,IAAI,KAAK,mCAAc,CAAC,eAAe;oBACjD,IAAI,CAAC,IAAI,CAAC,QAAQ,KAAK,MAAM,EAC7B;oBACA,OAAO;iBACR;gBAED,2DAAiC,CAAC,IAAI,EAAE,OAAO,EAAE,UAAU,EAAE,GAAG,CAAC,EAAE,CACjE,OAAO,CAAC,MAAM,CAAC;oBACb,IAAI;oBACJ,GAAG;oBACH,SAAS,EAAE,mBAAmB;iBAC/B,CAAC,CACH,CAAC;YACJ,CAAC;YACD,mBAAmB,CAAC,IAAI;gBACtB,iDAAuB,CAAC,IAAI,EAAE,OAAO,EAAE,UAAU,EAAE,GAAG,CAAC,EAAE,CACvD,OAAO,CAAC,MAAM,CAAC;oBACb,IAAI;oBACJ,GAAG;oBACH,SAAS,EAAE,mBAAmB;iBAC/B,CAAC,CACH,CAAC;YACJ,CAAC;SACF,CAAC;IACJ,CAAC;CACF,CAAC,CAAC"}

node_modules/@typescript-eslint/eslint-plugin/dist/rules/explicit-member-accessibility.js

@@ -0,0 +1,209 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const experimental_utils_1 = require("@typescript-eslint/experimental-utils");
+const util = __importStar(require("../util"));
+const accessibilityLevel = { enum: ['explicit', 'no-public', 'off'] };
+exports.default = util.createRule({
+    name: 'explicit-member-accessibility',
+    meta: {
+        type: 'problem',
+        docs: {
+            description: 'Require explicit accessibility modifiers on class properties and methods',
+            category: 'Stylistic Issues',
+            // too opinionated to be recommended
+            recommended: false,
+        },
+        fixable: 'code',
+        messages: {
+            missingAccessibility: 'Missing accessibility modifier on {{type}} {{name}}.',
+            unwantedPublicAccessibility: 'Public accessibility modifier on {{type}} {{name}}.',
+        },
+        schema: [
+            {
+                type: 'object',
+                properties: {
+                    accessibility: accessibilityLevel,
+                    overrides: {
+                        type: 'object',
+                        properties: {
+                            accessors: accessibilityLevel,
+                            constructors: accessibilityLevel,
+                            methods: accessibilityLevel,
+                            properties: accessibilityLevel,
+                            parameterProperties: accessibilityLevel,
+                        },
+                        additionalProperties: false,
+                    },
+                    ignoredMethodNames: {
+                        type: 'array',
+                        items: {
+                            type: 'string',
+                        },
+                    },
+                },
+                additionalProperties: false,
+            },
+        ],
+    },
+    defaultOptions: [{ accessibility: 'explicit' }],
+    create(context, [option]) {
+        var _a, _b, _c, _d, _e, _f, _g, _h;
+        const sourceCode = context.getSourceCode();
+        const baseCheck = (_a = option.accessibility) !== null && _a !== void 0 ? _a : 'explicit';
+        const overrides = (_b = option.overrides) !== null && _b !== void 0 ? _b : {};
+        const ctorCheck = (_c = overrides.constructors) !== null && _c !== void 0 ? _c : baseCheck;
+        const accessorCheck = (_d = overrides.accessors) !== null && _d !== void 0 ? _d : baseCheck;
+        const methodCheck = (_e = overrides.methods) !== null && _e !== void 0 ? _e : baseCheck;
+        const propCheck = (_f = overrides.properties) !== null && _f !== void 0 ? _f : baseCheck;
+        const paramPropCheck = (_g = overrides.parameterProperties) !== null && _g !== void 0 ? _g : baseCheck;
+        const ignoredMethodNames = new Set((_h = option.ignoredMethodNames) !== null && _h !== void 0 ? _h : []);
+        /**
+         * Generates the report for rule violations
+         */
+        function reportIssue(messageId, nodeType, node, nodeName, fix = null) {
+            context.report({
+                node: node,
+                messageId: messageId,
+                data: {
+                    type: nodeType,
+                    name: nodeName,
+                },
+                fix: fix,
+            });
+        }
+        /**
+         * Checks if a method declaration has an accessibility modifier.
+         * @param methodDefinition The node representing a MethodDefinition.
+         */
+        function checkMethodAccessibilityModifier(methodDefinition) {
+            let nodeType = 'method definition';
+            let check = baseCheck;
+            switch (methodDefinition.kind) {
+                case 'method':
+                    check = methodCheck;
+                    break;
+                case 'constructor':
+                    check = ctorCheck;
+                    break;
+                case 'get':
+                case 'set':
+                    check = accessorCheck;
+                    nodeType = `${methodDefinition.kind} property accessor`;
+                    break;
+            }
+            const methodName = util.getNameFromMember(methodDefinition, sourceCode);
+            if (check === 'off' || ignoredMethodNames.has(methodName)) {
+                return;
+            }
+            if (check === 'no-public' &&
+                methodDefinition.accessibility === 'public') {
+                reportIssue('unwantedPublicAccessibility', nodeType, methodDefinition, methodName, getUnwantedPublicAccessibilityFixer(methodDefinition));
+            }
+            else if (check === 'explicit' && !methodDefinition.accessibility) {
+                reportIssue('missingAccessibility', nodeType, methodDefinition, methodName);
+            }
+        }
+        /**
+         * Creates a fixer that removes a "public" keyword with following spaces
+         */
+        function getUnwantedPublicAccessibilityFixer(node) {
+            return function (fixer) {
+                const tokens = sourceCode.getTokens(node);
+                let rangeToRemove;
+                for (let i = 0; i < tokens.length; i++) {
+                    const token = tokens[i];
+                    if (token.type === experimental_utils_1.AST_TOKEN_TYPES.Keyword &&
+                        token.value === 'public') {
+                        const commensAfterPublicKeyword = sourceCode.getCommentsAfter(token);
+                        if (commensAfterPublicKeyword.length) {
+                            // public /* Hi there! */ static foo()
+                            // ^^^^^^^
+                            rangeToRemove = [
+                                token.range[0],
+                                commensAfterPublicKeyword[0].range[0],
+                            ];
+                            break;
+                        }
+                        else {
+                            // public static foo()
+                            // ^^^^^^^
+                            rangeToRemove = [token.range[0], tokens[i + 1].range[0]];
+                            break;
+                        }
+                    }
+                }
+                return fixer.removeRange(rangeToRemove);
+            };
+        }
+        /**
+         * Checks if property has an accessibility modifier.
+         * @param classProperty The node representing a ClassProperty.
+         */
+        function checkPropertyAccessibilityModifier(classProperty) {
+            const nodeType = 'class property';
+            const propertyName = util.getNameFromMember(classProperty, sourceCode);
+            if (propCheck === 'no-public' &&
+                classProperty.accessibility === 'public') {
+                reportIssue('unwantedPublicAccessibility', nodeType, classProperty, propertyName, getUnwantedPublicAccessibilityFixer(classProperty));
+            }
+            else if (propCheck === 'explicit' && !classProperty.accessibility) {
+                reportIssue('missingAccessibility', nodeType, classProperty, propertyName);
+            }
+        }
+        /**
+         * Checks that the parameter property has the desired accessibility modifiers set.
+         * @param node The node representing a Parameter Property
+         */
+        function checkParameterPropertyAccessibilityModifier(node) {
+            const nodeType = 'parameter property';
+            // HAS to be an identifier or assignment or TSC will throw
+            if (node.parameter.type !== experimental_utils_1.AST_NODE_TYPES.Identifier &&
+                node.parameter.type !== experimental_utils_1.AST_NODE_TYPES.AssignmentPattern) {
+                return;
+            }
+            const nodeName = node.parameter.type === experimental_utils_1.AST_NODE_TYPES.Identifier
+                ? node.parameter.name
+                : // has to be an Identifier or TSC will throw an error
+                    node.parameter.left.name;
+            switch (paramPropCheck) {
+                case 'explicit': {
+                    if (!node.accessibility) {
+                        reportIssue('missingAccessibility', nodeType, node, nodeName);
+                    }
+                    break;
+                }
+                case 'no-public': {
+                    if (node.accessibility === 'public' && node.readonly) {
+                        reportIssue('unwantedPublicAccessibility', nodeType, node, nodeName, getUnwantedPublicAccessibilityFixer(node));
+                    }
+                    break;
+                }
+            }
+        }
+        return {
+            TSParameterProperty: checkParameterPropertyAccessibilityModifier,
+            ClassProperty: checkPropertyAccessibilityModifier,
+            MethodDefinition: checkMethodAccessibilityModifier,
+        };
+    },
+});
+//# sourceMappingURL=explicit-member-accessibility.js.map

node_modules/@typescript-eslint/eslint-plugin/dist/rules/explicit-member-accessibility.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"explicit-member-accessibility.js","sourceRoot":"","sources":["../../src/rules/explicit-member-accessibility.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;AAAA,8EAK+C;AAC/C,8CAAgC;AAuBhC,MAAM,kBAAkB,GAAG,EAAE,IAAI,EAAE,CAAC,UAAU,EAAE,WAAW,EAAE,KAAK,CAAC,EAAE,CAAC;AAEtE,kBAAe,IAAI,CAAC,UAAU,CAAsB;IAClD,IAAI,EAAE,+BAA+B;IACrC,IAAI,EAAE;QACJ,IAAI,EAAE,SAAS;QACf,IAAI,EAAE;YACJ,WAAW,EACT,0EAA0E;YAC5E,QAAQ,EAAE,kBAAkB;YAC5B,oCAAoC;YACpC,WAAW,EAAE,KAAK;SACnB;QACD,OAAO,EAAE,MAAM;QACf,QAAQ,EAAE;YACR,oBAAoB,EAClB,sDAAsD;YACxD,2BAA2B,EACzB,qDAAqD;SACxD;QACD,MAAM,EAAE;YACN;gBACE,IAAI,EAAE,QAAQ;gBACd,UAAU,EAAE;oBACV,aAAa,EAAE,kBAAkB;oBACjC,SAAS,EAAE;wBACT,IAAI,EAAE,QAAQ;wBACd,UAAU,EAAE;4BACV,SAAS,EAAE,kBAAkB;4BAC7B,YAAY,EAAE,kBAAkB;4BAChC,OAAO,EAAE,kBAAkB;4BAC3B,UAAU,EAAE,kBAAkB;4BAC9B,mBAAmB,EAAE,kBAAkB;yBACxC;wBAED,oBAAoB,EAAE,KAAK;qBAC5B;oBACD,kBAAkB,EAAE;wBAClB,IAAI,EAAE,OAAO;wBACb,KAAK,EAAE;4BACL,IAAI,EAAE,QAAQ;yBACf;qBACF;iBACF;gBACD,oBAAoB,EAAE,KAAK;aAC5B;SACF;KACF;IACD,cAAc,EAAE,CAAC,EAAE,aAAa,EAAE,UAAU,EAAE,CAAC;IAC/C,MAAM,CAAC,OAAO,EAAE,CAAC,MAAM,CAAC;;QACtB,MAAM,UAAU,GAAG,OAAO,CAAC,aAAa,EAAE,CAAC;QAC3C,MAAM,SAAS,SAAuB,MAAM,CAAC,aAAa,mCAAI,UAAU,CAAC;QACzE,MAAM,SAAS,SAAG,MAAM,CAAC,SAAS,mCAAI,EAAE,CAAC;QACzC,MAAM,SAAS,SAAG,SAAS,CAAC,YAAY,mCAAI,SAAS,CAAC;QACtD,MAAM,aAAa,SAAG,SAAS,CAAC,SAAS,mCAAI,SAAS,CAAC;QACvD,MAAM,WAAW,SAAG,SAAS,CAAC,OAAO,mCAAI,SAAS,CAAC;QACnD,MAAM,SAAS,SAAG,SAAS,CAAC,UAAU,mCAAI,SAAS,CAAC;QACpD,MAAM,cAAc,SAAG,SAAS,CAAC,mBAAmB,mCAAI,SAAS,CAAC;QAClE,MAAM,kBAAkB,GAAG,IAAI,GAAG,OAAC,MAAM,CAAC,kBAAkB,mCAAI,EAAE,CAAC,CAAC;QACpE;;WAEG;QACH,SAAS,WAAW,CAClB,SAAqB,EACrB,QAAgB,EAChB,IAAmB,EACnB,QAAgB,EAChB,MAAyC,IAAI;YAE7C,OAAO,CAAC,MAAM,CAAC;gBACb,IAAI,EAAE,IAAI;gBACV,SAAS,EAAE,SAAS;gBACpB,IAAI,EAAE;oBACJ,IAAI,EAAE,QAAQ;oBACd,IAAI,EAAE,QAAQ;iBACf;gBACD,GAAG,EAAE,GAAG;aACT,CAAC,CAAC;QACL,CAAC;QAED;;;WAGG;QACH,SAAS,gCAAgC,CACvC,gBAA2C;YAE3C,IAAI,QAAQ,GAAG,mBAAmB,CAAC;YACnC,IAAI,KAAK,GAAG,SAAS,CAAC;YACtB,QAAQ,gBAAgB,CAAC,IAAI,EAAE;gBAC7B,KAAK,QAAQ;oBACX,KAAK,GAAG,WAAW,CAAC;oBACpB,MAAM;gBACR,KAAK,aAAa;oBAChB,KAAK,GAAG,SAAS,CAAC;oBAClB,MAAM;gBACR,KAAK,KAAK,CAAC;gBACX,KAAK,KAAK;oBACR,KAAK,GAAG,aAAa,CAAC;oBACtB,QAAQ,GAAG,GAAG,gBAAgB,CAAC,IAAI,oBAAoB,CAAC;oBACxD,MAAM;aACT;YAED,MAAM,UAAU,GAAG,IAAI,CAAC,iBAAiB,CAAC,gBAAgB,EAAE,UAAU,CAAC,CAAC;YAExE,IAAI,KAAK,KAAK,KAAK,IAAI,kBAAkB,CAAC,GAAG,CAAC,UAAU,CAAC,EAAE;gBACzD,OAAO;aACR;YAED,IACE,KAAK,KAAK,WAAW;gBACrB,gBAAgB,CAAC,aAAa,KAAK,QAAQ,EAC3C;gBACA,WAAW,CACT,6BAA6B,EAC7B,QAAQ,EACR,gBAAgB,EAChB,UAAU,EACV,mCAAmC,CAAC,gBAAgB,CAAC,CACtD,CAAC;aACH;iBAAM,IAAI,KAAK,KAAK,UAAU,IAAI,CAAC,gBAAgB,CAAC,aAAa,EAAE;gBAClE,WAAW,CACT,sBAAsB,EACtB,QAAQ,EACR,gBAAgB,EAChB,UAAU,CACX,CAAC;aACH;QACH,CAAC;QAED;;WAEG;QACH,SAAS,mCAAmC,CAC1C,IAGgC;YAEhC,OAAO,UAAU,KAAyB;gBACxC,MAAM,MAAM,GAAG,UAAU,CAAC,SAAS,CAAC,IAAI,CAAC,CAAC;gBAC1C,IAAI,aAAiC,CAAC;gBACtC,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE;oBACtC,MAAM,KAAK,GAAG,MAAM,CAAC,CAAC,CAAC,CAAC;oBACxB,IACE,KAAK,CAAC,IAAI,KAAK,oCAAe,CAAC,OAAO;wBACtC,KAAK,CAAC,KAAK,KAAK,QAAQ,EACxB;wBACA,MAAM,yBAAyB,GAAG,UAAU,CAAC,gBAAgB,CAC3D,KAAK,CACN,CAAC;wBACF,IAAI,yBAAyB,CAAC,MAAM,EAAE;4BACpC,sCAAsC;4BACtC,UAAU;4BACV,aAAa,GAAG;gCACd,KAAK,CAAC,KAAK,CAAC,CAAC,CAAC;gCACd,yBAAyB,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC;6BACtC,CAAC;4BACF,MAAM;yBACP;6BAAM;4BACL,sBAAsB;4BACtB,UAAU;4BACV,aAAa,GAAG,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,MAAM,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC;4BACzD,MAAM;yBACP;qBACF;iBACF;gBACD,OAAO,KAAK,CAAC,WAAW,CAAC,aAAc,CAAC,CAAC;YAC3C,CAAC,CAAC;QACJ,CAAC;QAED;;;WAGG;QACH,SAAS,kCAAkC,CACzC,aAAqC;YAErC,MAAM,QAAQ,GAAG,gBAAgB,CAAC;YAElC,MAAM,YAAY,GAAG,IAAI,CAAC,iBAAiB,CAAC,aAAa,EAAE,UAAU,CAAC,CAAC;YACvE,IACE,SAAS,KAAK,WAAW;gBACzB,aAAa,CAAC,aAAa,KAAK,QAAQ,EACxC;gBACA,WAAW,CACT,6BAA6B,EAC7B,QAAQ,EACR,aAAa,EACb,YAAY,EACZ,mCAAmC,CAAC,aAAa,CAAC,CACnD,CAAC;aACH;iBAAM,IAAI,SAAS,KAAK,UAAU,IAAI,CAAC,aAAa,CAAC,aAAa,EAAE;gBACnE,WAAW,CACT,sBAAsB,EACtB,QAAQ,EACR,aAAa,EACb,YAAY,CACb,CAAC;aACH;QACH,CAAC;QAED;;;WAGG;QACH,SAAS,2CAA2C,CAClD,IAAkC;YAElC,MAAM,QAAQ,GAAG,oBAAoB,CAAC;YACtC,0DAA0D;YAC1D,IACE,IAAI,CAAC,SAAS,CAAC,IAAI,KAAK,mCAAc,CAAC,UAAU;gBACjD,IAAI,CAAC,SAAS,CAAC,IAAI,KAAK,mCAAc,CAAC,iBAAiB,EACxD;gBACA,OAAO;aACR;YAED,MAAM,QAAQ,GACZ,IAAI,CAAC,SAAS,CAAC,IAAI,KAAK,mCAAc,CAAC,UAAU;gBAC/C,CAAC,CAAC,IAAI,CAAC,SAAS,CAAC,IAAI;gBACrB,CAAC,CAAC,qDAAqD;oBACpD,IAAI,CAAC,SAAS,CAAC,IAA4B,CAAC,IAAI,CAAC;YAExD,QAAQ,cAAc,EAAE;gBACtB,KAAK,UAAU,CAAC,CAAC;oBACf,IAAI,CAAC,IAAI,CAAC,aAAa,EAAE;wBACvB,WAAW,CAAC,sBAAsB,EAAE,QAAQ,EAAE,IAAI,EAAE,QAAQ,CAAC,CAAC;qBAC/D;oBACD,MAAM;iBACP;gBACD,KAAK,WAAW,CAAC,CAAC;oBAChB,IAAI,IAAI,CAAC,aAAa,KAAK,QAAQ,IAAI,IAAI,CAAC,QAAQ,EAAE;wBACpD,WAAW,CACT,6BAA6B,EAC7B,QAAQ,EACR,IAAI,EACJ,QAAQ,EACR,mCAAmC,CAAC,IAAI,CAAC,CAC1C,CAAC;qBACH;oBACD,MAAM;iBACP;aACF;QACH,CAAC;QAED,OAAO;YACL,mBAAmB,EAAE,2CAA2C;YAChE,aAAa,EAAE,kCAAkC;YACjD,gBAAgB,EAAE,gCAAgC;SACnD,CAAC;IACJ,CAAC;CACF,CAAC,CAAC"}

node_modules/@typescript-eslint/eslint-plugin/dist/rules/explicit-module-boundary-types.js

@@ -0,0 +1,412 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const experimental_utils_1 = require("@typescript-eslint/experimental-utils");
+const util = __importStar(require("../util"));
+const explicitReturnTypeUtils_1 = require("../util/explicitReturnTypeUtils");
+exports.default = util.createRule({
+    name: 'explicit-module-boundary-types',
+    meta: {
+        type: 'problem',
+        docs: {
+            description: "Require explicit return and argument types on exported functions' and classes' public class methods",
+            category: 'Stylistic Issues',
+            recommended: 'warn',
+        },
+        messages: {
+            missingReturnType: 'Missing return type on function.',
+            missingArgType: "Argument '{{name}}' should be typed.",
+            missingArgTypeUnnamed: '{{type}} argument should be typed.',
+            anyTypedArg: "Argument '{{name}}' should be typed with a non-any type.",
+            anyTypedArgUnnamed: '{{type}} argument should be typed with a non-any type.',
+        },
+        schema: [
+            {
+                type: 'object',
+                properties: {
+                    allowArgumentsExplicitlyTypedAsAny: {
+                        type: 'boolean',
+                    },
+                    allowDirectConstAssertionInArrowFunctions: {
+                        type: 'boolean',
+                    },
+                    allowedNames: {
+                        type: 'array',
+                        items: {
+                            type: 'string',
+                        },
+                    },
+                    allowHigherOrderFunctions: {
+                        type: 'boolean',
+                    },
+                    allowTypedFunctionExpressions: {
+                        type: 'boolean',
+                    },
+                    // DEPRECATED - To be removed in next major
+                    shouldTrackReferences: {
+                        type: 'boolean',
+                    },
+                },
+                additionalProperties: false,
+            },
+        ],
+    },
+    defaultOptions: [
+        {
+            allowArgumentsExplicitlyTypedAsAny: false,
+            allowDirectConstAssertionInArrowFunctions: true,
+            allowedNames: [],
+            allowHigherOrderFunctions: true,
+            allowTypedFunctionExpressions: true,
+        },
+    ],
+    create(context, [options]) {
+        const sourceCode = context.getSourceCode();
+        // tracks all of the functions we've already checked
+        const checkedFunctions = new Set();
+        // tracks functions that were found whilst traversing
+        const foundFunctions = [];
+        // all nodes visited, avoids infinite recursion for cyclic references
+        // (such as class member referring to itself)
+        const alreadyVisited = new Set();
+        /*
+        # How the rule works:
+    
+        As the rule traverses the AST, it immediately checks every single function that it finds is exported.
+        "exported" means that it is either directly exported, or that its name is exported.
+    
+        It also collects a list of every single function it finds on the way, but does not check them.
+        After it's finished traversing the AST, it then iterates through the list of found functions, and checks to see if
+        any of them are part of a higher-order function
+        */
+        return {
+            ExportDefaultDeclaration(node) {
+                checkNode(node.declaration);
+            },
+            'ExportNamedDeclaration:not([source])'(node) {
+                if (node.declaration) {
+                    checkNode(node.declaration);
+                }
+                else {
+                    for (const specifier of node.specifiers) {
+                        followReference(specifier.local);
+                    }
+                }
+            },
+            TSExportAssignment(node) {
+                checkNode(node.expression);
+            },
+            'ArrowFunctionExpression, FunctionDeclaration, FunctionExpression'(node) {
+                foundFunctions.push(node);
+            },
+            'Program:exit'() {
+                for (const func of foundFunctions) {
+                    if (isExportedHigherOrderFunction(func)) {
+                        checkNode(func);
+                    }
+                }
+            },
+        };
+        function checkParameters(node) {
+            function checkParameter(param) {
+                function report(namedMessageId, unnamedMessageId) {
+                    if (param.type === experimental_utils_1.AST_NODE_TYPES.Identifier) {
+                        context.report({
+                            node: param,
+                            messageId: namedMessageId,
+                            data: { name: param.name },
+                        });
+                    }
+                    else if (param.type === experimental_utils_1.AST_NODE_TYPES.ArrayPattern) {
+                        context.report({
+                            node: param,
+                            messageId: unnamedMessageId,
+                            data: { type: 'Array pattern' },
+                        });
+                    }
+                    else if (param.type === experimental_utils_1.AST_NODE_TYPES.ObjectPattern) {
+                        context.report({
+                            node: param,
+                            messageId: unnamedMessageId,
+                            data: { type: 'Object pattern' },
+                        });
+                    }
+                    else if (param.type === experimental_utils_1.AST_NODE_TYPES.RestElement) {
+                        if (param.argument.type === experimental_utils_1.AST_NODE_TYPES.Identifier) {
+                            context.report({
+                                node: param,
+                                messageId: namedMessageId,
+                                data: { name: param.argument.name },
+                            });
+                        }
+                        else {
+                            context.report({
+                                node: param,
+                                messageId: unnamedMessageId,
+                                data: { type: 'Rest' },
+                            });
+                        }
+                    }
+                }
+                switch (param.type) {
+                    case experimental_utils_1.AST_NODE_TYPES.ArrayPattern:
+                    case experimental_utils_1.AST_NODE_TYPES.Identifier:
+                    case experimental_utils_1.AST_NODE_TYPES.ObjectPattern:
+                    case experimental_utils_1.AST_NODE_TYPES.RestElement:
+                        if (!param.typeAnnotation) {
+                            report('missingArgType', 'missingArgTypeUnnamed');
+                        }
+                        else if (options.allowArgumentsExplicitlyTypedAsAny !== true &&
+                            param.typeAnnotation.typeAnnotation.type ===
+                                experimental_utils_1.AST_NODE_TYPES.TSAnyKeyword) {
+                            report('anyTypedArg', 'anyTypedArgUnnamed');
+                        }
+                        return;
+                    case experimental_utils_1.AST_NODE_TYPES.TSParameterProperty:
+                        return checkParameter(param.parameter);
+                    case experimental_utils_1.AST_NODE_TYPES.AssignmentPattern: // ignored as it has a type via its assignment
+                        return;
+                }
+            }
+            for (const arg of node.params) {
+                checkParameter(arg);
+            }
+        }
+        /**
+         * Checks if a function name is allowed and should not be checked.
+         */
+        function isAllowedName(node) {
+            if (!node || !options.allowedNames || !options.allowedNames.length) {
+                return false;
+            }
+            if (node.type === experimental_utils_1.AST_NODE_TYPES.VariableDeclarator) {
+                return (node.id.type === experimental_utils_1.AST_NODE_TYPES.Identifier &&
+                    options.allowedNames.includes(node.id.name));
+            }
+            else if (node.type === experimental_utils_1.AST_NODE_TYPES.MethodDefinition ||
+                node.type === experimental_utils_1.AST_NODE_TYPES.TSAbstractMethodDefinition) {
+                if (node.key.type === experimental_utils_1.AST_NODE_TYPES.Literal &&
+                    typeof node.key.value === 'string') {
+                    return options.allowedNames.includes(node.key.value);
+                }
+                if (node.key.type === experimental_utils_1.AST_NODE_TYPES.TemplateLiteral &&
+                    node.key.expressions.length === 0) {
+                    return options.allowedNames.includes(node.key.quasis[0].value.raw);
+                }
+                if (!node.computed && node.key.type === experimental_utils_1.AST_NODE_TYPES.Identifier) {
+                    return options.allowedNames.includes(node.key.name);
+                }
+            }
+            return false;
+        }
+        function isExportedHigherOrderFunction(node) {
+            var _a;
+            let current = node.parent;
+            while (current) {
+                if (current.type === experimental_utils_1.AST_NODE_TYPES.ReturnStatement) {
+                    // the parent of a return will always be a block statement, so we can skip over it
+                    current = (_a = current.parent) === null || _a === void 0 ? void 0 : _a.parent;
+                    continue;
+                }
+                if (!util.isFunction(current) ||
+                    !explicitReturnTypeUtils_1.doesImmediatelyReturnFunctionExpression(current)) {
+                    return false;
+                }
+                if (checkedFunctions.has(current)) {
+                    return true;
+                }
+                current = current.parent;
+            }
+            return false;
+        }
+        function followReference(node) {
+            const scope = context.getScope();
+            const variable = scope.set.get(node.name);
+            /* istanbul ignore if */ if (!variable) {
+                return;
+            }
+            // check all of the definitions
+            for (const definition of variable.defs) {
+                // cases we don't care about in this rule
+                if (definition.type === 'ImplicitGlobalVariable' ||
+                    definition.type === 'ImportBinding' ||
+                    // eslint-disable-next-line @typescript-eslint/internal/prefer-ast-types-enum
+                    definition.type === 'CatchClause' ||
+                    definition.type === 'Parameter') {
+                    continue;
+                }
+                checkNode(definition.node);
+            }
+            // follow references to find writes to the variable
+            for (const reference of variable.references) {
+                if (
+                // we don't want to check the initialization ref, as this is handled by the declaration check
+                !reference.init &&
+                    reference.writeExpr) {
+                    checkNode(reference.writeExpr);
+                }
+            }
+        }
+        function checkNode(node) {
+            if (node == null || alreadyVisited.has(node)) {
+                return;
+            }
+            alreadyVisited.add(node);
+            switch (node.type) {
+                case experimental_utils_1.AST_NODE_TYPES.ArrowFunctionExpression:
+                case experimental_utils_1.AST_NODE_TYPES.FunctionExpression:
+                    return checkFunctionExpression(node);
+                case experimental_utils_1.AST_NODE_TYPES.ArrayExpression:
+                    for (const element of node.elements) {
+                        checkNode(element);
+                    }
+                    return;
+                case experimental_utils_1.AST_NODE_TYPES.ClassProperty:
+                case experimental_utils_1.AST_NODE_TYPES.TSAbstractClassProperty:
+                    if (node.accessibility === 'private') {
+                        return;
+                    }
+                    return checkNode(node.value);
+                case experimental_utils_1.AST_NODE_TYPES.ClassDeclaration:
+                case experimental_utils_1.AST_NODE_TYPES.ClassExpression:
+                    for (const element of node.body.body) {
+                        checkNode(element);
+                    }
+                    return;
+                case experimental_utils_1.AST_NODE_TYPES.FunctionDeclaration:
+                    return checkFunction(node);
+                case experimental_utils_1.AST_NODE_TYPES.MethodDefinition:
+                case experimental_utils_1.AST_NODE_TYPES.TSAbstractMethodDefinition:
+                    if (node.accessibility === 'private') {
+                        return;
+                    }
+                    return checkNode(node.value);
+                case experimental_utils_1.AST_NODE_TYPES.Identifier:
+                    return followReference(node);
+                case experimental_utils_1.AST_NODE_TYPES.ObjectExpression:
+                    for (const property of node.properties) {
+                        checkNode(property);
+                    }
+                    return;
+                case experimental_utils_1.AST_NODE_TYPES.Property:
+                    return checkNode(node.value);
+                case experimental_utils_1.AST_NODE_TYPES.TSEmptyBodyFunctionExpression:
+                    return checkEmptyBodyFunctionExpression(node);
+                case experimental_utils_1.AST_NODE_TYPES.VariableDeclaration:
+                    for (const declaration of node.declarations) {
+                        checkNode(declaration);
+                    }
+                    return;
+                case experimental_utils_1.AST_NODE_TYPES.VariableDeclarator:
+                    return checkNode(node.init);
+            }
+        }
+        /**
+         * Check whether any ancestor of the provided function has a valid return type.
+         * This function assumes that the function either:
+         * - belongs to an exported function chain validated by isExportedHigherOrderFunction
+         * - is directly exported itself
+         */
+        function ancestorHasReturnType(node) {
+            let ancestor = node.parent;
+            // if the ancestor is not a return, then this function was not returned at all, so we can exit early
+            const isReturnStatement = (ancestor === null || ancestor === void 0 ? void 0 : ancestor.type) === experimental_utils_1.AST_NODE_TYPES.ReturnStatement;
+            const isBodylessArrow = (ancestor === null || ancestor === void 0 ? void 0 : ancestor.type) === experimental_utils_1.AST_NODE_TYPES.ArrowFunctionExpression &&
+                ancestor.body.type !== experimental_utils_1.AST_NODE_TYPES.BlockStatement;
+            if (!isReturnStatement && !isBodylessArrow) {
+                return false;
+            }
+            while (ancestor) {
+                switch (ancestor.type) {
+                    case experimental_utils_1.AST_NODE_TYPES.ArrowFunctionExpression:
+                    case experimental_utils_1.AST_NODE_TYPES.FunctionExpression:
+                    case experimental_utils_1.AST_NODE_TYPES.FunctionDeclaration:
+                        if (ancestor.returnType) {
+                            return true;
+                        }
+                        // assume
+                        break;
+                    // const x: Foo = () => {};
+                    // Assume that a typed variable types the function expression
+                    case experimental_utils_1.AST_NODE_TYPES.VariableDeclarator:
+                        if (ancestor.id.typeAnnotation) {
+                            return true;
+                        }
+                        break;
+                }
+                ancestor = ancestor.parent;
+            }
+            return false;
+        }
+        function checkEmptyBodyFunctionExpression(node) {
+            var _a, _b, _c;
+            const isConstructor = ((_a = node.parent) === null || _a === void 0 ? void 0 : _a.type) === experimental_utils_1.AST_NODE_TYPES.MethodDefinition &&
+                node.parent.kind === 'constructor';
+            const isSetAccessor = (((_b = node.parent) === null || _b === void 0 ? void 0 : _b.type) === experimental_utils_1.AST_NODE_TYPES.TSAbstractMethodDefinition ||
+                ((_c = node.parent) === null || _c === void 0 ? void 0 : _c.type) === experimental_utils_1.AST_NODE_TYPES.MethodDefinition) &&
+                node.parent.kind === 'set';
+            if (!isConstructor && !isSetAccessor && !node.returnType) {
+                context.report({
+                    node,
+                    messageId: 'missingReturnType',
+                });
+            }
+            checkParameters(node);
+        }
+        function checkFunctionExpression(node) {
+            if (checkedFunctions.has(node)) {
+                return;
+            }
+            checkedFunctions.add(node);
+            if (isAllowedName(node.parent) ||
+                explicitReturnTypeUtils_1.isTypedFunctionExpression(node, options) ||
+                ancestorHasReturnType(node)) {
+                return;
+            }
+            explicitReturnTypeUtils_1.checkFunctionExpressionReturnType(node, options, sourceCode, loc => {
+                context.report({
+                    node,
+                    loc,
+                    messageId: 'missingReturnType',
+                });
+            });
+            checkParameters(node);
+        }
+        function checkFunction(node) {
+            if (checkedFunctions.has(node)) {
+                return;
+            }
+            checkedFunctions.add(node);
+            if (isAllowedName(node.parent) || ancestorHasReturnType(node)) {
+                return;
+            }
+            explicitReturnTypeUtils_1.checkFunctionReturnType(node, options, sourceCode, loc => {
+                context.report({
+                    node,
+                    loc,
+                    messageId: 'missingReturnType',
+                });
+            });
+            checkParameters(node);
+        }
+    },
+});
+//# sourceMappingURL=explicit-module-boundary-types.js.map