@askviraj/linter 1.1.0 → 1.1.2

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

@@ -1,221 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.TypeVisitor = void 0;
-const types_1 = require("@typescript-eslint/types");
-const definition_1 = require("../definition");
-const scope_1 = require("../scope");
-const Visitor_1 = require("./Visitor");
-class TypeVisitor extends Visitor_1.Visitor {
-    #referencer;
-    constructor(referencer) {
-        super(referencer);
-        this.#referencer = referencer;
-    }
-    static visit(referencer, node) {
-        const typeReferencer = new TypeVisitor(referencer);
-        typeReferencer.visit(node);
-    }
-    ///////////////////
-    // Visit helpers //
-    ///////////////////
-    visitFunctionType(node) {
-        // arguments and type parameters can only be referenced from within the function
-        this.#referencer.scopeManager.nestFunctionTypeScope(node);
-        this.visit(node.typeParameters);
-        for (const param of node.params) {
-            let didVisitAnnotation = false;
-            this.visitPattern(param, (pattern, info) => {
-                // a parameter name creates a value type variable which can be referenced later via typeof arg
-                this.#referencer
-                    .currentScope()
-                    .defineIdentifier(pattern, new definition_1.ParameterDefinition(pattern, node, info.rest));
-                if (pattern.typeAnnotation) {
-                    this.visit(pattern.typeAnnotation);
-                    didVisitAnnotation = true;
-                }
-            });
-            // there are a few special cases where the type annotation is owned by the parameter, not the pattern
-            // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
-            if (!didVisitAnnotation && 'typeAnnotation' in param) {
-                this.visit(param.typeAnnotation);
-            }
-        }
-        this.visit(node.returnType);
-        this.#referencer.close(node);
-    }
-    visitPropertyKey(node) {
-        if (!node.computed) {
-            return;
-        }
-        // computed members are treated as value references, and TS expects they have a literal type
-        this.#referencer.visit(node.key);
-    }
-    /////////////////////
-    // Visit selectors //
-    /////////////////////
-    Identifier(node) {
-        this.#referencer.currentScope().referenceType(node);
-    }
-    MemberExpression(node) {
-        this.visit(node.object);
-        // don't visit the property
-    }
-    TSCallSignatureDeclaration(node) {
-        this.visitFunctionType(node);
-    }
-    TSConditionalType(node) {
-        // conditional types can define inferred type parameters
-        // which are only accessible from inside the conditional parameter
-        this.#referencer.scopeManager.nestConditionalTypeScope(node);
-        // type parameters inferred in the condition clause are not accessible within the false branch
-        this.visitChildren(node, ['falseType']);
-        this.#referencer.close(node);
-        this.visit(node.falseType);
-    }
-    TSConstructorType(node) {
-        this.visitFunctionType(node);
-    }
-    TSConstructSignatureDeclaration(node) {
-        this.visitFunctionType(node);
-    }
-    TSFunctionType(node) {
-        this.visitFunctionType(node);
-    }
-    TSImportType(node) {
-        // the TS parser allows any type to be the parameter, but it's a syntax error - so we can ignore it
-        this.visit(node.typeArguments);
-        // the qualifier is just part of a standard EntityName, so it should not be visited
-    }
-    TSIndexSignature(node) {
-        for (const param of node.parameters) {
-            if (param.type === types_1.AST_NODE_TYPES.Identifier) {
-                this.visit(param.typeAnnotation);
-            }
-        }
-        this.visit(node.typeAnnotation);
-    }
-    TSInferType(node) {
-        const typeParameter = node.typeParameter;
-        let scope = this.#referencer.currentScope();
-        /*
-        In cases where there is a sub-type scope created within a conditional type, then the generic should be defined in the
-        conditional type's scope, not the child type scope.
-        If we define it within the child type's scope then it won't be able to be referenced outside the child type
-        */
-        if (scope.type === scope_1.ScopeType.functionType ||
-            scope.type === scope_1.ScopeType.mappedType) {
-            // search up the scope tree to figure out if we're in a nested type scope
-            let currentScope = scope.upper;
-            while (currentScope) {
-                if (currentScope.type === scope_1.ScopeType.functionType ||
-                    currentScope.type === scope_1.ScopeType.mappedType) {
-                    // ensure valid type parents only
-                    currentScope = currentScope.upper;
-                    continue;
-                }
-                if (currentScope.type === scope_1.ScopeType.conditionalType) {
-                    scope = currentScope;
-                    break;
-                }
-                break;
-            }
-        }
-        scope.defineIdentifier(typeParameter.name, new definition_1.TypeDefinition(typeParameter.name, typeParameter));
-        this.visit(typeParameter.constraint);
-    }
-    TSInterfaceDeclaration(node) {
-        this.#referencer
-            .currentScope()
-            .defineIdentifier(node.id, new definition_1.TypeDefinition(node.id, node));
-        if (node.typeParameters) {
-            // type parameters cannot be referenced from outside their current scope
-            this.#referencer.scopeManager.nestTypeScope(node);
-            this.visit(node.typeParameters);
-        }
-        node.extends.forEach(this.visit, this);
-        this.visit(node.body);
-        if (node.typeParameters) {
-            this.#referencer.close(node);
-        }
-    }
-    TSMappedType(node) {
-        // mapped types key can only be referenced within their return value
-        this.#referencer.scopeManager.nestMappedTypeScope(node);
-        this.#referencer
-            .currentScope()
-            .defineIdentifier(node.key, new definition_1.TypeDefinition(node.key, node));
-        this.visit(node.constraint);
-        this.visit(node.nameType);
-        this.visit(node.typeAnnotation);
-        this.#referencer.close(node);
-    }
-    TSMethodSignature(node) {
-        this.visitPropertyKey(node);
-        this.visitFunctionType(node);
-    }
-    TSNamedTupleMember(node) {
-        this.visit(node.elementType);
-        // we don't visit the label as the label only exists for the purposes of documentation
-    }
-    TSPropertySignature(node) {
-        this.visitPropertyKey(node);
-        this.visit(node.typeAnnotation);
-    }
-    TSQualifiedName(node) {
-        this.visit(node.left);
-        // we don't visit the right as it a name on the thing, not a name to reference
-    }
-    TSTypeAliasDeclaration(node) {
-        this.#referencer
-            .currentScope()
-            .defineIdentifier(node.id, new definition_1.TypeDefinition(node.id, node));
-        if (node.typeParameters) {
-            // type parameters cannot be referenced from outside their current scope
-            this.#referencer.scopeManager.nestTypeScope(node);
-            this.visit(node.typeParameters);
-        }
-        this.visit(node.typeAnnotation);
-        if (node.typeParameters) {
-            this.#referencer.close(node);
-        }
-    }
-    TSTypeParameter(node) {
-        this.#referencer
-            .currentScope()
-            .defineIdentifier(node.name, new definition_1.TypeDefinition(node.name, node));
-        this.visit(node.constraint);
-        this.visit(node.default);
-    }
-    TSTypePredicate(node) {
-        if (node.parameterName.type !== types_1.AST_NODE_TYPES.TSThisType) {
-            this.#referencer.currentScope().referenceValue(node.parameterName);
-        }
-        this.visit(node.typeAnnotation);
-    }
-    // a type query `typeof foo` is a special case that references a _non-type_ variable,
-    TSTypeAnnotation(node) {
-        // check
-        this.visitChildren(node);
-    }
-    TSTypeQuery(node) {
-        let entityName;
-        if (node.exprName.type === types_1.AST_NODE_TYPES.TSQualifiedName) {
-            let iter = node.exprName;
-            while (iter.left.type === types_1.AST_NODE_TYPES.TSQualifiedName) {
-                iter = iter.left;
-            }
-            entityName = iter.left;
-        }
-        else {
-            entityName = node.exprName;
-            if (node.exprName.type === types_1.AST_NODE_TYPES.TSImportType) {
-                this.visit(node.exprName);
-            }
-        }
-        if (entityName.type === types_1.AST_NODE_TYPES.Identifier) {
-            this.#referencer.currentScope().referenceValue(entityName);
-        }
-        this.visit(node.typeArguments);
-    }
-}
-exports.TypeVisitor = TypeVisitor;

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

@@ -1,13 +0,0 @@
-import type { TSESTree } from '@typescript-eslint/types';
-import type { PatternVisitorCallback, PatternVisitorOptions } from './PatternVisitor';
-import type { VisitorOptions } from './VisitorBase';
-import { VisitorBase } from './VisitorBase';
-interface VisitPatternOptions extends PatternVisitorOptions {
-    processRightHandNodes?: boolean;
-}
-export declare class Visitor extends VisitorBase {
-    #private;
-    constructor(optionsOrVisitor: Visitor | VisitorOptions);
-    protected visitPattern(node: TSESTree.Node, callback: PatternVisitorCallback, options?: VisitPatternOptions): void;
-}
-export { VisitorBase, type VisitorOptions } from './VisitorBase';

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

@@ -1,29 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.VisitorBase = exports.Visitor = void 0;
-const PatternVisitor_1 = require("./PatternVisitor");
-const VisitorBase_1 = require("./VisitorBase");
-class Visitor extends VisitorBase_1.VisitorBase {
-    #options;
-    constructor(optionsOrVisitor) {
-        super(optionsOrVisitor instanceof Visitor
-            ? optionsOrVisitor.#options
-            : optionsOrVisitor);
-        this.#options =
-            optionsOrVisitor instanceof Visitor
-                ? optionsOrVisitor.#options
-                : optionsOrVisitor;
-    }
-    visitPattern(node, callback, options = { processRightHandNodes: false }) {
-        // Call the callback at left hand identifier nodes, and Collect right hand nodes.
-        const visitor = new PatternVisitor_1.PatternVisitor(this.#options, node, callback);
-        visitor.visit(node);
-        // Process the right hand nodes recursively.
-        if (options.processRightHandNodes) {
-            visitor.rightHandNodes.forEach(this.visit, this);
-        }
-    }
-}
-exports.Visitor = Visitor;
-var VisitorBase_2 = require("./VisitorBase");
-Object.defineProperty(exports, "VisitorBase", { enumerable: true, get: function () { return VisitorBase_2.VisitorBase; } });

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

@@ -1,21 +0,0 @@
-import type { TSESTree } from '@typescript-eslint/types';
-import type { VisitorKeys } from '@typescript-eslint/visitor-keys';
-export interface VisitorOptions {
-    childVisitorKeys?: VisitorKeys | null;
-    visitChildrenEvenIfSelectorExists?: boolean;
-}
-export declare abstract class VisitorBase {
-    #private;
-    constructor(options: VisitorOptions);
-    /**
-     * Default method for visiting children.
-     * @param node the node whose children should be visited
-     * @param excludeArr a list of keys to not visit
-     */
-    visitChildren<T extends TSESTree.Node>(node: T | null | undefined, excludeArr?: (keyof T)[]): void;
-    /**
-     * Dispatching node.
-     */
-    visit(node: TSESTree.Node | null | undefined): void;
-}
-export type { VisitorKeys } from '@typescript-eslint/visitor-keys';

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

@@ -1,67 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.VisitorBase = void 0;
-const visitor_keys_1 = require("@typescript-eslint/visitor-keys");
-function isObject(obj) {
-    return typeof obj === 'object' && obj != null;
-}
-function isNode(node) {
-    return isObject(node) && typeof node.type === 'string';
-}
-class VisitorBase {
-    #childVisitorKeys;
-    #visitChildrenEvenIfSelectorExists;
-    constructor(options) {
-        this.#childVisitorKeys = options.childVisitorKeys ?? visitor_keys_1.visitorKeys;
-        this.#visitChildrenEvenIfSelectorExists =
-            options.visitChildrenEvenIfSelectorExists ?? false;
-    }
-    /**
-     * Default method for visiting children.
-     * @param node the node whose children should be visited
-     * @param excludeArr a list of keys to not visit
-     */
-    visitChildren(node, excludeArr = []) {
-        if (node?.type == null) {
-            return;
-        }
-        const exclude = new Set([...excludeArr, 'parent']);
-        const children = this.#childVisitorKeys[node.type] ?? Object.keys(node);
-        for (const key of children) {
-            if (exclude.has(key)) {
-                continue;
-            }
-            const child = node[key];
-            if (!child) {
-                continue;
-            }
-            if (Array.isArray(child)) {
-                for (const subChild of child) {
-                    if (isNode(subChild)) {
-                        this.visit(subChild);
-                    }
-                }
-            }
-            else if (isNode(child)) {
-                this.visit(child);
-            }
-        }
-    }
-    /**
-     * Dispatching node.
-     */
-    visit(node) {
-        if (node?.type == null) {
-            return;
-        }
-        const visitor = this[node.type];
-        if (visitor) {
-            visitor.call(this, node);
-            if (!this.#visitChildrenEvenIfSelectorExists) {
-                return;
-            }
-        }
-        this.visitChildren(node);
-    }
-}
-exports.VisitorBase = VisitorBase;

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

@@ -1 +0,0 @@
-export { Referencer, type ReferencerOptions } from './Referencer';

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

@@ -1,5 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Referencer = void 0;
-var Referencer_1 = require("./Referencer");
-Object.defineProperty(exports, "Referencer", { enumerable: true, get: function () { return Referencer_1.Referencer; } });

package/node_modules/eslint-plugin-astro/node_modules/@typescript-eslint/scope-manager/dist/scope/BlockScope.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 BlockScope extends ScopeBase<ScopeType.block, TSESTree.BlockStatement, Scope> {
-    constructor(scopeManager: ScopeManager, upperScope: BlockScope['upper'], block: BlockScope['block']);
-}

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

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

package/node_modules/eslint-plugin-astro/node_modules/@typescript-eslint/scope-manager/dist/scope/CatchScope.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 CatchScope extends ScopeBase<ScopeType.catch, TSESTree.CatchClause, Scope> {
-    constructor(scopeManager: ScopeManager, upperScope: CatchScope['upper'], block: CatchScope['block']);
-}

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

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

package/node_modules/eslint-plugin-astro/node_modules/@typescript-eslint/scope-manager/dist/scope/ClassFieldInitializerScope.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 ClassFieldInitializerScope extends ScopeBase<ScopeType.classFieldInitializer, TSESTree.Expression, Scope> {
-    constructor(scopeManager: ScopeManager, upperScope: ClassFieldInitializerScope['upper'], block: ClassFieldInitializerScope['block']);
-}

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

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

package/node_modules/eslint-plugin-astro/node_modules/@typescript-eslint/scope-manager/dist/scope/ClassScope.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 ClassScope extends ScopeBase<ScopeType.class, TSESTree.ClassDeclaration | TSESTree.ClassExpression, Scope> {
-    constructor(scopeManager: ScopeManager, upperScope: ClassScope['upper'], block: ClassScope['block']);
-}

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

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

package/node_modules/eslint-plugin-astro/node_modules/@typescript-eslint/scope-manager/dist/scope/ClassStaticBlockScope.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 ClassStaticBlockScope extends ScopeBase<ScopeType.classStaticBlock, TSESTree.StaticBlock, Scope> {
-    constructor(scopeManager: ScopeManager, upperScope: ClassStaticBlockScope['upper'], block: ClassStaticBlockScope['block']);
-}

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

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

package/node_modules/eslint-plugin-astro/node_modules/@typescript-eslint/scope-manager/dist/scope/ConditionalTypeScope.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 ConditionalTypeScope extends ScopeBase<ScopeType.conditionalType, TSESTree.TSConditionalType, Scope> {
-    constructor(scopeManager: ScopeManager, upperScope: ConditionalTypeScope['upper'], block: ConditionalTypeScope['block']);
-}

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

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

package/node_modules/eslint-plugin-astro/node_modules/@typescript-eslint/scope-manager/dist/scope/ForScope.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 ForScope extends ScopeBase<ScopeType.for, TSESTree.ForInStatement | TSESTree.ForOfStatement | TSESTree.ForStatement, Scope> {
-    constructor(scopeManager: ScopeManager, upperScope: ForScope['upper'], block: ForScope['block']);
-}

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

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

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

@@ -1,9 +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 FunctionExpressionNameScope extends ScopeBase<ScopeType.functionExpressionName, TSESTree.FunctionExpression, Scope> {
-    readonly functionExpressionScope: true;
-    constructor(scopeManager: ScopeManager, upperScope: FunctionExpressionNameScope['upper'], block: FunctionExpressionNameScope['block']);
-}

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

@@ -1,17 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.FunctionExpressionNameScope = void 0;
-const definition_1 = require("../definition");
-const ScopeBase_1 = require("./ScopeBase");
-const ScopeType_1 = require("./ScopeType");
-class FunctionExpressionNameScope extends ScopeBase_1.ScopeBase {
-    functionExpressionScope;
-    constructor(scopeManager, upperScope, block) {
-        super(scopeManager, ScopeType_1.ScopeType.functionExpressionName, upperScope, block, false);
-        if (block.id) {
-            this.defineIdentifier(block.id, new definition_1.FunctionNameDefinition(block.id, block));
-        }
-        this.functionExpressionScope = true;
-    }
-}
-exports.FunctionExpressionNameScope = FunctionExpressionNameScope;

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

@@ -1,11 +0,0 @@
-import type { TSESTree } from '@typescript-eslint/types';
-import type { Reference } from '../referencer/Reference';
-import type { ScopeManager } from '../ScopeManager';
-import type { Variable } from '../variable';
-import type { Scope } from './Scope';
-import { ScopeBase } from './ScopeBase';
-import { ScopeType } from './ScopeType';
-export declare class FunctionScope extends ScopeBase<ScopeType.function, TSESTree.ArrowFunctionExpression | TSESTree.FunctionDeclaration | TSESTree.FunctionExpression | TSESTree.Program | TSESTree.TSDeclareFunction | TSESTree.TSEmptyBodyFunctionExpression, Scope> {
-    constructor(scopeManager: ScopeManager, upperScope: FunctionScope['upper'], block: FunctionScope['block'], isMethodDefinition: boolean);
-    protected isValidResolution(ref: Reference, variable: Variable): boolean;
-}

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

@@ -1,35 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.FunctionScope = void 0;
-const types_1 = require("@typescript-eslint/types");
-const ScopeBase_1 = require("./ScopeBase");
-const ScopeType_1 = require("./ScopeType");
-class FunctionScope extends ScopeBase_1.ScopeBase {
-    constructor(scopeManager, upperScope, block, isMethodDefinition) {
-        super(scopeManager, ScopeType_1.ScopeType.function, upperScope, block, isMethodDefinition);
-        // section 9.2.13, FunctionDeclarationInstantiation.
-        // NOTE Arrow functions never have an arguments objects.
-        if (this.block.type !== types_1.AST_NODE_TYPES.ArrowFunctionExpression) {
-            this.defineVariable('arguments', this.set, this.variables, null, null);
-        }
-    }
-    // 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.globalReturn` is true, `this.block` becomes a Program node.
-        if (this.block.type === types_1.AST_NODE_TYPES.Program) {
-            return true;
-        }
-        const bodyStart = this.block.body?.range[0] ?? -1;
-        // 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.
-        );
-    }
-}
-exports.FunctionScope = FunctionScope;

package/node_modules/eslint-plugin-astro/node_modules/@typescript-eslint/scope-manager/dist/scope/FunctionTypeScope.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 FunctionTypeScope extends ScopeBase<ScopeType.functionType, TSESTree.TSCallSignatureDeclaration | TSESTree.TSConstructorType | TSESTree.TSConstructSignatureDeclaration | TSESTree.TSFunctionType | TSESTree.TSMethodSignature, Scope> {
-    constructor(scopeManager: ScopeManager, upperScope: FunctionTypeScope['upper'], block: FunctionTypeScope['block']);
-}

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

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

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

@@ -1,17 +0,0 @@
-import type { TSESTree } from '@typescript-eslint/types';
-import type { ScopeManager } from '../ScopeManager';
-import type { ImplicitLibVariableOptions } from '../variable';
-import type { Scope } from './Scope';
-import { ScopeBase } from './ScopeBase';
-import { ScopeType } from './ScopeType';
-export declare class GlobalScope extends ScopeBase<ScopeType.global, TSESTree.Program, 
-/**
- * The global scope has no parent.
- */
-null> {
-    private readonly implicit;
-    constructor(scopeManager: ScopeManager, block: GlobalScope['block']);
-    addVariables(names: string[]): void;
-    close(scopeManager: ScopeManager): Scope | null;
-    defineImplicitVariable(name: string, options: ImplicitLibVariableOptions): void;
-}