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

package/dist/inner-plugins/constants.d.ts

@@ -1,4 +1,4 @@
-import type { Tap } from 'tapable';
+import type { Tap } from '@rspack/lite-tapable';
 export declare const pluginTapName = "RsdoctorRspackPlugin";
 export declare const pluginTapPostOptions: Tap;
 export declare const pluginTapPreOptions: Tap;

package/dist/inner-plugins/loaders/proxy.d.ts

@@ -1,7 +1,7 @@
-import type { Plugin as PluginType } from '@rsdoctor/types';
-import { Plugin } from '@rsdoctor/types';
+import type { Plugin as PluginType } from '@rsdoctor/shared/types';
+import { Plugin } from '@rsdoctor/shared/types';
 import type { ProxyLoaderOptions } from '../../types/index.js';
-declare const loaderModule: Plugin.LoaderDefinition<ProxyLoaderOptions, {}>;
-export declare const pitch: (this: PluginType.LoaderContext<ProxyLoaderOptions>) => string | void | Buffer<ArrayBufferLike> | Promise<string | Buffer<ArrayBufferLike>>;
+declare const loaderModule: Plugin.LoaderDefinition<ProxyLoaderOptions, object>;
+export declare const pitch: (this: PluginType.LoaderContext<ProxyLoaderOptions>) => void | string | Buffer<ArrayBufferLike> | Promise<string | Buffer<ArrayBufferLike>>;
 export declare const raw = true;
 export default loaderModule;

package/dist/inner-plugins/plugins/base.d.ts

@@ -1,4 +1,4 @@
-import type { Linter, Plugin, SDK } from '@rsdoctor/types';
+import type { Linter, Plugin, SDK } from '@rsdoctor/shared/types';
 import type { InternalPlugin, RsdoctorPluginInstance } from '../../types/index.js';
 export declare abstract class InternalBasePlugin<T extends Plugin.BaseCompiler> implements InternalPlugin<T, Linter.ExtendRuleData[]> {
     readonly scheduler: RsdoctorPluginInstance<T, Linter.ExtendRuleData[]>;
@@ -7,6 +7,6 @@ export declare abstract class InternalBasePlugin<T extends Plugin.BaseCompiler>
     abstract apply(compiler: T): void;
     get options(): Plugin.RsdoctorPluginOptionsNormalized<Linter.ExtendRuleData<any, string>[]>;
     get sdk(): SDK.RsdoctorBuilderSDKInstance;
-    get tapPostOptions(): import("tapable").Tap;
-    get tapPreOptions(): import("tapable").Tap;
+    get tapPostOptions(): import("@rspack/lite-tapable").Tap;
+    get tapPreOptions(): import("@rspack/lite-tapable").Tap;
 }

package/dist/inner-plugins/plugins/bundle.d.ts

@@ -1,4 +1,4 @@
-import { Plugin } from '@rsdoctor/types';
+import { Plugin } from '@rsdoctor/shared/types';
 import { InternalBasePlugin } from './base.js';
 export declare class InternalBundlePlugin<T extends Plugin.BaseCompiler> extends InternalBasePlugin<T> {
     readonly name = "bundle";

package/dist/inner-plugins/plugins/ensureModulesChunkGraph.d.ts

@@ -1,5 +1,5 @@
-import { RsdoctorPluginInstance } from '../../types/index.js';
-import { Linter, Plugin } from '@rsdoctor/types';
+import type { RsdoctorPluginInstance } from '../../types/index.js';
+import { Linter, Plugin } from '@rsdoctor/shared/types';
 /**
  * Represents a mapping item from a source map.
  */
@@ -13,7 +13,7 @@ export interface MappingItem {
 }
 /**
  * Main function to generate ModuleGraph and ChunkGraph from Rspack native data
- * or stats fallback, and collect source maps.
+ * and collect source maps.
  */
 export declare const ensureModulesChunksGraphFn: (compiler: Plugin.BaseCompiler, _this: RsdoctorPluginInstance<Plugin.BaseCompiler, Linter.ExtendRuleData[]>) => void;
 /**

package/dist/inner-plugins/plugins/errors.d.ts

@@ -1,6 +1,6 @@
-import { Rule, Err, Plugin } from '@rsdoctor/types';
+import { Rule, Err, Plugin } from '@rsdoctor/shared/types';
 import { InternalBasePlugin } from './base.js';
-import { DevToolError } from '@rsdoctor/utils/error';
+import { DevToolError } from '../../error/index.js';
 export declare class InternalErrorReporterPlugin<T extends Plugin.BaseCompiler> extends InternalBasePlugin<T> {
     readonly name = "error-reporter";
     apply(compiler: T): void;

package/dist/inner-plugins/plugins/loader.d.ts

@@ -1,4 +1,4 @@
-import { Plugin } from '@rsdoctor/types';
+import { Plugin } from '@rsdoctor/shared/types';
 import { InternalBasePlugin } from './base.js';
 export declare class InternalLoaderPlugin<T extends Plugin.BaseCompiler> extends InternalBasePlugin<T> {
     readonly name = "loader";

package/dist/inner-plugins/plugins/plugins.d.ts

@@ -1,4 +1,4 @@
-import { Plugin } from '@rsdoctor/types';
+import { Plugin } from '@rsdoctor/shared/types';
 import { InternalBasePlugin } from './base.js';
 export declare class InternalPluginsPlugin<T extends Plugin.BaseCompiler> extends InternalBasePlugin<T> {
     readonly name = "plugins";

package/dist/inner-plugins/plugins/progress.d.ts

@@ -1,5 +1,5 @@
-import { SDK } from '@rsdoctor/types';
-import type { Plugin } from '@rsdoctor/types';
+import { SDK } from '@rsdoctor/shared/types';
+import type { Plugin } from '@rsdoctor/shared/types';
 import { InternalBasePlugin } from './base.js';
 export declare class InternalProgressPlugin<T extends Plugin.BaseCompilerType<'rspack'>> extends InternalBasePlugin<T> {
     readonly name = "progress";

package/dist/inner-plugins/plugins/resolver.d.ts

@@ -1,4 +1,4 @@
-import { Plugin } from '@rsdoctor/types';
+import { Plugin } from '@rsdoctor/shared/types';
 import { InternalBasePlugin } from './base.js';
 export declare class InternalResolverPlugin<T extends Plugin.BaseCompiler> extends InternalBasePlugin<T> {
     readonly name = "resolver";

package/dist/inner-plugins/plugins/rspack.d.ts

@@ -1,4 +1,9 @@
-import { Linter, Plugin } from '@rsdoctor/types';
+import { Linter, Plugin } from '@rsdoctor/shared/types';
 import type { experiments } from '@rspack/core';
-import { RsdoctorPluginInstance } from '../../types/index.js';
-export declare function applyRspackNativePlugin(compiler: Plugin.BaseCompiler, plugin: RsdoctorPluginInstance<Plugin.BaseCompiler, Linter.ExtendRuleData[]>, RsdoctorRspackPlugin: typeof experiments.RsdoctorPlugin): void;
+import type { RsdoctorPluginInstance } from '../../types/index.js';
+export interface RspackNativeGraphState {
+    chunkGraph: boolean;
+    moduleGraph: boolean;
+}
+export declare function getRspackNativePlugin(compiler: Plugin.BaseCompiler): typeof experiments.RsdoctorPlugin;
+export declare function applyRspackNativePlugin(compiler: Plugin.BaseCompiler, plugin: RsdoctorPluginInstance<Plugin.BaseCompiler, Linter.ExtendRuleData[]>, RsdoctorRspackPlugin: typeof experiments.RsdoctorPlugin): RspackNativeGraphState;

package/dist/inner-plugins/plugins/rules.d.ts

@@ -1,5 +1,5 @@
 import { InternalBasePlugin } from './base.js';
-import { Plugin } from '@rsdoctor/types';
+import { Plugin } from '@rsdoctor/shared/types';
 export declare class InternalRulesPlugin extends InternalBasePlugin<Plugin.BaseCompiler> {
     readonly name = "rules";
     apply(compiler: Plugin.BaseCompiler): void;

package/dist/inner-plugins/plugins/sourcemapTool.d.ts

@@ -1,5 +1,5 @@
-import { RsdoctorPluginInstance } from '../../types/index.js';
-import { Linter, Plugin } from '@rsdoctor/types';
+import type { RsdoctorPluginInstance } from '../../types/index.js';
+import { Linter, Plugin } from '@rsdoctor/shared/types';
 export declare const UNASSIGNED = "[unassigned]";
 /**
  * Options for handling source map assets.

package/dist/inner-plugins/plugins/summary.d.ts

@@ -1,4 +1,4 @@
-import type { Plugin } from '@rsdoctor/types';
+import type { Plugin } from '@rsdoctor/shared/types';
 import { InternalBasePlugin } from './base.js';
 export declare class InternalSummaryPlugin<T extends Plugin.BaseCompiler> extends InternalBasePlugin<T> {
     readonly name = "summary";

package/dist/inner-plugins/utils/config.d.ts

@@ -1,5 +1,4 @@
-import { RsdoctorRspackPluginOptions, RsdoctorRspackPluginOptionsNormalized } from '../../types/index.js';
-import { Linter, Plugin, SDK } from '@rsdoctor/types';
+import { Linter, Plugin, SDK } from '@rsdoctor/shared/types';
 export declare function normalizeUserConfig<Rules extends Linter.ExtendRuleData[]>(config?: Plugin.RsdoctorRspackPluginOptions<Rules>): Plugin.RsdoctorPluginOptionsNormalized<Rules>;
 export declare const normalizeReportType: (reportCodeType: Plugin.IReportCodeType | Plugin.NewReportCodeType, mode: keyof typeof SDK.IMode) => SDK.ToDataType;
-export declare function normalizeRspackUserOptions<Rules extends Linter.ExtendRuleData[]>(options: RsdoctorRspackPluginOptions<Rules>): RsdoctorRspackPluginOptionsNormalized<Rules>;
+export declare const normalizeRspackUserOptions: typeof normalizeUserConfig;

package/dist/inner-plugins/utils/loader.d.ts

@@ -1,13 +1,10 @@
-import { Loader } from '@rsdoctor/utils/common';
-import { SDK, Plugin } from '@rsdoctor/types';
+import { SDK, Plugin } from '@rsdoctor/shared/types';
 import { ProxyLoaderInternalOptions, ProxyLoaderOptions } from '../../types/index.js';
 import { Utils as BuildUtils } from '../../build-utils/build/index.js';
 export declare function getInternalLoaderOptions(loaderContext: Plugin.LoaderContext<ProxyLoaderOptions>): ProxyLoaderInternalOptions;
-export declare function getLoaderOptionsWithoutInternalKeys(loaderContext: Plugin.LoaderContext<ProxyLoaderOptions>): Omit<ProxyLoaderOptions, typeof Loader.LoaderInternalPropertyName>;
+export declare function getLoaderOptionsWithoutInternalKeys(loaderContext: Plugin.LoaderContext<ProxyLoaderOptions>): Record<string, any>;
 export declare function getOriginLoaderModule(loaderContext: Plugin.LoaderContext<ProxyLoaderOptions>): ReturnType<typeof BuildUtils.loadLoaderModule>;
 export declare function shouldSkipLoader(loaderContext: Plugin.LoaderContext<ProxyLoaderOptions>): boolean;
-export type CompatibleResolve = Omit<Plugin.Configuration['resolve'], 'mainFields'> & {
-    mainFields?: string[];
-};
-export declare function interceptLoader<T extends Plugin.BuildRuleSetRule>(rules: T[], loaderPath: string, options: Omit<ProxyLoaderInternalOptions, 'loader' | 'hasOptions'>, cwd?: string, resolveLoader?: CompatibleResolve): T[];
+export type LoaderResolver = ReturnType<Plugin.BaseCompiler['resolverFactory']['get']>;
+export declare function interceptLoader<T extends Plugin.BuildRuleSetRule>(rules: T[], loaderPath: string, options: Omit<ProxyLoaderInternalOptions, 'loader' | 'hasOptions'>, loaderResolver: LoaderResolver, cwd?: string): T[];
 export declare function reportLoader(ctx: Plugin.LoaderContext<ProxyLoaderOptions>, start: number, startHRTime: [number, number], isPitch: boolean, sync: boolean, code: string, err: Error | null | undefined, res: string | Buffer | null, sourceMap?: Plugin.SourceMapInput): Promise<SDK.LoaderData>;

package/dist/inner-plugins/utils/normalize-config.d.ts

@@ -1,4 +1,4 @@
-import { Config, Plugin, SDK } from '@rsdoctor/types';
+import { Config, Plugin, SDK } from '@rsdoctor/shared/types';
 import type { RuleSetCondition as RspackRuleSetCondition, RuleSetRule as RspackRuleSetRule } from '@rspack/core';
 /**
  * Process mode-specific configurations with priority logic

package/dist/inner-plugins/utils/openBrowser.d.ts

@@ -0,0 +1 @@
+export declare function openBrowser(url: string, needEncodeURI?: boolean): Promise<boolean | undefined>;

package/dist/inner-plugins/utils/plugin.d.ts

@@ -1,4 +1,4 @@
-import type { SDK } from '@rsdoctor/types';
+import type { SDK } from '@rsdoctor/shared/types';
 import { IHook } from '../../build-utils/build/utils/index.js';
 export declare function reportPluginData(sdk: SDK.RsdoctorBuilderSDKInstance, hook: string, tapName: string, start: number, type: SDK.PluginHookData['type'], _res: unknown, err?: Error): void;
 export declare function interceptPluginHook(sdk: SDK.RsdoctorBuilderSDKInstance, name: string, hook: IHook): void;

package/dist/inner-plugins/utils/sdk.d.ts

@@ -1,8 +1,7 @@
-import { RsdoctorPrimarySDK } from '@rsdoctor/sdk';
-import { SDK } from '@rsdoctor/types';
+import { SDK } from '@rsdoctor/shared/types';
 declare global {
     var __rsdoctor_sdks__: SDK.RsdoctorBuilderSDKInstance[] | undefined;
     var __rsdoctor_sdk__: SDK.RsdoctorBuilderSDKInstance | undefined;
 }
 export declare function setSDK(t: SDK.RsdoctorBuilderSDKInstance): void;
-export declare function getSDK(builderName?: string): RsdoctorPrimarySDK | SDK.RsdoctorBuilderSDKInstance | undefined;
+export declare function getSDK(builderName?: string): SDK.RsdoctorBuilderSDKInstance | undefined;

package/dist/logger.d.ts

@@ -0,0 +1,9 @@
+import { color } from 'rslog';
+/**
+ * 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, color as chalk, rsdoctorLogger as logger };

package/dist/probe-loader.js

@@ -0,0 +1,2 @@
+import "node:module";
+export { default } from "./630.js";

package/dist/proxy-loader.d.ts

@@ -0,0 +1 @@
+export { default, pitch, raw } from './inner-plugins/loaders/proxy.js';

package/dist/proxy-loader.js

@@ -0,0 +1,48 @@
+import "node:module";
+import { shouldSkipLoader, reportLoader, getOriginLoaderModule } from "./26.js";
+import { createLoaderContextTrap } from "./630.js";
+let loaderModule = function(...args) {
+    if (shouldSkipLoader(this)) return void this.callback(null, ...args);
+    this.cacheable(!1);
+    let mod = getOriginLoaderModule(this);
+    if (mod.default) {
+        !1 === mod.raw && Buffer.isBuffer(args[0]) && (args[0] = args[0].toString());
+        let start = 0, startHRTime = [
+            0,
+            0
+        ], trap = createLoaderContextTrap.call(this, (err, res, sourceMap)=>{
+            reportLoader(this, start, startHRTime, !1, !1, args[0].toString(), err, res, sourceMap);
+        });
+        start = Date.now(), startHRTime = process.hrtime();
+        try {
+            let result = mod.default.apply(trap, args);
+            return !result || result instanceof Promise || reportLoader(this, start, startHRTime, !1, !0, args[0].toString(), null, result), result || '';
+        } catch (error) {
+            throw reportLoader(this, start, startHRTime, !1, !0, args[0].toString(), error, null), error;
+        }
+    }
+    this.callback(null, ...args);
+}, pitch = function() {
+    if (shouldSkipLoader(this)) return;
+    this.cacheable(!1);
+    let mod = getOriginLoaderModule(this);
+    if (mod.pitch && 'function' == typeof mod.pitch) {
+        let start = 0, startHRTime = [
+            0,
+            0
+        ], trap = createLoaderContextTrap.call(this, (err, res)=>{
+            reportLoader(this, start, startHRTime, !0, !1, err ? 'Loader Pitch Async Error' : '', err, res);
+        });
+        start = Date.now(), startHRTime = process.hrtime();
+        try {
+            let res = mod.pitch.apply(trap, arguments);
+            return !res || res instanceof Promise || reportLoader(this, start, startHRTime, !0, !0, '', null, res), res;
+        } catch (error) {
+            throw reportLoader(this, start, startHRTime, !0, !0, 'Loader Pitch Sync Error', error, null), error;
+        }
+    }
+};
+loaderModule.raw = !0, loaderModule.pitch = pitch;
+let raw = !0;
+export default loaderModule;
+export { pitch, raw };

package/dist/rslib-runtime.js

@@ -1,19 +1,28 @@
 import "node:module";
-var __webpack_modules__ = {};
-var __webpack_module_cache__ = {};
+var __webpack_modules__ = {}, __webpack_module_cache__ = {};
 function __webpack_require__(moduleId) {
     var cachedModule = __webpack_module_cache__[moduleId];
     if (void 0 !== cachedModule) return cachedModule.exports;
     var module = __webpack_module_cache__[moduleId] = {
         exports: {}
     };
-    __webpack_modules__[moduleId](module, module.exports, __webpack_require__);
-    return module.exports;
+    return __webpack_modules__[moduleId](module, module.exports, __webpack_require__), module.exports;
 }
-__webpack_require__.m = __webpack_modules__;
-(()=>{
-    __webpack_require__.add = function(modules) {
-        Object.assign(__webpack_require__.m, modules);
+__webpack_require__.m = __webpack_modules__, __webpack_require__.d = (exports, getters, values)=>{
+    var define = (defs, kind)=>{
+        for(var key in defs)__webpack_require__.o(defs, key) && !__webpack_require__.o(exports, key) && Object.defineProperty(exports, key, {
+            enumerable: !0,
+            [kind]: defs[key]
+        });
     };
-})();
+    define(getters, "get"), define(values, "value");
+}, __webpack_require__.add = function(modules) {
+    Object.assign(__webpack_require__.m, modules);
+}, __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop), __webpack_require__.r = (exports)=>{
+    "u" > typeof Symbol && Symbol.toStringTag && Object.defineProperty(exports, Symbol.toStringTag, {
+        value: 'Module'
+    }), Object.defineProperty(exports, '__esModule', {
+        value: !0
+    });
+};
 export { __webpack_require__ };

package/dist/{inner-plugins/constants.d.cts → rspack-plugin/constants.d.ts}

@@ -1,6 +1,9 @@
-import type { Tap } from 'tapable';
+import type { Tap } from '@rspack/lite-tapable';
 export declare const pluginTapName = "RsdoctorRspackPlugin";
 export declare const pluginTapPostOptions: Tap;
 export declare const pluginTapPreOptions: Tap;
 export declare const internalPluginTapPreOptions: (namespace: string) => Tap;
 export declare const internalPluginTapPostOptions: (namespace: string) => Tap;
+export declare const pkg: {
+    version: string;
+};

package/dist/rspack-plugin/index.d.ts

@@ -0,0 +1,2 @@
+export * from './plugin.js';
+export * from './multiple.js';

package/dist/rspack-plugin/multiple.d.ts

@@ -0,0 +1,8 @@
+import type { RsdoctorMultiplePluginOptions } from '../types/index.js';
+import { type Linter, type Plugin } from '@rsdoctor/shared/types';
+import { RsdoctorRspackPlugin } from './plugin.js';
+export declare class RsdoctorRspackMultiplePlugin<Rules extends Linter.ExtendRuleData[]> extends RsdoctorRspackPlugin<Rules> {
+    private controller;
+    constructor(options?: RsdoctorMultiplePluginOptions<Rules>);
+    apply(compiler: Plugin.BaseCompilerType<'rspack'>): void;
+}

package/dist/rspack-plugin/plugin.d.ts

@@ -0,0 +1,25 @@
+import type { RsdoctorRspackPluginInstance, RsdoctorRspackPluginOptions, RsdoctorRspackPluginOptionsNormalized } from '../types/index.js';
+import { RsdoctorPrimarySDK } from '../sdk/index.js';
+import { Linter, Plugin, SDK } from '@rsdoctor/shared/types';
+export declare class RsdoctorRspackPlugin<Rules extends Linter.ExtendRuleData[]> implements RsdoctorRspackPluginInstance<Rules> {
+    readonly name = "RsdoctorRspackPlugin";
+    readonly sdk: SDK.RsdoctorBuilderSDKInstance | RsdoctorPrimarySDK;
+    readonly isRsdoctorPlugin: boolean;
+    _bootstrapTask: Promise<unknown>;
+    protected browserIsOpened: boolean;
+    modulesGraph: SDK.ModuleGraphInstance;
+    options: RsdoctorRspackPluginOptionsNormalized<Rules>;
+    outsideInstance: boolean;
+    constructor(options?: RsdoctorRspackPluginOptions<Rules>);
+    apply(compiler: unknown): unknown;
+    /**
+     * @description Generate ModuleGraph and ChunkGraph from the Rspack native plugin.
+     * @param {Compiler} compiler
+     * @return {*}
+     * @memberof RsdoctorRspackPlugin
+     */
+    ensureModulesChunksGraphApplied(compiler: Plugin.BaseCompilerType<'rspack'>): void;
+    afterPlugins: (compiler: Plugin.BaseCompilerType<'rspack'>) => void;
+    done: (compiler: Plugin.BaseCompilerType<'rspack'>) => Promise<void>;
+    getRspackConfig(compiler: Plugin.BaseCompilerType<'rspack'>): void;
+}

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

@@ -0,0 +1,16 @@
+import { Range, OffsetRange, Position, DocumentEditData } from './types.js';
+/** 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.ts

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

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

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

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

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

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

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

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

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

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

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