@rsdoctor/core 1.6.1 → 2.0.0-alpha.1

package/dist/rule-utils/document/document.js

@@ -0,0 +1,46 @@
+import "node:module";
+import { Lodash } from "../../common/index.js";
+import { LinesAndColumns } from "lines-and-columns";
+class Document {
+    createFinder() {
+        const find = new LinesAndColumns(this._text);
+        this.positionAt = (offset)=>{
+            if (offset >= this._text.length) offset = this._text.length - 1;
+            if (offset < 0) offset = 0;
+            const result = find.locationForIndex(offset);
+            if (!result) return;
+            return {
+                line: result.line + 1,
+                column: result.column
+            };
+        };
+        this.offsetAt = (position)=>find.indexForLocation({
+                line: position.line - 1,
+                column: position.column
+            }) ?? void 0;
+    }
+    getText(range) {
+        if (!range) return this._text;
+        const start = 'number' == typeof range.start ? range.start : this.offsetAt(range.start);
+        const end = 'number' == typeof range.end ? range.end : this.offsetAt(range.end);
+        if (Lodash.isUndefined(start)) throw new Error(`Location ${JSON.stringify(start)} is illegal`);
+        if (Lodash.isUndefined(end)) throw new Error(`Location ${JSON.stringify(end)} is illegal`);
+        return this._text.slice(start, end);
+    }
+    edit(data) {
+        let { _text: content } = this;
+        const startOffset = Lodash.isNumber(data.start) ? data.start : this.offsetAt(data.start);
+        const endOffset = Lodash.isNumber(data.end) ? data.end : this.offsetAt(data.end);
+        if (Lodash.isUndefined(startOffset) || Lodash.isUndefined(endOffset)) return;
+        const startTxt = content.substring(0, startOffset);
+        const endTxt = content.substring(endOffset, content.length);
+        content = startTxt + data.newText + endTxt;
+        return content;
+    }
+    constructor(content){
+        this._text = '';
+        this._text = content;
+        this.createFinder();
+    }
+}
+export { Document };

package/dist/rule-utils/document/index.d.ts

@@ -0,0 +1,3 @@
+export * from './document.js';
+export * from './types.js';
+export * from './server.js';

package/dist/rule-utils/document/index.js

@@ -0,0 +1,4 @@
+import "node:module";
+export * from "./document.js";
+export * from "./types.js";
+export * from "./server.js";

package/dist/rule-utils/document/server.d.ts

@@ -0,0 +1,4 @@
+import { Document } from './document.js';
+/** Create Document */
+export declare function getDocument(content: string): Document;
+export declare function clearDocument(): void;

package/dist/rule-utils/document/server.js

@@ -0,0 +1,13 @@
+import "node:module";
+import { Document } from "./document.js";
+const store = new Map();
+function getDocument(content) {
+    if (store.has(content)) return store.get(content);
+    const doc = new Document(content);
+    store.set(content, doc);
+    return doc;
+}
+function clearDocument() {
+    store.clear();
+}
+export { clearDocument, getDocument };

package/dist/rule-utils/document/types.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Location
+ * - line starting point is 1
+ * - column starting point is 0
+ */
+export interface Position {
+    line: number;
+    column: number;
+}
+/** Location range */
+export interface Range {
+    start: Position;
+    end: Position;
+}
+/** Offset range */
+export interface OffsetRange {
+    start: number;
+    end: number;
+}
+/** Text repair data */
+export interface DocumentEditData {
+    /** Modify the starting position of string in the original text */
+    start: number | Position;
+    /** Modify string in the key position of the original text */
+    end: number | Position;
+    /**
+     * Replaced new text
+     * - If empty, delete the original text
+     */
+    newText?: string;
+}

package/dist/rule-utils/index.d.ts

@@ -0,0 +1,2 @@
+export * from './document/index.js';
+export * from './parser/index.js';

package/dist/rule-utils/index.js

@@ -0,0 +1,3 @@
+import "node:module";
+export * from "./document/index.js";
+export * from "./parser/index.js";

package/dist/rule-utils/parser/asserts.d.ts

@@ -0,0 +1,81 @@
+import { Node } from './types.js';
+export declare const asserts: {
+    readonly isProgram: (node: unknown) => node is Node.Program;
+    readonly isEmptyStatement: (node: unknown) => node is Node.EmptyStatement;
+    readonly isBlockStatement: (node: unknown) => node is Node.BlockStatement;
+    readonly isStaticBlock: (node: unknown) => node is Node.StaticBlock;
+    readonly isExpressionStatement: (node: unknown) => node is Node.ExpressionStatement;
+    readonly isIfStatement: (node: unknown) => node is Node.IfStatement;
+    readonly isLabeledStatement: (node: unknown) => node is Node.LabeledStatement;
+    readonly isBreakStatement: (node: unknown) => node is Node.BreakStatement;
+    readonly isContinueStatement: (node: unknown) => node is Node.ContinueStatement;
+    readonly isWithStatement: (node: unknown) => node is Node.WithStatement;
+    readonly isSwitchStatement: (node: unknown) => node is Node.SwitchStatement;
+    readonly isReturnStatement: (node: unknown) => node is Node.ReturnStatement;
+    readonly isThrowStatement: (node: unknown) => node is Node.ThrowStatement;
+    readonly isTryStatement: (node: unknown) => node is Node.TryStatement;
+    readonly isWhileStatement: (node: unknown) => node is Node.WhileStatement;
+    readonly isDoWhileStatement: (node: unknown) => node is Node.DoWhileStatement;
+    readonly isForStatement: (node: unknown) => node is Node.ForStatement;
+    readonly isForInStatement: (node: unknown) => node is Node.ForInStatement;
+    readonly isForOfStatement: (node: unknown) => node is Node.ForOfStatement;
+    readonly isDebuggerStatement: (node: unknown) => node is Node.DebuggerStatement;
+    readonly isFunctionDeclaration: (node: unknown) => node is Node.FunctionDeclaration;
+    readonly isVariableDeclaration: (node: unknown) => node is Node.VariableDeclaration;
+    readonly isVariableDeclarator: (node: unknown) => node is Node.VariableDeclarator;
+    readonly isChainExpression: (node: unknown) => node is Node.ChainExpression;
+    readonly isThisExpression: (node: unknown) => node is Node.ThisExpression;
+    readonly isArrayExpression: (node: unknown) => node is Node.ArrayExpression;
+    readonly isObjectExpression: (node: unknown) => node is Node.ObjectExpression;
+    readonly isPrivateIdentifier: (node: unknown) => node is Node.PrivateIdentifier;
+    readonly isProperty: (node: unknown) => node is Node.Property;
+    readonly isPropertyDefinition: (node: unknown) => node is Node.PropertyDefinition;
+    readonly isFunctionExpression: (node: unknown) => node is Node.FunctionExpression;
+    readonly isSequenceExpression: (node: unknown) => node is Node.SequenceExpression;
+    readonly isUnaryExpression: (node: unknown) => node is Node.UnaryExpression;
+    readonly isBinaryExpression: (node: unknown) => node is Node.BinaryExpression;
+    readonly isAssignmentExpression: (node: unknown) => node is Node.AssignmentExpression;
+    readonly isUpdateExpression: (node: unknown) => node is Node.UpdateExpression;
+    readonly isLogicalExpression: (node: unknown) => node is Node.LogicalExpression;
+    readonly isConditionalExpression: (node: unknown) => node is Node.ConditionalExpression;
+    readonly isNewExpression: (node: unknown) => node is Node.NewExpression;
+    readonly isSwitchCase: (node: unknown) => node is Node.SwitchCase;
+    readonly isCatchClause: (node: unknown) => node is Node.CatchClause;
+    readonly isIdentifier: (node: unknown) => node is Node.Identifier;
+    readonly isLiteral: (node: unknown) => node is Node.Literal;
+    readonly isSuper: (node: unknown) => node is Node.Super;
+    readonly isSpreadElement: (node: unknown) => node is Node.SpreadElement;
+    readonly isArrowFunctionExpression: (node: unknown) => node is Node.ArrowFunctionExpression;
+    readonly isYieldExpression: (node: unknown) => node is Node.YieldExpression;
+    readonly isTemplateLiteral: (node: unknown) => node is Node.TemplateLiteral;
+    readonly isTaggedTemplateExpression: (node: unknown) => node is Node.TaggedTemplateExpression;
+    readonly isTemplateElement: (node: unknown) => node is Node.TemplateElement;
+    readonly isObjectPattern: (node: unknown) => node is Node.ObjectPattern;
+    readonly isArrayPattern: (node: unknown) => node is Node.ArrayPattern;
+    readonly isRestElement: (node: unknown) => node is Node.RestElement;
+    readonly isAssignmentPattern: (node: unknown) => node is Node.AssignmentPattern;
+    readonly isClassBody: (node: unknown) => node is Node.ClassBody;
+    readonly isClassDeclaration: (node: unknown) => node is Node.ClassDeclaration;
+    readonly isClassExpression: (node: unknown) => node is Node.ClassExpression;
+    readonly isMetaProperty: (node: unknown) => node is Node.MetaProperty;
+    readonly isImportDeclaration: (node: unknown) => node is Node.ImportDeclaration;
+    readonly isImportSpecifier: (node: unknown) => node is Node.ImportSpecifier;
+    readonly isImportExpression: (node: unknown) => node is Node.ImportExpression;
+    readonly isImportDefaultSpecifier: (node: unknown) => node is Node.ImportDefaultSpecifier;
+    readonly isImportNamespaceSpecifier: (node: unknown) => node is Node.ImportNamespaceSpecifier;
+    readonly isExportNamedDeclaration: (node: unknown) => node is Node.ExportNamedDeclaration;
+    readonly isExportSpecifier: (node: unknown) => node is Node.ExportSpecifier;
+    readonly isExportDefaultDeclaration: (node: unknown) => node is Node.ExportDefaultDeclaration;
+    readonly isExportAllDeclaration: (node: unknown) => node is Node.ExportAllDeclaration;
+    readonly isAwaitExpression: (node: unknown) => node is Node.AwaitExpression;
+    readonly isMethodDefinition: (node: unknown) => node is Node.MethodDefinition;
+    readonly isMemberExpression: (node: unknown) => node is Node.MemberExpression;
+    readonly isComment: (node: unknown) => node is Node.Comment;
+    readonly isDirective: (node: unknown) => node is Node.Directive;
+    readonly isSimpleCallExpression: (node: unknown) => node is Node.SimpleCallExpression;
+    readonly isAssignmentProperty: (node: unknown) => node is Node.AssignmentProperty;
+    readonly isSimpleLiteral: (node: unknown) => node is Node.SimpleLiteral;
+    readonly isRegExpLiteral: (node: unknown) => node is Node.RegExpLiteral;
+    readonly isBigIntLiteral: (node: unknown) => node is Node.BigIntLiteral;
+    readonly isExportStatement: (node: unknown) => node is Node.ExportStatement;
+};

package/dist/rule-utils/parser/asserts.js

@@ -0,0 +1,105 @@
+import "node:module";
+import { Lodash } from "../../common/index.js";
+function isSyntaxNode(node) {
+    return Lodash.isObject(node) && 'type' in node;
+}
+function assertCreator(type) {
+    return (node)=>isSyntaxNode(node) && node.type === type;
+}
+const asserts = {
+    isProgram: assertCreator('Program'),
+    isEmptyStatement: assertCreator('EmptyStatement'),
+    isBlockStatement: assertCreator('BlockStatement'),
+    isStaticBlock: assertCreator('StaticBlock'),
+    isExpressionStatement: assertCreator('ExpressionStatement'),
+    isIfStatement: assertCreator('IfStatement'),
+    isLabeledStatement: assertCreator('LabeledStatement'),
+    isBreakStatement: assertCreator('BreakStatement'),
+    isContinueStatement: assertCreator('ContinueStatement'),
+    isWithStatement: assertCreator('WithStatement'),
+    isSwitchStatement: assertCreator('SwitchStatement'),
+    isReturnStatement: assertCreator('ReturnStatement'),
+    isThrowStatement: assertCreator('ThrowStatement'),
+    isTryStatement: assertCreator('TryStatement'),
+    isWhileStatement: assertCreator('WhileStatement'),
+    isDoWhileStatement: assertCreator('DoWhileStatement'),
+    isForStatement: assertCreator('ForStatement'),
+    isForInStatement: assertCreator('ForInStatement'),
+    isForOfStatement: assertCreator('ForOfStatement'),
+    isDebuggerStatement: assertCreator('DebuggerStatement'),
+    isFunctionDeclaration: assertCreator('FunctionDeclaration'),
+    isVariableDeclaration: assertCreator('VariableDeclaration'),
+    isVariableDeclarator: assertCreator('VariableDeclarator'),
+    isChainExpression: assertCreator('ChainExpression'),
+    isThisExpression: assertCreator('ThisExpression'),
+    isArrayExpression: assertCreator('ArrayExpression'),
+    isObjectExpression: assertCreator('ObjectExpression'),
+    isPrivateIdentifier: assertCreator('PrivateIdentifier'),
+    isProperty: assertCreator('Property'),
+    isPropertyDefinition: assertCreator('PropertyDefinition'),
+    isFunctionExpression: assertCreator('FunctionExpression'),
+    isSequenceExpression: assertCreator('SequenceExpression'),
+    isUnaryExpression: assertCreator('UnaryExpression'),
+    isBinaryExpression: assertCreator('BinaryExpression'),
+    isAssignmentExpression: assertCreator('AssignmentExpression'),
+    isUpdateExpression: assertCreator('UpdateExpression'),
+    isLogicalExpression: assertCreator('LogicalExpression'),
+    isConditionalExpression: assertCreator('ConditionalExpression'),
+    isNewExpression: assertCreator('NewExpression'),
+    isSwitchCase: assertCreator('SwitchCase'),
+    isCatchClause: assertCreator('CatchClause'),
+    isIdentifier: assertCreator('Identifier'),
+    isLiteral: assertCreator('Literal'),
+    isSuper: assertCreator('Super'),
+    isSpreadElement: assertCreator('SpreadElement'),
+    isArrowFunctionExpression: assertCreator('ArrowFunctionExpression'),
+    isYieldExpression: assertCreator('YieldExpression'),
+    isTemplateLiteral: assertCreator('TemplateLiteral'),
+    isTaggedTemplateExpression: assertCreator('TaggedTemplateExpression'),
+    isTemplateElement: assertCreator('TemplateElement'),
+    isObjectPattern: assertCreator('ObjectPattern'),
+    isArrayPattern: assertCreator('ArrayPattern'),
+    isRestElement: assertCreator('RestElement'),
+    isAssignmentPattern: assertCreator('AssignmentPattern'),
+    isClassBody: assertCreator('ClassBody'),
+    isClassDeclaration: assertCreator('ClassDeclaration'),
+    isClassExpression: assertCreator('ClassExpression'),
+    isMetaProperty: assertCreator('MetaProperty'),
+    isImportDeclaration: assertCreator('ImportDeclaration'),
+    isImportSpecifier: assertCreator('ImportSpecifier'),
+    isImportExpression: assertCreator('ImportExpression'),
+    isImportDefaultSpecifier: assertCreator('ImportDefaultSpecifier'),
+    isImportNamespaceSpecifier: assertCreator('ImportNamespaceSpecifier'),
+    isExportNamedDeclaration: assertCreator('ExportNamedDeclaration'),
+    isExportSpecifier: assertCreator('ExportSpecifier'),
+    isExportDefaultDeclaration: assertCreator('ExportDefaultDeclaration'),
+    isExportAllDeclaration: assertCreator('ExportAllDeclaration'),
+    isAwaitExpression: assertCreator('AwaitExpression'),
+    isMethodDefinition: assertCreator('MethodDefinition'),
+    isMemberExpression: assertCreator('MemberExpression'),
+    isComment (node) {
+        return isSyntaxNode(node) && ('Line' === node.type || 'Block' === node.type);
+    },
+    isDirective (node) {
+        return asserts.isExpressionStatement(node) && 'directive' in node;
+    },
+    isSimpleCallExpression (node) {
+        return isSyntaxNode(node) && 'CallExpression' === node.type;
+    },
+    isAssignmentProperty (node) {
+        return asserts.isProperty(node) && 'init' === node.kind;
+    },
+    isSimpleLiteral (node) {
+        return asserts.isLiteral(node) && !asserts.isRegExpLiteral(node) && !asserts.isBigIntLiteral(node);
+    },
+    isRegExpLiteral (node) {
+        return asserts.isLiteral(node) && 'regex' in node;
+    },
+    isBigIntLiteral (node) {
+        return asserts.isLiteral(node) && 'bigint' in node;
+    },
+    isExportStatement (node) {
+        return asserts.isExportAllDeclaration(node) || asserts.isExportDefaultDeclaration(node) || asserts.isExportNamedDeclaration(node);
+    }
+};
+export { asserts };

package/dist/rule-utils/parser/index.d.ts

@@ -0,0 +1,4 @@
+export * from './asserts.js';
+export * from './parser.js';
+export * from './utils.js';
+export * from './types.js';

package/dist/rule-utils/parser/index.js

@@ -0,0 +1,5 @@
+import "node:module";
+export * from "./asserts.js";
+export * from "./parser.js";
+export * from "./utils.js";
+export * from "./types.js";

package/dist/rule-utils/parser/parser.d.ts

@@ -0,0 +1,118 @@
+import { Parser as AcornParser, Options, Position } from 'acorn';
+import * as walk from 'acorn-walk';
+import * as utils from './utils.js';
+import type { Node } from './types.js';
+export type { Options as ParseOptions } from 'acorn';
+export interface ParseError extends Error {
+    loc?: Position;
+    pos: number;
+    raisedAt: number;
+}
+export declare const parser: {
+    /** AST iterator */
+    walk: typeof walk;
+    /**
+     * Compile code
+     * - Output root node is `Node.Program`
+     */
+    parse: (input: string, options: Options) => Node.Program;
+    /**
+     * Compile the next first expression
+     * - The output root node is `Node.ExpressionStatement`
+     */
+    parseExpressionAt: (input: string, pos: number, options: Options) => Node.ExpressionStatement;
+    /**
+     * add plugins for acorn
+     */
+    extend(...args: Parameters<typeof AcornParser.extend>): typeof AcornParser;
+    /** Set of assertions */
+    asserts: {
+        readonly isProgram: (node: unknown) => node is Node.Program;
+        readonly isEmptyStatement: (node: unknown) => node is Node.EmptyStatement;
+        readonly isBlockStatement: (node: unknown) => node is Node.BlockStatement;
+        readonly isStaticBlock: (node: unknown) => node is Node.StaticBlock;
+        readonly isExpressionStatement: (node: unknown) => node is Node.ExpressionStatement;
+        readonly isIfStatement: (node: unknown) => node is Node.IfStatement;
+        readonly isLabeledStatement: (node: unknown) => node is Node.LabeledStatement;
+        readonly isBreakStatement: (node: unknown) => node is Node.BreakStatement;
+        readonly isContinueStatement: (node: unknown) => node is Node.ContinueStatement;
+        readonly isWithStatement: (node: unknown) => node is Node.WithStatement;
+        readonly isSwitchStatement: (node: unknown) => node is Node.SwitchStatement;
+        readonly isReturnStatement: (node: unknown) => node is Node.ReturnStatement;
+        readonly isThrowStatement: (node: unknown) => node is Node.ThrowStatement;
+        readonly isTryStatement: (node: unknown) => node is Node.TryStatement;
+        readonly isWhileStatement: (node: unknown) => node is Node.WhileStatement;
+        readonly isDoWhileStatement: (node: unknown) => node is Node.DoWhileStatement;
+        readonly isForStatement: (node: unknown) => node is Node.ForStatement;
+        readonly isForInStatement: (node: unknown) => node is Node.ForInStatement;
+        readonly isForOfStatement: (node: unknown) => node is Node.ForOfStatement;
+        readonly isDebuggerStatement: (node: unknown) => node is Node.DebuggerStatement;
+        readonly isFunctionDeclaration: (node: unknown) => node is Node.FunctionDeclaration;
+        readonly isVariableDeclaration: (node: unknown) => node is Node.VariableDeclaration;
+        readonly isVariableDeclarator: (node: unknown) => node is Node.VariableDeclarator;
+        readonly isChainExpression: (node: unknown) => node is Node.ChainExpression;
+        readonly isThisExpression: (node: unknown) => node is Node.ThisExpression;
+        readonly isArrayExpression: (node: unknown) => node is Node.ArrayExpression;
+        readonly isObjectExpression: (node: unknown) => node is Node.ObjectExpression;
+        readonly isPrivateIdentifier: (node: unknown) => node is Node.PrivateIdentifier;
+        readonly isProperty: (node: unknown) => node is Node.Property;
+        readonly isPropertyDefinition: (node: unknown) => node is Node.PropertyDefinition;
+        readonly isFunctionExpression: (node: unknown) => node is Node.FunctionExpression;
+        readonly isSequenceExpression: (node: unknown) => node is Node.SequenceExpression;
+        readonly isUnaryExpression: (node: unknown) => node is Node.UnaryExpression;
+        readonly isBinaryExpression: (node: unknown) => node is Node.BinaryExpression;
+        readonly isAssignmentExpression: (node: unknown) => node is Node.AssignmentExpression;
+        readonly isUpdateExpression: (node: unknown) => node is Node.UpdateExpression;
+        readonly isLogicalExpression: (node: unknown) => node is Node.LogicalExpression;
+        readonly isConditionalExpression: (node: unknown) => node is Node.ConditionalExpression;
+        readonly isNewExpression: (node: unknown) => node is Node.NewExpression;
+        readonly isSwitchCase: (node: unknown) => node is Node.SwitchCase;
+        readonly isCatchClause: (node: unknown) => node is Node.CatchClause;
+        readonly isIdentifier: (node: unknown) => node is Node.Identifier;
+        readonly isLiteral: (node: unknown) => node is Node.Literal;
+        readonly isSuper: (node: unknown) => node is Node.Super;
+        readonly isSpreadElement: (node: unknown) => node is Node.SpreadElement;
+        readonly isArrowFunctionExpression: (node: unknown) => node is Node.ArrowFunctionExpression;
+        readonly isYieldExpression: (node: unknown) => node is Node.YieldExpression;
+        readonly isTemplateLiteral: (node: unknown) => node is Node.TemplateLiteral;
+        readonly isTaggedTemplateExpression: (node: unknown) => node is Node.TaggedTemplateExpression;
+        readonly isTemplateElement: (node: unknown) => node is Node.TemplateElement;
+        readonly isObjectPattern: (node: unknown) => node is Node.ObjectPattern;
+        readonly isArrayPattern: (node: unknown) => node is Node.ArrayPattern;
+        readonly isRestElement: (node: unknown) => node is Node.RestElement;
+        readonly isAssignmentPattern: (node: unknown) => node is Node.AssignmentPattern;
+        readonly isClassBody: (node: unknown) => node is Node.ClassBody;
+        readonly isClassDeclaration: (node: unknown) => node is Node.ClassDeclaration;
+        readonly isClassExpression: (node: unknown) => node is Node.ClassExpression;
+        readonly isMetaProperty: (node: unknown) => node is Node.MetaProperty;
+        readonly isImportDeclaration: (node: unknown) => node is Node.ImportDeclaration;
+        readonly isImportSpecifier: (node: unknown) => node is Node.ImportSpecifier;
+        readonly isImportExpression: (node: unknown) => node is Node.ImportExpression;
+        readonly isImportDefaultSpecifier: (node: unknown) => node is Node.ImportDefaultSpecifier;
+        readonly isImportNamespaceSpecifier: (node: unknown) => node is Node.ImportNamespaceSpecifier;
+        readonly isExportNamedDeclaration: (node: unknown) => node is Node.ExportNamedDeclaration;
+        readonly isExportSpecifier: (node: unknown) => node is Node.ExportSpecifier;
+        readonly isExportDefaultDeclaration: (node: unknown) => node is Node.ExportDefaultDeclaration;
+        readonly isExportAllDeclaration: (node: unknown) => node is Node.ExportAllDeclaration;
+        readonly isAwaitExpression: (node: unknown) => node is Node.AwaitExpression;
+        readonly isMethodDefinition: (node: unknown) => node is Node.MethodDefinition;
+        readonly isMemberExpression: (node: unknown) => node is Node.MemberExpression;
+        readonly isComment: (node: unknown) => node is Node.Comment;
+        readonly isDirective: (node: unknown) => node is Node.Directive;
+        readonly isSimpleCallExpression: (node: unknown) => node is Node.SimpleCallExpression;
+        readonly isAssignmentProperty: (node: unknown) => node is Node.AssignmentProperty;
+        readonly isSimpleLiteral: (node: unknown) => node is Node.SimpleLiteral;
+        readonly isRegExpLiteral: (node: unknown) => node is Node.RegExpLiteral;
+        readonly isBigIntLiteral: (node: unknown) => node is Node.BigIntLiteral;
+        readonly isExportStatement: (node: unknown) => node is Node.ExportStatement;
+    };
+    utils: typeof utils;
+    /**
+     * @internal
+     * parser for internal packages
+     */
+    internal: {
+        parse: (input: string, options: Options) => Node.Program;
+        parseExpressionAt: (input: string, pos: number, options: Options) => Node.ExpressionStatement;
+    };
+};

package/dist/rule-utils/parser/parser.js

@@ -0,0 +1,24 @@
+import "node:module";
+import { Parser } from "acorn";
+import { importAttributes } from "acorn-import-attributes";
+import * as __rspack_external_acorn_walk_1e4235a7 from "acorn-walk";
+import { asserts } from "./asserts.js";
+import * as __rspack_external__utils_js_a9c81ddd from "./utils.js";
+const acornParserInternal = Parser.extend(importAttributes);
+let acornParserExport = Parser.extend(importAttributes);
+const parser = {
+    walk: __rspack_external_acorn_walk_1e4235a7,
+    parse: (input, options)=>acornParserExport.parse(input, options),
+    parseExpressionAt: (input, pos, options)=>acornParserExport.parseExpressionAt(input, pos, options),
+    extend (...args) {
+        acornParserExport = acornParserExport.extend(...args);
+        return acornParserExport;
+    },
+    asserts: asserts,
+    utils: __rspack_external__utils_js_a9c81ddd,
+    internal: {
+        parse: (input, options)=>acornParserInternal.parse(input, options),
+        parseExpressionAt: (input, pos, options)=>acornParserInternal.parseExpressionAt(input, pos, options)
+    }
+};
+export { parser };

package/dist/rule-utils/parser/types.d.ts

@@ -0,0 +1,30 @@
+import type * as Node from 'estree';
+export type { Node };
+export declare enum ECMAVersion {
+    ES5 = "ES5",
+    ES6 = "ES6",
+    ES7P = "ES7+"
+}
+/**
+ * estree supplement type
+ * Mainly to match the node type of acorn
+ * The main reason for not using the type of acorn directly is that the node type described by acorn itself is too simple
+ */
+declare module 'estree' {
+    interface BaseNode {
+        start: number;
+        end: number;
+        loc?: SourceLocation | undefined;
+    }
+    interface Position {
+        offset: number;
+    }
+    /** all syntax nodes */
+    type SyntaxNode = Node.Comment | Node.Program | Node.Directive | Node.EmptyStatement | Node.BlockStatement | Node.StaticBlock | Node.ExpressionStatement | Node.IfStatement | Node.LabeledStatement | Node.BreakStatement | Node.ContinueStatement | Node.WithStatement | Node.SwitchStatement | Node.ReturnStatement | Node.ThrowStatement | Node.TryStatement | Node.WhileStatement | Node.DoWhileStatement | Node.ForStatement | Node.ForInStatement | Node.DebuggerStatement | Node.FunctionDeclaration | Node.VariableDeclaration | Node.VariableDeclarator | Node.ChainExpression | Node.ThisExpression | Node.ArrayExpression | Node.ObjectExpression | Node.PrivateIdentifier | Node.Property | Node.PropertyDefinition | Node.FunctionExpression | Node.SequenceExpression | Node.UnaryExpression | Node.BinaryExpression | Node.AssignmentExpression | Node.UpdateExpression | Node.LogicalExpression | Node.ConditionalExpression | Node.SimpleCallExpression | Node.NewExpression | Node.MemberExpression | Node.SwitchCase | Node.CatchClause | Node.Identifier | Node.SimpleLiteral | Node.RegExpLiteral | Node.BigIntLiteral | Node.ForOfStatement | Node.Super | Node.SpreadElement | Node.ArrowFunctionExpression | Node.YieldExpression | Node.TemplateLiteral | Node.TaggedTemplateExpression | Node.TemplateElement | Node.AssignmentProperty | Node.ObjectPattern | Node.ArrayPattern | Node.RestElement | Node.AssignmentPattern | Node.ClassBody | Node.MethodDefinition | Node.ClassDeclaration | Node.ClassExpression | Node.MetaProperty | Node.ImportDeclaration | Node.ImportSpecifier | Node.ImportExpression | Node.ImportDefaultSpecifier | Node.ImportNamespaceSpecifier | Node.ExportNamedDeclaration | Node.ExportSpecifier | Node.ExportDefaultDeclaration | Node.ExportAllDeclaration | Node.AwaitExpression;
+    /** all operators */
+    type SyntaxOperator = Node.UnaryOperator | Node.BinaryOperator | Node.LogicalOperator | Node.AssignmentOperator | Node.UpdateOperator;
+    /** Block-scoped statement */
+    type BlockScopeStatement = Node.StaticBlock | Node.BlockStatement | Node.ForInStatement | Node.ForOfStatement | Node.ForStatement | Node.CatchClause | Node.SwitchStatement;
+    /** Export statement */
+    type ExportStatement = Node.ExportAllDeclaration | Node.ExportDefaultDeclaration | Node.ExportNamedDeclaration;
+}

package/dist/rule-utils/parser/types.js

@@ -0,0 +1,8 @@
+import "node:module";
+var types_ECMAVersion = /*#__PURE__*/ function(ECMAVersion) {
+    ECMAVersion["ES5"] = "ES5";
+    ECMAVersion["ES6"] = "ES6";
+    ECMAVersion["ES7P"] = "ES7+";
+    return ECMAVersion;
+}({});
+export { types_ECMAVersion as ECMAVersion };

package/dist/rule-utils/parser/utils.d.ts

@@ -0,0 +1,30 @@
+import { ecmaVersion } from 'acorn';
+import { Node, ECMAVersion } from './types.js';
+/**
+ * Is the node semantics the same?
+ * @deprecated
+ * - Recursively compare whether the content of the node itself is the same
+ * - Ignore comments, positions, string symbols (single and double quotation marks)
+ * - String templates and string addition will be considered different
+ */
+export declare function isSameSemantics(node1: Node.SyntaxNode, node2: Node.SyntaxNode): boolean;
+/**
+ * Get all default reference statements
+ */
+export declare function getDefaultImports(node: Node.Program): Node.ImportDeclaration[];
+/** Get the literal in the text. */
+export declare function getIdentifierInPattern(name: string, node: Node.Pattern): Node.Identifier | undefined;
+/** Get the variable declaration statement identifier. */
+export declare function getIdentifierInDeclaration(name: string, node: Node.SyntaxNode): Node.Identifier | undefined;
+/** Get the reference declaration statement identifier. */
+export declare function getIdentifierInImport(name: string, node: Node.SyntaxNode): Node.Identifier | undefined;
+/** Get the export statement identifier. */
+export declare function getIdentifierInExport(name: string, node: Node.SyntaxNode): Node.Identifier | undefined;
+/** Determine that it can be resolved using the specified ECMA version */
+export declare function canParse(code: string, ecmaVersion: ecmaVersion): boolean;
+/** Determine whether it is all ES5 version code. */
+export declare function isES5(code: string): boolean;
+/** Determine whether it is all ES6 version code. */
+export declare function isES6(code: string): boolean;
+/** Detect ECMA version. */
+export declare function detectECMAVersion(code: string): ECMAVersion;

package/dist/rule-utils/parser/utils.js

@@ -0,0 +1,106 @@
+import "node:module";
+import { parse } from "acorn";
+import { ECMAVersion } from "./types.js";
+import { asserts } from "./asserts.js";
+function isSameSemantics(node1, node2) {
+    if (node1.type !== node2.type) return false;
+    switch(node1.type){
+        case 'CallExpression':
+            {
+                const next = node2;
+                return node1.arguments.length === next.arguments.length && Boolean(node1.optional) === Boolean(next.optional) && isSameSemantics(node1.callee, next.callee) && node1.arguments.every((node, i)=>isSameSemantics(node, next.arguments[i]));
+            }
+        case 'MemberExpression':
+            {
+                const next = node2;
+                return node1.computed === next.computed && Boolean(node1.optional) === Boolean(next.optional) && isSameSemantics(node1.object, next.object) && isSameSemantics(node1.property, next.property);
+            }
+        case 'Identifier':
+            return node1.name === node2.name;
+        case 'Literal':
+            if (asserts.isSimpleLiteral(node1) && asserts.isSimpleLiteral(node2)) return node1.value === node2.value;
+            return node1.raw === node2.raw;
+        case 'ObjectExpression':
+            {
+                const next = node2;
+                return node1.properties.length === next.properties.length && node1.properties.every((prop, i)=>isSameSemantics(prop, next.properties[i]));
+            }
+        case 'Property':
+            {
+                const next = node2;
+                return node1.computed === next.computed && node1.kind === next.kind && node1.method === next.method && isSameSemantics(node1.key, next.key) && isSameSemantics(node1.value, next.value);
+            }
+        default:
+            throw new Error(`Unknown node type: ${node1.type}`);
+    }
+}
+function getDefaultImports(node) {
+    return node.body.filter((statement)=>{
+        if ('ImportDeclaration' !== statement.type) return false;
+        const specifier = statement?.specifiers?.[0];
+        if (specifier?.type === 'ImportDefaultSpecifier') return true;
+        return false;
+    });
+}
+function getIdentifierInPattern(name, node) {
+    if (asserts.isIdentifier(node) && node.name === name) return node;
+    if (asserts.isObjectPattern(node)) for (const prop of node.properties){
+        if (asserts.isAssignmentProperty(prop)) return getIdentifierInPattern(name, prop.value);
+        if (asserts.isRestElement(prop)) return getIdentifierInPattern(name, prop);
+    }
+    if (asserts.isArrayPattern(node)) {
+        for (const el of node.elements)if (el) {
+            const result = getIdentifierInPattern(name, el);
+            if (result) return result;
+        }
+    }
+    if (asserts.isRestElement(node)) return getIdentifierInPattern(name, node.argument);
+    if (asserts.isAssignmentPattern(node)) return getIdentifierInPattern(name, node.left);
+}
+function getIdentifierInDeclaration(name, node) {
+    function getId(node) {
+        return asserts.isIdentifier(node.id) && node.id.name === name ? node.id : void 0;
+    }
+    if (asserts.isFunctionDeclaration(node)) return getId(node);
+    if (asserts.isClassDeclaration(node)) return getId(node);
+    if (asserts.isVariableDeclaration(node)) return node.declarations.find((item)=>getIdentifierInPattern(name, item.id))?.id;
+}
+function getIdentifierInImport(name, node) {
+    if (asserts.isImportDeclaration(node)) {
+        for (const specifier of node.specifiers ?? [])if (specifier.local.name === name) return specifier.local;
+    }
+}
+function getIdentifierInExport(name, node) {
+    if (asserts.isExportNamedDeclaration(node)) {
+        if (node.declaration) return getIdentifierInDeclaration(name, node.declaration);
+        for (const specifier of node.specifiers ?? [])if (specifier.exported.name === name) return specifier.exported;
+    }
+    if (asserts.isExportAllDeclaration(node) && node.exported) {
+        if (node.exported.name === name) return node.exported;
+    }
+}
+function canParse(code, ecmaVersion) {
+    try {
+        parse(code, {
+            ecmaVersion,
+            sourceType: 'number' == typeof ecmaVersion && ecmaVersion <= 5 ? "script" : 'module'
+        });
+        return true;
+    } catch  {
+        return false;
+    }
+}
+function isES5(code) {
+    return canParse(code, 5);
+}
+function isES6(code) {
+    return canParse(code, 6);
+}
+function detectECMAVersion(code) {
+    if (isES6(code)) {
+        if (isES5(code)) return ECMAVersion.ES5;
+        return ECMAVersion.ES6;
+    }
+    return ECMAVersion.ES7P;
+}
+export { canParse, detectECMAVersion, getDefaultImports, getIdentifierInDeclaration, getIdentifierInExport, getIdentifierInImport, getIdentifierInPattern, isES5, isES6, isSameSemantics };

package/dist/rules/linter.d.ts

@@ -1,4 +1,4 @@
-import { Linter as LinterType, SDK } from '@rsdoctor/types';
+import { Linter as LinterType, SDK } from '@rsdoctor/shared/types';
 export { LinterType };
 export declare class Linter<Rules extends LinterType.ExtendRuleData[]> {
     private rules;