@rsdoctor/core 2.0.0-alpha.0 → 2.0.0-alpha.1

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;

package/dist/rules/linter.js

@@ -1,5 +1,5 @@
 import "node:module";
-import { Linter } from "@rsdoctor/types";
+import { Linter } from "@rsdoctor/shared/types";
 import { Rule } from "./rule.js";
 import { rules as index_js_rules } from "./rules/index.js";
 import { toSeverity } from "./utils.js";

package/dist/rules/rule.d.ts

@@ -1,4 +1,4 @@
-import { Linter, SDK, Rule as RuleTypes } from '@rsdoctor/types';
+import { Linter, SDK, Rule as RuleTypes } from '@rsdoctor/shared/types';
 import { LinterType } from './linter.js';
 type DefaultRuleConfig = Linter.DefaultRuleConfig;
 export declare class Rule<Config = DefaultRuleConfig> implements Linter.RuleMeta<Config> {
@@ -16,7 +16,7 @@ export declare class Rule<Config = DefaultRuleConfig> implements Linter.RuleMeta
     get title(): string;
     get severity(): Linter.Severity;
     get config(): Config | undefined;
-    get category(): "compile" | "bundle" | RuleTypes.RuleMessageCategory | "emo";
+    get category(): "bundle" | "compile" | "emo" | RuleTypes.RuleMessageCategory;
     setOption(opt: Linter.RuleConfigItem): void;
     match(level: Linter.Severity): boolean;
     validate(context: SDK.RuntimeContext): Promise<Linter.ValidateResult>;

package/dist/rules/rule.js

@@ -1,6 +1,6 @@
 import "node:module";
-import { Linter, Rule } from "@rsdoctor/types";
-import { Lodash } from "@rsdoctor/utils/common";
+import { Linter, Rule } from "@rsdoctor/shared/types";
+import { Lodash } from "../common/index.js";
 import { noop, toSeverity } from "./utils.js";
 class rule_Rule {
     static from(data) {

package/dist/rules/rules/cjs-require/index.d.ts

@@ -1,4 +1,4 @@
-import { Linter } from '@rsdoctor/types';
+import { Linter } from '@rsdoctor/shared/types';
 import type { Config } from './types.js';
 export type { Config } from './types.js';
 export declare const rule: Linter.RuleData<Config, "cjs-require">;

package/dist/rules/rules/cjs-require/index.js

@@ -1,5 +1,5 @@
 import "node:module";
-import { Linter } from "@rsdoctor/types";
+import { Linter } from "@rsdoctor/shared/types";
 import { defineRule } from "../../rule.js";
 const title = 'cjs-require';
 const CJS_REQUIRE_TYPE = 'cjs require';

package/dist/rules/rules/cross-chunks-package/index.d.ts

@@ -1,4 +1,4 @@
-import { Linter } from '@rsdoctor/types';
+import { Linter } from '@rsdoctor/shared/types';
 import { Config } from './types.js';
 export type { Config } from './types.js';
 export declare const rule: Linter.RuleData<Config, "cross-chunks-package">;

package/dist/rules/rules/cross-chunks-package/index.js

@@ -1,8 +1,8 @@
 import "node:module";
-import { Linter } from "@rsdoctor/types";
+import { Linter } from "@rsdoctor/shared/types";
 import { defineRule } from "../../rule.js";
 import { getErrorMsgForDupPckChunks } from "./utils.js";
-import { uniq } from "es-toolkit/compat";
+import { uniq } from "../../../collection.js";
 const title = 'cross-chunks-package';
 const rule = defineRule(()=>({
         meta: {

package/dist/rules/rules/default-import-check/index.d.ts

@@ -1,4 +1,4 @@
-import { Linter } from '@rsdoctor/types';
+import { Linter } from '@rsdoctor/shared/types';
 import type { Config } from './types.js';
 export type { Config } from './types.js';
 export declare const rule: Linter.RuleData<Config, "default-import-check">;

package/dist/rules/rules/default-import-check/index.js

@@ -1,7 +1,7 @@
 import "node:module";
 import { builtinModules } from "module";
-import { Linter } from "@rsdoctor/types";
-import { getDocument, parser } from "@rsdoctor/utils/ruleUtils";
+import { Linter } from "@rsdoctor/shared/types";
+import { getDocument, parser } from "../../../rule-utils/index.js";
 import { getDefaultImportByRequest, getFixData, getSourceRangeFromTransformedOffset, hasSameLeftInAssignStatement } from "./utils.js";
 import { defineRule } from "../../rule.js";
 const title = 'default-import-check';

package/dist/rules/rules/default-import-check/utils.d.ts

@@ -1,5 +1,5 @@
-import { Node, Range } from '@rsdoctor/utils/ruleUtils';
-import type { SDK, Linter } from '@rsdoctor/types';
+import { Node, Range } from '../../../rule-utils/index.js';
+import type { SDK, Linter } from '@rsdoctor/shared/types';
 export declare function getDefaultImportByRequest(node: Node.Program, request: string): Node.ImportDeclaration | undefined;
 /**
  * Determine that it contains the same left value assignment expression in the enumeration.

package/dist/rules/rules/default-import-check/utils.js

@@ -1,6 +1,6 @@
 import "node:module";
-import { getDocument, parser } from "@rsdoctor/utils/ruleUtils";
-import { Lodash } from "@rsdoctor/utils/common";
+import { getDocument, parser } from "../../../rule-utils/index.js";
+import { Lodash } from "../../../common/index.js";
 function getDefaultImportByRequest(node, request) {
     return parser.utils.getDefaultImports(node).find((decl)=>decl.source.value === request);
 }

package/dist/rules/rules/duplicate-package/index.d.ts

@@ -1,4 +1,4 @@
-import { Linter } from '@rsdoctor/types';
-import * as duplicatePackageTypes from './types.js';
+import { Linter } from '@rsdoctor/shared/types';
+import type { Config } from './types.js';
 export type { Config, CheckVersion } from './types.js';
-export declare const rule: Linter.RuleData<duplicatePackageTypes.Config, "duplicate-package">;
+export declare const rule: Linter.RuleData<Config, "duplicate-package">;

package/dist/rules/rules/duplicate-package/index.js

@@ -1,11 +1,11 @@
 import "node:module";
-import { Linter } from "@rsdoctor/types";
+import { Linter } from "@rsdoctor/shared/types";
 import { diff, gt } from "semver";
 import { getErrorDetail, getErrorMsg } from "./utils.js";
 import { defineRule } from "../../rule.js";
-import * as __rspack_external__types_js_7eec16d2 from "./types.js";
+import * as __rspack_external__types_js_b06c0ce5 from "./types.js";
 const title = 'duplicate-package';
-const { CheckVersionMap: CheckVersionMap } = __rspack_external__types_js_7eec16d2;
+const { CheckVersionMap: CheckVersionMap } = __rspack_external__types_js_b06c0ce5;
 const rule = defineRule(()=>({
         meta: {
             code: 'E1001',

package/dist/rules/rules/duplicate-package/utils.d.ts

@@ -1,3 +1,3 @@
-import type { SDK, Rule } from '@rsdoctor/types';
+import type { SDK, Rule } from '@rsdoctor/shared/types';
 export declare function getErrorMsg(packages: SDK.PackageInstance[], root: string): string;
 export declare function getErrorDetail(pkg: SDK.PackageInstance, pkgGraph: SDK.PackageGraphInstance): Rule.PackageRelationData;

package/dist/rules/rules/ecma-version-check/index.d.ts

@@ -1,4 +1,5 @@
 import { Config } from './types.js';
-import { Linter } from '@rsdoctor/types';
+import { Linter } from '@rsdoctor/shared/types';
 export type { Config } from './types.js';
-export declare const rule: Linter.RuleData<Config, "ecma-version-check">;
+declare const title = "ecma-version-check";
+export declare const rule: Linter.RuleData<Config, typeof title>;

package/dist/rules/rules/ecma-version-check/index.js

@@ -3,7 +3,7 @@ import path from "path";
 import { CheckSyntax } from "@rsbuild/plugin-check-syntax";
 import { loadConfig } from "browserslist-load-config";
 import { defineRule } from "../../rule.js";
-import { Linter } from "@rsdoctor/types";
+import { Linter } from "@rsdoctor/shared/types";
 const title = 'ecma-version-check';
 const rule = defineRule(()=>({
         meta: {

package/dist/rules/rules/ecma-version-check/types.d.ts

@@ -1,3 +1,2 @@
 import type { PluginCheckSyntaxOptions } from '@rsbuild/plugin-check-syntax';
-export interface Config extends PluginCheckSyntaxOptions {
-}
+export type Config = PluginCheckSyntaxOptions;

package/dist/rules/rules/ecma-version-check/utils.d.ts

@@ -1,2 +1,2 @@
-import type { ECMAVersion } from '@rsdoctor/utils/ruleUtils';
+import type { ECMAVersion } from '../../../rule-utils/index.js';
 export declare function getVersionNumber(ECMAString: ECMAVersion): number | undefined;

package/dist/rules/rules/esm-resolved-to-cjs/index.d.ts

@@ -1,4 +1,4 @@
-import { Linter } from '@rsdoctor/types';
+import { Linter } from '@rsdoctor/shared/types';
 import type { Config } from './types.js';
 export type { Config } from './types.js';
 export declare const rule: Linter.RuleData<Config, "esm-resolved-to-cjs">;

package/dist/rules/rules/esm-resolved-to-cjs/index.js

@@ -1,7 +1,7 @@
 import "node:module";
 import fs from "fs";
 import path from "path";
-import { Linter, SDK } from "@rsdoctor/types";
+import { Linter, SDK } from "@rsdoctor/shared/types";
 import { defineRule } from "../../rule.js";
 const title = 'esm-resolved-to-cjs';
 function normalizePathForCompare(filePath) {