@rsdoctor/utils 1.5.8 → 1.5.10

package/dist/build/envinfo.d.cts

@@ -0,0 +1,13 @@
+export declare const getCPUInfo: () => Promise<string>;
+export declare const getOSInfo: () => Promise<string>;
+export declare const getMemoryInfo: () => Promise<string>;
+export declare const getNodeVersion: () => Promise<string>;
+export declare const getYarnVersion: () => Promise<string>;
+export declare const getNpmVersion: () => Promise<string>;
+export declare const getPnpmVersion: () => Promise<string>;
+export declare function getNpmPackageVersion(pkg: string): Promise<string>;
+export declare function getNpmPackageVersion(pkgs: string[]): Promise<string[]>;
+export declare function getGlobalNpmPackageVersion(pkg: string): Promise<string>;
+export declare function getGlobalNpmPackageVersion(pkgs: string[]): Promise<string[]>;
+export declare function getGitBranch(): Promise<string>;
+export declare function getGitRepo(): Promise<string>;

package/dist/build/file/cache.d.cts

@@ -0,0 +1,5 @@
+import { Common } from '@rsdoctor/types';
+export declare function readFile(path: string): Promise<string>;
+export declare function readFileSync(path: string): string;
+export declare function readJSON<T extends Common.PlainObject>(path: string): Promise<T>;
+export declare function readJSONSync<T extends Common.PlainObject>(path: string): T;

package/dist/build/file/index.d.cts

@@ -0,0 +1,3 @@
+export * from './sharding';
+export * as fse from 'fs-extra';
+export * as cache from './cache';

package/dist/build/file/sharding.d.cts

@@ -0,0 +1,21 @@
+export declare class FileSharding {
+    protected content: string;
+    protected limitBytes: number;
+    protected encoding: BufferEncoding;
+    constructor(content: string, limitBytes?: number, encoding?: BufferEncoding);
+    /**
+     * @param ext the extension name of the output file (must starts with ".")
+     */
+    createVirtualShardingFiles(ext?: string, index?: number): {
+        filename: string;
+        content: Buffer<ArrayBufferLike>;
+    }[];
+    /**
+     * @param folder absolute path of folder which used to save string sharding files.
+     * @param ext the extension name of the output file (must starts with ".")
+     */
+    writeStringToFolder(folder: string, ext?: string, index?: number): Promise<{
+        filename: string;
+        content: Buffer<ArrayBufferLike>;
+    }[]>;
+}

package/dist/build/index.d.cts

@@ -0,0 +1,5 @@
+export * as File from './file';
+export * as Json from './json';
+export * as Server from './server';
+export * as EnvInfo from './envinfo';
+export * as Process from './process';

package/dist/build/json.d.cts

@@ -0,0 +1,3 @@
+import { SDK } from '@rsdoctor/types';
+export declare function stringify<T, P = T extends undefined ? undefined : string>(json: T, replacer?: (this: any, key: string, value: any) => any, space?: string | number, cycle?: boolean): Promise<P>;
+export declare const readPackageJson: (file: string, readFile?: SDK.GetPackageFile) => SDK.PackageBasicData | undefined;

package/dist/build/process.d.cts

@@ -0,0 +1,2 @@
+export declare function getMemoryUsage(): NodeJS.MemoryUsage;
+export declare function getMemoryUsageMessage(): string;

package/dist/build/server.d.cts

@@ -0,0 +1,14 @@
+import connect from 'connect';
+import http from 'http';
+import { Thirdparty } from '@rsdoctor/types';
+export declare const defaultPort: number;
+export declare function getPort(expectPort: number): Promise<number>;
+export declare const createGetPortSyncFunctionString: (expectPort: number) => string;
+export declare function getPortSync(expectPort: number): number | never;
+export declare function createApp(): connect.Server;
+export declare function createServer(port: number): Promise<{
+    app: Thirdparty.connect.Server;
+    server: http.Server;
+    port: number;
+    close(): Promise<void> | never;
+}>;

package/dist/common/alerts.d.cts

@@ -0,0 +1,2 @@
+import { Rule, SDK } from '@rsdoctor/types';
+export declare function getPackageRelationAlertDetails(modules: SDK.ModuleGraphData['modules'], dependencies: SDK.ModuleGraphData['dependencies'], root: string, packageDependencies: Rule.DependencyWithPackageData[], moduleCodeMap: SDK.ModuleCodeData): SDK.ServerAPI.InferResponseType<SDK.ServerAPI.API.GetPackageRelationAlertDetails>;

package/dist/common/algorithm.d.cts

@@ -0,0 +1,4 @@
+export declare function mergeIntervals(intervals: [number, number][]): [number, number][];
+export declare function compressText(input: string): string;
+export declare function decompressText(input: string): string;
+export declare function random(min: number, max: number): number;

package/dist/common/bundle.d.cts

@@ -0,0 +1,3 @@
+export declare function getBundleDiffPageQueryString(files: string[]): string;
+export declare function getBundleDiffPageUrl(files: string[]): string;
+export declare function parseFilesFromBundlePageUrlQuery(queryValue: string): string[];

package/dist/common/crypto.d.cts

@@ -0,0 +1,2 @@
+export declare function encode(str: string): string;
+export declare function decode(str: string): string;

package/dist/common/data/index.d.cts

@@ -0,0 +1,10 @@
+import { SDK, Manifest } from '@rsdoctor/types';
+/**
+ * this class will run at both browser and node environment.
+ */
+export declare class APIDataLoader {
+    protected loader: Manifest.ManifestDataLoader;
+    constructor(loader: Manifest.ManifestDataLoader);
+    log(...args: unknown[]): void;
+    loadAPI<T extends SDK.ServerAPI.API, B extends SDK.ServerAPI.InferRequestBodyType<T> = SDK.ServerAPI.InferRequestBodyType<T>, R extends SDK.ServerAPI.InferResponseType<T> = SDK.ServerAPI.InferResponseType<T>>(...args: B extends void ? [api: T] : [api: T, body: B]): Promise<SDK.ServerAPI.InferResponseType<T>>;
+}

package/dist/common/decycle.d.cts

@@ -0,0 +1,10 @@
+/**
+ * The following code is based on
+ * https://github.com/valery-barysok/json-cycle/blob/master/cycle.js
+ *
+ *
+ * MIT Licensed
+ * Author juliyvchirkov
+ * https://github.com/valery-barysok/json-cycle?tab=MIT-1-ov-file
+ */
+export declare function decycle<T = any>(object: T): T;

package/dist/common/fetch.d.cts

@@ -0,0 +1,10 @@
+export declare function getFetch(): typeof fetch;
+export interface FetchOptions {
+    timeout?: number;
+    method?: string;
+    headers?: Record<string, string>;
+    body?: string;
+    signal?: AbortSignal;
+}
+export declare function fetchWithTimeout(url: string, options?: FetchOptions): Promise<Response>;
+export declare function postJSON(url: string, body: unknown, timeout?: number): Promise<Response>;

package/dist/common/file.d.cts

@@ -0,0 +1,2 @@
+export declare function isStyleExt(path: string): boolean;
+export declare function isJsExt(path: string): boolean;

package/dist/common/global-config.d.cts

@@ -0,0 +1,21 @@
+/**
+ * @description Writes the builder port information to mcp.json.
+ *
+ * The mcp.json file uses the following format:
+ * {
+ *   portList: {
+ *     builder1: portNumber,
+ *     builder2: portNumber,
+ *   },
+ *   port: portNumber // The port of the last builder is used by default
+ * }
+ *
+ * @param {number} port - The port number to write.
+ * @param {string} [builderName] - The name of the builder.
+ */
+export declare function writeMcpPort(port: number, builderName?: string): void;
+/**
+ * @description Gets the path to the mcp.json file.
+ * @returns {string} The path to the mcp.json file.
+ */
+export declare function getMcpConfigPath(): string;

package/dist/common/graph/assets.d.cts

@@ -0,0 +1,56 @@
+import { Client, SDK } from '@rsdoctor/types';
+export declare function formatAssetName(assetName: string, fileConfig?: string): string;
+export declare function isAssetMatchExtension(asset: SDK.AssetData, ext: string): boolean;
+export declare function isAssetMatchExtensions(asset: SDK.AssetData, exts: string[]): boolean;
+export declare function filterAssetsByExtensions(assets: SDK.AssetData[], exts: string | string[]): SDK.AssetData[];
+type FilterFunctionOrExtensions = string | string[] | ((asset: SDK.AssetData) => boolean);
+interface GetAssetsOptions {
+    /**
+     * turn off it when you need not file content.
+     * @default true
+     */
+    withFileContent?: boolean;
+    /**
+     * filter with assets
+     */
+    filterOrExtensions?: FilterFunctionOrExtensions;
+}
+export declare function filterAssets(assets: SDK.AssetData[], filterOrExtensions?: FilterFunctionOrExtensions): SDK.AssetData[];
+export declare function getAssetsSizeInfo(assets: SDK.AssetData[], chunks: SDK.ChunkData[], options?: GetAssetsOptions): {
+    count: number;
+    size: number;
+    files: {
+        path: string;
+        size: number;
+        gzipSize: number | undefined;
+        initial: boolean;
+        content: string | undefined;
+    }[];
+};
+export declare function isInitialAsset(asset: SDK.AssetData, chunks: SDK.ChunkData[]): boolean;
+export declare function getInitialAssetsSizeInfo(assets: SDK.AssetData[], chunks: SDK.ChunkData[], options?: GetAssetsOptions): {
+    count: number;
+    size: number;
+    files: {
+        path: string;
+        size: number;
+        gzipSize: number | undefined;
+        initial: boolean;
+        content: string | undefined;
+    }[];
+};
+export declare function getAssetsDiffResult(baseline: SDK.ChunkGraphData, current: SDK.ChunkGraphData): Client.RsdoctorClientAssetsDiffResult;
+/**
+ * @param bSize size of baseline
+ * @param cSize size of current
+ */
+export declare function diffSize(bSize: number, cSize: number): {
+    percent: number;
+    state: Client.RsdoctorClientDiffState;
+};
+export declare function diffAssetsByExtensions(baseline: SDK.ChunkGraphData, current: SDK.ChunkGraphData, filterOrExtensions?: FilterFunctionOrExtensions, isInitial?: boolean): Client.RsdoctorClientAssetsDiffItem;
+export declare function getAssetsSummary(assets: SDK.AssetData[], chunks: SDK.ChunkData[], options?: Omit<GetAssetsOptions, 'filterOrExtensions'>): Client.RsdoctorClientAssetsSummary;
+export declare function getAssetDetails(assetPath: string, assets: SDK.AssetData[], chunks: SDK.ChunkData[], modules: SDK.ModuleData[], checkModules: (module: SDK.ModuleData) => boolean): SDK.ServerAPI.InferResponseType<SDK.ServerAPI.API.GetAssetDetails>;
+export declare function getAllBundleData(assets: SDK.AssetData[], chunks: SDK.ChunkData[], modules: SDK.ModuleData[], filtersModules?: (keyof SDK.ModuleData)[]): SDK.ServerAPI.InferResponseType<SDK.ServerAPI.API.GetSummaryBundles>;
+export declare function extname(filename: string): string;
+export {};

package/dist/common/graph/bundle-diff.d.cts

@@ -0,0 +1,16 @@
+import { Client, SDK } from '@rsdoctor/types';
+/**
+ * Compute module diff between baseline and current.
+ * Modules are matched by their file path.
+ */
+export declare function getModulesDiffResult(baseline: SDK.ModuleGraphData, current: SDK.ModuleGraphData): Client.RsdoctorClientModulesDiffResult;
+/**
+ * Compute package diff between baseline and current.
+ * Packages are matched by name@version.
+ */
+export declare function getPackagesDiffResult(baseline: SDK.PackageGraphData, current: SDK.PackageGraphData): Client.RsdoctorClientPackagesDiffResult;
+/**
+ * Compute the full bundle diff result between baseline and current manifest data.
+ * Combines asset, module, and package diffs into a single result.
+ */
+export declare function getBundleDiffResult(baseline: SDK.BuilderStoreData, current: SDK.BuilderStoreData): Client.RsdoctorClientBundleDiffResult;

package/dist/common/graph/chunk.d.cts

@@ -0,0 +1,7 @@
+import { SDK } from '@rsdoctor/types';
+export declare function getChunkIdsByAsset(asset: SDK.AssetData): string[];
+export declare function getChunksByModule(module: SDK.ModuleData, chunks: SDK.ChunkData[]): SDK.ChunkData[];
+export declare function getChunkByChunkId(chunkId: string, chunks: SDK.ChunkData[]): SDK.ChunkData;
+export declare function getChunksByChunkIds(chunkIds: string[], chunks: SDK.ChunkData[], filters?: (keyof SDK.ChunkData)[]): SDK.ChunkData[];
+export declare function getChunksByAsset(asset: SDK.AssetData, chunks: SDK.ChunkData[], filters?: (keyof SDK.ChunkData)[]): SDK.ChunkData[];
+export declare function getChunksByModuleId(id: number, modules: SDK.ModuleData[], chunks: SDK.ChunkData[]): SDK.ChunkData[];

package/dist/common/graph/dependency.d.cts

@@ -0,0 +1,4 @@
+import { Rule, SDK } from '@rsdoctor/types';
+export declare function getDependencyByPackageData(dep: Rule.DependencyWithPackageData, dependencies: SDK.DependencyData[]): SDK.DependencyData | undefined;
+export declare function getDependenciesByModule(module: SDK.ModuleData, dependencies: SDK.DependencyData[]): SDK.DependencyData[];
+export declare function getDependencyByResolvedRequest(resolvedRequest: string, dependencies: SDK.DependencyData[]): SDK.DependencyData | undefined;

package/dist/common/graph/entrypoints.d.cts

@@ -0,0 +1,2 @@
+import { SDK } from '@rsdoctor/types';
+export declare function getEntryPoints(entrypoints: SDK.EntryPointData[]): SDK.ServerAPI.InferResponseType<SDK.ServerAPI.API.GetEntryPoints>;

package/dist/common/graph/index.d.cts

@@ -0,0 +1,6 @@
+export * from './assets';
+export * from './bundle-diff';
+export * from './chunk';
+export * from './modules';
+export * from './dependency';
+export * from './entrypoints';

package/dist/common/graph/modules.d.cts

@@ -0,0 +1,9 @@
+import { Rule, SDK } from '@rsdoctor/types';
+export declare function getModulesByAsset(asset: SDK.AssetData, chunks: SDK.ChunkData[], modules: SDK.ModuleData[], filterModules?: (keyof SDK.ModuleData)[], checkModules?: (module: SDK.ModuleData) => boolean): SDK.ModuleData[];
+export declare function getModuleIdsByChunk(chunk: SDK.ChunkData): number[];
+export declare function getModuleIdsByModulesIds(moduleIds: number[], modules: SDK.ModuleData[]): SDK.ModuleData[];
+export declare function getModulesByChunk(chunk: SDK.ChunkData, modules: SDK.ModuleData[], filterModules?: (keyof SDK.ModuleData)[]): SDK.ModuleData[];
+export declare function getModulesByChunks(chunks: SDK.ChunkData[], modules: SDK.ModuleData[], filterModules?: (keyof SDK.ModuleData)[], checkModules?: (module: SDK.ModuleData) => boolean): SDK.ModuleData[];
+export declare function getModuleByDependency(dep: SDK.DependencyData, modules: SDK.ModuleData[]): SDK.ModuleData | undefined;
+export declare function filterModulesAndDependenciesByPackageDeps(deps: Rule.DependencyWithPackageData[], dependencies: SDK.DependencyData[], modules: SDK.ModuleData[]): Pick<SDK.ModuleGraphData, 'dependencies' | 'modules'>;
+export declare function getModuleDetails(moduleId: number, modules: SDK.ModuleData[], dependencies: SDK.DependencyData[], sideEffectCodes?: SDK.SideEffectCodeData[]): SDK.ServerAPI.InferResponseType<SDK.ServerAPI.API.GetModuleDetails>;

package/dist/common/index.d.cts

@@ -0,0 +1,20 @@
+export * as Summary from './summary';
+export * as Crypto from './crypto';
+export * as Manifest from './manifest';
+export * as Loader from './loader';
+export * as Time from './time';
+export * as Algorithm from './algorithm';
+export * as Resolver from './resolver';
+export * as Graph from './graph';
+export * as Bundle from './bundle';
+export * as Url from './url';
+export * as Plugin from './plugin';
+export * as Data from './data';
+export * as Alerts from './alerts';
+export * as Fetch from './fetch';
+export * as Rspack from './rspack';
+export * as Package from './package';
+export * as Lodash from './lodash';
+export * as GlobalConfig from './global-config';
+export * as File from './file';
+export * from './decycle';

package/dist/common/loader.d.cts

@@ -0,0 +1,22 @@
+import { SDK } from '@rsdoctor/types';
+import { Plugin } from '@rsdoctor/types';
+export declare function findLoaderTotalTiming(loaders: Pick<SDK.LoaderTransformData, 'startAt' | 'endAt'>[]): {
+    start: number;
+    end: number;
+};
+export declare function getLoadersCosts(filter: (loader: Pick<SDK.LoaderTransformData, 'loader' | 'startAt' | 'endAt' | 'pid'>) => boolean, loaders: Pick<SDK.LoaderTransformData, 'loader' | 'startAt' | 'endAt' | 'pid'>[]): number;
+export declare function getLoaderCosts(loader: SDK.LoaderTransformData, loaders: SDK.LoaderTransformData[]): number;
+export declare function getLoaderNames(loaders: SDK.LoaderData): SDK.ServerAPI.InferResponseType<SDK.ServerAPI.API.GetLoaderNames>;
+export declare function getLoadersTransformData(loaders: SDK.LoaderData): SDK.LoaderTransformData[];
+export declare function getLoaderChartData(loaders: SDK.LoaderData): SDK.ServerAPI.InferResponseType<SDK.ServerAPI.API.GetLoaderChartData>;
+export declare function getLoaderFileTree(loaders: SDK.LoaderData): SDK.ServerAPI.InferResponseType<SDK.ServerAPI.API.GetLoaderFileTree>;
+export declare function getLoaderFileDetails(path: string, loaders: SDK.LoaderData): SDK.ServerAPI.InferResponseType<SDK.ServerAPI.API.GetLoaderFileDetails>;
+export declare function getLoaderFolderStatistics(folder: string, loaders: SDK.LoaderData): SDK.ServerAPI.InferResponseType<SDK.ServerAPI.API.GetLoaderFolderStatistics>;
+export declare function getDirectoriesLoaders(loaders: SDK.LoaderData, root?: string): {
+    directory: string;
+    stats: SDK.ServerAPI.InferResponseType<SDK.ServerAPI.API.GetLoaderFolderStatistics>;
+}[];
+export declare function getLoaderFileFirstInput(file: string, loaders: SDK.LoaderData): SDK.ServerAPI.InferResponseType<SDK.ServerAPI.API.GetLoaderFileFirstInput>;
+export declare function getLoaderFileInputAndOutput(file: string, loader: string, loaderIndex: number, loaders: SDK.LoaderData): SDK.ServerAPI.InferResponseType<SDK.ServerAPI.API.GetLoaderFileInputAndOutput>;
+export declare const LoaderInternalPropertyName = "__l__";
+export declare const isVue: (compiler: Plugin.BaseCompiler) => boolean;

package/dist/common/lodash.d.cts

@@ -0,0 +1,10 @@
+export declare function isUndefined(value: unknown): value is undefined;
+export declare function isNumber(value: unknown): value is number;
+export declare function isObject(value: unknown): value is Record<string, unknown>;
+export declare function isEmpty(value: unknown): boolean;
+export declare function last<T>(array: T[]): T | undefined;
+export declare function compact<T>(array: (T | null | undefined)[]): T[];
+export declare function isNil(value: unknown): value is null | undefined;
+export declare const isPlainObject: (obj: unknown) => obj is Record<string, any>;
+export declare const isString: (v: unknown) => v is string;
+export declare function pick<T extends Record<string, any>, K extends keyof T>(obj: T, keys: readonly K[]): Pick<T, K>;

package/dist/common/manifest.d.cts

@@ -0,0 +1,4 @@
+import { Manifest } from '@rsdoctor/types';
+export declare function isShardingData(data: unknown): data is string[];
+export declare function fetchShardingData(shardingFiles: string[], fetchImplement: (url: string) => Promise<string>): Promise<any>;
+export declare function fetchShardingFiles(data: Manifest.RsdoctorManifestWithShardingFiles['data'], fetchImplement: (url: string) => Promise<string>, filterKeys?: Array<keyof Manifest.RsdoctorManifestData>): Promise<Manifest.RsdoctorManifestData>;

package/dist/common/package.d.cts

@@ -0,0 +1,7 @@
+import { SDK } from '@rsdoctor/types';
+export declare const MODULE_PATH_PACKAGES: RegExp;
+export declare const PACKAGE_PATH_NAME: RegExp;
+/**
+ * Heuristics to extract package id, name, and path from a module path
+ */
+export declare const getPackageMetaFromModulePath: (modulePath: string) => SDK.PackageJSONData;

package/dist/common/plugin.d.cts

@@ -0,0 +1,5 @@
+import { SDK } from '@rsdoctor/types';
+export declare function getPluginHooks(plugin: SDK.PluginData): string[];
+export declare function getPluginTapNames(plugin: SDK.PluginData): string[];
+export declare function getPluginSummary(plugin: SDK.PluginData): SDK.ServerAPI.InferResponseType<SDK.ServerAPI.API.GetPluginSummary>;
+export declare function getPluginData(plugin: SDK.PluginData, selectedHooks?: string[], selectedTapNames?: string[]): SDK.ServerAPI.InferResponseType<SDK.ServerAPI.API.GetPluginData>;

package/dist/common/resolver.d.cts

@@ -0,0 +1,6 @@
+import { SDK } from '@rsdoctor/types';
+export declare function isResolveSuccessData(data: SDK.PathResolverData): data is SDK.PathResolverSuccessData;
+export declare function isResolveFailData(data: SDK.PathResolverData): data is SDK.PathResolverSuccessData;
+export declare function getResolverCosts(resolver: SDK.PathResolverData, resolvers: SDK.ResolverData): number;
+export declare function getResolverFileTree(resolver: SDK.ResolverData): SDK.ServerAPI.InferResponseType<SDK.ServerAPI.API.GetResolverFileTree>;
+export declare function getResolverFileDetails(filepath: string, resolvers: SDK.ResolverData, modules: SDK.ModuleData[], moduleCodeMap: SDK.ModuleCodeData): SDK.ServerAPI.InferResponseType<SDK.ServerAPI.API.GetResolverFileDetails>;

package/dist/common/rspack.d.cts

@@ -0,0 +1,17 @@
+import { SDK } from '@rsdoctor/types';
+export declare const RspackLoaderInternalPropertyName = "__l__";
+export declare enum RspackSummaryCostsDataName {
+    Bootstrap = "bootstrap->rspack:beforeCompile",
+    Compile = "rspack:beforeCompile->afterCompile",
+    Done = "rspack:afterCompile->done",
+    Minify = "rspack:minify(rspack:optimizeChunkAssets)"
+}
+/**
+ * Check if the compiler configuration supports source maps
+ * @param configs - Array of compiler configurations
+ * @returns Object containing compiler type and source map support status
+ */
+export declare function checkSourceMapSupport(configs: SDK.WebpackConfigData[]): {
+    isRspack: boolean;
+    hasSourceMap: boolean;
+};

package/dist/common/summary.d.cts

@@ -0,0 +1,6 @@
+export declare enum SummaryCostsDataName {
+    Bootstrap = "bootstrap->beforeCompile",
+    Compile = "beforeCompile->afterCompile",
+    Done = "afterCompile->done",
+    Minify = "minify(processAssets)"
+}

package/dist/common/time.d.cts

@@ -0,0 +1,4 @@
+export declare function toFixedDigits(num: number, digits?: number): number;
+export declare function getUnit(num: number, type: 'm' | 'h'): string;
+export declare function formatCosts(costs: number | string): string;
+export declare function getCurrentTimestamp(start: number, startHRTime: [number, number]): number;

package/dist/common/url.d.cts

@@ -0,0 +1,3 @@
+export declare function isUrl(uri: string): boolean;
+export declare function isFilePath(uri: string): boolean;
+export declare function isRemoteUrl(uri: unknown): boolean;

package/dist/common.cjs

@@ -637,7 +637,7 @@ for(var __rspack_i in (()=>{
         return {
             ...data,
             loaders: data.loaders.map((el)=>{
-                let { input, result, ...loaderWithoutCode } = el;
+                let { input: _input, result: _result, ...loaderWithoutCode } = el;
                 return {
                     ...loaderWithoutCode,
                     loader: getLoadrName(el.loader),
@@ -907,9 +907,12 @@ for(var __rspack_i in (()=>{
         return (0, graph_chunk.Ip)(asset, chunks).some((e)=>!!e.initial);
     }
     function getInitialAssetsSizeInfo(assets, chunks, options = {}) {
-        return options.filterOrExtensions && (assets = filterAssets(assets, options.filterOrExtensions)), getAssetsSizeInfo(assets, chunks, {
+        return getAssetsSizeInfo(assets, chunks, {
             ...options,
-            filterOrExtensions: (asset)=>isInitialAsset(asset, chunks)
+            filterOrExtensions: (asset)=>{
+                var asset1, filterOrExtensions;
+                return asset1 = asset, (!(filterOrExtensions = options.filterOrExtensions) || ('function' == typeof filterOrExtensions ? filterOrExtensions(asset1) : 'string' == typeof filterOrExtensions ? isAssetMatchExtension(asset1, filterOrExtensions) : isAssetMatchExtensions(asset1, filterOrExtensions))) && isInitialAsset(asset, chunks);
+            }
         });
     }
     function getAssetsDiffResult(baseline, current) {
@@ -1440,7 +1443,7 @@ for(var __rspack_i in (()=>{
                 case types_.SDK.ServerAPI.API.GetChunkGraphAI:
                     return this.loader.loadData('chunkGraph').then((res)=>{
                         let { assets = [] } = res || {};
-                        return assets.map(({ content, ...rest })=>rest);
+                        return assets.map(({ content: _, ...rest })=>rest);
                     });
                 case types_.SDK.ServerAPI.API.GetChunkByIdAI:
                     return Promise.all([

package/dist/common.js

@@ -313,7 +313,7 @@ function getLoaderFileDetails(path, loaders) {
     return {
         ...data,
         loaders: data.loaders.map((el)=>{
-            let { input, result, ...loaderWithoutCode } = el;
+            let { input: _input, result: _result, ...loaderWithoutCode } = el;
             return {
                 ...loaderWithoutCode,
                 loader: getLoadrName(el.loader),
@@ -610,9 +610,12 @@ function isInitialAsset(asset, chunks) {
     return getChunksByAsset(asset, chunks).some((e)=>!!e.initial);
 }
 function getInitialAssetsSizeInfo(assets, chunks, options = {}) {
-    return options.filterOrExtensions && (assets = filterAssets(assets, options.filterOrExtensions)), getAssetsSizeInfo(assets, chunks, {
+    return getAssetsSizeInfo(assets, chunks, {
         ...options,
-        filterOrExtensions: (asset)=>isInitialAsset(asset, chunks)
+        filterOrExtensions: (asset)=>{
+            var filterOrExtensions;
+            return (!(filterOrExtensions = options.filterOrExtensions) || ('function' == typeof filterOrExtensions ? filterOrExtensions(asset) : 'string' == typeof filterOrExtensions ? isAssetMatchExtension(asset, filterOrExtensions) : isAssetMatchExtensions(asset, filterOrExtensions))) && isInitialAsset(asset, chunks);
+        }
     });
 }
 function getAssetsDiffResult(baseline, current) {
@@ -1191,7 +1194,7 @@ class APIDataLoader {
             case SDK.ServerAPI.API.GetChunkGraphAI:
                 return this.loader.loadData('chunkGraph').then((res)=>{
                     let { assets = [] } = res || {};
-                    return assets.map(({ content, ...rest })=>rest);
+                    return assets.map(({ content: _, ...rest })=>rest);
                 });
             case SDK.ServerAPI.API.GetChunkByIdAI:
                 return Promise.all([

package/dist/error/error.d.cts

@@ -0,0 +1,35 @@
+import { Err, Rule } from '@rsdoctor/types';
+export declare class DevToolError extends Error implements Err.DevToolErrorInstance {
+    static from(err: unknown, opt?: Err.DevToolErrorParams): DevToolError;
+    readonly id: number;
+    readonly code?: string;
+    readonly category?: string;
+    readonly title: string;
+    readonly detail?: any;
+    readonly fixData?: Err.FixData;
+    readonly hint?: string;
+    readonly referenceUrl?: string;
+    private _codeFrame?;
+    private _controller;
+    private readonly _level;
+    constructor(title: string, message: string, opts?: Err.DevToolErrorParams);
+    get level(): keyof typeof Err.ErrorLevel;
+    get path(): string | undefined;
+    set path(file: string | undefined);
+    get codeFrame(): Err.CodeFrameOption | undefined;
+    private printCodeFrame;
+    toString(): string;
+    toData(): Rule.RuleStoreDataItem;
+    toError(): Error;
+    /**
+     * for json stringify
+     */
+    toJSON(): {
+        message: string;
+        name: string;
+        stack: string | undefined;
+    };
+    setControllerOption(opt: Err.ControllerOption): void;
+    setCodeFrame(opt: Err.CodeFrameOption): void;
+    isSame(error: Err.DevToolErrorInstance): boolean;
+}

package/dist/error/index.d.cts

@@ -0,0 +1,2 @@
+export * from './error';
+export { printErrors } from './utils';

package/dist/error/transform.d.cts

@@ -0,0 +1,3 @@
+import { Err } from '@rsdoctor/types';
+import { DevToolError } from './error';
+export declare function transform(err: any, opt?: Err.DevToolErrorParams): DevToolError;

package/dist/error/utils.d.cts

@@ -0,0 +1,4 @@
+import { Err, Logger } from '@rsdoctor/types';
+export declare function toLevel(level: keyof typeof Err.ErrorLevel): Err.ErrorLevel;
+export declare function insertSpace(rawLines: string, line: number, width: number): string;
+export declare function printErrors({ errors, warnings }: Err.DevToolErrorsData, logLevel?: Logger.LogLevelName): string;

package/dist/logger.d.cts

@@ -0,0 +1,9 @@
+import c from 'picocolors';
+/**
+ * log debug message
+ */
+export declare function debug(getMsg: () => string, prefix?: string): void;
+declare const rsdoctorLogger: import("rslog").Logger;
+declare function time(label: string): void;
+declare function timeEnd(label: string): void;
+export { time, timeEnd, c as chalk, rsdoctorLogger as logger };

package/dist/rule-utils/document/document.d.cts

@@ -0,0 +1,16 @@
+import { Range, OffsetRange, Position, DocumentEditData } from './types';
+/** Document Catalogue */
+export declare class Document {
+    /** Actual document content. */
+    private _text;
+    /** Get the displacement of the file position in the text. */
+    positionAt: (offset: number) => Position | undefined;
+    /** Get the position of the displacement point in the file. */
+    offsetAt: (position: Position) => number | undefined;
+    constructor(content: string);
+    /** Generate location search */
+    private createFinder;
+    getText(range?: Range | OffsetRange): string;
+    /** Edit document data */
+    edit(data: DocumentEditData): string | undefined;
+}

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

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

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

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

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

@@ -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.cts

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

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

@@ -0,0 +1,81 @@
+import { Node } from './types';
+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/index.d.cts

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

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

@@ -0,0 +1,118 @@
+import { Parser as AcornParser, Options, Position } from 'acorn';
+import * as walk from 'acorn-walk';
+import * as utils from './utils';
+import type { Node } from './types';
+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/types.d.cts

@@ -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/utils.d.cts

@@ -0,0 +1,30 @@
+import { ecmaVersion } from 'acorn';
+import { Node, ECMAVersion } from './types';
+/**
+ * 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/ruleUtils.cjs

@@ -81,7 +81,7 @@ class Document {
     positionAt;
     offsetAt;
     constructor(content){
-        this._text, this._text = content, this.createFinder();
+        this._text = content, this.createFinder();
     }
     createFinder() {
         let find = new external_lines_and_columns_namespaceObject.LinesAndColumns(this._text);
@@ -272,7 +272,7 @@ function canParse(code, ecmaVersion) {
             ecmaVersion,
             sourceType: 'number' == typeof ecmaVersion && ecmaVersion <= 5 ? "script" : 'module'
         }), !0;
-    } catch (err) {
+    } catch  {
         return !1;
     }
 }

package/dist/ruleUtils.js

@@ -22,7 +22,7 @@ class Document {
     positionAt;
     offsetAt;
     constructor(content){
-        this._text, this._text = content, this.createFinder();
+        this._text = content, this.createFinder();
     }
     createFinder() {
         let find = new LinesAndColumns(this._text);
@@ -211,7 +211,7 @@ function canParse(code, ecmaVersion) {
             ecmaVersion,
             sourceType: 'number' == typeof ecmaVersion && ecmaVersion <= 5 ? "script" : 'module'
         }), !0;
-    } catch (err) {
+    } catch  {
         return !1;
     }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rsdoctor/utils",
-  "version": "1.5.8",
+  "version": "1.5.10",
   "repository": {
     "type": "git",
     "url": "https://github.com/web-infra-dev/rsdoctor",
@@ -10,29 +10,54 @@
   "license": "MIT",
   "exports": {
     "./common": {
-      "types": "./dist/common/index.d.ts",
-      "import": "./dist/common.js",
-      "default": "./dist/common.cjs"
+      "import": {
+        "types": "./dist/common/index.d.ts",
+        "default": "./dist/common.js"
+      },
+      "require": {
+        "types": "./dist/common/index.d.cts",
+        "default": "./dist/common.cjs"
+      }
     },
     "./build": {
-      "types": "./dist/build/index.d.ts",
-      "import": "./dist/build.js",
-      "default": "./dist/build.cjs"
+      "import": {
+        "types": "./dist/build/index.d.ts",
+        "default": "./dist/build.js"
+      },
+      "require": {
+        "types": "./dist/build/index.d.cts",
+        "default": "./dist/build.cjs"
+      }
     },
     "./error": {
-      "types": "./dist/error/index.d.ts",
-      "import": "./dist/error.js",
-      "default": "./dist/error.cjs"
+      "import": {
+        "types": "./dist/error/index.d.ts",
+        "default": "./dist/error.js"
+      },
+      "require": {
+        "types": "./dist/error/index.d.cts",
+        "default": "./dist/error.cjs"
+      }
     },
     "./ruleUtils": {
-      "types": "./dist/rule-utils/index.d.ts",
-      "import": "./dist/ruleUtils.js",
-      "default": "./dist/ruleUtils.cjs"
+      "import": {
+        "types": "./dist/rule-utils/index.d.ts",
+        "default": "./dist/ruleUtils.js"
+      },
+      "require": {
+        "types": "./dist/rule-utils/index.d.cts",
+        "default": "./dist/ruleUtils.cjs"
+      }
     },
     "./logger": {
-      "types": "./dist/logger.d.ts",
-      "import": "./dist/logger.js",
-      "default": "./dist/logger.cjs"
+      "import": {
+        "types": "./dist/logger.d.ts",
+        "default": "./dist/logger.js"
+      },
+      "require": {
+        "types": "./dist/logger.d.cts",
+        "default": "./dist/logger.cjs"
+      }
     }
   },
   "typesVersions": {
@@ -76,7 +101,7 @@
     "picocolors": "^1.1.1",
     "rslog": "^1.3.2",
     "strip-ansi": "^6.0.1",
-    "@rsdoctor/types": "1.5.8"
+    "@rsdoctor/types": "1.5.10"
   },
   "devDependencies": {
     "@types/babel__code-frame": "7.27.0",