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

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/inner-plugins/utils/sdk.js

@@ -10,8 +10,8 @@ function getSDK(builderName) {
     let sdk = globalThis['__rsdoctor_sdk__'];
     if (sdk && sdk.name !== builderName) sdk = builderName ? sdks.find((s)=>s.name === builderName) || sdk : sdk;
     if (sdk && builderName && 'parent' in sdk) {
-        const _sdk = sdk;
-        const slaveSDK = _sdk.parent.slaves.find((_sdk)=>_sdk.name === builderName);
+        const parent = sdk.parent;
+        const slaveSDK = parent?.slaves.find((_sdk)=>_sdk.name === builderName);
         return slaveSDK || sdk;
     }
     return sdk;

package/dist/logger.d.ts

@@ -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/logger.js

@@ -0,0 +1,51 @@
+import "node:module";
+import picocolors from "picocolors";
+import { createLogger, logger } from "rslog";
+import { Constants } from "@rsdoctor/shared/types";
+function debug(getMsg, prefix = '') {
+    if (!process.env.DEBUG) return;
+    logger.level = 'verbose';
+    logger.debug(`${prefix} ${getMsg()}`);
+}
+const rsdoctorLogger = createLogger();
+rsdoctorLogger.override({
+    log: (message)=>{
+        console.log(`${picocolors.green('[RSDOCTOR LOG]')} ${message}`);
+    },
+    info: (message)=>{
+        console.log(`${picocolors.yellow('[RSDOCTOR INFO]')} ${message}`);
+    },
+    warn: (message)=>{
+        console.warn(`${picocolors.yellow('[RSDOCTOR WARN]')} ${message}`);
+    },
+    start: (message)=>{
+        console.log(`${picocolors.green('[RSDOCTOR START]')} ${message}`);
+    },
+    ready: (message)=>{
+        console.log(`${picocolors.green('[RSDOCTOR READY]')} ${message}`);
+    },
+    error: (message)=>{
+        console.error(`${picocolors.red('[RSDOCTOR ERROR]')} ${message}`);
+    },
+    success: (message)=>{
+        console.error(`${picocolors.green('[RSDOCTOR SUCCESS]')} ${message}`);
+    },
+    debug: (message)=>{
+        if (process.env.DEBUG) console.log(`${picocolors.blue('[RSDOCTOR DEBUG]')} ${message}`);
+    }
+});
+const _timers = new Map();
+function time(label) {
+    if (process.env.DEBUG !== Constants.RsdoctorProcessEnvDebugKey) return;
+    if (_timers.has(label)) return;
+    _timers.set(label, Date.now());
+}
+function timeEnd(label) {
+    if (process.env.DEBUG !== Constants.RsdoctorProcessEnvDebugKey) return;
+    const start = _timers.get(label);
+    if (null == start) return void logger.debug(`Timer '${label}' does not exist.`);
+    const duration = Date.now() - start;
+    logger.debug(`Timer '${label}' ended: ${duration}ms`);
+    _timers.delete(label);
+}
+export { debug, picocolors as chalk, rsdoctorLogger as logger, time, timeEnd };

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

@@ -4,3 +4,6 @@ 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/constants.js

@@ -0,0 +1,23 @@
+import "node:module";
+import { createRequire } from "node:module";
+const constants_require = createRequire(import.meta.url);
+const packageJson = constants_require('../../package.json');
+const pluginTapName = 'RsdoctorRspackPlugin';
+const pluginTapPostOptions = {
+    name: pluginTapName,
+    stage: 999
+};
+const pluginTapPreOptions = {
+    name: pluginTapName,
+    stage: -999
+};
+const internalPluginTapPreOptions = (namespace)=>({
+        name: `${pluginTapName}:${namespace}`,
+        stage: -998
+    });
+const internalPluginTapPostOptions = (namespace)=>({
+        name: `${pluginTapName}:${namespace}`,
+        stage: 1000
+    });
+const pkg = packageJson;
+export { internalPluginTapPostOptions, internalPluginTapPreOptions, pkg, pluginTapName, pluginTapPostOptions, pluginTapPreOptions };

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

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

package/dist/rspack-plugin/index.js

@@ -0,0 +1,3 @@
+import "node:module";
+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/multiple.js

@@ -0,0 +1,39 @@
+import "node:module";
+import { RsdoctorSDKController } from "../sdk.js";
+import { SDK } from "@rsdoctor/shared/types";
+import { normalizeUserConfig } from "../inner-plugins/index.js";
+import { RsdoctorRspackPlugin } from "./plugin.js";
+let globalController;
+class RsdoctorRspackMultiplePlugin extends RsdoctorRspackPlugin {
+    apply(compiler) {
+        if ('dependencies' in compiler.options) this.sdk.dependencies = compiler.options.dependencies;
+        super.apply(compiler);
+    }
+    constructor(options = {}){
+        const controller = (()=>{
+            if (globalController) return globalController;
+            const controller = new RsdoctorSDKController();
+            globalController = controller;
+            return controller;
+        })();
+        const normallizedOptions = normalizeUserConfig(options);
+        const instance = controller.createSlave({
+            name: options.name || 'Builder',
+            stage: options.stage,
+            extraConfig: {
+                innerClientPath: normallizedOptions.innerClientPath,
+                printLog: normallizedOptions.printLog,
+                server: normallizedOptions.server,
+                mode: normallizedOptions.output.mode ? normallizedOptions.output.mode : void 0,
+                brief: normallizedOptions.output.mode === SDK.IMode[SDK.IMode.brief] ? normallizedOptions.output.options || void 0 : void 0
+            },
+            type: normallizedOptions.output.reportCodeType
+        });
+        super({
+            ...options,
+            sdkInstance: instance
+        });
+        this.controller = controller;
+    }
+}
+export { RsdoctorRspackMultiplePlugin };

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/rspack-plugin/plugin.js

@@ -0,0 +1,133 @@
+import "node:module";
+import { Loader } from "../build-utils/index.js";
+import { InternalBundlePlugin, InternalErrorReporterPlugin, InternalLoaderPlugin, InternalPluginsPlugin, InternalResolverPlugin, InternalRulesPlugin, InternalSummaryPlugin, ensureModulesChunksGraphFn, handleBriefModeReport, normalizeRspackUserOptions, processCompilerConfig, setSDK } from "../inner-plugins/index.js";
+import { RsdoctorSDK, findRoot } from "../sdk.js";
+import { Constants, Manifest, SDK } from "@rsdoctor/shared/types";
+import path from "path";
+import { pkg, pluginTapName, pluginTapPostOptions } from "./constants.js";
+import { ModuleGraph } from "../graph/index.js";
+import { Loader as index_js_Loader } from "../common/index.js";
+import { logger, time, timeEnd } from "../logger.js";
+import { getRspackNativePlugin } from "../inner-plugins/plugins/rspack.js";
+let hasGreeted = false;
+class RsdoctorRspackPlugin {
+    apply(compiler) {
+        time('RsdoctorRspackPlugin.apply');
+        try {
+            if (!hasGreeted && !compiler.isChild()) {
+                hasGreeted = true;
+                logger.greet(`
+        \nRsdoctor v${pkg.version}\n`);
+            }
+            if (!this._bootstrapTask) this._bootstrapTask = this.sdk.bootstrap();
+            if (compiler.options.name) this.sdk.setName(compiler.options.name);
+            setSDK(this.sdk);
+            compiler.hooks.afterPlugins.tap(pluginTapPostOptions, this.afterPlugins.bind(this, compiler));
+            compiler.hooks.done.tapPromise({
+                ...pluginTapPostOptions,
+                stage: pluginTapPostOptions.stage + 100
+            }, this.done.bind(this, compiler));
+            new InternalSummaryPlugin(this).apply(compiler);
+            if (this.options.features.loader) {
+                new Loader.ProbeLoaderPlugin().apply(compiler);
+                this.sdk.addClientRoutes([
+                    Manifest.RsdoctorManifestClientRoutes.Loaders
+                ]);
+                if (!index_js_Loader.isVue(compiler)) new InternalLoaderPlugin(this).apply(compiler);
+            }
+            if (this.options.features.plugins) new InternalPluginsPlugin(this).apply(compiler);
+            if (this.options.features.bundle) new InternalBundlePlugin(this).apply(compiler);
+            if (this.options.features.resolver) new InternalResolverPlugin(this).apply(compiler);
+            new InternalRulesPlugin(this).apply(compiler);
+            new InternalErrorReporterPlugin(this).apply(compiler);
+            const RsdoctorRspackNativePlugin = getRspackNativePlugin(compiler);
+            logger.debug('[RspackNativePlugin] Enabled');
+            new RsdoctorRspackNativePlugin({
+                moduleGraphFeatures: true,
+                chunkGraphFeatures: true,
+                sourceMapFeatures: {
+                    cheap: false,
+                    module: false
+                }
+            }).apply(compiler);
+        } finally{
+            timeEnd('RsdoctorRspackPlugin.apply');
+        }
+    }
+    ensureModulesChunksGraphApplied(compiler) {
+        ensureModulesChunksGraphFn(compiler, this);
+    }
+    getRspackConfig(compiler) {
+        time('RsdoctorRspackPlugin.getRspackConfig');
+        try {
+            if (compiler.isChild()) return;
+            const configuration = processCompilerConfig(compiler.options);
+            const rspackVersion = compiler.webpack?.rspackVersion || compiler.webpack?.version;
+            this.sdk.reportConfiguration({
+                name: 'rspack',
+                version: rspackVersion || 'unknown',
+                config: configuration,
+                root: findRoot() || ''
+            });
+        } finally{
+            timeEnd('RsdoctorRspackPlugin.getRspackConfig');
+        }
+    }
+    constructor(options){
+        this.name = pluginTapName;
+        this.browserIsOpened = false;
+        this.afterPlugins = (compiler)=>{
+            time('RsdoctorRspackPlugin.afterPlugins');
+            try {
+                this.getRspackConfig(compiler);
+            } finally{
+                timeEnd('RsdoctorRspackPlugin.afterPlugins');
+            }
+        };
+        this.done = async (compiler)=>{
+            time('RsdoctorRspackPlugin.done');
+            try {
+                logger.debug('[RsdoctorRspackPlugin] bootstrap(start) in done()');
+                await this.sdk.bootstrap();
+                logger.debug('[RsdoctorRspackPlugin] bootstrap(end) in done()');
+                this.sdk.addClientRoutes([
+                    Manifest.RsdoctorManifestClientRoutes.Overall
+                ]);
+                if (this.outsideInstance && 'parent' in this.sdk) this.sdk.parent.master.setOutputDir(path.resolve(this.options.output.reportDir || compiler.outputPath, this.options.output.mode === SDK.IMode[SDK.IMode.brief] ? '' : `./${Constants.RsdoctorOutputFolder}`));
+                this.sdk.setOutputDir(path.resolve(this.options.output.reportDir || compiler.outputPath, this.options.output.mode === SDK.IMode[SDK.IMode.brief] ? '' : `./${Constants.RsdoctorOutputFolder}`));
+                await this.sdk.writeStore();
+                if (!this.options.disableClientServer) if (this.options.output.mode === SDK.IMode[SDK.IMode.brief]) await handleBriefModeReport(this.sdk, this.options, this.options.disableClientServer);
+                else await this.sdk.server.openClientPage('homepage');
+                if (this.options.disableClientServer || this.options.output.mode === SDK.IMode[SDK.IMode.brief] && Array.isArray(this.options.output.options?.type) && 1 === this.options.output.options.type.length && 'json' === this.options.output.options.type[0]) await this.sdk.dispose();
+            } finally{
+                timeEnd('RsdoctorRspackPlugin.done');
+            }
+        };
+        this.options = normalizeRspackUserOptions(Object.assign(options || {}, {
+            supports: {
+                ...options?.supports
+            }
+        }));
+        const { port, server, output, innerClientPath, printLog, sdkInstance } = this.options;
+        this.sdk = this.options.sdkInstance ?? new RsdoctorSDK({
+            port,
+            name: pluginTapName,
+            root: process.cwd(),
+            type: output.reportCodeType,
+            config: {
+                innerClientPath,
+                printLog,
+                server,
+                mode: output.mode ? output.mode : void 0,
+                brief: output.mode === SDK.IMode[SDK.IMode.brief] ? output.options || void 0 : void 0,
+                features: {
+                    treeShaking: this.options.features.treeShaking
+                }
+            }
+        });
+        this.outsideInstance = Boolean(sdkInstance);
+        this.modulesGraph = new ModuleGraph();
+        this.isRsdoctorPlugin = true;
+    }
+}
+export { RsdoctorRspackPlugin };

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/document.js

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

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

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

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

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

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

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

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

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

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

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

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

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

package/dist/rule-utils/index.js

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

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

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