@askviraj/linter 1.1.0 → 1.1.2

package/node_modules/eslint-plugin-astro/node_modules/@typescript-eslint/scope-manager/dist/scope/GlobalScope.js

@@ -1,60 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.GlobalScope = void 0;
-const types_1 = require("@typescript-eslint/types");
-const assert_1 = require("../assert");
-const ImplicitGlobalVariableDefinition_1 = require("../definition/ImplicitGlobalVariableDefinition");
-const variable_1 = require("../variable");
-const ScopeBase_1 = require("./ScopeBase");
-const ScopeType_1 = require("./ScopeType");
-class GlobalScope extends ScopeBase_1.ScopeBase {
-    // note this is accessed in used in the legacy eslint-scope tests, so it can't be true private
-    implicit;
-    constructor(scopeManager, block) {
-        super(scopeManager, ScopeType_1.ScopeType.global, null, block, false);
-        this.implicit = {
-            leftToBeResolved: [],
-            set: new Map(),
-            variables: [],
-        };
-    }
-    addVariables(names) {
-        for (const name of names) {
-            this.defineVariable(name, this.set, this.variables, null, null);
-            this.implicit.set.delete(name);
-        }
-        const nameSet = new Set(names);
-        for (const reference of this.through) {
-            if (nameSet.has(reference.identifier.name)) {
-                const variable = this.set.get(reference.identifier.name);
-                (0, assert_1.assert)(variable, `Expected variable with name "${reference.identifier.name}" to be specified.`);
-                reference.resolved = variable;
-                variable.references.push(reference);
-            }
-        }
-        this.through = this.through.filter(reference => !nameSet.has(reference.identifier.name));
-        this.implicit.variables = this.implicit.variables.filter(variable => !nameSet.has(variable.name));
-        this.implicit.leftToBeResolved = this.implicit.leftToBeResolved.filter(reference => !nameSet.has(reference.identifier.name));
-    }
-    close(scopeManager) {
-        (0, assert_1.assert)(this.leftToResolve);
-        for (const ref of this.leftToResolve) {
-            if (ref.maybeImplicitGlobal && !this.set.has(ref.identifier.name)) {
-                // create an implicit global variable from assignment expression
-                const info = ref.maybeImplicitGlobal;
-                const node = info.pattern;
-                if (node.type === types_1.AST_NODE_TYPES.Identifier) {
-                    this.defineVariable(node.name, this.implicit.set, this.implicit.variables, node, new ImplicitGlobalVariableDefinition_1.ImplicitGlobalVariableDefinition(info.pattern, info.node));
-                }
-            }
-        }
-        this.implicit.leftToBeResolved = this.leftToResolve;
-        super.close(scopeManager);
-        this.implicit.leftToBeResolved = [...this.through];
-        return null;
-    }
-    defineImplicitVariable(name, options) {
-        this.defineVariable(new variable_1.ImplicitLibVariable(this, name, options), this.set, this.variables, null, null);
-    }
-}
-exports.GlobalScope = GlobalScope;

package/node_modules/eslint-plugin-astro/node_modules/@typescript-eslint/scope-manager/dist/scope/MappedTypeScope.d.ts

@@ -1,8 +0,0 @@
-import type { TSESTree } from '@typescript-eslint/types';
-import type { ScopeManager } from '../ScopeManager';
-import type { Scope } from './Scope';
-import { ScopeBase } from './ScopeBase';
-import { ScopeType } from './ScopeType';
-export declare class MappedTypeScope extends ScopeBase<ScopeType.mappedType, TSESTree.TSMappedType, Scope> {
-    constructor(scopeManager: ScopeManager, upperScope: MappedTypeScope['upper'], block: MappedTypeScope['block']);
-}

package/node_modules/eslint-plugin-astro/node_modules/@typescript-eslint/scope-manager/dist/scope/MappedTypeScope.js

@@ -1,11 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.MappedTypeScope = void 0;
-const ScopeBase_1 = require("./ScopeBase");
-const ScopeType_1 = require("./ScopeType");
-class MappedTypeScope extends ScopeBase_1.ScopeBase {
-    constructor(scopeManager, upperScope, block) {
-        super(scopeManager, ScopeType_1.ScopeType.mappedType, upperScope, block, false);
-    }
-}
-exports.MappedTypeScope = MappedTypeScope;

package/node_modules/eslint-plugin-astro/node_modules/@typescript-eslint/scope-manager/dist/scope/ModuleScope.d.ts

@@ -1,8 +0,0 @@
-import type { TSESTree } from '@typescript-eslint/types';
-import type { ScopeManager } from '../ScopeManager';
-import type { Scope } from './Scope';
-import { ScopeBase } from './ScopeBase';
-import { ScopeType } from './ScopeType';
-export declare class ModuleScope extends ScopeBase<ScopeType.module, TSESTree.Program, Scope> {
-    constructor(scopeManager: ScopeManager, upperScope: ModuleScope['upper'], block: ModuleScope['block']);
-}

package/node_modules/eslint-plugin-astro/node_modules/@typescript-eslint/scope-manager/dist/scope/ModuleScope.js

@@ -1,11 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ModuleScope = void 0;
-const ScopeBase_1 = require("./ScopeBase");
-const ScopeType_1 = require("./ScopeType");
-class ModuleScope extends ScopeBase_1.ScopeBase {
-    constructor(scopeManager, upperScope, block) {
-        super(scopeManager, ScopeType_1.ScopeType.module, upperScope, block, false);
-    }
-}
-exports.ModuleScope = ModuleScope;

package/node_modules/eslint-plugin-astro/node_modules/@typescript-eslint/scope-manager/dist/scope/Scope.d.ts

@@ -1,19 +0,0 @@
-import type { BlockScope } from './BlockScope';
-import type { CatchScope } from './CatchScope';
-import type { ClassFieldInitializerScope } from './ClassFieldInitializerScope';
-import type { ClassScope } from './ClassScope';
-import type { ClassStaticBlockScope } from './ClassStaticBlockScope';
-import type { ConditionalTypeScope } from './ConditionalTypeScope';
-import type { ForScope } from './ForScope';
-import type { FunctionExpressionNameScope } from './FunctionExpressionNameScope';
-import type { FunctionScope } from './FunctionScope';
-import type { FunctionTypeScope } from './FunctionTypeScope';
-import type { GlobalScope } from './GlobalScope';
-import type { MappedTypeScope } from './MappedTypeScope';
-import type { ModuleScope } from './ModuleScope';
-import type { SwitchScope } from './SwitchScope';
-import type { TSEnumScope } from './TSEnumScope';
-import type { TSModuleScope } from './TSModuleScope';
-import type { TypeScope } from './TypeScope';
-import type { WithScope } from './WithScope';
-export type Scope = BlockScope | CatchScope | ClassFieldInitializerScope | ClassScope | ClassStaticBlockScope | ConditionalTypeScope | ForScope | FunctionExpressionNameScope | FunctionScope | FunctionTypeScope | GlobalScope | MappedTypeScope | ModuleScope | SwitchScope | TSEnumScope | TSModuleScope | TypeScope | WithScope;

package/node_modules/eslint-plugin-astro/node_modules/@typescript-eslint/scope-manager/dist/scope/Scope.js

@@ -1,2 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });

package/node_modules/eslint-plugin-astro/node_modules/@typescript-eslint/scope-manager/dist/scope/ScopeBase.d.ts

@@ -1,96 +0,0 @@
-import type { TSESTree } from '@typescript-eslint/types';
-import type { Definition } from '../definition';
-import type { ReferenceImplicitGlobal } from '../referencer/Reference';
-import type { ScopeManager } from '../ScopeManager';
-import type { FunctionScope } from './FunctionScope';
-import type { GlobalScope } from './GlobalScope';
-import type { ModuleScope } from './ModuleScope';
-import type { Scope } from './Scope';
-import type { TSModuleScope } from './TSModuleScope';
-import { Reference, ReferenceFlag } from '../referencer/Reference';
-import { Variable } from '../variable';
-import { ScopeType } from './ScopeType';
-type VariableScope = FunctionScope | GlobalScope | ModuleScope | TSModuleScope;
-export declare abstract class ScopeBase<Type extends ScopeType, Block extends TSESTree.Node, Upper extends Scope | null> {
-    #private;
-    /**
-     * A unique ID for this instance - primarily used to help debugging and testing
-     */
-    readonly $id: number;
-    /**
-     * The AST node which created this scope.
-     * @public
-     */
-    readonly block: Block;
-    /**
-     * The array of child scopes. This does not include grandchild scopes.
-     * @public
-     */
-    readonly childScopes: Scope[];
-    /**
-     * Whether this scope is created by a FunctionExpression.
-     * @public
-     */
-    readonly functionExpressionScope: boolean;
-    /**
-     * Whether 'use strict' is in effect in this scope.
-     * @public
-     */
-    isStrict: boolean;
-    /**
-     * List of {@link Reference}s that are left to be resolved (i.e. which
-     * need to be linked to the variable they refer to).
-     */
-    protected leftToResolve: Reference[] | null;
-    /**
-     * Any variable {@link 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.
-     * @public
-     */
-    readonly references: Reference[];
-    /**
-     * The map from variable names to variable objects.
-     * @public
-     */
-    readonly set: Map<string, Variable>;
-    /**
-     * The {@link Reference}s that are not resolved with this scope.
-     * @public
-     */
-    through: Reference[];
-    readonly type: Type;
-    /**
-     * Reference to the parent {@link Scope}.
-     * @public
-     */
-    readonly upper: Upper;
-    /**
-     * The scoped {@link Variable}s of this scope.
-     * In the case of a 'function' scope this includes the automatic argument `arguments` as its first element, as well
-     * as all further formal arguments.
-     * This does not include variables which are defined in child scopes.
-     * @public
-     */
-    readonly variables: Variable[];
-    readonly variableScope: VariableScope;
-    constructor(scopeManager: ScopeManager, type: Type, upperScope: Upper, block: Block, isMethodDefinition: boolean);
-    private isVariableScope;
-    close(_scopeManager: ScopeManager): Scope | null;
-    shouldStaticallyClose(): boolean;
-    /**
-     * To override by function scopes.
-     * References in default parameters isn't resolved to variables which are in their function body.
-     */
-    protected defineVariable(nameOrVariable: string | Variable, set: Map<string, Variable>, variables: Variable[], node: TSESTree.Identifier | null, def: Definition | null): void;
-    protected delegateToUpperScope(ref: Reference): void;
-    protected isValidResolution(_ref: Reference, _variable: Variable): boolean;
-    private addDeclaredVariablesOfNode;
-    defineIdentifier(node: TSESTree.Identifier, def: Definition): void;
-    defineLiteralIdentifier(node: TSESTree.StringLiteral, def: Definition): void;
-    referenceDualValueType(node: TSESTree.Identifier): void;
-    referenceType(node: TSESTree.Identifier): void;
-    referenceValue(node: TSESTree.Identifier | TSESTree.JSXIdentifier, assign?: ReferenceFlag, writeExpr?: TSESTree.Expression | null, maybeImplicitGlobal?: ReferenceImplicitGlobal | null, init?: boolean): void;
-}
-export {};

package/node_modules/eslint-plugin-astro/node_modules/@typescript-eslint/scope-manager/dist/scope/ScopeBase.js

@@ -1,308 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ScopeBase = void 0;
-const types_1 = require("@typescript-eslint/types");
-const assert_1 = require("../assert");
-const ID_1 = require("../ID");
-const Reference_1 = require("../referencer/Reference");
-const variable_1 = require("../variable");
-const ScopeType_1 = require("./ScopeType");
-/**
- * Test if scope is strict
- */
-function isStrictScope(scope, block, isMethodDefinition) {
-    let body;
-    // When upper scope is exists and strict, inner scope is also strict.
-    if (scope.upper?.isStrict) {
-        return true;
-    }
-    if (isMethodDefinition) {
-        return true;
-    }
-    if (scope.type === ScopeType_1.ScopeType.class ||
-        scope.type === ScopeType_1.ScopeType.conditionalType ||
-        scope.type === ScopeType_1.ScopeType.functionType ||
-        scope.type === ScopeType_1.ScopeType.mappedType ||
-        scope.type === ScopeType_1.ScopeType.module ||
-        scope.type === ScopeType_1.ScopeType.tsEnum ||
-        scope.type === ScopeType_1.ScopeType.tsModule ||
-        scope.type === ScopeType_1.ScopeType.type) {
-        return true;
-    }
-    if (scope.type === ScopeType_1.ScopeType.block || scope.type === ScopeType_1.ScopeType.switch) {
-        return false;
-    }
-    if (scope.type === ScopeType_1.ScopeType.function) {
-        const functionBody = block;
-        switch (functionBody.type) {
-            case types_1.AST_NODE_TYPES.ArrowFunctionExpression:
-                if (functionBody.body.type !== types_1.AST_NODE_TYPES.BlockStatement) {
-                    return false;
-                }
-                body = functionBody.body;
-                break;
-            case types_1.AST_NODE_TYPES.Program:
-                body = functionBody;
-                break;
-            default:
-                body = functionBody.body;
-        }
-        if (!body) {
-            return false;
-        }
-    }
-    else if (scope.type === ScopeType_1.ScopeType.global) {
-        body = block;
-    }
-    else {
-        return false;
-    }
-    // Search 'use strict' directive.
-    for (const stmt of body.body) {
-        if (stmt.type !== types_1.AST_NODE_TYPES.ExpressionStatement ||
-            stmt.directive == null) {
-            break;
-        }
-        if (stmt.directive === 'use strict') {
-            return true;
-        }
-    }
-    return false;
-}
-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]);
-    }
-}
-const generator = (0, ID_1.createIdGenerator)();
-const VARIABLE_SCOPE_TYPES = new Set([
-    ScopeType_1.ScopeType.classFieldInitializer,
-    ScopeType_1.ScopeType.classStaticBlock,
-    ScopeType_1.ScopeType.function,
-    ScopeType_1.ScopeType.global,
-    ScopeType_1.ScopeType.module,
-    ScopeType_1.ScopeType.tsModule,
-]);
-class ScopeBase {
-    /**
-     * A unique ID for this instance - primarily used to help debugging and testing
-     */
-    $id = generator();
-    /**
-     * The AST node which created this scope.
-     * @public
-     */
-    block;
-    /**
-     * The array of child scopes. This does not include grandchild scopes.
-     * @public
-     */
-    childScopes = [];
-    /**
-     * A map of the variables for each node in this scope.
-     * This is map is a pointer to the one in the parent ScopeManager instance
-     */
-    #declaredVariables;
-    /**
-     * 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.
-     * All those scopes are considered "dynamic".
-     */
-    #dynamic;
-    /**
-     * Whether this scope is created by a FunctionExpression.
-     * @public
-     */
-    functionExpressionScope = false;
-    /**
-     * Whether 'use strict' is in effect in this scope.
-     * @public
-     */
-    isStrict;
-    /**
-     * List of {@link Reference}s that are left to be resolved (i.e. which
-     * need to be linked to the variable they refer to).
-     */
-    leftToResolve = [];
-    /**
-     * Any variable {@link 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.
-     * @public
-     */
-    references = [];
-    /**
-     * The map from variable names to variable objects.
-     * @public
-     */
-    set = new Map();
-    /**
-     * The {@link Reference}s that are not resolved with this scope.
-     * @public
-     */
-    through = [];
-    type;
-    /**
-     * Reference to the parent {@link Scope}.
-     * @public
-     */
-    upper;
-    /**
-     * The scoped {@link Variable}s of this scope.
-     * In the case of a 'function' scope this includes the automatic argument `arguments` as its first element, as well
-     * as all further formal arguments.
-     * This does not include variables which are defined in child scopes.
-     * @public
-     */
-    variables = [];
-    /**
-     * For scopes that can contain variable declarations, this is a self-reference.
-     * For other scope types this is the *variableScope* value of the parent scope.
-     * @public
-     */
-    #dynamicCloseRef = (ref) => {
-        // notify all names are through to global
-        let current = this;
-        do {
-            /* eslint-disable @typescript-eslint/no-non-null-assertion */
-            current.through.push(ref);
-            current = current.upper;
-            /* eslint-enable @typescript-eslint/no-non-null-assertion */
-        } while (current);
-    };
-    #staticCloseRef = (ref) => {
-        const resolve = () => {
-            const name = ref.identifier.name;
-            const variable = this.set.get(name);
-            if (!variable) {
-                return false;
-            }
-            if (!this.isValidResolution(ref, variable)) {
-                return false;
-            }
-            // make sure we don't match a type reference to a value variable
-            const isValidTypeReference = ref.isTypeReference && variable.isTypeVariable;
-            const isValidValueReference = ref.isValueReference && variable.isValueVariable;
-            if (!isValidTypeReference && !isValidValueReference) {
-                return false;
-            }
-            variable.references.push(ref);
-            ref.resolved = variable;
-            return true;
-        };
-        if (!resolve()) {
-            this.delegateToUpperScope(ref);
-        }
-    };
-    variableScope;
-    constructor(scopeManager, type, upperScope, block, isMethodDefinition) {
-        const upperScopeAsScopeBase = upperScope;
-        this.type = type;
-        this.#dynamic =
-            this.type === ScopeType_1.ScopeType.global || this.type === ScopeType_1.ScopeType.with;
-        this.block = block;
-        this.variableScope = this.isVariableScope()
-            ? this
-            : // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-                upperScopeAsScopeBase.variableScope;
-        this.upper = upperScope;
-        /**
-         * Whether 'use strict' is in effect in this scope.
-         * @member {boolean} Scope#isStrict
-         */
-        this.isStrict = isStrictScope(this, block, isMethodDefinition);
-        // this is guaranteed to be correct at runtime
-        upperScopeAsScopeBase?.childScopes.push(this);
-        this.#declaredVariables = scopeManager.declaredVariables;
-        registerScope(scopeManager, this);
-    }
-    isVariableScope() {
-        return VARIABLE_SCOPE_TYPES.has(this.type);
-    }
-    close(_scopeManager) {
-        const closeRef = this.shouldStaticallyClose()
-            ? this.#staticCloseRef
-            : this.#dynamicCloseRef;
-        // Try Resolving all references in this scope.
-        (0, assert_1.assert)(this.leftToResolve);
-        this.leftToResolve.forEach(ref => closeRef(ref));
-        this.leftToResolve = null;
-        return this.upper;
-    }
-    shouldStaticallyClose() {
-        return !this.#dynamic || this.type === 'global';
-    }
-    /**
-     * To override by function scopes.
-     * References in default parameters isn't resolved to variables which are in their function body.
-     */
-    defineVariable(nameOrVariable, set, variables, node, def) {
-        const name = typeof nameOrVariable === 'string' ? nameOrVariable : nameOrVariable.name;
-        let variable = set.get(name);
-        if (!variable) {
-            variable =
-                typeof nameOrVariable === 'string'
-                    ? new variable_1.Variable(name, this)
-                    : nameOrVariable;
-            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);
-        }
-    }
-    delegateToUpperScope(ref) {
-        this.upper?.leftToResolve?.push(ref);
-        this.through.push(ref);
-    }
-    isValidResolution(_ref, _variable) {
-        return true;
-    }
-    addDeclaredVariablesOfNode(variable, node) {
-        if (node == null) {
-            return;
-        }
-        let variables = this.#declaredVariables.get(node);
-        if (variables == null) {
-            variables = [];
-            this.#declaredVariables.set(node, variables);
-        }
-        if (!variables.includes(variable)) {
-            variables.push(variable);
-        }
-    }
-    defineIdentifier(node, def) {
-        this.defineVariable(node.name, this.set, this.variables, node, def);
-    }
-    defineLiteralIdentifier(node, def) {
-        this.defineVariable(node.value, this.set, this.variables, null, def);
-    }
-    referenceDualValueType(node) {
-        const ref = new Reference_1.Reference(node, this, Reference_1.ReferenceFlag.Read, null, null, false, Reference_1.ReferenceTypeFlag.Type | Reference_1.ReferenceTypeFlag.Value);
-        this.references.push(ref);
-        this.leftToResolve?.push(ref);
-    }
-    referenceType(node) {
-        const ref = new Reference_1.Reference(node, this, Reference_1.ReferenceFlag.Read, null, null, false, Reference_1.ReferenceTypeFlag.Type);
-        this.references.push(ref);
-        this.leftToResolve?.push(ref);
-    }
-    referenceValue(node, assign = Reference_1.ReferenceFlag.Read, writeExpr, maybeImplicitGlobal, init = false) {
-        const ref = new Reference_1.Reference(node, this, assign, writeExpr, maybeImplicitGlobal, init, Reference_1.ReferenceTypeFlag.Value);
-        this.references.push(ref);
-        this.leftToResolve?.push(ref);
-    }
-}
-exports.ScopeBase = ScopeBase;

package/node_modules/eslint-plugin-astro/node_modules/@typescript-eslint/scope-manager/dist/scope/ScopeType.d.ts

@@ -1,20 +0,0 @@
-export declare enum ScopeType {
-    block = "block",
-    catch = "catch",
-    class = "class",
-    classFieldInitializer = "class-field-initializer",
-    classStaticBlock = "class-static-block",
-    conditionalType = "conditionalType",
-    for = "for",
-    function = "function",
-    functionExpressionName = "function-expression-name",
-    functionType = "functionType",
-    global = "global",
-    mappedType = "mappedType",
-    module = "module",
-    switch = "switch",
-    tsEnum = "tsEnum",
-    tsModule = "tsModule",
-    type = "type",
-    with = "with"
-}

package/node_modules/eslint-plugin-astro/node_modules/@typescript-eslint/scope-manager/dist/scope/ScopeType.js

@@ -1,24 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ScopeType = void 0;
-var ScopeType;
-(function (ScopeType) {
-    ScopeType["block"] = "block";
-    ScopeType["catch"] = "catch";
-    ScopeType["class"] = "class";
-    ScopeType["classFieldInitializer"] = "class-field-initializer";
-    ScopeType["classStaticBlock"] = "class-static-block";
-    ScopeType["conditionalType"] = "conditionalType";
-    ScopeType["for"] = "for";
-    ScopeType["function"] = "function";
-    ScopeType["functionExpressionName"] = "function-expression-name";
-    ScopeType["functionType"] = "functionType";
-    ScopeType["global"] = "global";
-    ScopeType["mappedType"] = "mappedType";
-    ScopeType["module"] = "module";
-    ScopeType["switch"] = "switch";
-    ScopeType["tsEnum"] = "tsEnum";
-    ScopeType["tsModule"] = "tsModule";
-    ScopeType["type"] = "type";
-    ScopeType["with"] = "with";
-})(ScopeType || (exports.ScopeType = ScopeType = {}));

package/node_modules/eslint-plugin-astro/node_modules/@typescript-eslint/scope-manager/dist/scope/SwitchScope.d.ts

@@ -1,8 +0,0 @@
-import type { TSESTree } from '@typescript-eslint/types';
-import type { ScopeManager } from '../ScopeManager';
-import type { Scope } from './Scope';
-import { ScopeBase } from './ScopeBase';
-import { ScopeType } from './ScopeType';
-export declare class SwitchScope extends ScopeBase<ScopeType.switch, TSESTree.SwitchStatement, Scope> {
-    constructor(scopeManager: ScopeManager, upperScope: SwitchScope['upper'], block: SwitchScope['block']);
-}

package/node_modules/eslint-plugin-astro/node_modules/@typescript-eslint/scope-manager/dist/scope/SwitchScope.js

@@ -1,11 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.SwitchScope = void 0;
-const ScopeBase_1 = require("./ScopeBase");
-const ScopeType_1 = require("./ScopeType");
-class SwitchScope extends ScopeBase_1.ScopeBase {
-    constructor(scopeManager, upperScope, block) {
-        super(scopeManager, ScopeType_1.ScopeType.switch, upperScope, block, false);
-    }
-}
-exports.SwitchScope = SwitchScope;

package/node_modules/eslint-plugin-astro/node_modules/@typescript-eslint/scope-manager/dist/scope/TSEnumScope.d.ts

@@ -1,8 +0,0 @@
-import type { TSESTree } from '@typescript-eslint/types';
-import type { ScopeManager } from '../ScopeManager';
-import type { Scope } from './Scope';
-import { ScopeBase } from './ScopeBase';
-import { ScopeType } from './ScopeType';
-export declare class TSEnumScope extends ScopeBase<ScopeType.tsEnum, TSESTree.TSEnumDeclaration, Scope> {
-    constructor(scopeManager: ScopeManager, upperScope: TSEnumScope['upper'], block: TSEnumScope['block']);
-}

package/node_modules/eslint-plugin-astro/node_modules/@typescript-eslint/scope-manager/dist/scope/TSEnumScope.js

@@ -1,11 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.TSEnumScope = void 0;
-const ScopeBase_1 = require("./ScopeBase");
-const ScopeType_1 = require("./ScopeType");
-class TSEnumScope extends ScopeBase_1.ScopeBase {
-    constructor(scopeManager, upperScope, block) {
-        super(scopeManager, ScopeType_1.ScopeType.tsEnum, upperScope, block, false);
-    }
-}
-exports.TSEnumScope = TSEnumScope;

package/node_modules/eslint-plugin-astro/node_modules/@typescript-eslint/scope-manager/dist/scope/TSModuleScope.d.ts

@@ -1,8 +0,0 @@
-import type { TSESTree } from '@typescript-eslint/types';
-import type { ScopeManager } from '../ScopeManager';
-import type { Scope } from './Scope';
-import { ScopeBase } from './ScopeBase';
-import { ScopeType } from './ScopeType';
-export declare class TSModuleScope extends ScopeBase<ScopeType.tsModule, TSESTree.TSModuleDeclaration, Scope> {
-    constructor(scopeManager: ScopeManager, upperScope: TSModuleScope['upper'], block: TSModuleScope['block']);
-}

package/node_modules/eslint-plugin-astro/node_modules/@typescript-eslint/scope-manager/dist/scope/TSModuleScope.js

@@ -1,11 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.TSModuleScope = void 0;
-const ScopeBase_1 = require("./ScopeBase");
-const ScopeType_1 = require("./ScopeType");
-class TSModuleScope extends ScopeBase_1.ScopeBase {
-    constructor(scopeManager, upperScope, block) {
-        super(scopeManager, ScopeType_1.ScopeType.tsModule, upperScope, block, false);
-    }
-}
-exports.TSModuleScope = TSModuleScope;

package/node_modules/eslint-plugin-astro/node_modules/@typescript-eslint/scope-manager/dist/scope/TypeScope.d.ts

@@ -1,8 +0,0 @@
-import type { TSESTree } from '@typescript-eslint/types';
-import type { ScopeManager } from '../ScopeManager';
-import type { Scope } from './Scope';
-import { ScopeBase } from './ScopeBase';
-import { ScopeType } from './ScopeType';
-export declare class TypeScope extends ScopeBase<ScopeType.type, TSESTree.TSInterfaceDeclaration | TSESTree.TSTypeAliasDeclaration, Scope> {
-    constructor(scopeManager: ScopeManager, upperScope: TypeScope['upper'], block: TypeScope['block']);
-}