@alexlit/lint-kit 173.3.0 → 175.0.0

package/packages/config-eslint/node_modules/espree/lib/token-translator.js

@@ -0,0 +1,306 @@
+/**
+ * @fileoverview Translates tokens between Acorn format and Esprima format.
+ * @author Nicholas C. Zakas
+ */
+
+/**
+ * @import * as acorn from "acorn";
+ * @import { EnhancedTokTypes } from "./espree.js"
+ * @import { NormalizedEcmaVersion } from "./options.js";
+ * @import { EspreeToken as EsprimaToken } from "../espree.js";
+ */
+/**
+ * Based on the `acorn.Token` class, but without a fixed `type` (since we need
+ * it to be a string). Avoiding `type` lets us make one extending interface
+ * more strict and another more lax.
+ *
+ * We could make `value` more strict to `string` even though the original is
+ * `any`.
+ *
+ * `start` and `end` are required in `acorn.Token`
+ *
+ * `loc` and `range` are from `acorn.Token`
+ *
+ * Adds `regex`.
+ */
+/**
+ * @typedef {{
+ *   jsxAttrValueToken: boolean;
+ *   ecmaVersion: NormalizedEcmaVersion;
+ * }} ExtraNoTokens
+ * @typedef {{
+ *   tokens: EsprimaToken[]
+ * } & ExtraNoTokens} Extra
+ */
+
+//------------------------------------------------------------------------------
+// Private
+//------------------------------------------------------------------------------
+
+// Esprima Token Types
+const Token = {
+    Boolean: "Boolean",
+    EOF: "<end>",
+    Identifier: "Identifier",
+    PrivateIdentifier: "PrivateIdentifier",
+    Keyword: "Keyword",
+    Null: "Null",
+    Numeric: "Numeric",
+    Punctuator: "Punctuator",
+    String: "String",
+    RegularExpression: "RegularExpression",
+    Template: "Template",
+    JSXIdentifier: "JSXIdentifier",
+    JSXText: "JSXText"
+};
+
+/**
+ * Converts part of a template into an Esprima token.
+ * @param {acorn.Token[]} tokens The Acorn tokens representing the template.
+ * @param {string} code The source code.
+ * @returns {EsprimaToken} The Esprima equivalent of the template token.
+ * @private
+ */
+function convertTemplatePart(tokens, code) {
+    const firstToken = tokens[0],
+        lastTemplateToken =
+            /**
+             * @type {acorn.Token & {
+             *   loc: acorn.SourceLocation,
+             *   range: [number, number]
+             * }}
+             */ (tokens.at(-1));
+
+    /** @type {EsprimaToken} */
+    const token = {
+        type: Token.Template,
+        value: code.slice(firstToken.start, lastTemplateToken.end)
+    };
+
+    if (firstToken.loc) {
+        token.loc = {
+            start: firstToken.loc.start,
+            end: lastTemplateToken.loc.end
+        };
+    }
+
+    if (firstToken.range) {
+        token.start = firstToken.range[0];
+        token.end = lastTemplateToken.range[1];
+        token.range = [token.start, token.end];
+    }
+
+    return token;
+}
+
+/* eslint-disable jsdoc/check-types -- The API allows either */
+/**
+ * Contains logic to translate Acorn tokens into Esprima tokens.
+ */
+class TokenTranslator {
+
+    /**
+     * Contains logic to translate Acorn tokens into Esprima tokens.
+     * @param {EnhancedTokTypes} acornTokTypes The Acorn token types.
+     * @param {string|String} code The source code Acorn is parsing. This is necessary
+     *      to correct the "value" property of some tokens.
+     */
+    constructor(acornTokTypes, code) {
+        /* eslint-enable jsdoc/check-types -- The API allows either */
+
+        // token types
+        this._acornTokTypes = acornTokTypes;
+
+        // token buffer for templates
+        /** @type {acorn.Token[]} */
+        this._tokens = [];
+
+        // track the last curly brace
+        this._curlyBrace = null;
+
+        // the source code
+        this._code = code;
+
+    }
+
+    /**
+     * Translates a single Esprima token to a single Acorn token. This may be
+     * inaccurate due to how templates are handled differently in Esprima and
+     * Acorn, but should be accurate for all other tokens.
+     * @param {acorn.Token} token The Acorn token to translate.
+     * @param {ExtraNoTokens} extra Espree extra object.
+     * @returns {EsprimaToken} The Esprima version of the token.
+     */
+    translate(token, extra) {
+
+        const type = token.type,
+            tt = this._acornTokTypes,
+
+            // We use an unknown type because `acorn.Token` is a class whose
+            //   `type` property we cannot override to our desired `string`;
+            //   this also allows us to define a stricter `EsprimaToken` with
+            //   a string-only `type` property
+            unknownTokenType = /** @type {unknown} */ (token),
+            newToken = /** @type {EsprimaToken} */ (unknownTokenType);
+
+        if (type === tt.name) {
+            newToken.type = Token.Identifier;
+
+            // TODO: See if this is an Acorn bug
+            if ("value" in token && token.value === "static") {
+                newToken.type = Token.Keyword;
+            }
+
+            if (extra.ecmaVersion > 5 && ("value" in token && (token.value === "yield" || token.value === "let"))) {
+                newToken.type = Token.Keyword;
+            }
+
+        } else if (type === tt.privateId) {
+            newToken.type = Token.PrivateIdentifier;
+
+        } else if (type === tt.semi || type === tt.comma ||
+                 type === tt.parenL || type === tt.parenR ||
+                 type === tt.braceL || type === tt.braceR ||
+                 type === tt.dot || type === tt.bracketL ||
+                 type === tt.colon || type === tt.question ||
+                 type === tt.bracketR || type === tt.ellipsis ||
+                 type === tt.arrow || type === tt.jsxTagStart ||
+                 type === tt.incDec || type === tt.starstar ||
+                 type === tt.jsxTagEnd || type === tt.prefix ||
+                 type === tt.questionDot ||
+                 ("binop" in type && type.binop && !type.keyword) ||
+                 ("isAssign" in type && type.isAssign)) {
+
+            newToken.type = Token.Punctuator;
+            newToken.value = this._code.slice(token.start, token.end);
+        } else if (type === tt.jsxName) {
+            newToken.type = Token.JSXIdentifier;
+        } else if (type.label === "jsxText" || type === tt.jsxAttrValueToken) {
+            newToken.type = Token.JSXText;
+        } else if (type.keyword) {
+            if (type.keyword === "true" || type.keyword === "false") {
+                newToken.type = Token.Boolean;
+            } else if (type.keyword === "null") {
+                newToken.type = Token.Null;
+            } else {
+                newToken.type = Token.Keyword;
+            }
+        } else if (type === tt.num) {
+            newToken.type = Token.Numeric;
+            newToken.value = this._code.slice(token.start, token.end);
+        } else if (type === tt.string) {
+
+            if (extra.jsxAttrValueToken) {
+                extra.jsxAttrValueToken = false;
+                newToken.type = Token.JSXText;
+            } else {
+                newToken.type = Token.String;
+            }
+
+            newToken.value = this._code.slice(token.start, token.end);
+        } else if (type === tt.regexp) {
+            newToken.type = Token.RegularExpression;
+            const value = /** @type {{flags: string, pattern: string}} */ (
+                "value" in token && token.value
+            );
+
+            newToken.regex = {
+                flags: value.flags,
+                pattern: value.pattern
+            };
+            newToken.value = `/${value.pattern}/${value.flags}`;
+        }
+
+        return newToken;
+    }
+
+    /**
+     * Function to call during Acorn's onToken handler.
+     * @param {acorn.Token} token The Acorn token.
+     * @param {Extra} extra The Espree extra object.
+     * @returns {void}
+     */
+    onToken(token, extra) {
+
+        const tt = this._acornTokTypes,
+            tokens = extra.tokens,
+            templateTokens = this._tokens;
+
+        /**
+         * Flushes the buffered template tokens and resets the template
+         * tracking.
+         * @returns {void}
+         * @private
+         */
+        const translateTemplateTokens = () => {
+            tokens.push(convertTemplatePart(this._tokens, this._code));
+            this._tokens = [];
+        };
+
+        if (token.type === tt.eof) {
+
+            // might be one last curlyBrace
+            if (this._curlyBrace) {
+                tokens.push(this.translate(this._curlyBrace, extra));
+            }
+
+            return;
+        }
+
+        if (token.type === tt.backQuote) {
+
+            // if there's already a curly, it's not part of the template
+            if (this._curlyBrace) {
+                tokens.push(this.translate(this._curlyBrace, extra));
+                this._curlyBrace = null;
+            }
+
+            templateTokens.push(token);
+
+            // it's the end
+            if (templateTokens.length > 1) {
+                translateTemplateTokens();
+            }
+
+            return;
+        }
+        if (token.type === tt.dollarBraceL) {
+            templateTokens.push(token);
+            translateTemplateTokens();
+            return;
+        }
+        if (token.type === tt.braceR) {
+
+            // if there's already a curly, it's not part of the template
+            if (this._curlyBrace) {
+                tokens.push(this.translate(this._curlyBrace, extra));
+            }
+
+            // store new curly for later
+            this._curlyBrace = token;
+            return;
+        }
+        if (token.type === tt.template || token.type === tt.invalidTemplate) {
+            if (this._curlyBrace) {
+                templateTokens.push(this._curlyBrace);
+                this._curlyBrace = null;
+            }
+
+            templateTokens.push(token);
+            return;
+        }
+
+        if (this._curlyBrace) {
+            tokens.push(this.translate(this._curlyBrace, extra));
+            this._curlyBrace = null;
+        }
+
+        tokens.push(this.translate(token, extra));
+    }
+}
+
+//------------------------------------------------------------------------------
+// Public
+//------------------------------------------------------------------------------
+
+export default TokenTranslator;

package/packages/config-eslint/node_modules/espree/lib/types.js

@@ -0,0 +1,118 @@
+/**
+ * @import * as acorn from "acorn";
+ * @import { Options, EspreeTokens } from "../espree.js";
+ */
+
+/**
+ * @typedef {acorn.tokTypes & {
+ *   jsxName: acorn.TokenType,
+ *   jsxText: acorn.TokenType,
+ *   jsxTagEnd: acorn.TokenType,
+ *   jsxTagStart: acorn.TokenType
+ * }} TokTypes
+ */
+
+/**
+ * @typedef {new (
+ *   token: string,
+ *   isExpr: boolean,
+ *   preserveSpace: boolean,
+ *   override?: (parser: any) => void
+ * ) => void} TokContext
+ */
+
+/**
+ * @typedef {{
+ *   tc_oTag: TokContext,
+ *   tc_cTag: TokContext,
+ *   tc_expr: TokContext
+ * }} TokContexts
+ */
+
+/**
+ * @typedef {{
+ *   generator?: boolean
+ * } & acorn.Node} EsprimaNode
+ */
+
+/**
+ * @typedef {"Block"|"Hashbang"|"Line"} CommentType
+ */
+
+/**
+ * @typedef {{
+ *   tokenize: () => EspreeTokens,
+ *   parse: () => acorn.Program
+ * }} EspreeParser
+ */
+
+/* eslint-disable jsdoc/valid-types -- Waiting on jsdoc plugin update */
+/**
+ * @typedef {acorn.Parser & {
+ *   jsx_readToken(): string;
+ *   jsx_readNewLine(normalizeCRLF: boolean): void;
+ *   jsx_readString(quote: number): void;
+ *   jsx_readEntity(): string;
+ *   jsx_readWord(): void;
+ *   jsx_parseIdentifier(): acorn.Node;
+ *   jsx_parseNamespacedName(): acorn.Node;
+ *   jsx_parseElementName(): acorn.Node | string;
+ *   jsx_parseAttributeValue(): acorn.Node;
+ *   jsx_parseEmptyExpression(): acorn.Node;
+ *   jsx_parseExpressionContainer(): acorn.Node;
+ *   jsx_parseAttribute(): acorn.Node;
+ *   jsx_parseOpeningElementAt(startPos: number, startLoc?: acorn.SourceLocation): acorn.Node;
+ *   jsx_parseClosingElementAt(startPos: number, startLoc?: acorn.SourceLocation): acorn.Node;
+ *   jsx_parseElementAt(startPos: number, startLoc?: acorn.SourceLocation): acorn.Node;
+ *   jsx_parseText(): acorn.Node;
+ *   jsx_parseElement(): acorn.Node;
+ * }} AcornJsxParser
+ */
+
+/**
+ * We pick (statics) from acorn rather than plain extending to avoid complaint
+ *   about base constructors needing the same return type (i.e., we return
+ *   `AcornJsxParser` here)
+ * @typedef {Pick<typeof acorn.Parser, keyof typeof acorn.Parser> & {
+ *   readonly acornJsx: {
+ *     tokTypes: TokTypes;
+ *     tokContexts: TokContexts
+ *   };
+ *   new (options: acorn.Options, input: string, startPos?: number): AcornJsxParser;
+ * }} AcornJsxParserCtor
+ */
+/**
+ * @typedef {{
+ *   new (opts: Options | null | undefined, code: string | object): EspreeParser
+ * } & Pick<typeof acorn.Parser, keyof typeof acorn.Parser>} EspreeParserCtor
+ */
+/**
+ * @typedef {{
+ *   new (opts: Options | null | undefined, code: string | object): EspreeParser
+ * } & Pick<AcornJsxParserCtor, keyof AcornJsxParserCtor>} EspreeParserJsxCtor
+ */
+
+/**
+ * @typedef {Pick<AcornJsxParserCtor, keyof AcornJsxParserCtor> & {
+ *   acorn: {
+ *     tokTypes: TokTypes,
+ *     getLineInfo: (input: string, pos: number) => {
+ *       line: number,
+ *       column: number
+ *     }
+ *   }
+ *   new (options: acorn.Options, input: string, startPos?: number): AcornJsxParser & {
+ *     next: () => void,
+ *     type: acorn.TokenType,
+ *     curLine: number,
+ *     start: number,
+ *     end: number,
+ *     finishNode (node: acorn.Node, type: string): acorn.Node,
+ *     finishNodeAt (node: acorn.Node, type: string, pos: number, loc: acorn.Position): acorn.Node,
+ *     parseTopLevel (node: acorn.Node): acorn.Node,
+ *     nextToken (): void
+ *   }
+ * }} AcornJsxParserCtorEnhanced
+ */
+
+/* eslint-enable jsdoc/valid-types -- Bug in older versions */

package/packages/config-eslint/node_modules/espree/package.json

@@ -0,0 +1,72 @@
+{
+  "name": "espree",
+  "description": "An Esprima-compatible JavaScript parser built on Acorn",
+  "author": "Nicholas C. Zakas <nicholas+npm@nczconsulting.com>",
+  "homepage": "https://github.com/eslint/js/blob/main/packages/espree/README.md",
+  "main": "dist/espree.cjs",
+  "types": "./dist/espree.d.cts",
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": {
+        "import": "./dist/espree.d.ts",
+        "require": "./dist/espree.d.cts"
+      },
+      "import": "./espree.js",
+      "require": "./dist/espree.cjs",
+      "default": "./dist/espree.cjs"
+    },
+    "./package.json": "./package.json"
+  },
+  "version": "11.1.0",
+  "files": [
+    "lib",
+    "dist",
+    "espree.js"
+  ],
+  "engines": {
+    "node": "^20.19.0 || ^22.13.0 || >=24"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/eslint/js.git",
+    "directory": "packages/espree"
+  },
+  "bugs": {
+    "url": "https://github.com/eslint/js/issues"
+  },
+  "funding": "https://opencollective.com/eslint",
+  "license": "BSD-2-Clause",
+  "dependencies": {
+    "acorn": "^8.15.0",
+    "acorn-jsx": "^5.3.2",
+    "eslint-visitor-keys": "^5.0.0"
+  },
+  "devDependencies": {
+    "@arethetypeswrong/cli": "^0.18.2",
+    "rollup": "^2.79.1",
+    "shelljs": "^0.8.5",
+    "tsd": "^0.33.0",
+    "typescript": "^5.9.3"
+  },
+  "keywords": [
+    "ast",
+    "ecmascript",
+    "javascript",
+    "parser",
+    "syntax",
+    "acorn"
+  ],
+  "scripts": {
+    "build": "rollup -c rollup.config.js && npm run build:types && node -e \"fs.rmSync('dist/lib', { recursive: true })\"",
+    "build:debug": "npm run build -- -m",
+    "build:docs": "node tools/sync-docs.js",
+    "build:types": "tsc && tsc -p tsconfig-cjs.json",
+    "lint:types": "attw --pack",
+    "pretest": "npm run build",
+    "test": "npm run test:types && npm run test:cjs && npm run test:esm",
+    "test:cjs": "mocha --color --reporter progress --timeout 30000 \"tests/**/*.test.cjs\"",
+    "test:esm": "c8 mocha --color --reporter progress --timeout 30000 \"tests/**/*.test.js\"",
+    "test:types": "tsd --typings dist/espree.d.ts"
+  }
+}

package/packages/config-eslint/node_modules/ignore/LICENSE-MIT

@@ -0,0 +1,21 @@
+Copyright (c) 2013 Kael Zhang <i@kael.me>, contributors
+http://kael.me/
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.