• Version 3.7.7
  • Published
  • 6.27 kB
  • 2 dependencies
  • MIT license


npm i @types/eslint-scope
yarn add @types/eslint-scope
pnpm add @types/eslint-scope


TypeScript definitions for eslint-scope



variable version

const version: string;


    function analyze

    analyze: (ast: {}, options?: AnalysisOptions) => ScopeManager;


      class Reference

      class Reference implements eslint.Scope.Reference {}

        property from

        from: Scope;

          property identifier

          identifier: estree.Identifier;

            property init

            init: boolean;

              property resolved

              resolved: Variable;

                property writeExpr

                writeExpr: any;

                  method isRead

                  isRead: () => boolean;

                    method isReadOnly

                    isReadOnly: () => boolean;

                      method isReadWrite

                      isReadWrite: () => boolean;

                        method isWrite

                        isWrite: () => boolean;

                          method isWriteOnly

                          isWriteOnly: () => boolean;

                            class Scope

                            class Scope implements eslint.Scope.Scope {}

                              property block

                              block: estree.Node;

                                property childScopes

                                childScopes: Scope[];

                                  property functionExpressionScope

                                  functionExpressionScope: boolean;

                                    property isStrict

                                    isStrict: boolean;

                                      property references

                                      references: Reference[];

                                        property set

                                        set: Map<string, Variable>;

                                          property through

                                          through: Reference[];

                                            property type

                                            | 'function'
                                            | 'block'
                                            | 'catch'
                                            | 'class'
                                            | 'for'
                                            | 'function-expression-name'
                                            | 'global'
                                            | 'module'
                                            | 'switch'
                                            | 'with'
                                            | 'TDZ';

                                              property upper

                                              upper: Scope;

                                                property variables

                                                variables: Variable[];

                                                  property variableScope

                                                  variableScope: Scope;

                                                    class ScopeManager

                                                    class ScopeManager implements eslint.Scope.ScopeManager {}

                                                      property globalScope

                                                      globalScope: Scope;

                                                        property scopes

                                                        scopes: Scope[];

                                                          method acquire

                                                          acquire: (node: {}, inner?: boolean) => Scope | null;

                                                            method getDeclaredVariables

                                                            getDeclaredVariables: (node: {}) => Variable[];

                                                              class Variable

                                                              class Variable implements eslint.Scope.Variable {}

                                                                property defs

                                                                defs: eslint.Scope.Definition[];

                                                                  property identifiers

                                                                  identifiers: estree.Identifier[];

                                                                    property name

                                                                    name: string;

                                                                      property references

                                                                      references: Reference[];

                                                                        property scope

                                                                        scope: Scope;


                                                                          interface AnalysisOptions

                                                                          interface AnalysisOptions {}

                                                                            property directive

                                                                            directive?: boolean;

                                                                              property ecmaVersion

                                                                              ecmaVersion?: number;

                                                                                property fallback

                                                                                fallback?: string | ((node: {}) => string[]);

                                                                                  property ignoreEval

                                                                                  ignoreEval?: boolean;

                                                                                    property impliedStrict

                                                                                    impliedStrict?: boolean;

                                                                                      property nodejsScope

                                                                                      nodejsScope?: boolean;

                                                                                        property optimistic

                                                                                        optimistic?: boolean;

                                                                                          property sourceType

                                                                                          sourceType?: 'script' | 'module';

                                                                                            Package Files (1)

                                                                                            Dependencies (2)

                                                                                            Dev Dependencies (0)

                                                                                            No dev dependencies.

                                                                                            Peer Dependencies (0)

                                                                                            No peer dependencies.


                                                                                            To add a badge like this onejsDocs.io badgeto your package's README, use the codes available below.

                                                                                            You may also use Shields.io to create a custom badge linking to https://www.jsdocs.io/package/@types/eslint-scope.

                                                                                            • Markdown
                                                                                            • HTML
                                                                                              <a href="https://www.jsdocs.io/package/@types/eslint-scope"><img src="https://img.shields.io/badge/jsDocs.io-reference-blue" alt="jsDocs.io"></a>