@rspack/core 1.0.9 → 1.0.11

package/dist/config/adapter.js

@@ -1,691 +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.getRawChunkLoading = exports.getRawLibrary = exports.getRawResolve = exports.getRawOptions = void 0;
-const node_assert_1 = __importDefault(require("node:assert"));
-const binding_1 = require("@rspack/binding");
-const Stats_1 = require("../Stats");
-const util_1 = require("../util");
-const identifier_1 = require("../util/identifier");
-const adapterRuleUse_1 = require("./adapterRuleUse");
-const getRawOptions = (options, compiler) => {
-    (0, node_assert_1.default)(!(0, util_1.isNil)(options.context) && !(0, util_1.isNil)(options.devtool) && !(0, util_1.isNil)(options.cache), "context, devtool, cache should not be nil after defaults");
-    const devtool = options.devtool === false ? "" : options.devtool;
-    const mode = options.mode;
-    const experiments = getRawExperiments(options.experiments);
-    return {
-        mode,
-        target: getRawTarget(options.target),
-        context: options.context,
-        output: getRawOutput(options.output),
-        resolve: getRawResolve(options.resolve),
-        resolveLoader: getRawResolve(options.resolveLoader),
-        module: getRawModule(options.module, {
-            compiler,
-            devtool,
-            mode,
-            context: options.context,
-            experiments
-        }),
-        devtool,
-        optimization: getRawOptimization(options.optimization),
-        stats: getRawStats(options.stats),
-        snapshot: getRawSnapshotOptions(options.snapshot),
-        cache: {
-            type: options.cache ? "memory" : "disable",
-            // TODO: implement below cache options
-            maxGenerations: 0,
-            maxAge: 0,
-            profile: false,
-            buildDependencies: [],
-            cacheDirectory: "",
-            cacheLocation: "",
-            name: "",
-            version: ""
-        },
-        experiments,
-        node: getRawNode(options.node),
-        // SAFETY: applied default value in `applyRspackOptionsDefaults`.
-        profile: options.profile,
-        // SAFETY: applied default value in `applyRspackOptionsDefaults`.
-        bail: options.bail,
-        __references: {}
-    };
-};
-exports.getRawOptions = getRawOptions;
-function getRawTarget(target) {
-    if (!target) {
-        return [];
-    }
-    if (typeof target === "string") {
-        return [target];
-    }
-    return target;
-}
-function getRawExtensionAlias(alias = {}) {
-    const entries = Object.entries(alias).map(([key, value]) => {
-        if (Array.isArray(value)) {
-            return [key, value];
-        }
-        return [key, [value]];
-    });
-    return Object.fromEntries(entries);
-}
-function getRawAlias(alias = {}) {
-    return Object.entries(alias).map(([key, value]) => ({
-        path: key,
-        redirect: Array.isArray(value) ? value : [value]
-    }));
-}
-function getRawResolveByDependency(byDependency) {
-    if (byDependency === undefined)
-        return byDependency;
-    return Object.fromEntries(Object.entries(byDependency).map(([k, v]) => [k, getRawResolve(v)]));
-}
-function getRawTsConfig(tsConfig) {
-    (0, node_assert_1.default)(typeof tsConfig !== "string", "should resolve string tsConfig in normalization");
-    if (tsConfig === undefined)
-        return tsConfig;
-    const { configFile, references } = tsConfig;
-    return {
-        configFile,
-        referencesType: references === "auto" ? "auto" : references ? "manual" : "disabled",
-        references: references === "auto" ? undefined : references
-    };
-}
-function getRawResolve(resolve) {
-    return {
-        ...resolve,
-        alias: getRawAlias(resolve.alias),
-        fallback: getRawAlias(resolve.fallback),
-        extensionAlias: getRawExtensionAlias(resolve.extensionAlias),
-        tsconfig: getRawTsConfig(resolve.tsConfig),
-        byDependency: getRawResolveByDependency(resolve.byDependency)
-    };
-}
-exports.getRawResolve = getRawResolve;
-function getRawCrossOriginLoading(crossOriginLoading) {
-    if (typeof crossOriginLoading === "boolean") {
-        return { type: "bool", boolPayload: crossOriginLoading };
-    }
-    return { type: "string", stringPayload: crossOriginLoading };
-}
-function getRawOutput(output) {
-    const chunkLoading = output.chunkLoading;
-    const wasmLoading = output.wasmLoading;
-    const workerChunkLoading = output.workerChunkLoading;
-    const workerWasmLoading = output.workerWasmLoading;
-    return {
-        path: output.path,
-        pathinfo: output.pathinfo,
-        publicPath: output.publicPath,
-        clean: output.clean,
-        assetModuleFilename: output.assetModuleFilename,
-        filename: output.filename,
-        chunkFilename: output.chunkFilename,
-        chunkLoading: getRawChunkLoading(chunkLoading),
-        crossOriginLoading: getRawCrossOriginLoading(output.crossOriginLoading),
-        cssFilename: output.cssFilename,
-        cssChunkFilename: output.cssChunkFilename,
-        cssHeadDataCompression: output.cssHeadDataCompression,
-        hotUpdateChunkFilename: output.hotUpdateChunkFilename,
-        hotUpdateMainFilename: output.hotUpdateMainFilename,
-        hotUpdateGlobal: output.hotUpdateGlobal,
-        uniqueName: output.uniqueName,
-        chunkLoadingGlobal: output.chunkLoadingGlobal,
-        enabledLibraryTypes: output.enabledLibraryTypes,
-        library: output.library && getRawLibrary(output.library),
-        strictModuleErrorHandling: output.strictModuleErrorHandling,
-        globalObject: output.globalObject,
-        importFunctionName: output.importFunctionName,
-        importMetaName: output.importMetaName,
-        iife: output.iife,
-        module: output.module,
-        wasmLoading: wasmLoading === false ? "false" : wasmLoading,
-        enabledWasmLoadingTypes: output.enabledWasmLoadingTypes,
-        enabledChunkLoadingTypes: output.enabledChunkLoadingTypes,
-        webassemblyModuleFilename: output.webassemblyModuleFilename,
-        trustedTypes: output.trustedTypes,
-        sourceMapFilename: output.sourceMapFilename,
-        hashFunction: output.hashFunction,
-        hashDigest: output.hashDigest,
-        hashDigestLength: output.hashDigestLength,
-        hashSalt: output.hashSalt,
-        asyncChunks: output.asyncChunks,
-        workerChunkLoading: workerChunkLoading === false ? "false" : workerChunkLoading,
-        workerWasmLoading: workerWasmLoading === false ? "false" : workerWasmLoading,
-        workerPublicPath: output.workerPublicPath,
-        scriptType: output.scriptType === false ? "false" : output.scriptType,
-        charset: output.charset,
-        chunkLoadTimeout: output.chunkLoadTimeout,
-        environment: output.environment
-    };
-}
-function getRawLibrary(library) {
-    const { type, name, export: libraryExport, umdNamedDefine, auxiliaryComment, amdContainer } = library;
-    return {
-        amdContainer,
-        auxiliaryComment: typeof auxiliaryComment === "string"
-            ? {
-                commonjs: auxiliaryComment,
-                commonjs2: auxiliaryComment,
-                amd: auxiliaryComment,
-                root: auxiliaryComment
-            }
-            : auxiliaryComment,
-        libraryType: type,
-        name: (0, util_1.isNil)(name) ? name : getRawLibraryName(name),
-        export: Array.isArray(libraryExport) || libraryExport == null
-            ? libraryExport
-            : [libraryExport],
-        umdNamedDefine
-    };
-}
-exports.getRawLibrary = getRawLibrary;
-function getRawLibraryName(name) {
-    if (typeof name === "string") {
-        return {
-            type: "string",
-            stringPayload: name
-        };
-    }
-    if (Array.isArray(name)) {
-        return {
-            type: "array",
-            arrayPayload: name
-        };
-    }
-    if (typeof name === "object" && !Array.isArray(name)) {
-        return {
-            type: "umdObject",
-            umdObjectPayload: {
-                commonjs: name.commonjs,
-                root: Array.isArray(name.root) || (0, util_1.isNil)(name.root)
-                    ? name.root
-                    : [name.root],
-                amd: name.amd
-            }
-        };
-    }
-    throw new Error("unreachable");
-}
-function getRawModule(module, options) {
-    (0, node_assert_1.default)(!(0, util_1.isNil)(module.defaultRules), "module.defaultRules should not be nil after defaults");
-    // "..." in defaultRules will be flatten in `applyModuleDefaults`, and "..." in rules is empty, so it's safe to use `as RuleSetRule[]` at here
-    const ruleSet = [
-        { rules: module.defaultRules },
-        { rules: module.rules }
-    ];
-    const rules = ruleSet.map((rule, index) => getRawModuleRule(rule, `ruleSet[${index}]`, options, "javascript/auto"));
-    return {
-        rules,
-        parser: getRawParserOptionsMap(module.parser),
-        generator: getRawGeneratorOptionsMap(module.generator),
-        noParse: module.noParse
-    };
-}
-function tryMatch(payload, condition) {
-    if (typeof condition === "string") {
-        return payload.startsWith(condition);
-    }
-    if (condition instanceof RegExp) {
-        return condition.test(payload);
-    }
-    if (typeof condition === "function") {
-        return condition(payload);
-    }
-    if (Array.isArray(condition)) {
-        return condition.some(c => tryMatch(payload, c));
-    }
-    if (condition && typeof condition === "object") {
-        if (condition.and) {
-            return condition.and.every(c => tryMatch(payload, c));
-        }
-        if (condition.or) {
-            return condition.or.some(c => tryMatch(payload, c));
-        }
-        if (condition.not) {
-            return !tryMatch(payload, condition.not);
-        }
-    }
-    return false;
-}
-const getRawModuleRule = (rule, path, options, upperType) => {
-    // Rule.loader is a shortcut to Rule.use: [ { loader } ].
-    // See: https://webpack.js.org/configuration/module/#ruleloader
-    if (rule.loader) {
-        rule.use = [
-            {
-                loader: rule.loader,
-                options: rule.options
-            }
-        ];
-    }
-    let funcUse;
-    if (typeof rule.use === "function") {
-        const use = rule.use;
-        funcUse = (rawContext) => {
-            const context = {
-                ...rawContext,
-                compiler: options.compiler
-            };
-            const uses = use(context);
-            return (0, adapterRuleUse_1.createRawModuleRuleUses)(uses ?? [], `${path}.use`, options);
-        };
-    }
-    const rawModuleRule = {
-        test: rule.test ? getRawRuleSetCondition(rule.test) : undefined,
-        include: rule.include ? getRawRuleSetCondition(rule.include) : undefined,
-        exclude: rule.exclude ? getRawRuleSetCondition(rule.exclude) : undefined,
-        issuer: rule.issuer ? getRawRuleSetCondition(rule.issuer) : undefined,
-        issuerLayer: rule.issuerLayer
-            ? getRawRuleSetCondition(rule.issuerLayer)
-            : undefined,
-        dependency: rule.dependency
-            ? getRawRuleSetCondition(rule.dependency)
-            : undefined,
-        descriptionData: rule.descriptionData
-            ? Object.fromEntries(Object.entries(rule.descriptionData).map(([k, v]) => [
-                k,
-                getRawRuleSetCondition(v)
-            ]))
-            : undefined,
-        with: rule.with
-            ? Object.fromEntries(Object.entries(rule.with).map(([k, v]) => [
-                k,
-                getRawRuleSetCondition(v)
-            ]))
-            : undefined,
-        resource: rule.resource ? getRawRuleSetCondition(rule.resource) : undefined,
-        resourceQuery: rule.resourceQuery
-            ? getRawRuleSetCondition(rule.resourceQuery)
-            : undefined,
-        resourceFragment: rule.resourceFragment
-            ? getRawRuleSetCondition(rule.resourceFragment)
-            : undefined,
-        scheme: rule.scheme ? getRawRuleSetCondition(rule.scheme) : undefined,
-        mimetype: rule.mimetype ? getRawRuleSetCondition(rule.mimetype) : undefined,
-        sideEffects: rule.sideEffects,
-        use: typeof rule.use === "function"
-            ? funcUse
-            : (0, adapterRuleUse_1.createRawModuleRuleUses)(rule.use ?? [], `${path}.use`, options),
-        type: rule.type,
-        layer: rule.layer,
-        parser: rule.parser
-            ? getRawParserOptions(rule.parser, rule.type ?? upperType)
-            : undefined,
-        generator: rule.generator
-            ? getRawGeneratorOptions(rule.generator, rule.type ?? upperType)
-            : undefined,
-        resolve: rule.resolve ? getRawResolve(rule.resolve) : undefined,
-        oneOf: rule.oneOf
-            ? rule.oneOf.map((rule, index) => getRawModuleRule(rule, `${path}.oneOf[${index}]`, options, rule.type ?? upperType))
-            : undefined,
-        rules: rule.rules
-            ? rule.rules.map((rule, index) => getRawModuleRule(rule, `${path}.rules[${index}]`, options, rule.type ?? upperType))
-            : undefined,
-        enforce: rule.enforce
-    };
-    // Function calls may contain side-effects when interoperating with single-threaded environment.
-    // In order to mitigate the issue, Rspack tries to merge these calls together.
-    // See: https://github.com/web-infra-dev/rspack/issues/4003#issuecomment-1689662380
-    if (typeof rule.test === "function" ||
-        typeof rule.resource === "function" ||
-        typeof rule.resourceQuery === "function" ||
-        typeof rule.resourceFragment === "function") {
-        delete rawModuleRule.test;
-        delete rawModuleRule.resource;
-        delete rawModuleRule.resourceQuery;
-        delete rawModuleRule.resourceFragment;
-        rawModuleRule.rspackResource = getRawRuleSetCondition(resourceQueryFragment => {
-            const { path, query, fragment } = (0, identifier_1.parseResource)(resourceQueryFragment);
-            if (rule.test && !tryMatch(path, rule.test)) {
-                return false;
-            }
-            if (rule.resource && !tryMatch(path, rule.resource)) {
-                return false;
-            }
-            if (rule.resourceQuery && !tryMatch(query, rule.resourceQuery)) {
-                return false;
-            }
-            if (rule.resourceFragment &&
-                !tryMatch(fragment, rule.resourceFragment)) {
-                return false;
-            }
-            return true;
-        });
-    }
-    return rawModuleRule;
-};
-function getRawRuleSetCondition(condition) {
-    if (typeof condition === "string") {
-        return {
-            type: binding_1.RawRuleSetConditionType.string,
-            string: condition
-        };
-    }
-    if (condition instanceof RegExp) {
-        return {
-            type: binding_1.RawRuleSetConditionType.regexp,
-            regexp: {
-                source: condition.source,
-                flags: condition.flags
-            }
-        };
-    }
-    if (typeof condition === "function") {
-        return {
-            type: binding_1.RawRuleSetConditionType.func,
-            func: condition
-        };
-    }
-    if (Array.isArray(condition)) {
-        return {
-            type: binding_1.RawRuleSetConditionType.array,
-            array: condition.map(i => getRawRuleSetCondition(i))
-        };
-    }
-    if (typeof condition === "object" && condition !== null) {
-        return {
-            type: binding_1.RawRuleSetConditionType.logical,
-            logical: [getRawRuleSetLogicalConditions(condition)]
-        };
-    }
-    throw new Error("unreachable: condition should be one of string, RegExp, Array, Object");
-}
-function getRawRuleSetLogicalConditions(logical) {
-    return {
-        and: logical.and
-            ? logical.and.map(i => getRawRuleSetCondition(i))
-            : undefined,
-        or: logical.or ? logical.or.map(i => getRawRuleSetCondition(i)) : undefined,
-        not: logical.not ? getRawRuleSetCondition(logical.not) : undefined
-    };
-}
-function getRawParserOptionsMap(parser) {
-    return Object.fromEntries(Object.entries(parser)
-        .map(([k, v]) => [k, getRawParserOptions(v, k)])
-        .filter(([k, v]) => v !== undefined));
-}
-function getRawGeneratorOptionsMap(generator) {
-    return Object.fromEntries(Object.entries(generator)
-        .map(([k, v]) => [k, getRawGeneratorOptions(v, k)])
-        .filter(([k, v]) => v !== undefined));
-}
-function getRawParserOptions(parser, type) {
-    if (type === "asset") {
-        return {
-            type: "asset",
-            asset: getRawAssetParserOptions(parser)
-        };
-    }
-    if (type === "javascript") {
-        return {
-            type: "javascript",
-            javascript: getRawJavascriptParserOptions(parser)
-        };
-    }
-    if (type === "javascript/auto") {
-        return {
-            type: "javascript/auto",
-            javascript: getRawJavascriptParserOptions(parser)
-        };
-    }
-    if (type === "javascript/dynamic") {
-        return {
-            type: "javascript/dynamic",
-            javascript: getRawJavascriptParserOptions(parser)
-        };
-    }
-    if (type === "javascript/esm") {
-        return {
-            type: "javascript/esm",
-            javascript: getRawJavascriptParserOptions(parser)
-        };
-    }
-    if (type === "css") {
-        return {
-            type: "css",
-            css: getRawCssParserOptions(parser)
-        };
-    }
-    if (type === "css/auto") {
-        return {
-            type: "css/auto",
-            cssAuto: getRawCssParserOptions(parser)
-        };
-    }
-    if (type === "css/module") {
-        return {
-            type: "css/module",
-            cssModule: getRawCssParserOptions(parser)
-        };
-    }
-    // FIXME: shouldn't depend on module type, for example: `rules: [{ test: /\.css/, generator: {..} }]` will error
-    throw new Error(`unreachable: unknow module type: ${type}`);
-}
-function getRawJavascriptParserOptions(parser) {
-    return {
-        dynamicImportMode: parser.dynamicImportMode,
-        dynamicImportPreload: parser.dynamicImportPreload?.toString(),
-        dynamicImportPrefetch: parser.dynamicImportPrefetch?.toString(),
-        dynamicImportFetchPriority: parser.dynamicImportFetchPriority,
-        importMeta: parser.importMeta,
-        url: parser.url?.toString(),
-        exprContextCritical: parser.exprContextCritical,
-        wrappedContextCritical: parser.wrappedContextCritical,
-        exportsPresence: parser.exportsPresence === false ? "false" : parser.exportsPresence,
-        importExportsPresence: parser.importExportsPresence === false
-            ? "false"
-            : parser.importExportsPresence,
-        reexportExportsPresence: parser.reexportExportsPresence === false
-            ? "false"
-            : parser.reexportExportsPresence,
-        strictExportPresence: parser.strictExportPresence,
-        worker: typeof parser.worker === "boolean"
-            ? parser.worker
-                ? ["..."]
-                : []
-            : parser.worker,
-        overrideStrict: parser.overrideStrict,
-        requireAsExpression: parser.requireAsExpression,
-        requireDynamic: parser.requireDynamic,
-        requireResolve: parser.requireResolve,
-        importDynamic: parser.importDynamic
-    };
-}
-function getRawAssetParserOptions(parser) {
-    return {
-        dataUrlCondition: parser.dataUrlCondition
-            ? getRawAssetParserDataUrl(parser.dataUrlCondition)
-            : undefined
-    };
-}
-function getRawAssetParserDataUrl(dataUrlCondition) {
-    if (typeof dataUrlCondition === "object" && dataUrlCondition !== null) {
-        return {
-            type: "options",
-            options: {
-                maxSize: dataUrlCondition.maxSize
-            }
-        };
-    }
-    throw new Error(`unreachable: AssetParserDataUrl type should be one of "options", but got ${dataUrlCondition}`);
-}
-function getRawCssParserOptions(parser) {
-    return {
-        namedExports: parser.namedExports
-    };
-}
-function getRawGeneratorOptions(generator, type) {
-    if (type === "asset") {
-        return {
-            type: "asset",
-            asset: generator ? getRawAssetGeneratorOptions(generator) : undefined
-        };
-    }
-    if (type === "asset/inline") {
-        return {
-            type: "asset/inline",
-            assetInline: generator
-                ? getRawAssetInlineGeneratorOptions(generator)
-                : undefined
-        };
-    }
-    if (type === "asset/resource") {
-        return {
-            type: "asset/resource",
-            assetResource: generator
-                ? getRawAssetResourceGeneratorOptions(generator)
-                : undefined
-        };
-    }
-    if (type === "css") {
-        return {
-            type: "css",
-            css: getRawCssGeneratorOptions(generator)
-        };
-    }
-    if (type === "css/auto") {
-        return {
-            type: "css/auto",
-            cssAuto: getRawCssAutoOrModuleGeneratorOptions(generator)
-        };
-    }
-    if (type === "css/module") {
-        return {
-            type: "css/module",
-            cssModule: getRawCssAutoOrModuleGeneratorOptions(generator)
-        };
-    }
-    if ([
-        "javascript",
-        "javascript/auto",
-        "javascript/dynamic",
-        "javascript/esm"
-    ].includes(type)) {
-        return undefined;
-    }
-    throw new Error(`unreachable: unknow module type: ${type}`);
-}
-function getRawAssetGeneratorOptions(options) {
-    return {
-        ...getRawAssetInlineGeneratorOptions(options),
-        ...getRawAssetResourceGeneratorOptions(options)
-    };
-}
-function getRawAssetInlineGeneratorOptions(options) {
-    return {
-        dataUrl: options.dataUrl
-            ? getRawAssetGeneratorDataUrl(options.dataUrl)
-            : undefined
-    };
-}
-function getRawAssetResourceGeneratorOptions(options) {
-    return {
-        emit: options.emit,
-        filename: options.filename,
-        publicPath: options.publicPath
-    };
-}
-function getRawAssetGeneratorDataUrl(dataUrl) {
-    if (typeof dataUrl === "object" && dataUrl !== null) {
-        const encoding = dataUrl.encoding === false ? "false" : dataUrl.encoding;
-        return {
-            encoding,
-            mimetype: dataUrl.mimetype
-        };
-    }
-    if (typeof dataUrl === "function" && dataUrl !== null) {
-        return dataUrl;
-    }
-    throw new Error(`unreachable: AssetGeneratorDataUrl type should be one of "options", "function", but got ${dataUrl}`);
-}
-function getRawCssGeneratorOptions(options) {
-    return {
-        exportsOnly: options.exportsOnly,
-        esModule: options.esModule
-    };
-}
-function getRawCssAutoOrModuleGeneratorOptions(options) {
-    return {
-        localIdentName: options.localIdentName,
-        exportsConvention: options.exportsConvention,
-        exportsOnly: options.exportsOnly,
-        esModule: options.esModule
-    };
-}
-function getRawOptimization(optimization) {
-    (0, node_assert_1.default)(!(0, util_1.isNil)(optimization.removeAvailableModules) &&
-        !(0, util_1.isNil)(optimization.sideEffects) &&
-        !(0, util_1.isNil)(optimization.realContentHash) &&
-        !(0, util_1.isNil)(optimization.providedExports) &&
-        !(0, util_1.isNil)(optimization.usedExports) &&
-        !(0, util_1.isNil)(optimization.innerGraph) &&
-        "optimization.moduleIds, optimization.removeAvailableModules, optimization.removeEmptyChunks, optimization.sideEffects, optimization.realContentHash, optimization.providedExports, optimization.usedExports, optimization.innerGraph, optimization.concatenateModules should not be nil after defaults");
-    return {
-        removeAvailableModules: optimization.removeAvailableModules,
-        sideEffects: String(optimization.sideEffects),
-        usedExports: String(optimization.usedExports),
-        providedExports: optimization.providedExports,
-        innerGraph: optimization.innerGraph,
-        concatenateModules: !!optimization.concatenateModules,
-        mangleExports: String(optimization.mangleExports)
-    };
-}
-function getRawSnapshotOptions(_snapshot) {
-    return {};
-}
-function getRawExperiments(experiments) {
-    const { topLevelAwait, layers, incremental, rspackFuture } = experiments;
-    (0, node_assert_1.default)(!(0, util_1.isNil)(topLevelAwait) &&
-        !(0, util_1.isNil)(rspackFuture) &&
-        !(0, util_1.isNil)(layers) &&
-        !(0, util_1.isNil)(incremental));
-    return {
-        layers,
-        topLevelAwait,
-        incremental: getRawIncremental(incremental),
-        rspackFuture: getRawRspackFutureOptions(rspackFuture)
-    };
-}
-function getRawIncremental(incremental) {
-    if (incremental === false) {
-        return undefined;
-    }
-    return {
-        make: incremental.make,
-        emitAssets: incremental.emitAssets,
-        inferAsyncModules: incremental.inferAsyncModules,
-        providedExports: incremental.providedExports,
-        moduleHashes: incremental.moduleHashes,
-        moduleCodegen: incremental.moduleCodegen,
-        moduleRuntimeRequirements: incremental.moduleRuntimeRequirements
-    };
-}
-function getRawRspackFutureOptions(future) {
-    return {};
-}
-function getRawNode(node) {
-    if (node === false) {
-        return undefined;
-    }
-    (0, node_assert_1.default)(!(0, util_1.isNil)(node.__dirname) && !(0, util_1.isNil)(node.global) && !(0, util_1.isNil)(node.__filename));
-    return {
-        dirname: String(node.__dirname),
-        filename: String(node.__filename),
-        global: String(node.global)
-    };
-}
-function getRawStats(stats) {
-    const statsOptions = (0, Stats_1.normalizeStatsPreset)(stats);
-    return {
-        colors: statsOptions.colors ?? false
-    };
-}
-function getRawChunkLoading(chunkLoading) {
-    return chunkLoading === false ? "false" : chunkLoading;
-}
-exports.getRawChunkLoading = getRawChunkLoading;