@chromatic-com/cypress 0.13.0 → 0.13.1

package/embedded/node_modules/eslint-scope/dist/eslint-scope.cjs

@@ -1,2339 +0,0 @@
-'use strict';
-
-Object.defineProperty(exports, '__esModule', { value: true });
-
-var estraverse = require('estraverse');
-var esrecurse = require('esrecurse');
-
-function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
-
-var estraverse__default = /*#__PURE__*/_interopDefaultLegacy(estraverse);
-var esrecurse__default = /*#__PURE__*/_interopDefaultLegacy(esrecurse);
-
-/**
- * @fileoverview Assertion utilities.
- * @author Nicholas C. Zakas
- */
-
-/**
- * Throws an error if the given condition is not truthy.
- * @param {boolean} condition The condition to check.
- * @param {string} message The message to include with the error.
- * @returns {void}
- * @throws {Error} When the condition is not truthy.
- */
-function assert(condition, message = "Assertion failed.") {
-    if (!condition) {
-        throw new Error(message);
-    }
-}
-
-/*
-  Copyright (C) 2015 Yusuke Suzuki <utatane.tea@gmail.com>
-
-  Redistribution and use in source and binary forms, with or without
-  modification, are permitted provided that the following conditions are met:
-
-    * Redistributions of source code must retain the above copyright
-      notice, this list of conditions and the following disclaimer.
-    * Redistributions in binary form must reproduce the above copyright
-      notice, this list of conditions and the following disclaimer in the
-      documentation and/or other materials provided with the distribution.
-
-  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
-  AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
-  IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
-  ARE DISCLAIMED. IN NO EVENT SHALL <COPYRIGHT HOLDER> BE LIABLE FOR ANY
-  DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-  (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-  ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
-  THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-*/
-
-const READ = 0x1;
-const WRITE = 0x2;
-const RW = READ | WRITE;
-
-/**
- * A Reference represents a single occurrence of an identifier in code.
- * @constructor Reference
- */
-class Reference {
-    constructor(ident, scope, flag, writeExpr, maybeImplicitGlobal, partial, init) {
-
-        /**
-         * Identifier syntax node.
-         * @member {espreeIdentifier} Reference#identifier
-         */
-        this.identifier = ident;
-
-        /**
-         * Reference to the enclosing Scope.
-         * @member {Scope} Reference#from
-         */
-        this.from = scope;
-
-        /**
-         * Whether the reference comes from a dynamic scope (such as 'eval',
-         * 'with', etc.), and may be trapped by dynamic scopes.
-         * @member {boolean} Reference#tainted
-         */
-        this.tainted = false;
-
-        /**
-         * The variable this reference is resolved with.
-         * @member {Variable} Reference#resolved
-         */
-        this.resolved = null;
-
-        /**
-         * The read-write mode of the reference. (Value is one of {@link
-         * Reference.READ}, {@link Reference.RW}, {@link Reference.WRITE}).
-         * @member {number} Reference#flag
-         * @private
-         */
-        this.flag = flag;
-        if (this.isWrite()) {
-
-            /**
-             * If reference is writeable, this is the tree being written to it.
-             * @member {espreeNode} Reference#writeExpr
-             */
-            this.writeExpr = writeExpr;
-
-            /**
-             * Whether the Reference might refer to a partial value of writeExpr.
-             * @member {boolean} Reference#partial
-             */
-            this.partial = partial;
-
-            /**
-             * Whether the Reference is to write of initialization.
-             * @member {boolean} Reference#init
-             */
-            this.init = init;
-        }
-        this.__maybeImplicitGlobal = maybeImplicitGlobal;
-    }
-
-    /**
-     * Whether the reference is static.
-     * @function Reference#isStatic
-     * @returns {boolean} static
-     */
-    isStatic() {
-        return !this.tainted && this.resolved && this.resolved.scope.isStatic();
-    }
-
-    /**
-     * Whether the reference is writeable.
-     * @function Reference#isWrite
-     * @returns {boolean} write
-     */
-    isWrite() {
-        return !!(this.flag & Reference.WRITE);
-    }
-
-    /**
-     * Whether the reference is readable.
-     * @function Reference#isRead
-     * @returns {boolean} read
-     */
-    isRead() {
-        return !!(this.flag & Reference.READ);
-    }
-
-    /**
-     * Whether the reference is read-only.
-     * @function Reference#isReadOnly
-     * @returns {boolean} read only
-     */
-    isReadOnly() {
-        return this.flag === Reference.READ;
-    }
-
-    /**
-     * Whether the reference is write-only.
-     * @function Reference#isWriteOnly
-     * @returns {boolean} write only
-     */
-    isWriteOnly() {
-        return this.flag === Reference.WRITE;
-    }
-
-    /**
-     * Whether the reference is read-write.
-     * @function Reference#isReadWrite
-     * @returns {boolean} read write
-     */
-    isReadWrite() {
-        return this.flag === Reference.RW;
-    }
-}
-
-/**
- * @constant Reference.READ
- * @private
- */
-Reference.READ = READ;
-
-/**
- * @constant Reference.WRITE
- * @private
- */
-Reference.WRITE = WRITE;
-
-/**
- * @constant Reference.RW
- * @private
- */
-Reference.RW = RW;
-
-/* vim: set sw=4 ts=4 et tw=80 : */
-
-/*
-  Copyright (C) 2015 Yusuke Suzuki <utatane.tea@gmail.com>
-
-  Redistribution and use in source and binary forms, with or without
-  modification, are permitted provided that the following conditions are met:
-
-    * Redistributions of source code must retain the above copyright
-      notice, this list of conditions and the following disclaimer.
-    * Redistributions in binary form must reproduce the above copyright
-      notice, this list of conditions and the following disclaimer in the
-      documentation and/or other materials provided with the distribution.
-
-  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
-  AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
-  IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
-  ARE DISCLAIMED. IN NO EVENT SHALL <COPYRIGHT HOLDER> BE LIABLE FOR ANY
-  DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-  (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-  ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
-  THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-*/
-
-/**
- * A Variable represents a locally scoped identifier. These include arguments to
- * functions.
- * @constructor Variable
- */
-class Variable {
-    constructor(name, scope) {
-
-        /**
-         * The variable name, as given in the source code.
-         * @member {string} Variable#name
-         */
-        this.name = name;
-
-        /**
-         * List of defining occurrences of this variable (like in 'var ...'
-         * statements or as parameter), as AST nodes.
-         * @member {espree.Identifier[]} Variable#identifiers
-         */
-        this.identifiers = [];
-
-        /**
-         * List of {@link Reference|references} of this variable (excluding parameter entries)
-         * in its defining scope and all nested scopes. For defining
-         * occurrences only see {@link Variable#defs}.
-         * @member {Reference[]} Variable#references
-         */
-        this.references = [];
-
-        /**
-         * List of defining occurrences of this variable (like in 'var ...'
-         * statements or as parameter), as custom objects.
-         * @member {Definition[]} Variable#defs
-         */
-        this.defs = [];
-
-        this.tainted = false;
-
-        /**
-         * Whether this is a stack variable.
-         * @member {boolean} Variable#stack
-         */
-        this.stack = true;
-
-        /**
-         * Reference to the enclosing Scope.
-         * @member {Scope} Variable#scope
-         */
-        this.scope = scope;
-    }
-}
-
-Variable.CatchClause = "CatchClause";
-Variable.Parameter = "Parameter";
-Variable.FunctionName = "FunctionName";
-Variable.ClassName = "ClassName";
-Variable.Variable = "Variable";
-Variable.ImportBinding = "ImportBinding";
-Variable.ImplicitGlobalVariable = "ImplicitGlobalVariable";
-
-/* vim: set sw=4 ts=4 et tw=80 : */
-
-/*
-  Copyright (C) 2015 Yusuke Suzuki <utatane.tea@gmail.com>
-
-  Redistribution and use in source and binary forms, with or without
-  modification, are permitted provided that the following conditions are met:
-
-    * Redistributions of source code must retain the above copyright
-      notice, this list of conditions and the following disclaimer.
-    * Redistributions in binary form must reproduce the above copyright
-      notice, this list of conditions and the following disclaimer in the
-      documentation and/or other materials provided with the distribution.
-
-  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
-  AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
-  IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
-  ARE DISCLAIMED. IN NO EVENT SHALL <COPYRIGHT HOLDER> BE LIABLE FOR ANY
-  DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-  (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-  ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
-  THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-*/
-
-/**
- * @constructor Definition
- */
-class Definition {
-    constructor(type, name, node, parent, index, kind) {
-
-        /**
-         * @member {string} Definition#type - type of the occurrence (e.g. "Parameter", "Variable", ...).
-         */
-        this.type = type;
-
-        /**
-         * @member {espree.Identifier} Definition#name - the identifier AST node of the occurrence.
-         */
-        this.name = name;
-
-        /**
-         * @member {espree.Node} Definition#node - the enclosing node of the identifier.
-         */
-        this.node = node;
-
-        /**
-         * @member {espree.Node?} Definition#parent - the enclosing statement node of the identifier.
-         */
-        this.parent = parent;
-
-        /**
-         * @member {number?} Definition#index - the index in the declaration statement.
-         */
-        this.index = index;
-
-        /**
-         * @member {string?} Definition#kind - the kind of the declaration statement.
-         */
-        this.kind = kind;
-    }
-}
-
-/**
- * @constructor ParameterDefinition
- */
-class ParameterDefinition extends Definition {
-    constructor(name, node, index, rest) {
-        super(Variable.Parameter, name, node, null, index, null);
-
-        /**
-         * Whether the parameter definition is a part of a rest parameter.
-         * @member {boolean} ParameterDefinition#rest
-         */
-        this.rest = rest;
-    }
-}
-
-/* vim: set sw=4 ts=4 et tw=80 : */
-
-/*
-  Copyright (C) 2015 Yusuke Suzuki <utatane.tea@gmail.com>
-
-  Redistribution and use in source and binary forms, with or without
-  modification, are permitted provided that the following conditions are met:
-
-    * Redistributions of source code must retain the above copyright
-      notice, this list of conditions and the following disclaimer.
-    * Redistributions in binary form must reproduce the above copyright
-      notice, this list of conditions and the following disclaimer in the
-      documentation and/or other materials provided with the distribution.
-
-  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
-  AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
-  IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
-  ARE DISCLAIMED. IN NO EVENT SHALL <COPYRIGHT HOLDER> BE LIABLE FOR ANY
-  DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-  (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-  ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
-  THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-*/
-
-const { Syntax: Syntax$2 } = estraverse__default["default"];
-
-/**
- * Test if scope is struct
- * @param {Scope} scope scope
- * @param {Block} block block
- * @param {boolean} isMethodDefinition is method definition
- * @returns {boolean} is strict scope
- */
-function isStrictScope(scope, block, isMethodDefinition) {
-    let body;
-
-    // When upper scope is exists and strict, inner scope is also strict.
-    if (scope.upper && scope.upper.isStrict) {
-        return true;
-    }
-
-    if (isMethodDefinition) {
-        return true;
-    }
-
-    if (scope.type === "class" || scope.type === "module") {
-        return true;
-    }
-
-    if (scope.type === "block" || scope.type === "switch") {
-        return false;
-    }
-
-    if (scope.type === "function") {
-        if (block.type === Syntax$2.ArrowFunctionExpression && block.body.type !== Syntax$2.BlockStatement) {
-            return false;
-        }
-
-        if (block.type === Syntax$2.Program) {
-            body = block;
-        } else {
-            body = block.body;
-        }
-
-        if (!body) {
-            return false;
-        }
-    } else if (scope.type === "global") {
-        body = block;
-    } else {
-        return false;
-    }
-
-    // Search for a 'use strict' directive.
-    for (let i = 0, iz = body.body.length; i < iz; ++i) {
-        const stmt = body.body[i];
-
-        /*
-         * Check if the current statement is a directive.
-         * If it isn't, then we're past the directive prologue
-         * so stop the search because directives cannot
-         * appear after this point.
-         *
-         * Some parsers set `directive:null` on non-directive
-         * statements, so the `typeof` check is safer than
-         * checking for property existence.
-         */
-        if (typeof stmt.directive !== "string") {
-            break;
-        }
-
-        if (stmt.directive === "use strict") {
-            return true;
-        }
-    }
-
-    return false;
-}
-
-/**
- * Register scope
- * @param {ScopeManager} scopeManager scope manager
- * @param {Scope} scope scope
- * @returns {void}
- */
-function registerScope(scopeManager, scope) {
-    scopeManager.scopes.push(scope);
-
-    const scopes = scopeManager.__nodeToScope.get(scope.block);
-
-    if (scopes) {
-        scopes.push(scope);
-    } else {
-        scopeManager.__nodeToScope.set(scope.block, [scope]);
-    }
-}
-
-/**
- * Should be statically
- * @param {Object} def def
- * @returns {boolean} should be statically
- */
-function shouldBeStatically(def) {
-    return (
-        (def.type === Variable.ClassName) ||
-        (def.type === Variable.Variable && def.parent.kind !== "var")
-    );
-}
-
-/**
- * @constructor Scope
- */
-class Scope {
-    constructor(scopeManager, type, upperScope, block, isMethodDefinition) {
-
-        /**
-         * One of "global", "module", "function", "function-expression-name", "block", "switch", "catch", "with", "for",
-         * "class", "class-field-initializer", "class-static-block".
-         * @member {string} Scope#type
-         */
-        this.type = type;
-
-        /**
-         * The scoped {@link Variable}s of this scope, as <code>{ Variable.name
-         * : Variable }</code>.
-         * @member {Map} Scope#set
-         */
-        this.set = new Map();
-
-        /**
-         * The tainted variables of this scope, as <code>{ Variable.name :
-         * boolean }</code>.
-         *  @member {Map} Scope#taints
-         */
-        this.taints = new Map();
-
-        /**
-         * Generally, through the lexical scoping of JS you can always know
-         * which variable an identifier in the source code refers to. There are
-         * a few exceptions to this rule. With 'global' and 'with' scopes you
-         * can only decide at runtime which variable a reference refers to.
-         * Moreover, if 'eval()' is used in a scope, it might introduce new
-         * bindings in this or its parent scopes.
-         * All those scopes are considered 'dynamic'.
-         * @member {boolean} Scope#dynamic
-         */
-        this.dynamic = this.type === "global" || this.type === "with";
-
-        /**
-         * A reference to the scope-defining syntax node.
-         * @member {espree.Node} Scope#block
-         */
-        this.block = block;
-
-        /**
-         * The {@link Reference|references} that are not resolved with this scope.
-         * @member {Reference[]} Scope#through
-         */
-        this.through = [];
-
-        /**
-         * The scoped {@link Variable}s of this scope. In the case of a
-         * 'function' scope this includes the automatic argument <em>arguments</em> as
-         * its first element, as well as all further formal arguments.
-         * @member {Variable[]} Scope#variables
-         */
-        this.variables = [];
-
-        /**
-         * Any variable {@link Reference|reference} found in this scope. This
-         * includes occurrences of local variables as well as variables from
-         * parent scopes (including the global scope). For local variables
-         * this also includes defining occurrences (like in a 'var' statement).
-         * In a 'function' scope this does not include the occurrences of the
-         * formal parameter in the parameter list.
-         * @member {Reference[]} Scope#references
-         */
-        this.references = [];
-
-        /**
-         * For 'global' and 'function' scopes, this is a self-reference. For
-         * other scope types this is the <em>variableScope</em> value of the
-         * parent scope.
-         * @member {Scope} Scope#variableScope
-         */
-        this.variableScope =
-            this.type === "global" ||
-            this.type === "module" ||
-            this.type === "function" ||
-            this.type === "class-field-initializer" ||
-            this.type === "class-static-block"
-                ? this
-                : upperScope.variableScope;
-
-        /**
-         * Whether this scope is created by a FunctionExpression.
-         * @member {boolean} Scope#functionExpressionScope
-         */
-        this.functionExpressionScope = false;
-
-        /**
-         * Whether this is a scope that contains an 'eval()' invocation.
-         * @member {boolean} Scope#directCallToEvalScope
-         */
-        this.directCallToEvalScope = false;
-
-        /**
-         * @member {boolean} Scope#thisFound
-         */
-        this.thisFound = false;
-
-        this.__left = [];
-
-        /**
-         * Reference to the parent {@link Scope|scope}.
-         * @member {Scope} Scope#upper
-         */
-        this.upper = upperScope;
-
-        /**
-         * Whether 'use strict' is in effect in this scope.
-         * @member {boolean} Scope#isStrict
-         */
-        this.isStrict = scopeManager.isStrictModeSupported()
-            ? isStrictScope(this, block, isMethodDefinition)
-            : false;
-
-        /**
-         * List of nested {@link Scope}s.
-         * @member {Scope[]} Scope#childScopes
-         */
-        this.childScopes = [];
-        if (this.upper) {
-            this.upper.childScopes.push(this);
-        }
-
-        this.__declaredVariables = scopeManager.__declaredVariables;
-
-        registerScope(scopeManager, this);
-    }
-
-    __shouldStaticallyClose(scopeManager) {
-        return (!this.dynamic || scopeManager.__isOptimistic());
-    }
-
-    __shouldStaticallyCloseForGlobal(ref) {
-
-        // On global scope, let/const/class declarations should be resolved statically.
-        const name = ref.identifier.name;
-
-        if (!this.set.has(name)) {
-            return false;
-        }
-
-        const variable = this.set.get(name);
-        const defs = variable.defs;
-
-        return defs.length > 0 && defs.every(shouldBeStatically);
-    }
-
-    __staticCloseRef(ref) {
-        if (!this.__resolve(ref)) {
-            this.__delegateToUpperScope(ref);
-        }
-    }
-
-    __dynamicCloseRef(ref) {
-
-        // notify all names are through to global
-        let current = this;
-
-        do {
-            current.through.push(ref);
-            current = current.upper;
-        } while (current);
-    }
-
-    __globalCloseRef(ref) {
-
-        // let/const/class declarations should be resolved statically.
-        // others should be resolved dynamically.
-        if (this.__shouldStaticallyCloseForGlobal(ref)) {
-            this.__staticCloseRef(ref);
-        } else {
-            this.__dynamicCloseRef(ref);
-        }
-    }
-
-    __close(scopeManager) {
-        let closeRef;
-
-        if (this.__shouldStaticallyClose(scopeManager)) {
-            closeRef = this.__staticCloseRef;
-        } else if (this.type !== "global") {
-            closeRef = this.__dynamicCloseRef;
-        } else {
-            closeRef = this.__globalCloseRef;
-        }
-
-        // Try Resolving all references in this scope.
-        for (let i = 0, iz = this.__left.length; i < iz; ++i) {
-            const ref = this.__left[i];
-
-            closeRef.call(this, ref);
-        }
-        this.__left = null;
-
-        return this.upper;
-    }
-
-    // To override by function scopes.
-    // References in default parameters isn't resolved to variables which are in their function body.
-    __isValidResolution(ref, variable) { // eslint-disable-line class-methods-use-this, no-unused-vars  -- Desired as instance method with signature
-        return true;
-    }
-
-    __resolve(ref) {
-        const name = ref.identifier.name;
-
-        if (!this.set.has(name)) {
-            return false;
-        }
-        const variable = this.set.get(name);
-
-        if (!this.__isValidResolution(ref, variable)) {
-            return false;
-        }
-        variable.references.push(ref);
-        variable.stack = variable.stack && ref.from.variableScope === this.variableScope;
-        if (ref.tainted) {
-            variable.tainted = true;
-            this.taints.set(variable.name, true);
-        }
-        ref.resolved = variable;
-
-        return true;
-    }
-
-    __delegateToUpperScope(ref) {
-        if (this.upper) {
-            this.upper.__left.push(ref);
-        }
-        this.through.push(ref);
-    }
-
-    __addDeclaredVariablesOfNode(variable, node) {
-        if (node === null || node === void 0) {
-            return;
-        }
-
-        let variables = this.__declaredVariables.get(node);
-
-        if (variables === null || variables === void 0) {
-            variables = [];
-            this.__declaredVariables.set(node, variables);
-        }
-        if (!variables.includes(variable)) {
-            variables.push(variable);
-        }
-    }
-
-    __defineGeneric(name, set, variables, node, def) {
-        let variable;
-
-        variable = set.get(name);
-        if (!variable) {
-            variable = new Variable(name, this);
-            set.set(name, variable);
-            variables.push(variable);
-        }
-
-        if (def) {
-            variable.defs.push(def);
-            this.__addDeclaredVariablesOfNode(variable, def.node);
-            this.__addDeclaredVariablesOfNode(variable, def.parent);
-        }
-        if (node) {
-            variable.identifiers.push(node);
-        }
-    }
-
-    __define(node, def) {
-        if (node && node.type === Syntax$2.Identifier) {
-            this.__defineGeneric(
-                node.name,
-                this.set,
-                this.variables,
-                node,
-                def
-            );
-        }
-    }
-
-    __referencing(node, assign, writeExpr, maybeImplicitGlobal, partial, init) {
-
-        // because Array element may be null
-        if (!node || (node.type !== Syntax$2.Identifier && node.type !== "JSXIdentifier")) {
-            return;
-        }
-
-        // Specially handle like `this`.
-        if (node.name === "super") {
-            return;
-        }
-
-        const ref = new Reference(node, this, assign || Reference.READ, writeExpr, maybeImplicitGlobal, !!partial, !!init);
-
-        this.references.push(ref);
-        this.__left.push(ref);
-    }
-
-    __detectEval() {
-        let current = this;
-
-        this.directCallToEvalScope = true;
-        do {
-            current.dynamic = true;
-            current = current.upper;
-        } while (current);
-    }
-
-    __detectThis() {
-        this.thisFound = true;
-    }
-
-    __isClosed() {
-        return this.__left === null;
-    }
-
-    /**
-     * returns resolved {Reference}
-     * @function Scope#resolve
-     * @param {Espree.Identifier} ident identifier to be resolved.
-     * @returns {Reference} reference
-     */
-    resolve(ident) {
-        let ref, i, iz;
-
-        assert(this.__isClosed(), "Scope should be closed.");
-        assert(ident.type === Syntax$2.Identifier, "Target should be identifier.");
-        for (i = 0, iz = this.references.length; i < iz; ++i) {
-            ref = this.references[i];
-            if (ref.identifier === ident) {
-                return ref;
-            }
-        }
-        return null;
-    }
-
-    /**
-     * returns this scope is static
-     * @function Scope#isStatic
-     * @returns {boolean} static
-     */
-    isStatic() {
-        return !this.dynamic;
-    }
-
-    /**
-     * returns this scope has materialized arguments
-     * @function Scope#isArgumentsMaterialized
-     * @returns {boolean} arguemnts materialized
-     */
-    isArgumentsMaterialized() { // eslint-disable-line class-methods-use-this -- Desired as instance method
-        return true;
-    }
-
-    /**
-     * returns this scope has materialized `this` reference
-     * @function Scope#isThisMaterialized
-     * @returns {boolean} this materialized
-     */
-    isThisMaterialized() { // eslint-disable-line class-methods-use-this -- Desired as instance method
-        return true;
-    }
-
-    isUsedName(name) {
-        if (this.set.has(name)) {
-            return true;
-        }
-        for (let i = 0, iz = this.through.length; i < iz; ++i) {
-            if (this.through[i].identifier.name === name) {
-                return true;
-            }
-        }
-        return false;
-    }
-}
-
-/**
- * Global scope.
- */
-class GlobalScope extends Scope {
-    constructor(scopeManager, block) {
-        super(scopeManager, "global", null, block, false);
-        this.implicit = {
-            set: new Map(),
-            variables: [],
-
-            /**
-             * List of {@link Reference}s that are left to be resolved (i.e. which
-             * need to be linked to the variable they refer to).
-             * @member {Reference[]} Scope#implicit#left
-             */
-            left: []
-        };
-    }
-
-    __close(scopeManager) {
-        const implicit = [];
-
-        for (let i = 0, iz = this.__left.length; i < iz; ++i) {
-            const ref = this.__left[i];
-
-            if (ref.__maybeImplicitGlobal && !this.set.has(ref.identifier.name)) {
-                implicit.push(ref.__maybeImplicitGlobal);
-            }
-        }
-
-        // create an implicit global variable from assignment expression
-        for (let i = 0, iz = implicit.length; i < iz; ++i) {
-            const info = implicit[i];
-
-            this.__defineImplicit(info.pattern,
-                new Definition(
-                    Variable.ImplicitGlobalVariable,
-                    info.pattern,
-                    info.node,
-                    null,
-                    null,
-                    null
-                ));
-
-        }
-
-        this.implicit.left = this.__left;
-
-        return super.__close(scopeManager);
-    }
-
-    __defineImplicit(node, def) {
-        if (node && node.type === Syntax$2.Identifier) {
-            this.__defineGeneric(
-                node.name,
-                this.implicit.set,
-                this.implicit.variables,
-                node,
-                def
-            );
-        }
-    }
-}
-
-/**
- * Module scope.
- */
-class ModuleScope extends Scope {
-    constructor(scopeManager, upperScope, block) {
-        super(scopeManager, "module", upperScope, block, false);
-    }
-}
-
-/**
- * Function expression name scope.
- */
-class FunctionExpressionNameScope extends Scope {
-    constructor(scopeManager, upperScope, block) {
-        super(scopeManager, "function-expression-name", upperScope, block, false);
-        this.__define(block.id,
-            new Definition(
-                Variable.FunctionName,
-                block.id,
-                block,
-                null,
-                null,
-                null
-            ));
-        this.functionExpressionScope = true;
-    }
-}
-
-/**
- * Catch scope.
- */
-class CatchScope extends Scope {
-    constructor(scopeManager, upperScope, block) {
-        super(scopeManager, "catch", upperScope, block, false);
-    }
-}
-
-/**
- * With statement scope.
- */
-class WithScope extends Scope {
-    constructor(scopeManager, upperScope, block) {
-        super(scopeManager, "with", upperScope, block, false);
-    }
-
-    __close(scopeManager) {
-        if (this.__shouldStaticallyClose(scopeManager)) {
-            return super.__close(scopeManager);
-        }
-
-        for (let i = 0, iz = this.__left.length; i < iz; ++i) {
-            const ref = this.__left[i];
-
-            ref.tainted = true;
-            this.__delegateToUpperScope(ref);
-        }
-        this.__left = null;
-
-        return this.upper;
-    }
-}
-
-/**
- * Block scope.
- */
-class BlockScope extends Scope {
-    constructor(scopeManager, upperScope, block) {
-        super(scopeManager, "block", upperScope, block, false);
-    }
-}
-
-/**
- * Switch scope.
- */
-class SwitchScope extends Scope {
-    constructor(scopeManager, upperScope, block) {
-        super(scopeManager, "switch", upperScope, block, false);
-    }
-}
-
-/**
- * Function scope.
- */
-class FunctionScope extends Scope {
-    constructor(scopeManager, upperScope, block, isMethodDefinition) {
-        super(scopeManager, "function", upperScope, block, isMethodDefinition);
-
-        // section 9.2.13, FunctionDeclarationInstantiation.
-        // NOTE Arrow functions never have an arguments objects.
-        if (this.block.type !== Syntax$2.ArrowFunctionExpression) {
-            this.__defineArguments();
-        }
-    }
-
-    isArgumentsMaterialized() {
-
-        // TODO(Constellation)
-        // We can more aggressive on this condition like this.
-        //
-        // function t() {
-        //     // arguments of t is always hidden.
-        //     function arguments() {
-        //     }
-        // }
-        if (this.block.type === Syntax$2.ArrowFunctionExpression) {
-            return false;
-        }
-
-        if (!this.isStatic()) {
-            return true;
-        }
-
-        const variable = this.set.get("arguments");
-
-        assert(variable, "Always have arguments variable.");
-        return variable.tainted || variable.references.length !== 0;
-    }
-
-    isThisMaterialized() {
-        if (!this.isStatic()) {
-            return true;
-        }
-        return this.thisFound;
-    }
-
-    __defineArguments() {
-        this.__defineGeneric(
-            "arguments",
-            this.set,
-            this.variables,
-            null,
-            null
-        );
-        this.taints.set("arguments", true);
-    }
-
-    // References in default parameters isn't resolved to variables which are in their function body.
-    //     const x = 1
-    //     function f(a = x) { // This `x` is resolved to the `x` in the outer scope.
-    //         const x = 2
-    //         console.log(a)
-    //     }
-    __isValidResolution(ref, variable) {
-
-        // If `options.nodejsScope` is true, `this.block` becomes a Program node.
-        if (this.block.type === "Program") {
-            return true;
-        }
-
-        const bodyStart = this.block.body.range[0];
-
-        // It's invalid resolution in the following case:
-        return !(
-            variable.scope === this &&
-            ref.identifier.range[0] < bodyStart && // the reference is in the parameter part.
-            variable.defs.every(d => d.name.range[0] >= bodyStart) // the variable is in the body.
-        );
-    }
-}
-
-/**
- * Scope of for, for-in, and for-of statements.
- */
-class ForScope extends Scope {
-    constructor(scopeManager, upperScope, block) {
-        super(scopeManager, "for", upperScope, block, false);
-    }
-}
-
-/**
- * Class scope.
- */
-class ClassScope extends Scope {
-    constructor(scopeManager, upperScope, block) {
-        super(scopeManager, "class", upperScope, block, false);
-    }
-}
-
-/**
- * Class field initializer scope.
- */
-class ClassFieldInitializerScope extends Scope {
-    constructor(scopeManager, upperScope, block) {
-        super(scopeManager, "class-field-initializer", upperScope, block, true);
-    }
-}
-
-/**
- * Class static block scope.
- */
-class ClassStaticBlockScope extends Scope {
-    constructor(scopeManager, upperScope, block) {
-        super(scopeManager, "class-static-block", upperScope, block, true);
-    }
-}
-
-/* vim: set sw=4 ts=4 et tw=80 : */
-
-/*
-  Copyright (C) 2015 Yusuke Suzuki <utatane.tea@gmail.com>
-
-  Redistribution and use in source and binary forms, with or without
-  modification, are permitted provided that the following conditions are met:
-
-    * Redistributions of source code must retain the above copyright
-      notice, this list of conditions and the following disclaimer.
-    * Redistributions in binary form must reproduce the above copyright
-      notice, this list of conditions and the following disclaimer in the
-      documentation and/or other materials provided with the distribution.
-
-  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
-  AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
-  IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
-  ARE DISCLAIMED. IN NO EVENT SHALL <COPYRIGHT HOLDER> BE LIABLE FOR ANY
-  DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-  (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-  ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
-  THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-*/
-
-/**
- * @constructor ScopeManager
- */
-class ScopeManager {
-    constructor(options) {
-        this.scopes = [];
-        this.globalScope = null;
-        this.__nodeToScope = new WeakMap();
-        this.__currentScope = null;
-        this.__options = options;
-        this.__declaredVariables = new WeakMap();
-    }
-
-    __isOptimistic() {
-        return this.__options.optimistic;
-    }
-
-    __ignoreEval() {
-        return this.__options.ignoreEval;
-    }
-
-    __isJSXEnabled() {
-        return this.__options.jsx === true;
-    }
-
-    isGlobalReturn() {
-        return this.__options.nodejsScope || this.__options.sourceType === "commonjs";
-    }
-
-    isModule() {
-        return this.__options.sourceType === "module";
-    }
-
-    isImpliedStrict() {
-        return this.__options.impliedStrict;
-    }
-
-    isStrictModeSupported() {
-        return this.__options.ecmaVersion >= 5;
-    }
-
-    // Returns appropriate scope for this node.
-    __get(node) {
-        return this.__nodeToScope.get(node);
-    }
-
-    /**
-     * Get variables that are declared by the node.
-     *
-     * "are declared by the node" means the node is same as `Variable.defs[].node` or `Variable.defs[].parent`.
-     * If the node declares nothing, this method returns an empty array.
-     * CAUTION: This API is experimental. See https://github.com/estools/escope/pull/69 for more details.
-     * @param {Espree.Node} node a node to get.
-     * @returns {Variable[]} variables that declared by the node.
-     */
-    getDeclaredVariables(node) {
-        return this.__declaredVariables.get(node) || [];
-    }
-
-    /**
-     * acquire scope from node.
-     * @function ScopeManager#acquire
-     * @param {Espree.Node} node node for the acquired scope.
-     * @param {?boolean} [inner=false] look up the most inner scope, default value is false.
-     * @returns {Scope?} Scope from node
-     */
-    acquire(node, inner) {
-
-        /**
-         * predicate
-         * @param {Scope} testScope scope to test
-         * @returns {boolean} predicate
-         */
-        function predicate(testScope) {
-            if (testScope.type === "function" && testScope.functionExpressionScope) {
-                return false;
-            }
-            return true;
-        }
-
-        const scopes = this.__get(node);
-
-        if (!scopes || scopes.length === 0) {
-            return null;
-        }
-
-        // Heuristic selection from all scopes.
-        // If you would like to get all scopes, please use ScopeManager#acquireAll.
-        if (scopes.length === 1) {
-            return scopes[0];
-        }
-
-        if (inner) {
-            for (let i = scopes.length - 1; i >= 0; --i) {
-                const scope = scopes[i];
-
-                if (predicate(scope)) {
-                    return scope;
-                }
-            }
-        } else {
-            for (let i = 0, iz = scopes.length; i < iz; ++i) {
-                const scope = scopes[i];
-
-                if (predicate(scope)) {
-                    return scope;
-                }
-            }
-        }
-
-        return null;
-    }
-
-    /**
-     * acquire all scopes from node.
-     * @function ScopeManager#acquireAll
-     * @param {Espree.Node} node node for the acquired scope.
-     * @returns {Scopes?} Scope array
-     */
-    acquireAll(node) {
-        return this.__get(node);
-    }
-
-    /**
-     * release the node.
-     * @function ScopeManager#release
-     * @param {Espree.Node} node releasing node.
-     * @param {?boolean} [inner=false] look up the most inner scope, default value is false.
-     * @returns {Scope?} upper scope for the node.
-     */
-    release(node, inner) {
-        const scopes = this.__get(node);
-
-        if (scopes && scopes.length) {
-            const scope = scopes[0].upper;
-
-            if (!scope) {
-                return null;
-            }
-            return this.acquire(scope.block, inner);
-        }
-        return null;
-    }
-
-    attach() { } // eslint-disable-line class-methods-use-this -- Desired as instance method
-
-    detach() { } // eslint-disable-line class-methods-use-this -- Desired as instance method
-
-    __nestScope(scope) {
-        if (scope instanceof GlobalScope) {
-            assert(this.__currentScope === null);
-            this.globalScope = scope;
-        }
-        this.__currentScope = scope;
-        return scope;
-    }
-
-    __nestGlobalScope(node) {
-        return this.__nestScope(new GlobalScope(this, node));
-    }
-
-    __nestBlockScope(node) {
-        return this.__nestScope(new BlockScope(this, this.__currentScope, node));
-    }
-
-    __nestFunctionScope(node, isMethodDefinition) {
-        return this.__nestScope(new FunctionScope(this, this.__currentScope, node, isMethodDefinition));
-    }
-
-    __nestForScope(node) {
-        return this.__nestScope(new ForScope(this, this.__currentScope, node));
-    }
-
-    __nestCatchScope(node) {
-        return this.__nestScope(new CatchScope(this, this.__currentScope, node));
-    }
-
-    __nestWithScope(node) {
-        return this.__nestScope(new WithScope(this, this.__currentScope, node));
-    }
-
-    __nestClassScope(node) {
-        return this.__nestScope(new ClassScope(this, this.__currentScope, node));
-    }
-
-    __nestClassFieldInitializerScope(node) {
-        return this.__nestScope(new ClassFieldInitializerScope(this, this.__currentScope, node));
-    }
-
-    __nestClassStaticBlockScope(node) {
-        return this.__nestScope(new ClassStaticBlockScope(this, this.__currentScope, node));
-    }
-
-    __nestSwitchScope(node) {
-        return this.__nestScope(new SwitchScope(this, this.__currentScope, node));
-    }
-
-    __nestModuleScope(node) {
-        return this.__nestScope(new ModuleScope(this, this.__currentScope, node));
-    }
-
-    __nestFunctionExpressionNameScope(node) {
-        return this.__nestScope(new FunctionExpressionNameScope(this, this.__currentScope, node));
-    }
-
-    __isES6() {
-        return this.__options.ecmaVersion >= 6;
-    }
-}
-
-/* vim: set sw=4 ts=4 et tw=80 : */
-
-/*
-  Copyright (C) 2015 Yusuke Suzuki <utatane.tea@gmail.com>
-
-  Redistribution and use in source and binary forms, with or without
-  modification, are permitted provided that the following conditions are met:
-
-    * Redistributions of source code must retain the above copyright
-      notice, this list of conditions and the following disclaimer.
-    * Redistributions in binary form must reproduce the above copyright
-      notice, this list of conditions and the following disclaimer in the
-      documentation and/or other materials provided with the distribution.
-
-  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
-  AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
-  IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
-  ARE DISCLAIMED. IN NO EVENT SHALL <COPYRIGHT HOLDER> BE LIABLE FOR ANY
-  DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-  (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-  ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
-  THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-*/
-
-const { Syntax: Syntax$1 } = estraverse__default["default"];
-
-/**
- * Get last array element
- * @param {Array} xs array
- * @returns {any} Last elment
- */
-function getLast(xs) {
-    return xs.at(-1) || null;
-}
-
-/**
- * Visitor for destructuring patterns.
- */
-class PatternVisitor extends esrecurse__default["default"].Visitor {
-    static isPattern(node) {
-        const nodeType = node.type;
-
-        return (
-            nodeType === Syntax$1.Identifier ||
-            nodeType === Syntax$1.ObjectPattern ||
-            nodeType === Syntax$1.ArrayPattern ||
-            nodeType === Syntax$1.SpreadElement ||
-            nodeType === Syntax$1.RestElement ||
-            nodeType === Syntax$1.AssignmentPattern
-        );
-    }
-
-    constructor(options, rootPattern, callback) {
-        super(null, options);
-        this.rootPattern = rootPattern;
-        this.callback = callback;
-        this.assignments = [];
-        this.rightHandNodes = [];
-        this.restElements = [];
-    }
-
-    Identifier(pattern) {
-        const lastRestElement = getLast(this.restElements);
-
-        this.callback(pattern, {
-            topLevel: pattern === this.rootPattern,
-            rest: lastRestElement !== null && lastRestElement !== void 0 && lastRestElement.argument === pattern,
-            assignments: this.assignments
-        });
-    }
-
-    Property(property) {
-
-        // Computed property's key is a right hand node.
-        if (property.computed) {
-            this.rightHandNodes.push(property.key);
-        }
-
-        // If it's shorthand, its key is same as its value.
-        // If it's shorthand and has its default value, its key is same as its value.left (the value is AssignmentPattern).
-        // If it's not shorthand, the name of new variable is its value's.
-        this.visit(property.value);
-    }
-
-    ArrayPattern(pattern) {
-        for (let i = 0, iz = pattern.elements.length; i < iz; ++i) {
-            const element = pattern.elements[i];
-
-            this.visit(element);
-        }
-    }
-
-    AssignmentPattern(pattern) {
-        this.assignments.push(pattern);
-        this.visit(pattern.left);
-        this.rightHandNodes.push(pattern.right);
-        this.assignments.pop();
-    }
-
-    RestElement(pattern) {
-        this.restElements.push(pattern);
-        this.visit(pattern.argument);
-        this.restElements.pop();
-    }
-
-    MemberExpression(node) {
-
-        // Computed property's key is a right hand node.
-        if (node.computed) {
-            this.rightHandNodes.push(node.property);
-        }
-
-        // the object is only read, write to its property.
-        this.rightHandNodes.push(node.object);
-    }
-
-    //
-    // ForInStatement.left and AssignmentExpression.left are LeftHandSideExpression.
-    // By spec, LeftHandSideExpression is Pattern or MemberExpression.
-    //   (see also: https://github.com/estree/estree/pull/20#issuecomment-74584758)
-    // But espree 2.0 parses to ArrayExpression, ObjectExpression, etc...
-    //
-
-    SpreadElement(node) {
-        this.visit(node.argument);
-    }
-
-    ArrayExpression(node) {
-        node.elements.forEach(this.visit, this);
-    }
-
-    AssignmentExpression(node) {
-        this.assignments.push(node);
-        this.visit(node.left);
-        this.rightHandNodes.push(node.right);
-        this.assignments.pop();
-    }
-
-    CallExpression(node) {
-
-        // arguments are right hand nodes.
-        node.arguments.forEach(a => {
-            this.rightHandNodes.push(a);
-        });
-        this.visit(node.callee);
-    }
-}
-
-/* vim: set sw=4 ts=4 et tw=80 : */
-
-/*
-  Copyright (C) 2015 Yusuke Suzuki <utatane.tea@gmail.com>
-
-  Redistribution and use in source and binary forms, with or without
-  modification, are permitted provided that the following conditions are met:
-
-    * Redistributions of source code must retain the above copyright
-      notice, this list of conditions and the following disclaimer.
-    * Redistributions in binary form must reproduce the above copyright
-      notice, this list of conditions and the following disclaimer in the
-      documentation and/or other materials provided with the distribution.
-
-  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
-  AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
-  IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
-  ARE DISCLAIMED. IN NO EVENT SHALL <COPYRIGHT HOLDER> BE LIABLE FOR ANY
-  DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-  (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-  ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
-  THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-*/
-
-const { Syntax } = estraverse__default["default"];
-
-/**
- * Traverse identifier in pattern
- * @param {Object} options options
- * @param {pattern} rootPattern root pattern
- * @param {Refencer} referencer referencer
- * @param {callback} callback callback
- * @returns {void}
- */
-function traverseIdentifierInPattern(options, rootPattern, referencer, callback) {
-
-    // Call the callback at left hand identifier nodes, and Collect right hand nodes.
-    const visitor = new PatternVisitor(options, rootPattern, callback);
-
-    visitor.visit(rootPattern);
-
-    // Process the right hand nodes recursively.
-    if (referencer !== null && referencer !== void 0) {
-        visitor.rightHandNodes.forEach(referencer.visit, referencer);
-    }
-}
-
-// Importing ImportDeclaration.
-// http://people.mozilla.org/~jorendorff/es6-draft.html#sec-moduledeclarationinstantiation
-// https://github.com/estree/estree/blob/master/es6.md#importdeclaration
-// FIXME: Now, we don't create module environment, because the context is
-// implementation dependent.
-
-/**
- * Visitor for import specifiers.
- */
-class Importer extends esrecurse__default["default"].Visitor {
-    constructor(declaration, referencer) {
-        super(null, referencer.options);
-        this.declaration = declaration;
-        this.referencer = referencer;
-    }
-
-    visitImport(id, specifier) {
-        this.referencer.visitPattern(id, pattern => {
-            this.referencer.currentScope().__define(pattern,
-                new Definition(
-                    Variable.ImportBinding,
-                    pattern,
-                    specifier,
-                    this.declaration,
-                    null,
-                    null
-                ));
-        });
-    }
-
-    ImportNamespaceSpecifier(node) {
-        const local = (node.local || node.id);
-
-        if (local) {
-            this.visitImport(local, node);
-        }
-    }
-
-    ImportDefaultSpecifier(node) {
-        const local = (node.local || node.id);
-
-        this.visitImport(local, node);
-    }
-
-    ImportSpecifier(node) {
-        const local = (node.local || node.id);
-
-        if (node.name) {
-            this.visitImport(node.name, node);
-        } else {
-            this.visitImport(local, node);
-        }
-    }
-}
-
-/**
- * Referencing variables and creating bindings.
- */
-class Referencer extends esrecurse__default["default"].Visitor {
-    constructor(options, scopeManager) {
-        super(null, options);
-        this.options = options;
-        this.scopeManager = scopeManager;
-        this.parent = null;
-        this.isInnerMethodDefinition = false;
-    }
-
-    currentScope() {
-        return this.scopeManager.__currentScope;
-    }
-
-    close(node) {
-        while (this.currentScope() && node === this.currentScope().block) {
-            this.scopeManager.__currentScope = this.currentScope().__close(this.scopeManager);
-        }
-    }
-
-    pushInnerMethodDefinition(isInnerMethodDefinition) {
-        const previous = this.isInnerMethodDefinition;
-
-        this.isInnerMethodDefinition = isInnerMethodDefinition;
-        return previous;
-    }
-
-    popInnerMethodDefinition(isInnerMethodDefinition) {
-        this.isInnerMethodDefinition = isInnerMethodDefinition;
-    }
-
-    referencingDefaultValue(pattern, assignments, maybeImplicitGlobal, init) {
-        const scope = this.currentScope();
-
-        assignments.forEach(assignment => {
-            scope.__referencing(
-                pattern,
-                Reference.WRITE,
-                assignment.right,
-                maybeImplicitGlobal,
-                pattern !== assignment.left,
-                init
-            );
-        });
-    }
-
-    visitPattern(node, options, callback) {
-        let visitPatternOptions = options;
-        let visitPatternCallback = callback;
-
-        if (typeof options === "function") {
-            visitPatternCallback = options;
-            visitPatternOptions = { processRightHandNodes: false };
-        }
-
-        traverseIdentifierInPattern(
-            this.options,
-            node,
-            visitPatternOptions.processRightHandNodes ? this : null,
-            visitPatternCallback
-        );
-    }
-
-    visitFunction(node) {
-        let i, iz;
-
-        // FunctionDeclaration name is defined in upper scope
-        // NOTE: Not referring variableScope. It is intended.
-        // Since
-        //  in ES5, FunctionDeclaration should be in FunctionBody.
-        //  in ES6, FunctionDeclaration should be block scoped.
-
-        if (node.type === Syntax.FunctionDeclaration) {
-
-            // id is defined in upper scope
-            this.currentScope().__define(node.id,
-                new Definition(
-                    Variable.FunctionName,
-                    node.id,
-                    node,
-                    null,
-                    null,
-                    null
-                ));
-        }
-
-        // FunctionExpression with name creates its special scope;
-        // FunctionExpressionNameScope.
-        if (node.type === Syntax.FunctionExpression && node.id) {
-            this.scopeManager.__nestFunctionExpressionNameScope(node);
-        }
-
-        // Consider this function is in the MethodDefinition.
-        this.scopeManager.__nestFunctionScope(node, this.isInnerMethodDefinition);
-
-        const that = this;
-
-        /**
-         * Visit pattern callback
-         * @param {pattern} pattern pattern
-         * @param {Object} info info
-         * @returns {void}
-         */
-        function visitPatternCallback(pattern, info) {
-            that.currentScope().__define(pattern,
-                new ParameterDefinition(
-                    pattern,
-                    node,
-                    i,
-                    info.rest
-                ));
-
-            that.referencingDefaultValue(pattern, info.assignments, null, true);
-        }
-
-        // Process parameter declarations.
-        for (i = 0, iz = node.params.length; i < iz; ++i) {
-            this.visitPattern(node.params[i], { processRightHandNodes: true }, visitPatternCallback);
-        }
-
-        // if there's a rest argument, add that
-        if (node.rest) {
-            this.visitPattern({
-                type: "RestElement",
-                argument: node.rest
-            }, pattern => {
-                this.currentScope().__define(pattern,
-                    new ParameterDefinition(
-                        pattern,
-                        node,
-                        node.params.length,
-                        true
-                    ));
-            });
-        }
-
-        // In TypeScript there are a number of function-like constructs which have no body,
-        // so check it exists before traversing
-        if (node.body) {
-
-            // Skip BlockStatement to prevent creating BlockStatement scope.
-            if (node.body.type === Syntax.BlockStatement) {
-                this.visitChildren(node.body);
-            } else {
-                this.visit(node.body);
-            }
-        }
-
-        this.close(node);
-    }
-
-    visitClass(node) {
-        if (node.type === Syntax.ClassDeclaration) {
-            this.currentScope().__define(node.id,
-                new Definition(
-                    Variable.ClassName,
-                    node.id,
-                    node,
-                    null,
-                    null,
-                    null
-                ));
-        }
-
-        this.scopeManager.__nestClassScope(node);
-
-        if (node.id) {
-            this.currentScope().__define(node.id,
-                new Definition(
-                    Variable.ClassName,
-                    node.id,
-                    node
-                ));
-        }
-
-        this.visit(node.superClass);
-        this.visit(node.body);
-
-        this.close(node);
-    }
-
-    visitProperty(node) {
-        let previous;
-
-        if (node.computed) {
-            this.visit(node.key);
-        }
-
-        const isMethodDefinition = node.type === Syntax.MethodDefinition;
-
-        if (isMethodDefinition) {
-            previous = this.pushInnerMethodDefinition(true);
-        }
-        this.visit(node.value);
-        if (isMethodDefinition) {
-            this.popInnerMethodDefinition(previous);
-        }
-    }
-
-    visitForIn(node) {
-        if (node.left.type === Syntax.VariableDeclaration && node.left.kind !== "var") {
-            this.scopeManager.__nestForScope(node);
-        }
-
-        if (node.left.type === Syntax.VariableDeclaration) {
-            this.visit(node.left);
-            this.visitPattern(node.left.declarations[0].id, pattern => {
-                this.currentScope().__referencing(pattern, Reference.WRITE, node.right, null, true, true);
-            });
-        } else {
-            this.visitPattern(node.left, { processRightHandNodes: true }, (pattern, info) => {
-                let maybeImplicitGlobal = null;
-
-                if (!this.currentScope().isStrict) {
-                    maybeImplicitGlobal = {
-                        pattern,
-                        node
-                    };
-                }
-                this.referencingDefaultValue(pattern, info.assignments, maybeImplicitGlobal, false);
-                this.currentScope().__referencing(pattern, Reference.WRITE, node.right, maybeImplicitGlobal, true, false);
-            });
-        }
-        this.visit(node.right);
-        this.visit(node.body);
-
-        this.close(node);
-    }
-
-    visitVariableDeclaration(variableTargetScope, type, node, index) {
-
-        const decl = node.declarations[index];
-        const init = decl.init;
-
-        this.visitPattern(decl.id, { processRightHandNodes: true }, (pattern, info) => {
-            variableTargetScope.__define(
-                pattern,
-                new Definition(
-                    type,
-                    pattern,
-                    decl,
-                    node,
-                    index,
-                    node.kind
-                )
-            );
-
-            this.referencingDefaultValue(pattern, info.assignments, null, true);
-            if (init) {
-                this.currentScope().__referencing(pattern, Reference.WRITE, init, null, !info.topLevel, true);
-            }
-        });
-    }
-
-    AssignmentExpression(node) {
-        if (PatternVisitor.isPattern(node.left)) {
-            if (node.operator === "=") {
-                this.visitPattern(node.left, { processRightHandNodes: true }, (pattern, info) => {
-                    let maybeImplicitGlobal = null;
-
-                    if (!this.currentScope().isStrict) {
-                        maybeImplicitGlobal = {
-                            pattern,
-                            node
-                        };
-                    }
-                    this.referencingDefaultValue(pattern, info.assignments, maybeImplicitGlobal, false);
-                    this.currentScope().__referencing(pattern, Reference.WRITE, node.right, maybeImplicitGlobal, !info.topLevel, false);
-                });
-            } else {
-                this.currentScope().__referencing(node.left, Reference.RW, node.right);
-            }
-        } else {
-            this.visit(node.left);
-        }
-        this.visit(node.right);
-    }
-
-    CatchClause(node) {
-        this.scopeManager.__nestCatchScope(node);
-
-        this.visitPattern(node.param, { processRightHandNodes: true }, (pattern, info) => {
-            this.currentScope().__define(pattern,
-                new Definition(
-                    Variable.CatchClause,
-                    pattern,
-                    node,
-                    null,
-                    null,
-                    null
-                ));
-            this.referencingDefaultValue(pattern, info.assignments, null, true);
-        });
-        this.visit(node.body);
-
-        this.close(node);
-    }
-
-    Program(node) {
-        this.scopeManager.__nestGlobalScope(node);
-
-        if (this.scopeManager.isGlobalReturn()) {
-
-            // Force strictness of GlobalScope to false when using node.js scope.
-            this.currentScope().isStrict = false;
-            this.scopeManager.__nestFunctionScope(node, false);
-        }
-
-        if (this.scopeManager.__isES6() && this.scopeManager.isModule()) {
-            this.scopeManager.__nestModuleScope(node);
-        }
-
-        if (this.scopeManager.isStrictModeSupported() && this.scopeManager.isImpliedStrict()) {
-            this.currentScope().isStrict = true;
-        }
-
-        this.visitChildren(node);
-        this.close(node);
-    }
-
-    Identifier(node) {
-        this.currentScope().__referencing(node);
-    }
-
-    // eslint-disable-next-line class-methods-use-this -- Desired as instance method
-    PrivateIdentifier() {
-
-        // Do nothing.
-    }
-
-    UpdateExpression(node) {
-        if (PatternVisitor.isPattern(node.argument)) {
-            this.currentScope().__referencing(node.argument, Reference.RW, null);
-        } else {
-            this.visitChildren(node);
-        }
-    }
-
-    MemberExpression(node) {
-        this.visit(node.object);
-        if (node.computed) {
-            this.visit(node.property);
-        }
-    }
-
-    Property(node) {
-        this.visitProperty(node);
-    }
-
-    PropertyDefinition(node) {
-        const { computed, key, value } = node;
-
-        if (computed) {
-            this.visit(key);
-        }
-        if (value) {
-            this.scopeManager.__nestClassFieldInitializerScope(value);
-            this.visit(value);
-            this.close(value);
-        }
-    }
-
-    StaticBlock(node) {
-        this.scopeManager.__nestClassStaticBlockScope(node);
-
-        this.visitChildren(node);
-
-        this.close(node);
-    }
-
-    MethodDefinition(node) {
-        this.visitProperty(node);
-    }
-
-    BreakStatement() {} // eslint-disable-line class-methods-use-this -- Desired as instance method
-
-    ContinueStatement() {} // eslint-disable-line class-methods-use-this -- Desired as instance method
-
-    LabeledStatement(node) {
-        this.visit(node.body);
-    }
-
-    ForStatement(node) {
-
-        // Create ForStatement declaration.
-        // NOTE: In ES6, ForStatement dynamically generates
-        // per iteration environment. However, escope is
-        // a static analyzer, we only generate one scope for ForStatement.
-        if (node.init && node.init.type === Syntax.VariableDeclaration && node.init.kind !== "var") {
-            this.scopeManager.__nestForScope(node);
-        }
-
-        this.visitChildren(node);
-
-        this.close(node);
-    }
-
-    ClassExpression(node) {
-        this.visitClass(node);
-    }
-
-    ClassDeclaration(node) {
-        this.visitClass(node);
-    }
-
-    CallExpression(node) {
-
-        // Check this is direct call to eval
-        if (!this.scopeManager.__ignoreEval() && node.callee.type === Syntax.Identifier && node.callee.name === "eval") {
-
-            // NOTE: This should be `variableScope`. Since direct eval call always creates Lexical environment and
-            // let / const should be enclosed into it. Only VariableDeclaration affects on the caller's environment.
-            this.currentScope().variableScope.__detectEval();
-        }
-        this.visitChildren(node);
-    }
-
-    BlockStatement(node) {
-        if (this.scopeManager.__isES6()) {
-            this.scopeManager.__nestBlockScope(node);
-        }
-
-        this.visitChildren(node);
-
-        this.close(node);
-    }
-
-    ThisExpression() {
-        this.currentScope().variableScope.__detectThis();
-    }
-
-    WithStatement(node) {
-        this.visit(node.object);
-
-        // Then nest scope for WithStatement.
-        this.scopeManager.__nestWithScope(node);
-
-        this.visit(node.body);
-
-        this.close(node);
-    }
-
-    VariableDeclaration(node) {
-        const variableTargetScope = (node.kind === "var") ? this.currentScope().variableScope : this.currentScope();
-
-        for (let i = 0, iz = node.declarations.length; i < iz; ++i) {
-            const decl = node.declarations[i];
-
-            this.visitVariableDeclaration(variableTargetScope, Variable.Variable, node, i);
-            if (decl.init) {
-                this.visit(decl.init);
-            }
-        }
-    }
-
-    // sec 13.11.8
-    SwitchStatement(node) {
-        this.visit(node.discriminant);
-
-        if (this.scopeManager.__isES6()) {
-            this.scopeManager.__nestSwitchScope(node);
-        }
-
-        for (let i = 0, iz = node.cases.length; i < iz; ++i) {
-            this.visit(node.cases[i]);
-        }
-
-        this.close(node);
-    }
-
-    FunctionDeclaration(node) {
-        this.visitFunction(node);
-    }
-
-    FunctionExpression(node) {
-        this.visitFunction(node);
-    }
-
-    ForOfStatement(node) {
-        this.visitForIn(node);
-    }
-
-    ForInStatement(node) {
-        this.visitForIn(node);
-    }
-
-    ArrowFunctionExpression(node) {
-        this.visitFunction(node);
-    }
-
-    ImportDeclaration(node) {
-        assert(this.scopeManager.__isES6() && this.scopeManager.isModule(), "ImportDeclaration should appear when the mode is ES6 and in the module context.");
-
-        const importer = new Importer(node, this);
-
-        importer.visit(node);
-    }
-
-    visitExportDeclaration(node) {
-        if (node.source) {
-            return;
-        }
-        if (node.declaration) {
-            this.visit(node.declaration);
-            return;
-        }
-
-        this.visitChildren(node);
-    }
-
-    // TODO: ExportDeclaration doesn't exist. for bc?
-    ExportDeclaration(node) {
-        this.visitExportDeclaration(node);
-    }
-
-    ExportAllDeclaration(node) {
-        this.visitExportDeclaration(node);
-    }
-
-    ExportDefaultDeclaration(node) {
-        this.visitExportDeclaration(node);
-    }
-
-    ExportNamedDeclaration(node) {
-        this.visitExportDeclaration(node);
-    }
-
-    ExportSpecifier(node) {
-
-        // TODO: `node.id` doesn't exist. for bc?
-        const local = (node.id || node.local);
-
-        this.visit(local);
-    }
-
-    MetaProperty() { // eslint-disable-line class-methods-use-this -- Desired as instance method
-
-        // do nothing.
-    }
-
-    JSXIdentifier(node) {
-
-        // Special case: "this" should not count as a reference
-        if (this.scopeManager.__isJSXEnabled() && node.name !== "this") {
-            this.currentScope().__referencing(node);
-        }
-    }
-
-    JSXMemberExpression(node) {
-        this.visit(node.object);
-    }
-
-    JSXElement(node) {
-        if (this.scopeManager.__isJSXEnabled()) {
-            this.visit(node.openingElement);
-            node.children.forEach(this.visit, this);
-        } else {
-            this.visitChildren(node);
-        }
-    }
-
-    JSXOpeningElement(node) {
-        if (this.scopeManager.__isJSXEnabled()) {
-
-            const nameNode = node.name;
-            const isComponentName = nameNode.type === "JSXIdentifier" && nameNode.name[0].toUpperCase() === nameNode.name[0];
-            const isComponent = isComponentName || nameNode.type === "JSXMemberExpression";
-
-            // we only want to visit JSXIdentifier nodes if they are capitalized
-            if (isComponent) {
-                this.visit(nameNode);
-            }
-        }
-
-        node.attributes.forEach(this.visit, this);
-    }
-
-    JSXAttribute(node) {
-        if (node.value) {
-            this.visit(node.value);
-        }
-    }
-
-    JSXExpressionContainer(node) {
-        this.visit(node.expression);
-    }
-
-    JSXNamespacedName(node) {
-        this.visit(node.namespace);
-        this.visit(node.name);
-    }
-}
-
-/* vim: set sw=4 ts=4 et tw=80 : */
-
-const version = "8.4.0";
-
-/*
-  Copyright (C) 2012-2014 Yusuke Suzuki <utatane.tea@gmail.com>
-  Copyright (C) 2013 Alex Seville <hi@alexanderseville.com>
-  Copyright (C) 2014 Thiago de Arruda <tpadilha84@gmail.com>
-
-  Redistribution and use in source and binary forms, with or without
-  modification, are permitted provided that the following conditions are met:
-
-    * Redistributions of source code must retain the above copyright
-      notice, this list of conditions and the following disclaimer.
-    * Redistributions in binary form must reproduce the above copyright
-      notice, this list of conditions and the following disclaimer in the
-      documentation and/or other materials provided with the distribution.
-
-  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
-  AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
-  IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
-  ARE DISCLAIMED. IN NO EVENT SHALL <COPYRIGHT HOLDER> BE LIABLE FOR ANY
-  DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-  (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-  ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
-  THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-*/
-
-/**
- * Set the default options
- * @returns {Object} options
- */
-function defaultOptions() {
-    return {
-        optimistic: false,
-        nodejsScope: false,
-        impliedStrict: false,
-        sourceType: "script", // one of ['script', 'module', 'commonjs']
-        ecmaVersion: 5,
-        childVisitorKeys: null,
-        fallback: "iteration"
-    };
-}
-
-/**
- * Preform deep update on option object
- * @param {Object} target Options
- * @param {Object} override Updates
- * @returns {Object} Updated options
- */
-function updateDeeply(target, override) {
-
-    /**
-     * Is hash object
-     * @param {Object} value Test value
-     * @returns {boolean} Result
-     */
-    function isHashObject(value) {
-        return typeof value === "object" && value instanceof Object && !(value instanceof Array) && !(value instanceof RegExp);
-    }
-
-    for (const key in override) {
-        if (Object.hasOwn(override, key)) {
-            const val = override[key];
-
-            if (isHashObject(val)) {
-                if (isHashObject(target[key])) {
-                    updateDeeply(target[key], val);
-                } else {
-                    target[key] = updateDeeply({}, val);
-                }
-            } else {
-                target[key] = val;
-            }
-        }
-    }
-    return target;
-}
-
-/**
- * Main interface function. Takes an Espree syntax tree and returns the
- * analyzed scopes.
- * @function analyze
- * @param {espree.Tree} tree Abstract Syntax Tree
- * @param {Object} providedOptions Options that tailor the scope analysis
- * @param {boolean} [providedOptions.optimistic=false] the optimistic flag
- * @param {boolean} [providedOptions.ignoreEval=false] whether to check 'eval()' calls
- * @param {boolean} [providedOptions.nodejsScope=false] whether the whole
- * script is executed under node.js environment. When enabled, escope adds
- * a function scope immediately following the global scope.
- * @param {boolean} [providedOptions.impliedStrict=false] implied strict mode
- * (if ecmaVersion >= 5).
- * @param {string} [providedOptions.sourceType='script'] the source type of the script. one of 'script', 'module', and 'commonjs'
- * @param {number} [providedOptions.ecmaVersion=5] which ECMAScript version is considered
- * @param {boolean} [providedOptions.jsx=false] support JSX references
- * @param {Object} [providedOptions.childVisitorKeys=null] Additional known visitor keys. See [esrecurse](https://github.com/estools/esrecurse)'s the `childVisitorKeys` option.
- * @param {string} [providedOptions.fallback='iteration'] A kind of the fallback in order to encounter with unknown node. See [esrecurse](https://github.com/estools/esrecurse)'s the `fallback` option.
- * @returns {ScopeManager} ScopeManager
- */
-function analyze(tree, providedOptions) {
-    const options = updateDeeply(defaultOptions(), providedOptions);
-    const scopeManager = new ScopeManager(options);
-    const referencer = new Referencer(options, scopeManager);
-
-    referencer.visit(tree);
-
-    assert(scopeManager.__currentScope === null, "currentScope should be null.");
-
-    return scopeManager;
-}
-
-/* vim: set sw=4 ts=4 et tw=80 : */
-
-exports.Definition = Definition;
-exports.PatternVisitor = PatternVisitor;
-exports.Reference = Reference;
-exports.Referencer = Referencer;
-exports.Scope = Scope;
-exports.ScopeManager = ScopeManager;
-exports.Variable = Variable;
-exports.analyze = analyze;
-exports.version = version;
-//# sourceMappingURL=eslint-scope.cjs.map