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

package/dist/inner-plugins/utils/plugin.js

@@ -1,70 +0,0 @@
-import "node:module";
-import { DevToolError } from "../../error/index.js";
-function reportPluginData(sdk, hook, tapName, start, type, _res, err) {
-    const end = Date.now();
-    sdk.reportPlugin({
-        [hook]: [
-            {
-                tapName,
-                costs: end - start,
-                startAt: start,
-                endAt: end,
-                type,
-                result: null,
-                error: err ? [
-                    new DevToolError(`${tapName} ${hook} Error`, err.message, {
-                        controller: {
-                            noStack: false,
-                            noColor: true
-                        },
-                        stack: err.stack
-                    })
-                ] : []
-            }
-        ]
-    });
-}
-function interceptPluginHook(sdk, name, hook) {
-    if (!hook?.intercept) return;
-    hook.intercept({
-        register (tap) {
-            const o = tap.fn;
-            if ('sync' === tap.type) tap.fn = function(...args) {
-                const start = Date.now();
-                try {
-                    const res = o.apply(this, args);
-                    reportPluginData(sdk, name, tap.name, start, tap.type, res);
-                    return res;
-                } catch (error) {
-                    reportPluginData(sdk, name, tap.name, start, tap.type, null, error);
-                    throw error;
-                }
-            };
-            else if ('async' === tap.type) tap.fn = async function(...args) {
-                const start = Date.now();
-                try {
-                    const res = await o.apply(this, args);
-                    reportPluginData(sdk, name, tap.name, start, tap.type, res);
-                    return res;
-                } catch (error) {
-                    reportPluginData(sdk, name, tap.name, start, tap.type, null, error);
-                    throw error;
-                }
-            };
-            else if ('promise' === tap.type) tap.fn = function(...args) {
-                const start = Date.now();
-                const isChild = args?.[0]?.compiler?.isChild();
-                return o.apply(this, args).then((res)=>{
-                    if (isChild) return res;
-                    reportPluginData(sdk, name, tap.name, start, tap.type, res);
-                    return res;
-                }).catch((error)=>{
-                    reportPluginData(sdk, name, tap.name, start, tap.type, null, error);
-                    throw error;
-                });
-            };
-            return tap;
-        }
-    });
-}
-export { interceptPluginHook, reportPluginData };

package/dist/inner-plugins/utils/sdk.js

@@ -1,19 +0,0 @@
-import "node:module";
-const globalKey = '__rsdoctor_sdks__';
-function setSDK(t) {
-    if (!globalThis.__rsdoctor_sdks__) globalThis.__rsdoctor_sdks__ = [];
-    globalThis.__rsdoctor_sdks__.push(t);
-    globalThis.__rsdoctor_sdk__ = t;
-}
-function getSDK(builderName) {
-    const sdks = globalThis[globalKey] || [];
-    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 parent = sdk.parent;
-        const slaveSDK = parent?.slaves.find((_sdk)=>_sdk.name === builderName);
-        return slaveSDK || sdk;
-    }
-    return sdk;
-}
-export { getSDK, setSDK };

package/dist/logger.js

@@ -1,51 +0,0 @@
-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/rspack-plugin/constants.js

@@ -1,23 +0,0 @@
-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.js

@@ -1,3 +0,0 @@
-import "node:module";
-export * from "./plugin.js";
-export * from "./multiple.js";

package/dist/rspack-plugin/multiple.js

@@ -1,39 +0,0 @@
-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.js

@@ -1,133 +0,0 @@
-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.js

@@ -1,46 +0,0 @@
-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.js

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

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

@@ -1,13 +0,0 @@
-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.js

@@ -1 +0,0 @@
-import "node:module";

package/dist/rule-utils/index.js

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

package/dist/rule-utils/parser/asserts.js

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

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

@@ -1,5 +0,0 @@
-import "node:module";
-export * from "./asserts.js";
-export * from "./parser.js";
-export * from "./utils.js";
-export * from "./types.js";

package/dist/rule-utils/parser/parser.js

@@ -1,24 +0,0 @@
-import "node:module";
-import { Parser } from "acorn";
-import { importAttributes } from "acorn-import-attributes";
-import * as __rspack_external_acorn_walk_1e4235a7 from "acorn-walk";
-import { asserts } from "./asserts.js";
-import * as __rspack_external__utils_js_a9c81ddd from "./utils.js";
-const acornParserInternal = Parser.extend(importAttributes);
-let acornParserExport = Parser.extend(importAttributes);
-const parser = {
-    walk: __rspack_external_acorn_walk_1e4235a7,
-    parse: (input, options)=>acornParserExport.parse(input, options),
-    parseExpressionAt: (input, pos, options)=>acornParserExport.parseExpressionAt(input, pos, options),
-    extend (...args) {
-        acornParserExport = acornParserExport.extend(...args);
-        return acornParserExport;
-    },
-    asserts: asserts,
-    utils: __rspack_external__utils_js_a9c81ddd,
-    internal: {
-        parse: (input, options)=>acornParserInternal.parse(input, options),
-        parseExpressionAt: (input, pos, options)=>acornParserInternal.parseExpressionAt(input, pos, options)
-    }
-};
-export { parser };

package/dist/rule-utils/parser/types.js

@@ -1,8 +0,0 @@
-import "node:module";
-var types_ECMAVersion = /*#__PURE__*/ function(ECMAVersion) {
-    ECMAVersion["ES5"] = "ES5";
-    ECMAVersion["ES6"] = "ES6";
-    ECMAVersion["ES7P"] = "ES7+";
-    return ECMAVersion;
-}({});
-export { types_ECMAVersion as ECMAVersion };