@rsdoctor/utils 0.1.1 → 0.1.2

package/dist/type/build/envinfo.d.ts

@@ -9,4 +9,4 @@ 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>;
+export declare function getGitRepo(): Promise<string>;

package/dist/type/build/file/cache.d.ts

@@ -2,4 +2,4 @@ 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;
+export declare function readJSONSync<T extends Common.PlainObject>(path: string): T;

package/dist/type/build/file/index.d.ts

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

package/dist/type/build/file/sharding.d.ts

@@ -1,22 +1,22 @@
 /// <reference types="node" />
 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): {
-    filename: string;
-    content: Buffer;
-  }[];
-  /**
-   * @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): Promise<{
-    filename: string;
-    content: Buffer;
-  }[]>;
-}
+    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): {
+        filename: string;
+        content: Buffer;
+    }[];
+    /**
+     * @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): Promise<{
+        filename: string;
+        content: Buffer;
+    }[]>;
+}

package/dist/type/build/index.d.ts

@@ -2,4 +2,4 @@ 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';
+export * as Process from './process';

package/dist/type/build/json.d.ts

@@ -1 +1 @@
-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 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>;

package/dist/type/build/process.d.ts

@@ -1,3 +1,3 @@
 /// <reference types="node" />
 export declare function getMemoryUsage(): NodeJS.MemoryUsage;
-export declare function getMemoryUsageMessage(): string;
+export declare function getMemoryUsageMessage(): string;

package/dist/type/build/server.d.ts

@@ -8,8 +8,8 @@ export declare const createGetPortSyncFunctionString: (expectPort: number) => st
 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;
-}>;
+    app: Thirdparty.connect.Server;
+    server: http.Server;
+    port: number;
+    close(): Promise<void> | never;
+}>;

package/dist/type/common/alerts.d.ts

@@ -1,2 +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>;
+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/type/common/algorithm.d.ts

@@ -1,4 +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;
+export declare function random(min: number, max: number): number;

package/dist/type/common/bundle.d.ts

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

package/dist/type/common/crypto.d.ts

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

package/dist/type/common/data/index.d.ts

@@ -3,8 +3,8 @@ import { SDK, Manifest } from '@rsdoctor/types';
  * this class will run at both brower 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>>;
-}
+    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/type/common/graph/assets.d.ts

@@ -5,37 +5,37 @@ export declare function isAssetMatchExtensions(asset: SDK.AssetData, exts: strin
 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;
+    /**
+     * 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;
+    count: number;
     size: number;
-    initial: boolean;
-    content: string | undefined;
-  }[];
+    files: {
+        path: string;
+        size: number;
+        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;
+    count: number;
     size: number;
-    initial: boolean;
-    content: string | undefined;
-  }[];
+    files: {
+        path: string;
+        size: number;
+        initial: boolean;
+        content: string | undefined;
+    }[];
 };
 export declare function getAssetsDiffResult(baseline: SDK.ChunkGraphData, current: SDK.ChunkGraphData): Client.RsdoctorClientAssetsDiffResult;
 /**
@@ -43,10 +43,10 @@ export declare function getAssetsDiffResult(baseline: SDK.ChunkGraphData, curren
  * @param cSize size of current
  */
 export declare function diffSize(bSize: number, cSize: number): {
-  percent: number;
-  state: Client.RsdoctorClientDiffState;
+    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[]): SDK.ServerAPI.InferResponseType<SDK.ServerAPI.API.GetAssetDetails>;
-export {};
+export {};

package/dist/type/common/graph/chunk.d.ts

@@ -4,4 +4,4 @@ export declare function getChunksByModule(module: SDK.ModuleData, chunks: SDK.Ch
 export declare function getChunkByChunkId(chunkId: string, chunks: SDK.ChunkData[]): SDK.ChunkData;
 export declare function getChunksByChunkIds(chunkIds: string[], chunks: SDK.ChunkData[]): SDK.ChunkData[];
 export declare function getChunksByAsset(asset: SDK.AssetData, chunks: SDK.ChunkData[]): SDK.ChunkData[];
-export declare function getChunksByModuleId(id: number, modules: SDK.ModuleData[], chunks: SDK.ChunkData[]): SDK.ChunkData[];
+export declare function getChunksByModuleId(id: number, modules: SDK.ModuleData[], chunks: SDK.ChunkData[]): SDK.ChunkData[];

package/dist/type/common/graph/dependency.d.ts

@@ -1,4 +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;
+export declare function getDependencyByResolvedRequest(resolvedRequest: string, dependencies: SDK.DependencyData[]): SDK.DependencyData | undefined;

package/dist/type/common/graph/entrypoints.d.ts

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

package/dist/type/common/graph/index.d.ts

@@ -2,4 +2,4 @@ export * from './assets';
 export * from './chunk';
 export * from './modules';
 export * from './dependency';
-export * from './entrypoints';
+export * from './entrypoints';

package/dist/type/common/graph/modules.d.ts

@@ -6,4 +6,4 @@ export declare function getModulesByChunk(chunk: SDK.ChunkData, modules: SDK.Mod
 export declare function getModulesByChunks(chunks: SDK.ChunkData[], modules: SDK.ModuleData[]): 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[]): SDK.ServerAPI.InferResponseType<SDK.ServerAPI.API.GetModuleDetails>;
+export declare function getModuleDetails(moduleId: number, modules: SDK.ModuleData[], dependencies: SDK.DependencyData[]): SDK.ServerAPI.InferResponseType<SDK.ServerAPI.API.GetModuleDetails>;

package/dist/type/common/index.d.ts

@@ -12,4 +12,4 @@ export * as Plugin from './plugin';
 export * as Data from './data';
 export * as Alerts from './alerts';
 export * as Rspack from './rspack';
-export * as Package from './package';
+export * as Package from './package';

package/dist/type/common/loader.d.ts

@@ -1,7 +1,7 @@
 import { SDK } from '@rsdoctor/types';
 export declare function findLoaderTotalTiming(loaders: Pick<SDK.LoaderTransformData, 'startAt' | 'endAt'>[]): {
-  start: number;
-  end: number;
+    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;
@@ -13,4 +13,4 @@ export declare function getLoaderFileDetails(path: string, loaders: SDK.LoaderDa
 export declare function getLoaderFolderStatistics(folder: string, loaders: SDK.LoaderData): 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 LoaderInternalPropertyName = "__l__";

package/dist/type/common/manifest.d.ts

@@ -1,4 +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>;
+export declare function fetchShardingFiles(data: Manifest.RsdoctorManifestWithShardingFiles['data'], fetchImplement: (url: string) => Promise<string>, filterKeys?: Array<keyof Manifest.RsdoctorManifestData>): Promise<Manifest.RsdoctorManifestData>;

package/dist/type/common/package.d.ts

@@ -4,4 +4,4 @@ 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;
+export declare const getPackageMetaFromModulePath: (modulePath: string) => SDK.PackageJSONData;

package/dist/type/common/plugin.d.ts

@@ -2,4 +2,4 @@ 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>;
+export declare function getPluginData(plugin: SDK.PluginData, selectedHooks?: string[], selectedTapNames?: string[]): SDK.ServerAPI.InferResponseType<SDK.ServerAPI.API.GetPluginData>;

package/dist/type/common/resolver.d.ts

@@ -3,4 +3,4 @@ export declare function isResolveSuccessData(data: SDK.PathResolverData): data i
 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>;
+export declare function getResolverFileDetails(filepath: string, resolvers: SDK.ResolverData, modules: SDK.ModuleData[], moduleCodeMap: SDK.ModuleCodeData): SDK.ServerAPI.InferResponseType<SDK.ServerAPI.API.GetResolverFileDetails>;

package/dist/type/common/rspack.d.ts

@@ -1,7 +1,7 @@
 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)",
-}
+    Bootstrap = "bootstrap->rspack:beforeCompile",
+    Compile = "rspack:beforeCompile->afterCompile",
+    Done = "rspack:afterCompile->done",
+    Minify = "rspack:minify(rspack:optimizeChunkAssets)"
+}

package/dist/type/common/summary.d.ts

@@ -1,6 +1,6 @@
 export declare enum SummaryCostsDataName {
-  Bootstrap = "bootstrap->beforeCompile",
-  Compile = "beforeCompile->afterCompile",
-  Done = "afterCompile->done",
-  Minify = "minify(webpack4:optimizeChunkAssets|webpack5:processAssets|rspack:processAssets)",
-}
+    Bootstrap = "bootstrap->beforeCompile",
+    Compile = "beforeCompile->afterCompile",
+    Done = "afterCompile->done",
+    Minify = "minify(webpack4:optimizeChunkAssets|webpack5:processAssets|rspack:processAssets)"
+}

package/dist/type/common/time.d.ts

@@ -1,4 +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;
+export declare function getCurrentTimestamp(start: number, startHRTime: [number, number]): number;

package/dist/type/common/url.d.ts

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

package/dist/type/error/error.d.ts

@@ -1,35 +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(): "Ignore" | "Warn" | "Error";
-  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;
-}
+    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(): "Ignore" | "Warn" | "Error";
+    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/type/error/index.d.ts

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

package/dist/type/error/transform.d.ts

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

package/dist/type/error/utils.d.ts

@@ -1,7 +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;
+export declare function printErrors({ errors, warnings }: Err.DevToolErrorsData, logLevel?: Logger.LogLevelName): string;

package/dist/type/index.d.ts

@@ -1,2 +1,2 @@
 export * as RuleUtils from './rule-utils';
-export * as Logger from './logger';
+export * as Logger from './logger';

package/dist/type/logger.d.ts

@@ -4,4 +4,4 @@ import { logger } from 'rslog';
  * log debug message
  */
 export declare function debug(getMsg: () => string, prefix?: string): void;
-export { chalk, logger };
+export { chalk, logger };

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

@@ -1,16 +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;
-}
+    /** 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/type/rule-utils/document/index.d.ts

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

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

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

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

@@ -4,28 +4,28 @@
  * - column starting point is 0
  */
 export interface Position {
-  line: number;
-  column: number;
+    line: number;
+    column: number;
 }
 /** Location range */
 export interface Range {
-  start: Position;
-  end: Position;
+    start: Position;
+    end: Position;
 }
 /** Offset range */
 export interface OffsetRange {
-  start: number;
-  end: number;
+    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;
-}
+    /** 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/type/rule-utils/index.d.ts

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

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

@@ -1,81 +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;
-};
+    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/type/rule-utils/parser/index.d.ts

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

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

@@ -4,115 +4,115 @@ 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;
+    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; /** Set of assertions */
-    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: {
+    /** 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; /** Set of assertions */
+        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/type/rule-utils/parser/types.d.ts

@@ -1,9 +1,9 @@
 import type * as Node from 'estree';
 export type { Node };
 export declare enum ECMAVersion {
-  ES5 = "ES5",
-  ES6 = "ES6",
-  ES7P = "ES7+",
+    ES5 = "ES5",
+    ES6 = "ES6",
+    ES7P = "ES7+"
 }
 /**
  * estree supplement type
@@ -11,20 +11,20 @@ export declare enum ECMAVersion {
  * 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;
-}
+    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/type/rule-utils/parser/utils.d.ts

@@ -27,4 +27,4 @@ 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;
+export declare function detectECMAVersion(code: string): ECMAVersion;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rsdoctor/utils",
-  "version": "0.1.1",
+  "version": "0.1.2",
   "repository": {
     "type": "git",
     "url": "https://github.com/web-infra-dev/rsdoctor",
@@ -62,7 +62,7 @@
     "lodash": "^4.17.21",
     "rslog": "^1.2.0",
     "strip-ansi": "^6.0.1",
-    "@rsdoctor/types": "0.1.1"
+    "@rsdoctor/types": "0.1.2"
   },
   "devDependencies": {
     "@types/deep-eql": "4.0.0",