@rspack-canary/test-tools 1.5.6-canary-7c0091e4-20250920173916 → 1.5.7-canary-a3406c0a-20250922173625

package/dist/processor/hot.js

@@ -1,147 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.HotProcessor = void 0;
-const node_path_1 = __importDefault(require("node:path"));
-const core_1 = require("@rspack/core");
-const helper_1 = require("../helper");
-const plugins_1 = require("../helper/plugins");
-const plugin_1 = require("../plugin");
-const type_1 = require("../type");
-const basic_1 = require("./basic");
-class HotProcessor extends basic_1.BasicProcessor {
-    constructor(_hotOptions) {
-        const fakeUpdateLoaderOptions = {
-            updateIndex: 0,
-            totalUpdates: 1,
-            changedFiles: []
-        };
-        super({
-            defaultOptions: HotProcessor.defaultOptions,
-            overrideOptions: HotProcessor.overrideOptions,
-            findBundle: HotProcessor.findBundle,
-            runable: true,
-            ..._hotOptions
-        });
-        this._hotOptions = _hotOptions;
-        this.runner = null;
-        this.updateOptions = fakeUpdateLoaderOptions;
-    }
-    async run(env, context) {
-        context.setValue(this._options.name, "hotUpdateContext", this.updateOptions);
-        await super.run(env, context);
-    }
-    static findBundle(context) {
-        const compiler = context.getCompiler(this._hotOptions.name);
-        if (!compiler)
-            throw new Error("Compiler should exists when find bundle");
-        const testConfig = context.getTestConfig();
-        if (typeof testConfig.findBundle === "function") {
-            return testConfig.findBundle(this.updateOptions.updateIndex, compiler.getOptions());
-        }
-        const files = [];
-        const prefiles = [];
-        const stats = compiler.getStats();
-        if (!stats)
-            throw new Error("Stats should exists when find bundle");
-        const info = stats.toJson({ all: false, entrypoints: true });
-        if (this._hotOptions.target === "web" ||
-            this._hotOptions.target === "webworker") {
-            for (const file of info.entrypoints.main.assets) {
-                if ((0, helper_1.isJavaScript)(file.name)) {
-                    files.push(file.name);
-                }
-                else {
-                    prefiles.push(file.name);
-                }
-            }
-        }
-        else {
-            const assets = info.entrypoints.main.assets.filter(s => (0, helper_1.isJavaScript)(s.name));
-            files.push(assets[assets.length - 1].name);
-        }
-        return [...prefiles, ...files];
-    }
-    async afterAll(context) {
-        await super.afterAll(context);
-        if (context.getTestConfig().checkSteps === false) {
-            return;
-        }
-        if (this.updateOptions.updateIndex + 1 !==
-            this.updateOptions.totalUpdates) {
-            throw new Error(`Should run all hot steps (${this.updateOptions.updateIndex + 1} / ${this.updateOptions.totalUpdates}): ${this._options.name}`);
-        }
-    }
-    static defaultOptions(context) {
-        const options = {
-            context: context.getSource(),
-            mode: "development",
-            devtool: false,
-            output: {
-                path: context.getDist(),
-                filename: "bundle.js",
-                chunkFilename: "[name].chunk.[fullhash].js",
-                publicPath: "https://test.cases/path/",
-                library: { type: "commonjs2" }
-            },
-            optimization: {
-                moduleIds: "named"
-            },
-            target: this._hotOptions.target,
-            experiments: {
-                css: true,
-                // test incremental: "safe" here, we test default incremental in Incremental-*.test.js
-                incremental: "safe",
-                rspackFuture: {
-                    bundlerInfo: {
-                        force: false
-                    }
-                },
-                inlineConst: true,
-                lazyBarrel: true
-            }
-        };
-        if (this._hotOptions.compilerType === type_1.ECompilerType.Rspack) {
-            options.plugins ??= [];
-            options.plugins.push(new core_1.rspack.HotModuleReplacementPlugin(), new plugins_1.TestHotUpdatePlugin(this.updateOptions));
-        }
-        return options;
-    }
-    static overrideOptions(context, options) {
-        if (!options.entry) {
-            options.entry = "./index.js";
-        }
-        options.module ??= {};
-        for (const cssModuleType of ["css/auto", "css/module", "css"]) {
-            options.module.generator ??= {};
-            options.module.generator[cssModuleType] ??= {};
-            options.module.generator[cssModuleType].exportsOnly ??=
-                this._hotOptions.target === "async-node";
-        }
-        options.module.rules ??= [];
-        options.module.rules.push({
-            use: [
-                {
-                    loader: node_path_1.default.resolve(__dirname, "../helper/loaders/hot-update.js"),
-                    options: this.updateOptions
-                }
-            ],
-            enforce: "pre"
-        });
-        if (this._hotOptions.compilerType === type_1.ECompilerType.Rspack) {
-            options.plugins ??= [];
-            options.plugins.push(new core_1.rspack.LoaderOptionsPlugin(this.updateOptions));
-        }
-        if (!global.printLogger) {
-            options.infrastructureLogging = {
-                level: "error"
-            };
-        }
-        if (options.lazyCompilation) {
-            options.plugins.push(new plugin_1.LazyCompilationTestPlugin());
-        }
-    }
-}
-exports.HotProcessor = HotProcessor;

package/dist/processor/normal.d.ts

@@ -1,12 +0,0 @@
-import type { ECompilerType, ITestContext, TCompilerOptions } from "../type";
-import { BasicProcessor, type IBasicProcessorOptions } from "./basic";
-export interface INormalProcessorOptions<T extends ECompilerType> extends IBasicProcessorOptions<T> {
-    compilerOptions?: TCompilerOptions<T>;
-    root: string;
-}
-export declare class NormalProcessor<T extends ECompilerType> extends BasicProcessor<T> {
-    protected _normalOptions: INormalProcessorOptions<T>;
-    constructor(_normalOptions: INormalProcessorOptions<T>);
-    static defaultOptions<T extends ECompilerType>(this: NormalProcessor<T>, context: ITestContext): TCompilerOptions<T>;
-    static overrideOptions<T extends ECompilerType>(options: TCompilerOptions<T>): void;
-}

package/dist/processor/normal.js

@@ -1,170 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.NormalProcessor = void 0;
-const node_fs_1 = __importDefault(require("node:fs"));
-const node_path_1 = __importDefault(require("node:path"));
-const basic_1 = require("./basic");
-class NormalProcessor extends basic_1.BasicProcessor {
-    constructor(_normalOptions) {
-        super({
-            findBundle: (context, options) => {
-                const testConfig = context.getTestConfig();
-                if (typeof testConfig.findBundle === "function") {
-                    return testConfig.findBundle(0, options);
-                }
-                const filename = options.output?.filename;
-                return typeof filename === "string" ? filename : undefined;
-            },
-            defaultOptions: NormalProcessor.defaultOptions,
-            ..._normalOptions
-        });
-        this._normalOptions = _normalOptions;
-    }
-    static defaultOptions(context) {
-        let testConfig = {};
-        const testConfigPath = node_path_1.default.join(context.getSource(), "test.config.js");
-        if (node_fs_1.default.existsSync(testConfigPath)) {
-            testConfig = require(testConfigPath);
-        }
-        const TerserPlugin = require("terser-webpack-plugin");
-        const terserForTesting = new TerserPlugin({
-            parallel: false
-        });
-        const { root, compilerOptions } = this._normalOptions;
-        return {
-            amd: {},
-            context: root,
-            entry: `./${node_path_1.default.relative(root, context.getSource())}/`,
-            target: compilerOptions?.target || "async-node",
-            devtool: compilerOptions?.devtool,
-            mode: compilerOptions?.mode || "none",
-            optimization: compilerOptions?.mode
-                ? {
-                    // emitOnErrors: true,
-                    minimizer: [terserForTesting],
-                    ...testConfig.optimization
-                }
-                : {
-                    removeAvailableModules: true,
-                    removeEmptyChunks: true,
-                    mergeDuplicateChunks: true,
-                    // CHANGE: rspack does not support `flagIncludedChunks` yet.
-                    // flagIncludedChunks: true,
-                    sideEffects: true,
-                    providedExports: true,
-                    usedExports: true,
-                    mangleExports: true,
-                    // CHANGE: rspack does not support `emitOnErrors` yet.
-                    // emitOnErrors: true,
-                    concatenateModules: !!testConfig?.optimization?.concatenateModules,
-                    innerGraph: true,
-                    // CHANGE: size is not supported yet
-                    // moduleIds: "size",
-                    // chunkIds: "size",
-                    moduleIds: "named",
-                    chunkIds: "named",
-                    minimizer: [terserForTesting],
-                    ...compilerOptions?.optimization
-                },
-            // CHANGE: rspack does not support `performance` yet.
-            // performance: {
-            // 	hints: false
-            // },
-            node: {
-                __dirname: "mock",
-                __filename: "mock"
-            },
-            cache: compilerOptions?.cache && {
-                // cacheDirectory,
-                ...compilerOptions.cache
-            },
-            output: {
-                pathinfo: "verbose",
-                path: context.getDist(),
-                filename: compilerOptions?.module ? "bundle.mjs" : "bundle.js"
-            },
-            resolve: {
-                modules: ["web_modules", "node_modules"],
-                mainFields: ["webpack", "browser", "web", "browserify", "main"],
-                aliasFields: ["browser"],
-                extensions: [".webpack.js", ".web.js", ".js", ".json"]
-            },
-            resolveLoader: {
-                modules: ["web_loaders", "web_modules", "node_loaders", "node_modules"],
-                mainFields: ["webpackLoader", "webLoader", "loader", "main"],
-                extensions: [
-                    ".webpack-loader.js",
-                    ".web-loader.js",
-                    ".loader.js",
-                    ".js"
-                ]
-            },
-            module: {
-                rules: [
-                    {
-                        test: /\.coffee$/,
-                        loader: "coffee-loader"
-                    },
-                    {
-                        test: /\.pug/,
-                        loader: "@webdiscus/pug-loader"
-                    },
-                    {
-                        test: /\.wat$/i,
-                        loader: "wast-loader",
-                        type: "webassembly/async"
-                    }
-                ]
-            },
-            plugins: (compilerOptions?.plugins || [])
-                .concat(testConfig.plugins || [])
-                .concat(function () {
-                this.hooks.compilation.tap("TestCasesTest", compilation => {
-                    const hooks = [
-                    // CHANGE: the following hooks are not supported yet, so comment it out
-                    // "optimize",
-                    // "optimizeModules",
-                    // "optimizeChunks",
-                    // "afterOptimizeTree",
-                    // "afterOptimizeAssets"
-                    ];
-                    for (const hook of hooks) {
-                        compilation.hooks[hook].tap("TestCasesTest", () => compilation.checkConstraints());
-                    }
-                });
-            }),
-            experiments: {
-                css: false,
-                rspackFuture: {
-                    bundlerInfo: {
-                        force: false
-                    }
-                },
-                asyncWebAssembly: true,
-                topLevelAwait: true,
-                inlineConst: true,
-                lazyBarrel: true,
-                // CHANGE: rspack does not support `backCompat` yet.
-                // backCompat: false,
-                // CHANGE: Rspack enables `css` by default.
-                // Turning off here to fallback to webpack's default css processing logic.
-                ...(compilerOptions?.module ? { outputModule: true } : {})
-            }
-            // infrastructureLogging: compilerOptions?.cache && {
-            //   debug: true,
-            //   console: createLogger(infraStructureLog)
-            // }
-        };
-    }
-    static overrideOptions(options) {
-        if (!global.printLogger) {
-            options.infrastructureLogging = {
-                level: "error"
-            };
-        }
-    }
-}
-exports.NormalProcessor = NormalProcessor;

package/dist/processor/stats-api.d.ts

@@ -1,18 +0,0 @@
-import type { ECompilerType, ITestContext, ITestEnv, TCompiler, TCompilerOptions, TCompilerStats } from "../type";
-import { SimpleTaskProcessor } from "./simple";
-export interface IStatsAPIProcessorOptions<T extends ECompilerType> {
-    options?: (context: ITestContext) => TCompilerOptions<T>;
-    name: string;
-    compilerType: T;
-    snapshotName?: string;
-    compiler?: (context: ITestContext, compiler: TCompiler<T>) => Promise<void>;
-    build?: (context: ITestContext, compiler: TCompiler<T>) => Promise<void>;
-    check?: (stats: TCompilerStats<T>, compiler: TCompiler<T>) => Promise<void>;
-}
-export declare class StatsAPIProcessor<T extends ECompilerType> extends SimpleTaskProcessor<T> {
-    protected _statsAPIOptions: IStatsAPIProcessorOptions<T>;
-    constructor(_statsAPIOptions: IStatsAPIProcessorOptions<T>);
-    compiler(context: ITestContext): Promise<void>;
-    run(env: ITestEnv, context: ITestContext): Promise<void>;
-    check(env: ITestEnv, context: ITestContext): Promise<void>;
-}

package/dist/processor/stats-api.js

@@ -1,48 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.StatsAPIProcessor = void 0;
-const memfs_1 = require("memfs");
-const simple_1 = require("./simple");
-class StatsAPIProcessor extends simple_1.SimpleTaskProcessor {
-    constructor(_statsAPIOptions) {
-        super({
-            options: context => {
-                const res = (_statsAPIOptions.options?.(context) ||
-                    {});
-                res.experiments ??= {};
-                res.experiments.css ??= true;
-                res.experiments.rspackFuture ??= {};
-                res.experiments.rspackFuture.bundlerInfo ??= {};
-                res.experiments.rspackFuture.bundlerInfo.force ??= false;
-                if (!global.printLogger) {
-                    res.infrastructureLogging = {
-                        level: "error"
-                    };
-                }
-                return res;
-            },
-            build: _statsAPIOptions.build,
-            compilerType: _statsAPIOptions.compilerType,
-            name: _statsAPIOptions.name,
-            compiler: _statsAPIOptions.compiler
-        });
-        this._statsAPIOptions = _statsAPIOptions;
-    }
-    async compiler(context) {
-        await super.compiler(context);
-        const compiler = this.getCompiler(context).getCompiler();
-        if (compiler) {
-            compiler.outputFileSystem = (0, memfs_1.createFsFromVolume)(new memfs_1.Volume());
-        }
-    }
-    async run(env, context) {
-        // do nothing
-    }
-    async check(env, context) {
-        const compiler = this.getCompiler(context);
-        const stats = compiler.getStats();
-        env.expect(typeof stats).toBe("object");
-        await this._statsAPIOptions.check?.(stats, compiler.getCompiler());
-    }
-}
-exports.StatsAPIProcessor = StatsAPIProcessor;

package/dist/processor/stats.d.ts

@@ -1,18 +0,0 @@
-import type { ECompilerType, ITestContext, ITestEnv, TCompilerOptions } from "../type";
-import { type IMultiTaskProcessorOptions, MultiTaskProcessor } from "./multi";
-export interface IStatsProcessorOptions<T extends ECompilerType> extends Omit<IMultiTaskProcessorOptions<T>, "runable"> {
-    snapshotName: string;
-    writeStatsOuptut?: boolean;
-}
-export declare class StatsProcessor<T extends ECompilerType> extends MultiTaskProcessor<T> {
-    private stderr;
-    private snapshotName;
-    private writeStatsOuptut?;
-    constructor(_statsOptions: IStatsProcessorOptions<T>);
-    before(context: ITestContext): Promise<void>;
-    after(context: ITestContext): Promise<void>;
-    compiler(context: ITestContext): Promise<void>;
-    check(env: ITestEnv, context: ITestContext): Promise<void>;
-    static defaultOptions<T extends ECompilerType>(index: number, context: ITestContext): TCompilerOptions<T>;
-    static overrideOptions<T extends ECompilerType>(index: number, context: ITestContext, options: TCompilerOptions<T>): void;
-}

package/dist/processor/stats.js

@@ -1,206 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.StatsProcessor = void 0;
-const node_fs_1 = __importDefault(require("node:fs"));
-const node_path_1 = __importDefault(require("node:path"));
-const placeholder_1 = require("../helper/expect/placeholder");
-const captureStdio_1 = __importDefault(require("../helper/legacy/captureStdio"));
-const multi_1 = require("./multi");
-const REG_ERROR_CASE = /error$/;
-class RspackStats {
-    constructor(value) {
-        this.value = value;
-    }
-}
-class StatsProcessor extends multi_1.MultiTaskProcessor {
-    constructor(_statsOptions) {
-        super({
-            defaultOptions: (StatsProcessor.defaultOptions),
-            overrideOptions: (StatsProcessor.overrideOptions),
-            runable: false,
-            ..._statsOptions
-        });
-        this.snapshotName = _statsOptions.snapshotName;
-        this.writeStatsOuptut = _statsOptions.writeStatsOuptut;
-    }
-    async before(context) {
-        this.stderr = (0, captureStdio_1.default)(process.stderr, true);
-    }
-    async after(context) {
-        this.stderr.restore();
-    }
-    async compiler(context) {
-        await super.compiler(context);
-        const instance = this.getCompiler(context).getCompiler();
-        const compilers = instance.compilers
-            ? instance.compilers
-            : [instance];
-        for (const compiler of compilers) {
-            if (!compiler.inputFileSystem) {
-                continue;
-            }
-            const ifs = compiler.inputFileSystem;
-            const inputFileSystem = Object.create(ifs);
-            compiler.inputFileSystem = inputFileSystem;
-            inputFileSystem.readFile = (...args) => {
-                const callback = args.pop();
-                ifs.readFile.apply(ifs, args.concat([
-                    (err, result) => {
-                        if (err)
-                            return callback(err);
-                        if (!/\.(js|json|txt)$/.test(args[0]))
-                            return callback(null, result);
-                        callback(null, (0, placeholder_1.normalizePlaceholder)(result.toString("utf-8")));
-                    }
-                ]));
-            };
-            // CHANGE: The checkConstraints() function is currently not implemented in rspack
-            // compiler.hooks.compilation.tap("StatsTestCasesTest", compilation => {
-            // 	[
-            // 		"optimize",
-            // 		"optimizeModules",
-            // 		"optimizeChunks",
-            // 		"afterOptimizeTree",
-            // 		"afterOptimizeAssets",
-            // 		"beforeHash"
-            // 	].forEach(hook => {
-            // 		compilation.hooks[hook].tap("TestCasesTest", () =>
-            // 			compilation.checkConstraints()
-            // 		);
-            // 	});
-            // });
-        }
-    }
-    async check(env, context) {
-        const compiler = this.getCompiler(context);
-        const stats = compiler.getStats();
-        const c = compiler.getCompiler();
-        if (!stats || !c)
-            return;
-        for (const compilation of []
-            .concat(stats.stats || stats)
-            .map((s) => s.compilation)) {
-            compilation.logging.delete("webpack.Compilation.ModuleProfile");
-        }
-        if (REG_ERROR_CASE.test(this._options.name)) {
-            env.expect(stats.hasErrors()).toBe(true);
-        }
-        else if (stats.hasErrors()) {
-            throw new Error(stats.toString({
-                all: false,
-                errors: true
-                // errorStack: true,
-                // errorDetails: true
-            }));
-        }
-        else if (this.writeStatsOuptut) {
-            node_fs_1.default.writeFileSync(node_path_1.default.join(context.getDist(), "stats.txt"), stats.toString({
-                preset: "verbose",
-                // context: context.getSource(),
-                colors: false
-            }), "utf-8");
-        }
-        let toStringOptions = {
-            context: context.getSource(),
-            colors: false
-        };
-        let hasColorSetting = false;
-        if (typeof c.options.stats !== "undefined") {
-            toStringOptions = c.options.stats;
-            if (toStringOptions === null || typeof toStringOptions !== "object")
-                toStringOptions = { preset: toStringOptions };
-            if (!toStringOptions.context)
-                toStringOptions.context = context.getSource();
-            hasColorSetting = typeof toStringOptions.colors !== "undefined";
-        }
-        if (Array.isArray(c.options) && !toStringOptions.children) {
-            toStringOptions.children = c.options.map(o => o.stats);
-        }
-        // mock timestamps
-        for (const { compilation: s } of [].concat(stats.stats || stats)) {
-            env.expect(s.startTime).toBeGreaterThan(0);
-            env.expect(s.endTime).toBeGreaterThan(0);
-            s.endTime = new Date("04/20/1970, 12:42:42 PM").getTime();
-            s.startTime = s.endTime - 1234;
-        }
-        let actual = stats.toString(toStringOptions);
-        env.expect(typeof actual).toBe("string");
-        actual = this.stderr.toString() + actual;
-        if (!hasColorSetting) {
-            actual = actual
-                .replace(/\u001b\[[0-9;]*m/g, "")
-                // CHANGE: The time unit display in Rspack is second
-                .replace(/[.0-9]+(\s?s)/g, "X$1")
-                // CHANGE: Replace bundle size, since bundle sizes may differ between platforms
-                .replace(/[0-9]+\.?[0-9]+ KiB/g, "xx KiB");
-        }
-        const snapshotPath = node_path_1.default.isAbsolute(this.snapshotName)
-            ? this.snapshotName
-            : node_path_1.default.resolve(context.getSource(), `./__snapshots__/${this.snapshotName}`);
-        env.expect(new RspackStats(actual)).toMatchFileSnapshot(snapshotPath);
-        const testConfig = context.getTestConfig();
-        if (typeof testConfig?.validate === "function") {
-            testConfig.validate(stats, this.stderr.toString());
-        }
-    }
-    static defaultOptions(index, context) {
-        if (node_fs_1.default.existsSync(node_path_1.default.join(context.getSource(), "rspack.config.js"))) {
-            return {
-                experiments: {
-                    css: true,
-                    rspackFuture: {
-                        bundlerInfo: {
-                            force: false
-                        }
-                    }
-                }
-            };
-        }
-        return {
-            context: context.getSource(),
-            mode: "development",
-            entry: "./index.js",
-            output: {
-                filename: "bundle.js",
-                path: context.getDist()
-            },
-            optimization: {
-                minimize: false
-            },
-            experiments: {
-                css: true,
-                rspackFuture: {
-                    bundlerInfo: {
-                        force: false
-                    }
-                },
-                inlineConst: true,
-                lazyBarrel: true
-            }
-        };
-    }
-    static overrideOptions(index, context, options) {
-        if (!options.context)
-            options.context = context.getSource();
-        if (!options.output)
-            options.output = options.output || {};
-        if (!options.output.path)
-            options.output.path = context.getDist();
-        if (!options.plugins)
-            options.plugins = [];
-        if (!options.optimization)
-            options.optimization = {};
-        if (options.optimization.minimize === undefined) {
-            options.optimization.minimize = false;
-        }
-        if (!global.printLogger) {
-            options.infrastructureLogging = {
-                level: "error"
-            };
-        }
-    }
-}
-exports.StatsProcessor = StatsProcessor;

package/dist/processor/treeshaking.d.ts

@@ -1,10 +0,0 @@
-import type { ECompilerType, ITestContext, TCompilerOptions } from "../type";
-import { type ISnapshotProcessorOptions, SnapshotProcessor } from "./snapshot";
-export interface ITreeShakingProcessorOptions<T extends ECompilerType> extends Omit<ISnapshotProcessorOptions<T>, "runable"> {
-}
-export declare class TreeShakingProcessor<T extends ECompilerType> extends SnapshotProcessor<T> {
-    protected _treeShakingOptions: ITreeShakingProcessorOptions<T>;
-    constructor(_treeShakingOptions: ITreeShakingProcessorOptions<T>);
-    static overrideOptions<T extends ECompilerType>(context: ITestContext, options: TCompilerOptions<T>): void;
-    serializeEachFile(content: string): string;
-}

package/dist/processor/treeshaking.js

@@ -1,33 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.TreeShakingProcessor = void 0;
-const placeholder_1 = require("../helper/expect/placeholder");
-const builtin_1 = require("./builtin");
-const snapshot_1 = require("./snapshot");
-class TreeShakingProcessor extends snapshot_1.SnapshotProcessor {
-    constructor(_treeShakingOptions) {
-        super({
-            defaultOptions: builtin_1.BuiltinProcessor.defaultOptions,
-            overrideOptions: (TreeShakingProcessor.overrideOptions),
-            runable: false,
-            ..._treeShakingOptions
-        });
-        this._treeShakingOptions = _treeShakingOptions;
-    }
-    static overrideOptions(context, options) {
-        options.target = options.target || ["web", "es2022"];
-        options.optimization ??= {};
-        options.optimization.providedExports = true;
-        options.optimization.innerGraph = true;
-        options.optimization.usedExports = true;
-        if (!global.printLogger) {
-            options.infrastructureLogging = {
-                level: "error"
-            };
-        }
-    }
-    serializeEachFile(content) {
-        return (0, placeholder_1.normalizePlaceholder)(content);
-    }
-}
-exports.TreeShakingProcessor = TreeShakingProcessor;