corsa-oxlint 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 ubugeeei and contributors
+
+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.

package/README.md

@@ -0,0 +1,171 @@
+# corsa-oxlint
+
+`corsa-oxlint` is a self-hosted `typescript-eslint`-style framework for
+building Oxlint JS plugins with real type information powered by `tsgo`.
+
+> [!WARNING]
+> This package is still an early WIP.
+> The core direction is stable, but the API surface will keep moving while
+> `typescript-go`, Oxlint's JS plugin APIs, and the surrounding benchmarks are
+> still evolving.
+
+## What It Does
+
+- exposes `ESLintUtils.RuleCreator()` and `getParserServices()` backed by `tsgo`
+- preserves the familiar subpath layout without depending on `@typescript-eslint`
+- binds Rust-implemented hot paths into JS through `napi-rs`
+- lets custom Oxlint rules query types and symbols from JS or TS
+- ships a `RuleTester` wrapper that injects temp projects and type-aware config
+- ships a growing TS-native ruleset under `corsa-oxlint/rules`
+
+The design goal is simple: performance-critical pieces live in Rust, `napi-rs`
+bridges them into Node, and end users still get to author custom plugins and
+custom rules in plain JS/TS.
+
+## Configuration
+
+Oxlint does not expose arbitrary parser options at runtime, so
+`corsa-oxlint` reads its type-aware settings from
+`settings.typescriptOxlint`.
+
+```ts
+import { ESLintUtils } from "corsa-oxlint";
+
+const createRule = ESLintUtils.RuleCreator((name) => `https://example.com/rules/${name}`);
+
+export const noStringPlusNumber = createRule({
+  name: "no-string-plus-number",
+  meta: {
+    type: "problem",
+    docs: {
+      description: "forbid string + number",
+      requiresTypeChecking: true,
+    },
+    messages: {
+      unexpected: "string plus number is forbidden",
+    },
+    schema: [],
+  },
+  defaultOptions: [],
+  create(context) {
+    const services = ESLintUtils.getParserServices(context);
+    const checker = services.program.getTypeChecker();
+
+    return {
+      BinaryExpression(node) {
+        if (node.operator !== "+") {
+          return;
+        }
+        const left = checker.getTypeAtLocation(node.left);
+        const right = checker.getTypeAtLocation(node.right);
+        if (!left || !right) {
+          return;
+        }
+        const leftText = checker.typeToString(checker.getBaseTypeOfLiteralType(left) ?? left);
+        const rightText = checker.typeToString(checker.getBaseTypeOfLiteralType(right) ?? right);
+        if (leftText === "string" && rightText === "number") {
+          context.report({ node, messageId: "unexpected" });
+        }
+      },
+    };
+  },
+});
+```
+
+```js
+export default [
+  {
+    settings: {
+      typescriptOxlint: {
+        parserOptions: {
+          project: ["./tsconfig.json"],
+          tsconfigRootDir: import.meta.dirname,
+          tsgo: {
+            executable: "./.cache/tsgo",
+            mode: "msgpack",
+            requestTimeoutMs: 30000,
+          },
+        },
+      },
+    },
+  },
+];
+```
+
+## Native Rules
+
+`corsa-oxlint/rules` exports the TS-native rule set and plugin surface.
+Rule parity is tracked against upstream `tsgolint/internal/rules`, but the
+runtime implementation lives entirely in this package.
+
+```ts
+import { typescriptOxlintPlugin } from "corsa-oxlint/rules";
+
+export default [
+  {
+    plugins: {
+      typescript: typescriptOxlintPlugin,
+    },
+    rules: {
+      "typescript/no-floating-promises": "error",
+      "typescript/prefer-promise-reject-errors": "error",
+      "typescript/restrict-plus-operands": ["error", { allowNumberAndString: false }],
+    },
+  },
+];
+```
+
+Current native coverage includes:
+
+- `await-thenable`
+- `no-array-delete`
+- `no-base-to-string`
+- `no-floating-promises`
+- `no-for-in-array`
+- `no-implied-eval`
+- `no-mixed-enums`
+- `no-unsafe-assignment`
+- `no-unsafe-return`
+- `no-unsafe-unary-minus`
+- `only-throw-error`
+- `prefer-find`
+- `prefer-includes`
+- `prefer-promise-reject-errors`
+- `prefer-regexp-exec`
+- `prefer-string-starts-ends-with`
+- `require-array-sort-compare`
+- `restrict-plus-operands`
+- `use-unknown-in-catch-callback-variable`
+
+The remaining upstream rules stay listed in `pendingNativeRuleNames`, and
+`native_rules.test.ts` fails if implemented + pending drift away from the
+tracked upstream rule list.
+
+## Runtime Safety Controls
+
+The underlying `@corsa-bind/napi` client now exposes a few production-oriented
+runtime controls:
+
+- `requestTimeoutMs`
+- `shutdownTimeoutMs`
+- `outboundCapacity`
+- `allowUnstableUpstreamCalls`
+
+Leaving `allowUnstableUpstreamCalls` unset keeps unstable upstream endpoints
+such as `printNode` disabled by default.
+
+## Development
+
+```bash
+vp install
+vp run -w build_typescript_oxlint
+vp fmt
+vp lint
+vp check
+vp test run --config ./vite.config.ts src/bindings/nodejs/typescript_oxlint/ts/**/*.test.ts
+vp test bench --config ./vite.config.ts bench/src/typescript_oxlint.bench.ts
+vp test bench --config ./vite.config.ts bench/src/typescript_oxlint_rules.bench.ts
+```
+
+Repository-level examples live under [`examples/`](../../examples/README.md),
+including custom-rule, custom-plugin, and native-rules flat-config samples.

package/dist/_virtual/_rolldown/runtime.js

@@ -0,0 +1,13 @@
+//#region \0rolldown/runtime.js
+var __defProp = Object.defineProperty;
+var __exportAll = (all, no_symbols) => {
+	let target = {};
+	for (var name in all) __defProp(target, name, {
+		get: all[name],
+		enumerable: true
+	});
+	if (!no_symbols) __defProp(target, Symbol.toStringTag, { value: "Module" });
+	return target;
+};
+//#endregion
+export { __exportAll };

package/dist/ast_utils.d.ts

@@ -0,0 +1,17 @@
+declare namespace ast_utils_d_exports {
+  export { ASTUtils, isIdentifier, isNodeOfType };
+}
+declare function isNodeOfType(node: {
+  readonly type?: string;
+} | null | undefined, type: string): boolean;
+declare function isIdentifier(node: {
+  readonly type?: string;
+  readonly name?: string;
+} | null | undefined, name?: string): boolean;
+declare const ASTUtils: Readonly<{
+  isIdentifier: typeof isIdentifier;
+  isNodeOfType: typeof isNodeOfType;
+}>;
+//#endregion
+export { ASTUtils, ast_utils_d_exports, isIdentifier, isNodeOfType };
+//# sourceMappingURL=ast_utils.d.ts.map

package/dist/ast_utils.js

@@ -0,0 +1,21 @@
+import { __exportAll } from "./_virtual/_rolldown/runtime.js";
+//#region src/bindings/nodejs/typescript_oxlint/ts/ast_utils.ts
+var ast_utils_exports = /* @__PURE__ */ __exportAll({
+	ASTUtils: () => ASTUtils,
+	isIdentifier: () => isIdentifier,
+	isNodeOfType: () => isNodeOfType
+});
+function isNodeOfType(node, type) {
+	return node?.type === type;
+}
+function isIdentifier(node, name) {
+	return node?.type === "Identifier" && (name === void 0 || node.name === name);
+}
+const ASTUtils = Object.freeze({
+	isIdentifier,
+	isNodeOfType
+});
+//#endregion
+export { ASTUtils, ast_utils_exports, isIdentifier, isNodeOfType };
+
+//# sourceMappingURL=ast_utils.js.map

package/dist/ast_utils.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ast_utils.js","names":[],"sources":["../ts/ast_utils.ts"],"sourcesContent":["export function isNodeOfType(\n  node: { readonly type?: string } | null | undefined,\n  type: string,\n): boolean {\n  return node?.type === type;\n}\n\nexport function isIdentifier(\n  node: { readonly type?: string; readonly name?: string } | null | undefined,\n  name?: string,\n): boolean {\n  return node?.type === \"Identifier\" && (name === undefined || node.name === name);\n}\n\nexport const ASTUtils = Object.freeze({\n  isIdentifier,\n  isNodeOfType,\n});\n"],"mappings":";;;;;;;AAAA,SAAgB,aACd,MACA,MACS;AACT,QAAO,MAAM,SAAS;;AAGxB,SAAgB,aACd,MACA,MACS;AACT,QAAO,MAAM,SAAS,iBAAiB,SAAS,KAAA,KAAa,KAAK,SAAS;;AAG7E,MAAa,WAAW,OAAO,OAAO;CACpC;CACA;CACD,CAAC"}

package/dist/checker.d.ts

@@ -0,0 +1,11 @@
+import { ContextWithParserOptions, TsgoProgramShape, TsgoTypeCheckerShape } from "./types.js";
+import { createNodeMaps } from "./node_map.js";
+
+//#region src/bindings/nodejs/typescript_oxlint/ts/checker.d.ts
+declare function createProgram(context: ContextWithParserOptions): TsgoProgramShape & {
+  readonly nodeMaps: ReturnType<typeof createNodeMaps>;
+};
+declare function createTypeChecker(context: ContextWithParserOptions): TsgoTypeCheckerShape;
+//#endregion
+export { createProgram, createTypeChecker };
+//# sourceMappingURL=checker.d.ts.map

package/dist/checker.js

@@ -0,0 +1,80 @@
+import { createNodeMaps, toPosition } from "./node_map.js";
+import { sessionForContext } from "./registry.js";
+//#region src/bindings/nodejs/typescript_oxlint/ts/checker.ts
+function createProgram(context) {
+	return {
+		nodeMaps: createNodeMaps(context),
+		getCompilerOptions() {
+			return sessionForContext(context).session.getCompilerOptions();
+		},
+		getCurrentDirectory() {
+			return sessionForContext(context).project.rootDir;
+		},
+		getRootFileNames() {
+			return sessionForContext(context).session.getRootFileNames();
+		},
+		getSourceFile(fileName = context.filename) {
+			return {
+				fileName,
+				text: context.sourceCode.text
+			};
+		},
+		getTypeChecker() {
+			return createTypeChecker(context);
+		}
+	};
+}
+function createTypeChecker(context) {
+	return {
+		getTypeAtLocation(node) {
+			return sessionForContext(context).session.getTypeAtPosition(filenameFor(context, node), toPosition(node));
+		},
+		getContextualType(node) {
+			return this.getTypeAtLocation(node);
+		},
+		getSymbolAtLocation(node) {
+			return sessionForContext(context).session.getSymbolAtPosition(filenameFor(context, node), toPosition(node));
+		},
+		getTypeOfSymbol(symbol) {
+			return sessionForContext(context).session.getTypeOfSymbol(symbol);
+		},
+		getDeclaredTypeOfSymbol(symbol) {
+			return sessionForContext(context).session.getDeclaredTypeOfSymbol(symbol);
+		},
+		getTypeOfSymbolAtLocation(symbol, node) {
+			return this.getTypeAtLocation(node) ?? this.getTypeOfSymbol(symbol);
+		},
+		typeToString(type, enclosingDeclaration, flags) {
+			return sessionForContext(context).session.typeToString(type, flags);
+		},
+		getBaseTypeOfLiteralType(type) {
+			return sessionForContext(context).session.getBaseTypeOfLiteralType(type);
+		},
+		getPropertiesOfType(type) {
+			return sessionForContext(context).session.getPropertiesOfType(type);
+		},
+		getSignaturesOfType(type, kind) {
+			return sessionForContext(context).session.getSignaturesOfType(type, kind);
+		},
+		getReturnTypeOfSignature(signature) {
+			return sessionForContext(context).session.getReturnTypeOfSignature(signature);
+		},
+		getTypePredicateOfSignature(signature) {
+			return sessionForContext(context).session.getTypePredicateOfSignature(signature);
+		},
+		getBaseTypes(type) {
+			return sessionForContext(context).session.getBaseTypes(type);
+		},
+		getTypeArguments(type) {
+			return sessionForContext(context).session.getTypeArguments(type);
+		}
+	};
+}
+function filenameFor(context, node) {
+	if ("fileName" in node) return node.fileName;
+	return context.filename;
+}
+//#endregion
+export { createProgram, createTypeChecker };
+
+//# sourceMappingURL=checker.js.map

package/dist/checker.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"checker.js","names":[],"sources":["../ts/checker.ts"],"sourcesContent":["import type { Node } from \"@oxlint/plugins\";\n\nimport { createNodeMaps, toPosition } from \"./node_map\";\nimport { sessionForContext } from \"./registry\";\nimport type {\n  ContextWithParserOptions,\n  TsgoNode,\n  TsgoProgramShape,\n  TsgoSignature,\n  TsgoSymbol,\n  TsgoType,\n  TsgoTypeCheckerShape,\n} from \"./types\";\n\nexport function createProgram(\n  context: ContextWithParserOptions,\n): TsgoProgramShape & { readonly nodeMaps: ReturnType<typeof createNodeMaps> } {\n  const nodeMaps = createNodeMaps(context);\n  return {\n    nodeMaps,\n    getCompilerOptions() {\n      return sessionForContext(context).session.getCompilerOptions();\n    },\n    getCurrentDirectory() {\n      return sessionForContext(context).project.rootDir;\n    },\n    getRootFileNames() {\n      return sessionForContext(context).session.getRootFileNames();\n    },\n    getSourceFile(fileName = context.filename) {\n      return { fileName, text: context.sourceCode.text };\n    },\n    getTypeChecker() {\n      return createTypeChecker(context);\n    },\n  };\n}\n\nexport function createTypeChecker(context: ContextWithParserOptions): TsgoTypeCheckerShape {\n  return {\n    getTypeAtLocation(node) {\n      return sessionForContext(context).session.getTypeAtPosition(\n        filenameFor(context, node),\n        toPosition(node),\n      );\n    },\n    getContextualType(node) {\n      return this.getTypeAtLocation(node);\n    },\n    getSymbolAtLocation(node) {\n      return sessionForContext(context).session.getSymbolAtPosition(\n        filenameFor(context, node),\n        toPosition(node),\n      );\n    },\n    getTypeOfSymbol(symbol) {\n      return sessionForContext(context).session.getTypeOfSymbol(symbol);\n    },\n    getDeclaredTypeOfSymbol(symbol) {\n      return sessionForContext(context).session.getDeclaredTypeOfSymbol(symbol);\n    },\n    getTypeOfSymbolAtLocation(symbol, node) {\n      return this.getTypeAtLocation(node) ?? this.getTypeOfSymbol(symbol);\n    },\n    typeToString(type, enclosingDeclaration, flags) {\n      void enclosingDeclaration;\n      return sessionForContext(context).session.typeToString(type, flags);\n    },\n    getBaseTypeOfLiteralType(type) {\n      return sessionForContext(context).session.getBaseTypeOfLiteralType(type);\n    },\n    getPropertiesOfType(type) {\n      return sessionForContext(context).session.getPropertiesOfType(type);\n    },\n    getSignaturesOfType(type, kind) {\n      return sessionForContext(context).session.getSignaturesOfType(type, kind);\n    },\n    getReturnTypeOfSignature(signature) {\n      return sessionForContext(context).session.getReturnTypeOfSignature(signature);\n    },\n    getTypePredicateOfSignature(signature) {\n      return sessionForContext(context).session.getTypePredicateOfSignature(signature);\n    },\n    getBaseTypes(type) {\n      return sessionForContext(context).session.getBaseTypes(type);\n    },\n    getTypeArguments(type) {\n      return sessionForContext(context).session.getTypeArguments(type);\n    },\n  };\n}\n\nfunction filenameFor(\n  context: ContextWithParserOptions,\n  node: Node | TsgoNode | TsgoType | TsgoSymbol | TsgoSignature,\n): string {\n  if (\"fileName\" in node) {\n    return node.fileName;\n  }\n  return context.filename;\n}\n"],"mappings":";;;AAcA,SAAgB,cACd,SAC6E;AAE7E,QAAO;EACL,UAFe,eAAe,QAAQ;EAGtC,qBAAqB;AACnB,UAAO,kBAAkB,QAAQ,CAAC,QAAQ,oBAAoB;;EAEhE,sBAAsB;AACpB,UAAO,kBAAkB,QAAQ,CAAC,QAAQ;;EAE5C,mBAAmB;AACjB,UAAO,kBAAkB,QAAQ,CAAC,QAAQ,kBAAkB;;EAE9D,cAAc,WAAW,QAAQ,UAAU;AACzC,UAAO;IAAE;IAAU,MAAM,QAAQ,WAAW;IAAM;;EAEpD,iBAAiB;AACf,UAAO,kBAAkB,QAAQ;;EAEpC;;AAGH,SAAgB,kBAAkB,SAAyD;AACzF,QAAO;EACL,kBAAkB,MAAM;AACtB,UAAO,kBAAkB,QAAQ,CAAC,QAAQ,kBACxC,YAAY,SAAS,KAAK,EAC1B,WAAW,KAAK,CACjB;;EAEH,kBAAkB,MAAM;AACtB,UAAO,KAAK,kBAAkB,KAAK;;EAErC,oBAAoB,MAAM;AACxB,UAAO,kBAAkB,QAAQ,CAAC,QAAQ,oBACxC,YAAY,SAAS,KAAK,EAC1B,WAAW,KAAK,CACjB;;EAEH,gBAAgB,QAAQ;AACtB,UAAO,kBAAkB,QAAQ,CAAC,QAAQ,gBAAgB,OAAO;;EAEnE,wBAAwB,QAAQ;AAC9B,UAAO,kBAAkB,QAAQ,CAAC,QAAQ,wBAAwB,OAAO;;EAE3E,0BAA0B,QAAQ,MAAM;AACtC,UAAO,KAAK,kBAAkB,KAAK,IAAI,KAAK,gBAAgB,OAAO;;EAErE,aAAa,MAAM,sBAAsB,OAAO;AAE9C,UAAO,kBAAkB,QAAQ,CAAC,QAAQ,aAAa,MAAM,MAAM;;EAErE,yBAAyB,MAAM;AAC7B,UAAO,kBAAkB,QAAQ,CAAC,QAAQ,yBAAyB,KAAK;;EAE1E,oBAAoB,MAAM;AACxB,UAAO,kBAAkB,QAAQ,CAAC,QAAQ,oBAAoB,KAAK;;EAErE,oBAAoB,MAAM,MAAM;AAC9B,UAAO,kBAAkB,QAAQ,CAAC,QAAQ,oBAAoB,MAAM,KAAK;;EAE3E,yBAAyB,WAAW;AAClC,UAAO,kBAAkB,QAAQ,CAAC,QAAQ,yBAAyB,UAAU;;EAE/E,4BAA4B,WAAW;AACrC,UAAO,kBAAkB,QAAQ,CAAC,QAAQ,4BAA4B,UAAU;;EAElF,aAAa,MAAM;AACjB,UAAO,kBAAkB,QAAQ,CAAC,QAAQ,aAAa,KAAK;;EAE9D,iBAAiB,MAAM;AACrB,UAAO,kBAAkB,QAAQ,CAAC,QAAQ,iBAAiB,KAAK;;EAEnE;;AAGH,SAAS,YACP,SACA,MACQ;AACR,KAAI,cAAc,KAChB,QAAO,KAAK;AAEd,QAAO,QAAQ"}

package/dist/compat.d.ts

@@ -0,0 +1,194 @@
+//#region src/bindings/nodejs/typescript_oxlint/ts/compat.d.ts
+declare const AST_NODE_TYPES: Readonly<{
+  readonly ArrayExpression: "ArrayExpression";
+  readonly ArrowFunctionExpression: "ArrowFunctionExpression";
+  readonly AssignmentExpression: "AssignmentExpression";
+  readonly AwaitExpression: "AwaitExpression";
+  readonly BinaryExpression: "BinaryExpression";
+  readonly BlockStatement: "BlockStatement";
+  readonly CallExpression: "CallExpression";
+  readonly CatchClause: "CatchClause";
+  readonly ChainExpression: "ChainExpression";
+  readonly ConditionalExpression: "ConditionalExpression";
+  readonly ExpressionStatement: "ExpressionStatement";
+  readonly ForInStatement: "ForInStatement";
+  readonly ForOfStatement: "ForOfStatement";
+  readonly FunctionDeclaration: "FunctionDeclaration";
+  readonly FunctionExpression: "FunctionExpression";
+  readonly Identifier: "Identifier";
+  readonly IfStatement: "IfStatement";
+  readonly ImportDeclaration: "ImportDeclaration";
+  readonly Literal: "Literal";
+  readonly LogicalExpression: "LogicalExpression";
+  readonly MemberExpression: "MemberExpression";
+  readonly MethodDefinition: "MethodDefinition";
+  readonly NewExpression: "NewExpression";
+  readonly ObjectExpression: "ObjectExpression";
+  readonly Program: "Program";
+  readonly Property: "Property";
+  readonly ReturnStatement: "ReturnStatement";
+  readonly SequenceExpression: "SequenceExpression";
+  readonly SpreadElement: "SpreadElement";
+  readonly SwitchStatement: "SwitchStatement";
+  readonly TaggedTemplateExpression: "TaggedTemplateExpression";
+  readonly TemplateLiteral: "TemplateLiteral";
+  readonly ThrowStatement: "ThrowStatement";
+  readonly TryStatement: "TryStatement";
+  readonly UnaryExpression: "UnaryExpression";
+  readonly UpdateExpression: "UpdateExpression";
+  readonly VariableDeclaration: "VariableDeclaration";
+  readonly VariableDeclarator: "VariableDeclarator";
+  readonly TSAnyKeyword: "TSAnyKeyword";
+  readonly TSAsExpression: "TSAsExpression";
+  readonly TSBooleanKeyword: "TSBooleanKeyword";
+  readonly TSCallSignatureDeclaration: "TSCallSignatureDeclaration";
+  readonly TSConditionalType: "TSConditionalType";
+  readonly TSConstructSignatureDeclaration: "TSConstructSignatureDeclaration";
+  readonly TSDeclareFunction: "TSDeclareFunction";
+  readonly TSEnumDeclaration: "TSEnumDeclaration";
+  readonly TSExpressionWithTypeArguments: "TSExpressionWithTypeArguments";
+  readonly TSFunctionType: "TSFunctionType";
+  readonly TSImportType: "TSImportType";
+  readonly TSIndexedAccessType: "TSIndexedAccessType";
+  readonly TSInferType: "TSInferType";
+  readonly TSInterfaceDeclaration: "TSInterfaceDeclaration";
+  readonly TSLiteralType: "TSLiteralType";
+  readonly TSMappedType: "TSMappedType";
+  readonly TSMethodSignature: "TSMethodSignature";
+  readonly TSModuleDeclaration: "TSModuleDeclaration";
+  readonly TSNeverKeyword: "TSNeverKeyword";
+  readonly TSNullKeyword: "TSNullKeyword";
+  readonly TSNumberKeyword: "TSNumberKeyword";
+  readonly TSObjectKeyword: "TSObjectKeyword";
+  readonly TSPropertySignature: "TSPropertySignature";
+  readonly TSStringKeyword: "TSStringKeyword";
+  readonly TSThisType: "TSThisType";
+  readonly TSTupleType: "TSTupleType";
+  readonly TSTypeAliasDeclaration: "TSTypeAliasDeclaration";
+  readonly TSTypeAnnotation: "TSTypeAnnotation";
+  readonly TSTypeAssertion: "TSTypeAssertion";
+  readonly TSTypeLiteral: "TSTypeLiteral";
+  readonly TSTypeOperator: "TSTypeOperator";
+  readonly TSTypeParameter: "TSTypeParameter";
+  readonly TSTypeParameterDeclaration: "TSTypeParameterDeclaration";
+  readonly TSTypeParameterInstantiation: "TSTypeParameterInstantiation";
+  readonly TSTypePredicate: "TSTypePredicate";
+  readonly TSTypeReference: "TSTypeReference";
+  readonly TSUndefinedKeyword: "TSUndefinedKeyword";
+  readonly TSUnionType: "TSUnionType";
+  readonly TSUnknownKeyword: "TSUnknownKeyword";
+  readonly TSVoidKeyword: "TSVoidKeyword";
+}>;
+declare const AST_TOKEN_TYPES: Readonly<{
+  readonly Boolean: "Boolean";
+  readonly Identifier: "Identifier";
+  readonly JSXIdentifier: "JSXIdentifier";
+  readonly JSXText: "JSXText";
+  readonly Keyword: "Keyword";
+  readonly Null: "Null";
+  readonly Numeric: "Numeric";
+  readonly PrivateIdentifier: "PrivateIdentifier";
+  readonly Punctuator: "Punctuator";
+  readonly RegularExpression: "RegularExpression";
+  readonly String: "String";
+  readonly Template: "Template";
+}>;
+declare const TSESTree: Readonly<{
+  AST_NODE_TYPES: Readonly<{
+    readonly ArrayExpression: "ArrayExpression";
+    readonly ArrowFunctionExpression: "ArrowFunctionExpression";
+    readonly AssignmentExpression: "AssignmentExpression";
+    readonly AwaitExpression: "AwaitExpression";
+    readonly BinaryExpression: "BinaryExpression";
+    readonly BlockStatement: "BlockStatement";
+    readonly CallExpression: "CallExpression";
+    readonly CatchClause: "CatchClause";
+    readonly ChainExpression: "ChainExpression";
+    readonly ConditionalExpression: "ConditionalExpression";
+    readonly ExpressionStatement: "ExpressionStatement";
+    readonly ForInStatement: "ForInStatement";
+    readonly ForOfStatement: "ForOfStatement";
+    readonly FunctionDeclaration: "FunctionDeclaration";
+    readonly FunctionExpression: "FunctionExpression";
+    readonly Identifier: "Identifier";
+    readonly IfStatement: "IfStatement";
+    readonly ImportDeclaration: "ImportDeclaration";
+    readonly Literal: "Literal";
+    readonly LogicalExpression: "LogicalExpression";
+    readonly MemberExpression: "MemberExpression";
+    readonly MethodDefinition: "MethodDefinition";
+    readonly NewExpression: "NewExpression";
+    readonly ObjectExpression: "ObjectExpression";
+    readonly Program: "Program";
+    readonly Property: "Property";
+    readonly ReturnStatement: "ReturnStatement";
+    readonly SequenceExpression: "SequenceExpression";
+    readonly SpreadElement: "SpreadElement";
+    readonly SwitchStatement: "SwitchStatement";
+    readonly TaggedTemplateExpression: "TaggedTemplateExpression";
+    readonly TemplateLiteral: "TemplateLiteral";
+    readonly ThrowStatement: "ThrowStatement";
+    readonly TryStatement: "TryStatement";
+    readonly UnaryExpression: "UnaryExpression";
+    readonly UpdateExpression: "UpdateExpression";
+    readonly VariableDeclaration: "VariableDeclaration";
+    readonly VariableDeclarator: "VariableDeclarator";
+    readonly TSAnyKeyword: "TSAnyKeyword";
+    readonly TSAsExpression: "TSAsExpression";
+    readonly TSBooleanKeyword: "TSBooleanKeyword";
+    readonly TSCallSignatureDeclaration: "TSCallSignatureDeclaration";
+    readonly TSConditionalType: "TSConditionalType";
+    readonly TSConstructSignatureDeclaration: "TSConstructSignatureDeclaration";
+    readonly TSDeclareFunction: "TSDeclareFunction";
+    readonly TSEnumDeclaration: "TSEnumDeclaration";
+    readonly TSExpressionWithTypeArguments: "TSExpressionWithTypeArguments";
+    readonly TSFunctionType: "TSFunctionType";
+    readonly TSImportType: "TSImportType";
+    readonly TSIndexedAccessType: "TSIndexedAccessType";
+    readonly TSInferType: "TSInferType";
+    readonly TSInterfaceDeclaration: "TSInterfaceDeclaration";
+    readonly TSLiteralType: "TSLiteralType";
+    readonly TSMappedType: "TSMappedType";
+    readonly TSMethodSignature: "TSMethodSignature";
+    readonly TSModuleDeclaration: "TSModuleDeclaration";
+    readonly TSNeverKeyword: "TSNeverKeyword";
+    readonly TSNullKeyword: "TSNullKeyword";
+    readonly TSNumberKeyword: "TSNumberKeyword";
+    readonly TSObjectKeyword: "TSObjectKeyword";
+    readonly TSPropertySignature: "TSPropertySignature";
+    readonly TSStringKeyword: "TSStringKeyword";
+    readonly TSThisType: "TSThisType";
+    readonly TSTupleType: "TSTupleType";
+    readonly TSTypeAliasDeclaration: "TSTypeAliasDeclaration";
+    readonly TSTypeAnnotation: "TSTypeAnnotation";
+    readonly TSTypeAssertion: "TSTypeAssertion";
+    readonly TSTypeLiteral: "TSTypeLiteral";
+    readonly TSTypeOperator: "TSTypeOperator";
+    readonly TSTypeParameter: "TSTypeParameter";
+    readonly TSTypeParameterDeclaration: "TSTypeParameterDeclaration";
+    readonly TSTypeParameterInstantiation: "TSTypeParameterInstantiation";
+    readonly TSTypePredicate: "TSTypePredicate";
+    readonly TSTypeReference: "TSTypeReference";
+    readonly TSUndefinedKeyword: "TSUndefinedKeyword";
+    readonly TSUnionType: "TSUnionType";
+    readonly TSUnknownKeyword: "TSUnknownKeyword";
+    readonly TSVoidKeyword: "TSVoidKeyword";
+  }>;
+  AST_TOKEN_TYPES: Readonly<{
+    readonly Boolean: "Boolean";
+    readonly Identifier: "Identifier";
+    readonly JSXIdentifier: "JSXIdentifier";
+    readonly JSXText: "JSXText";
+    readonly Keyword: "Keyword";
+    readonly Null: "Null";
+    readonly Numeric: "Numeric";
+    readonly PrivateIdentifier: "PrivateIdentifier";
+    readonly Punctuator: "Punctuator";
+    readonly RegularExpression: "RegularExpression";
+    readonly String: "String";
+    readonly Template: "Template";
+  }>;
+}>;
+//#endregion
+export { AST_NODE_TYPES, AST_TOKEN_TYPES, TSESTree };
+//# sourceMappingURL=compat.d.ts.map

package/dist/compat.js

@@ -0,0 +1,103 @@
+//#region src/bindings/nodejs/typescript_oxlint/ts/compat.ts
+const AST_NODE_TYPES = Object.freeze({
+	ArrayExpression: "ArrayExpression",
+	ArrowFunctionExpression: "ArrowFunctionExpression",
+	AssignmentExpression: "AssignmentExpression",
+	AwaitExpression: "AwaitExpression",
+	BinaryExpression: "BinaryExpression",
+	BlockStatement: "BlockStatement",
+	CallExpression: "CallExpression",
+	CatchClause: "CatchClause",
+	ChainExpression: "ChainExpression",
+	ConditionalExpression: "ConditionalExpression",
+	ExpressionStatement: "ExpressionStatement",
+	ForInStatement: "ForInStatement",
+	ForOfStatement: "ForOfStatement",
+	FunctionDeclaration: "FunctionDeclaration",
+	FunctionExpression: "FunctionExpression",
+	Identifier: "Identifier",
+	IfStatement: "IfStatement",
+	ImportDeclaration: "ImportDeclaration",
+	Literal: "Literal",
+	LogicalExpression: "LogicalExpression",
+	MemberExpression: "MemberExpression",
+	MethodDefinition: "MethodDefinition",
+	NewExpression: "NewExpression",
+	ObjectExpression: "ObjectExpression",
+	Program: "Program",
+	Property: "Property",
+	ReturnStatement: "ReturnStatement",
+	SequenceExpression: "SequenceExpression",
+	SpreadElement: "SpreadElement",
+	SwitchStatement: "SwitchStatement",
+	TaggedTemplateExpression: "TaggedTemplateExpression",
+	TemplateLiteral: "TemplateLiteral",
+	ThrowStatement: "ThrowStatement",
+	TryStatement: "TryStatement",
+	UnaryExpression: "UnaryExpression",
+	UpdateExpression: "UpdateExpression",
+	VariableDeclaration: "VariableDeclaration",
+	VariableDeclarator: "VariableDeclarator",
+	TSAnyKeyword: "TSAnyKeyword",
+	TSAsExpression: "TSAsExpression",
+	TSBooleanKeyword: "TSBooleanKeyword",
+	TSCallSignatureDeclaration: "TSCallSignatureDeclaration",
+	TSConditionalType: "TSConditionalType",
+	TSConstructSignatureDeclaration: "TSConstructSignatureDeclaration",
+	TSDeclareFunction: "TSDeclareFunction",
+	TSEnumDeclaration: "TSEnumDeclaration",
+	TSExpressionWithTypeArguments: "TSExpressionWithTypeArguments",
+	TSFunctionType: "TSFunctionType",
+	TSImportType: "TSImportType",
+	TSIndexedAccessType: "TSIndexedAccessType",
+	TSInferType: "TSInferType",
+	TSInterfaceDeclaration: "TSInterfaceDeclaration",
+	TSLiteralType: "TSLiteralType",
+	TSMappedType: "TSMappedType",
+	TSMethodSignature: "TSMethodSignature",
+	TSModuleDeclaration: "TSModuleDeclaration",
+	TSNeverKeyword: "TSNeverKeyword",
+	TSNullKeyword: "TSNullKeyword",
+	TSNumberKeyword: "TSNumberKeyword",
+	TSObjectKeyword: "TSObjectKeyword",
+	TSPropertySignature: "TSPropertySignature",
+	TSStringKeyword: "TSStringKeyword",
+	TSThisType: "TSThisType",
+	TSTupleType: "TSTupleType",
+	TSTypeAliasDeclaration: "TSTypeAliasDeclaration",
+	TSTypeAnnotation: "TSTypeAnnotation",
+	TSTypeAssertion: "TSTypeAssertion",
+	TSTypeLiteral: "TSTypeLiteral",
+	TSTypeOperator: "TSTypeOperator",
+	TSTypeParameter: "TSTypeParameter",
+	TSTypeParameterDeclaration: "TSTypeParameterDeclaration",
+	TSTypeParameterInstantiation: "TSTypeParameterInstantiation",
+	TSTypePredicate: "TSTypePredicate",
+	TSTypeReference: "TSTypeReference",
+	TSUndefinedKeyword: "TSUndefinedKeyword",
+	TSUnionType: "TSUnionType",
+	TSUnknownKeyword: "TSUnknownKeyword",
+	TSVoidKeyword: "TSVoidKeyword"
+});
+const AST_TOKEN_TYPES = Object.freeze({
+	Boolean: "Boolean",
+	Identifier: "Identifier",
+	JSXIdentifier: "JSXIdentifier",
+	JSXText: "JSXText",
+	Keyword: "Keyword",
+	Null: "Null",
+	Numeric: "Numeric",
+	PrivateIdentifier: "PrivateIdentifier",
+	Punctuator: "Punctuator",
+	RegularExpression: "RegularExpression",
+	String: "String",
+	Template: "Template"
+});
+const TSESTree = Object.freeze({
+	AST_NODE_TYPES,
+	AST_TOKEN_TYPES
+});
+//#endregion
+export { AST_NODE_TYPES, AST_TOKEN_TYPES, TSESTree };
+
+//# sourceMappingURL=compat.js.map

package/dist/compat.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"compat.js","names":[],"sources":["../ts/compat.ts"],"sourcesContent":["export const AST_NODE_TYPES = Object.freeze({\n  ArrayExpression: \"ArrayExpression\",\n  ArrowFunctionExpression: \"ArrowFunctionExpression\",\n  AssignmentExpression: \"AssignmentExpression\",\n  AwaitExpression: \"AwaitExpression\",\n  BinaryExpression: \"BinaryExpression\",\n  BlockStatement: \"BlockStatement\",\n  CallExpression: \"CallExpression\",\n  CatchClause: \"CatchClause\",\n  ChainExpression: \"ChainExpression\",\n  ConditionalExpression: \"ConditionalExpression\",\n  ExpressionStatement: \"ExpressionStatement\",\n  ForInStatement: \"ForInStatement\",\n  ForOfStatement: \"ForOfStatement\",\n  FunctionDeclaration: \"FunctionDeclaration\",\n  FunctionExpression: \"FunctionExpression\",\n  Identifier: \"Identifier\",\n  IfStatement: \"IfStatement\",\n  ImportDeclaration: \"ImportDeclaration\",\n  Literal: \"Literal\",\n  LogicalExpression: \"LogicalExpression\",\n  MemberExpression: \"MemberExpression\",\n  MethodDefinition: \"MethodDefinition\",\n  NewExpression: \"NewExpression\",\n  ObjectExpression: \"ObjectExpression\",\n  Program: \"Program\",\n  Property: \"Property\",\n  ReturnStatement: \"ReturnStatement\",\n  SequenceExpression: \"SequenceExpression\",\n  SpreadElement: \"SpreadElement\",\n  SwitchStatement: \"SwitchStatement\",\n  TaggedTemplateExpression: \"TaggedTemplateExpression\",\n  TemplateLiteral: \"TemplateLiteral\",\n  ThrowStatement: \"ThrowStatement\",\n  TryStatement: \"TryStatement\",\n  UnaryExpression: \"UnaryExpression\",\n  UpdateExpression: \"UpdateExpression\",\n  VariableDeclaration: \"VariableDeclaration\",\n  VariableDeclarator: \"VariableDeclarator\",\n  TSAnyKeyword: \"TSAnyKeyword\",\n  TSAsExpression: \"TSAsExpression\",\n  TSBooleanKeyword: \"TSBooleanKeyword\",\n  TSCallSignatureDeclaration: \"TSCallSignatureDeclaration\",\n  TSConditionalType: \"TSConditionalType\",\n  TSConstructSignatureDeclaration: \"TSConstructSignatureDeclaration\",\n  TSDeclareFunction: \"TSDeclareFunction\",\n  TSEnumDeclaration: \"TSEnumDeclaration\",\n  TSExpressionWithTypeArguments: \"TSExpressionWithTypeArguments\",\n  TSFunctionType: \"TSFunctionType\",\n  TSImportType: \"TSImportType\",\n  TSIndexedAccessType: \"TSIndexedAccessType\",\n  TSInferType: \"TSInferType\",\n  TSInterfaceDeclaration: \"TSInterfaceDeclaration\",\n  TSLiteralType: \"TSLiteralType\",\n  TSMappedType: \"TSMappedType\",\n  TSMethodSignature: \"TSMethodSignature\",\n  TSModuleDeclaration: \"TSModuleDeclaration\",\n  TSNeverKeyword: \"TSNeverKeyword\",\n  TSNullKeyword: \"TSNullKeyword\",\n  TSNumberKeyword: \"TSNumberKeyword\",\n  TSObjectKeyword: \"TSObjectKeyword\",\n  TSPropertySignature: \"TSPropertySignature\",\n  TSStringKeyword: \"TSStringKeyword\",\n  TSThisType: \"TSThisType\",\n  TSTupleType: \"TSTupleType\",\n  TSTypeAliasDeclaration: \"TSTypeAliasDeclaration\",\n  TSTypeAnnotation: \"TSTypeAnnotation\",\n  TSTypeAssertion: \"TSTypeAssertion\",\n  TSTypeLiteral: \"TSTypeLiteral\",\n  TSTypeOperator: \"TSTypeOperator\",\n  TSTypeParameter: \"TSTypeParameter\",\n  TSTypeParameterDeclaration: \"TSTypeParameterDeclaration\",\n  TSTypeParameterInstantiation: \"TSTypeParameterInstantiation\",\n  TSTypePredicate: \"TSTypePredicate\",\n  TSTypeReference: \"TSTypeReference\",\n  TSUndefinedKeyword: \"TSUndefinedKeyword\",\n  TSUnionType: \"TSUnionType\",\n  TSUnknownKeyword: \"TSUnknownKeyword\",\n  TSVoidKeyword: \"TSVoidKeyword\",\n} as const);\n\nexport const AST_TOKEN_TYPES = Object.freeze({\n  Boolean: \"Boolean\",\n  Identifier: \"Identifier\",\n  JSXIdentifier: \"JSXIdentifier\",\n  JSXText: \"JSXText\",\n  Keyword: \"Keyword\",\n  Null: \"Null\",\n  Numeric: \"Numeric\",\n  PrivateIdentifier: \"PrivateIdentifier\",\n  Punctuator: \"Punctuator\",\n  RegularExpression: \"RegularExpression\",\n  String: \"String\",\n  Template: \"Template\",\n} as const);\n\nexport const TSESTree = Object.freeze({\n  AST_NODE_TYPES,\n  AST_TOKEN_TYPES,\n});\n"],"mappings":";AAAA,MAAa,iBAAiB,OAAO,OAAO;CAC1C,iBAAiB;CACjB,yBAAyB;CACzB,sBAAsB;CACtB,iBAAiB;CACjB,kBAAkB;CAClB,gBAAgB;CAChB,gBAAgB;CAChB,aAAa;CACb,iBAAiB;CACjB,uBAAuB;CACvB,qBAAqB;CACrB,gBAAgB;CAChB,gBAAgB;CAChB,qBAAqB;CACrB,oBAAoB;CACpB,YAAY;CACZ,aAAa;CACb,mBAAmB;CACnB,SAAS;CACT,mBAAmB;CACnB,kBAAkB;CAClB,kBAAkB;CAClB,eAAe;CACf,kBAAkB;CAClB,SAAS;CACT,UAAU;CACV,iBAAiB;CACjB,oBAAoB;CACpB,eAAe;CACf,iBAAiB;CACjB,0BAA0B;CAC1B,iBAAiB;CACjB,gBAAgB;CAChB,cAAc;CACd,iBAAiB;CACjB,kBAAkB;CAClB,qBAAqB;CACrB,oBAAoB;CACpB,cAAc;CACd,gBAAgB;CAChB,kBAAkB;CAClB,4BAA4B;CAC5B,mBAAmB;CACnB,iCAAiC;CACjC,mBAAmB;CACnB,mBAAmB;CACnB,+BAA+B;CAC/B,gBAAgB;CAChB,cAAc;CACd,qBAAqB;CACrB,aAAa;CACb,wBAAwB;CACxB,eAAe;CACf,cAAc;CACd,mBAAmB;CACnB,qBAAqB;CACrB,gBAAgB;CAChB,eAAe;CACf,iBAAiB;CACjB,iBAAiB;CACjB,qBAAqB;CACrB,iBAAiB;CACjB,YAAY;CACZ,aAAa;CACb,wBAAwB;CACxB,kBAAkB;CAClB,iBAAiB;CACjB,eAAe;CACf,gBAAgB;CAChB,iBAAiB;CACjB,4BAA4B;CAC5B,8BAA8B;CAC9B,iBAAiB;CACjB,iBAAiB;CACjB,oBAAoB;CACpB,aAAa;CACb,kBAAkB;CAClB,eAAe;CAChB,CAAU;AAEX,MAAa,kBAAkB,OAAO,OAAO;CAC3C,SAAS;CACT,YAAY;CACZ,eAAe;CACf,SAAS;CACT,SAAS;CACT,MAAM;CACN,SAAS;CACT,mBAAmB;CACnB,YAAY;CACZ,mBAAmB;CACnB,QAAQ;CACR,UAAU;CACX,CAAU;AAEX,MAAa,WAAW,OAAO,OAAO;CACpC;CACA;CACD,CAAC"}