@bleedingdev/modern-js-app-tools 3.9.0-ultramodern.4 → 3.9.0-ultramodern.6

package/dist/cjs/plugins/deploy/utils/npmAliases.js

@@ -1,226 +0,0 @@
-"use strict";
-var __webpack_require__ = {};
-(()=>{
-    __webpack_require__.n = (module)=>{
-        var getter = module && module.__esModule ? ()=>module['default'] : ()=>module;
-        __webpack_require__.d(getter, {
-            a: getter
-        });
-        return getter;
-    };
-})();
-(()=>{
-    __webpack_require__.d = (exports1, getters, values)=>{
-        var define = (defs, kind)=>{
-            for(var key in defs)if (__webpack_require__.o(defs, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
-                enumerable: true,
-                [kind]: defs[key]
-            });
-        };
-        define(getters, "get");
-        define(values, "value");
-    };
-})();
-(()=>{
-    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
-})();
-(()=>{
-    __webpack_require__.r = (exports1)=>{
-        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
-            value: 'Module'
-        });
-        Object.defineProperty(exports1, '__esModule', {
-            value: true
-        });
-    };
-})();
-var __webpack_exports__ = {};
-__webpack_require__.r(__webpack_exports__);
-__webpack_require__.d(__webpack_exports__, {
-    preserveNpmAliases: ()=>preserveNpmAliases,
-    readPackageIdentity: ()=>readPackageIdentity
-});
-const promises_namespaceObject = require("node:fs/promises");
-var promises_default = /*#__PURE__*/ __webpack_require__.n(promises_namespaceObject);
-const external_node_path_namespaceObject = require("node:path");
-var external_node_path_default = /*#__PURE__*/ __webpack_require__.n(external_node_path_namespaceObject);
-const dependencyKeys = [
-    'dependencies',
-    'optionalDependencies'
-];
-const exactVersionPattern = /^\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?(?:\+[0-9A-Za-z.-]+)?$/u;
-async function readPackageJson(filePath) {
-    return JSON.parse(await promises_default().readFile(filePath, 'utf8'));
-}
-function parseNpmAlias(aliasName, specifier) {
-    if (!specifier.startsWith('npm:')) return;
-    const target = specifier.slice(4);
-    const versionSeparator = target.lastIndexOf('@');
-    if (versionSeparator <= 0 || versionSeparator === target.length - 1) throw new Error(`Invalid npm alias specifier for ${aliasName}: ${specifier}`);
-    return {
-        aliasName,
-        targetName: target.slice(0, versionSeparator),
-        targetVersion: target.slice(versionSeparator + 1)
-    };
-}
-function aliasesFromPackageJson(packageJson) {
-    const aliases = [];
-    for (const dependencyKey of dependencyKeys)for (const [aliasName, specifier] of Object.entries(packageJson[dependencyKey] ?? {})){
-        const alias = parseNpmAlias(aliasName, specifier);
-        if (alias) aliases.push(alias);
-    }
-    return aliases;
-}
-async function collectPackageRecords(nodeModulesDirectory) {
-    const records = [];
-    const visitedNodeModules = new Set();
-    const visitPackage = async (directory)=>{
-        const packageJsonPath = external_node_path_default().join(directory, 'package.json');
-        try {
-            const packageJson = await readPackageJson(packageJsonPath);
-            if (packageJson.name && packageJson.version) records.push({
-                directory,
-                packageJson
-            });
-        } catch (error) {
-            if ('ENOENT' !== error.code) throw error;
-        }
-        await visitNodeModules(external_node_path_default().join(directory, 'node_modules'));
-    };
-    const visitScope = async (scopeDirectory)=>{
-        const entries = await promises_default().readdir(scopeDirectory, {
-            withFileTypes: true
-        });
-        for (const entry of entries)if (entry.isDirectory()) await visitPackage(external_node_path_default().join(scopeDirectory, entry.name));
-    };
-    const visitNdepeStore = async (storeDirectory)=>{
-        const entries = await promises_default().readdir(storeDirectory, {
-            withFileTypes: true
-        });
-        for (const entry of entries)if (entry.isDirectory()) {
-            const entryPath = external_node_path_default().join(storeDirectory, entry.name);
-            if (entry.name.startsWith('@')) await visitScope(entryPath);
-            else await visitNodeModules(external_node_path_default().join(entryPath, 'node_modules'));
-        }
-    };
-    const visitNodeModules = async (directory)=>{
-        const resolvedDirectory = external_node_path_default().resolve(directory);
-        if (visitedNodeModules.has(resolvedDirectory)) return;
-        visitedNodeModules.add(resolvedDirectory);
-        let entries;
-        try {
-            entries = await promises_default().readdir(directory, {
-                withFileTypes: true
-            });
-        } catch (error) {
-            if ('ENOENT' === error.code) return;
-            throw error;
-        }
-        for (const entry of entries){
-            if (!entry.isDirectory()) continue;
-            const entryPath = external_node_path_default().join(directory, entry.name);
-            if ('.ndepe' === entry.name) await visitNdepeStore(entryPath);
-            else if (entry.name.startsWith('@')) await visitScope(entryPath);
-            else await visitPackage(entryPath);
-        }
-    };
-    await visitNodeModules(nodeModulesDirectory);
-    return records;
-}
-async function resolveAliasTarget(ownerDirectory, alias, outputDirectory) {
-    let directory = ownerDirectory;
-    const outputRoot = external_node_path_default().resolve(outputDirectory);
-    const resolvedOutputRoot = await promises_default().realpath(outputRoot);
-    while(directory === outputRoot || directory.startsWith(`${outputRoot}${external_node_path_default().sep}`)){
-        const candidate = external_node_path_default().join(directory, 'node_modules', alias.targetName);
-        try {
-            const resolvedCandidate = await promises_default().realpath(candidate);
-            if (resolvedCandidate !== resolvedOutputRoot && !resolvedCandidate.startsWith(`${resolvedOutputRoot}${external_node_path_default().sep}`)) throw new Error(`Cannot preserve npm alias ${alias.aliasName}: emitted target ${candidate} resolves outside deployment output to ${resolvedCandidate}`);
-            const packageJson = await readPackageJson(external_node_path_default().join(candidate, 'package.json'));
-            if (packageJson.name !== alias.targetName || !packageJson.version) throw new Error(`npm alias ${alias.aliasName} resolved ${candidate} to unexpected package ${String(packageJson.name)}`);
-            if (exactVersionPattern.test(alias.targetVersion) && packageJson.version !== alias.targetVersion) return;
-            return {
-                directory: candidate,
-                packageJson
-            };
-        } catch (error) {
-            if ('ENOENT' !== error.code) throw error;
-        }
-        if (directory === outputRoot) break;
-        directory = external_node_path_default().dirname(directory);
-    }
-}
-async function ensureAliasLink(ownerDirectory, alias, target) {
-    const aliasPath = external_node_path_default().join(ownerDirectory, 'node_modules', alias.aliasName);
-    await promises_default().mkdir(external_node_path_default().dirname(aliasPath), {
-        recursive: true
-    });
-    try {
-        const [existing, expected] = await Promise.all([
-            promises_default().realpath(aliasPath),
-            promises_default().realpath(target.directory)
-        ]);
-        if (existing === expected) return;
-        throw new Error(`Cannot preserve npm alias ${alias.aliasName}: ${aliasPath} already resolves to ${existing}, expected ${expected}`);
-    } catch (error) {
-        if ('ENOENT' !== error.code) throw error;
-    }
-    const linkTarget = external_node_path_default().relative(external_node_path_default().dirname(aliasPath), target.directory);
-    await promises_default().symlink(linkTarget, aliasPath, 'dir');
-}
-function aliasSpecifier(alias) {
-    return `npm:${alias.targetName}@${alias.targetVersion}`;
-}
-async function readPackageIdentity(entryPath) {
-    let directory = external_node_path_default().dirname(entryPath);
-    const root = external_node_path_default().parse(directory).root;
-    while(directory !== root){
-        try {
-            const packageJson = await readPackageJson(external_node_path_default().join(directory, 'package.json'));
-            if (packageJson.name && packageJson.version) return {
-                name: packageJson.name,
-                version: packageJson.version
-            };
-        } catch (error) {
-            if ('ENOENT' !== error.code) throw error;
-        }
-        directory = external_node_path_default().dirname(directory);
-    }
-    throw new Error(`Cannot find owning package for deployment entry ${entryPath}`);
-}
-async function preserveNpmAliases({ appDirectory, outputDirectory, implicitAliases = [] }) {
-    const records = await collectPackageRecords(external_node_path_default().join(outputDirectory, 'node_modules'));
-    const appPackageJson = await readPackageJson(external_node_path_default().join(appDirectory, 'package.json'));
-    const rootAliases = [
-        ...aliasesFromPackageJson(appPackageJson),
-        ...implicitAliases
-    ].filter((alias)=>alias.aliasName !== alias.targetName);
-    const emittedRootAliases = [];
-    for (const alias of rootAliases){
-        const target = await resolveAliasTarget(outputDirectory, alias, outputDirectory);
-        if (!target) {
-            if (implicitAliases.includes(alias)) throw new Error(`Cannot preserve implicit npm alias ${alias.aliasName}: emitted target ${alias.targetName}@${alias.targetVersion} is missing`);
-            continue;
-        }
-        await ensureAliasLink(outputDirectory, alias, target);
-        emittedRootAliases.push(alias);
-    }
-    for (const record of records)for (const alias of aliasesFromPackageJson(record.packageJson).filter((candidate)=>candidate.aliasName !== candidate.targetName)){
-        const target = await resolveAliasTarget(record.directory, alias, outputDirectory);
-        if (target) await ensureAliasLink(record.directory, alias, target);
-    }
-    const outputPackageJsonPath = external_node_path_default().join(outputDirectory, 'package.json');
-    const outputPackageJson = await readPackageJson(outputPackageJsonPath);
-    outputPackageJson.dependencies ??= {};
-    for (const alias of emittedRootAliases)outputPackageJson.dependencies[alias.aliasName] = aliasSpecifier(alias);
-    await promises_default().writeFile(outputPackageJsonPath, `${JSON.stringify(outputPackageJson, null, 2)}\n`);
-}
-exports.preserveNpmAliases = __webpack_exports__.preserveNpmAliases;
-exports.readPackageIdentity = __webpack_exports__.readPackageIdentity;
-for(var __rspack_i in __webpack_exports__)if (-1 === [
-    "preserveNpmAliases",
-    "readPackageIdentity"
-].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
-Object.defineProperty(exports, '__esModule', {
-    value: true
-});

package/dist/cjs/plugins/ultramodernReleaseEnvelope.js

@@ -1,44 +0,0 @@
-"use strict";
-var __webpack_require__ = {};
-(()=>{
-    __webpack_require__.d = (exports1, getters, values)=>{
-        var define = (defs, kind)=>{
-            for(var key in defs)if (__webpack_require__.o(defs, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
-                enumerable: true,
-                [kind]: defs[key]
-            });
-        };
-        define(getters, "get");
-        define(values, "value");
-    };
-})();
-(()=>{
-    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
-})();
-(()=>{
-    __webpack_require__.r = (exports1)=>{
-        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
-            value: 'Module'
-        });
-        Object.defineProperty(exports1, '__esModule', {
-            value: true
-        });
-    };
-})();
-var __webpack_exports__ = {};
-__webpack_require__.r(__webpack_exports__);
-__webpack_require__.d(__webpack_exports__, {
-    default: ()=>ultramodernReleaseEnvelope
-});
-const plugin_namespaceObject = require("@modern-js/app-tools-extensions/release-envelope/plugin");
-const index_js_namespaceObject = require("./deploy/index.js");
-const ultramodernReleaseEnvelope = ()=>(0, plugin_namespaceObject.createUltramodernReleaseEnvelopePlugin)({
-        resolveDeployTarget: index_js_namespaceObject.resolveDeployTarget
-    });
-exports["default"] = __webpack_exports__["default"];
-for(var __rspack_i in __webpack_exports__)if (-1 === [
-    "default"
-].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
-Object.defineProperty(exports, '__esModule', {
-    value: true
-});

package/dist/cjs/presetUltramodern.js

@@ -1,175 +0,0 @@
-"use strict";
-var __webpack_require__ = {};
-(()=>{
-    __webpack_require__.n = (module)=>{
-        var getter = module && module.__esModule ? ()=>module['default'] : ()=>module;
-        __webpack_require__.d(getter, {
-            a: getter
-        });
-        return getter;
-    };
-})();
-(()=>{
-    __webpack_require__.d = (exports1, getters, values)=>{
-        var define = (defs, kind)=>{
-            for(var key in defs)if (__webpack_require__.o(defs, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
-                enumerable: true,
-                [kind]: defs[key]
-            });
-        };
-        define(getters, "get");
-        define(values, "value");
-    };
-})();
-(()=>{
-    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
-})();
-(()=>{
-    __webpack_require__.r = (exports1)=>{
-        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
-            value: 'Module'
-        });
-        Object.defineProperty(exports1, '__esModule', {
-            value: true
-        });
-    };
-})();
-var __webpack_exports__ = {};
-__webpack_require__.r(__webpack_exports__);
-__webpack_require__.d(__webpack_exports__, {
-    createPresetUltramodernConfig: ()=>createPresetUltramodernConfig,
-    presetUltramodern: ()=>presetUltramodern,
-    ultramodernReleaseEnvelopePlugin: ()=>ultramodernReleaseEnvelope_js_default()
-});
-const external_node_fs_namespaceObject = require("node:fs");
-var external_node_fs_default = /*#__PURE__*/ __webpack_require__.n(external_node_fs_namespaceObject);
-const external_node_path_namespaceObject = require("node:path");
-var external_node_path_default = /*#__PURE__*/ __webpack_require__.n(external_node_path_namespaceObject);
-const native_type_checker_namespaceObject = require("@modern-js/app-tools-extensions/native-type-checker");
-const release_identity_namespaceObject = require("@modern-js/app-tools-extensions/release-identity");
-const cli_namespaceObject = require("@modern-js/plugin/cli");
-const core_namespaceObject = require("@rsbuild/core");
-const build_environment_js_namespaceObject = require("./config/build-environment.js");
-const ultramodernReleaseEnvelope_js_namespaceObject = require("./plugins/ultramodernReleaseEnvelope.js");
-var ultramodernReleaseEnvelope_js_default = /*#__PURE__*/ __webpack_require__.n(ultramodernReleaseEnvelope_js_namespaceObject);
-const DEFAULT_OTLP_ENDPOINT = 'http://127.0.0.1:4318/v1/logs';
-const DEFAULT_VICTORIA_METRICS_ENDPOINT = 'http://127.0.0.1:8428/api/v1/import/prometheus';
-const resolveReactRouterPackageDir = (appDirectory)=>{
-    const resolveNodeModulePackageJson = (packageName, fromDirectory)=>{
-        let currentDirectory = external_node_path_default().resolve(fromDirectory);
-        while(true){
-            const packageJson = external_node_path_default().join(currentDirectory, 'node_modules', packageName, 'package.json');
-            if (external_node_fs_default().existsSync(packageJson)) return external_node_fs_default().realpathSync(packageJson);
-            const parentDirectory = external_node_path_default().dirname(currentDirectory);
-            if (parentDirectory === currentDirectory) return;
-            currentDirectory = parentDirectory;
-        }
-    };
-    const reactRouterPackageJson = resolveNodeModulePackageJson('react-router', appDirectory);
-    if (reactRouterPackageJson) return external_node_path_default().dirname(reactRouterPackageJson);
-    const reactRouterDomPackageJson = resolveNodeModulePackageJson('react-router-dom', appDirectory);
-    if (!reactRouterDomPackageJson) return;
-    const nestedReactRouterPackageJson = resolveNodeModulePackageJson('react-router', external_node_path_default().dirname(reactRouterDomPackageJson));
-    if (nestedReactRouterPackageJson) return external_node_path_default().dirname(nestedReactRouterPackageJson);
-};
-const setReactRouterBridgeSafeAliases = (chain, { isProd })=>{
-    const chainContext = chain.get('context');
-    const appDirectory = 'string' == typeof chainContext && chainContext.length > 0 ? chainContext : process.cwd();
-    const reactRouterPackageDir = resolveReactRouterPackageDir(appDirectory);
-    if (!reactRouterPackageDir) return;
-    const productionEntry = external_node_path_default().join(reactRouterPackageDir, 'dist/production/index.mjs');
-    const developmentEntry = external_node_path_default().join(reactRouterPackageDir, 'dist/development/index.mjs');
-    chain.resolve.alias.set('react-router$', isProd ? productionEntry : developmentEntry);
-    chain.resolve.alias.set('react-router/dist/production/index.js', productionEntry);
-    chain.resolve.alias.set('react-router/dist/development/index.js', developmentEntry);
-};
-const createPresetUltramodernConfig = (options = {})=>{
-    const { appId = 'app', deliveryUnit, enableBffRequestId = true, enableTelemetry = true, enableTelemetryExporters, otlpEndpoint = process.env.MODERN_TELEMETRY_OTLP_ENDPOINT, victoriaMetricsEndpoint = process.env.MODERN_TELEMETRY_VICTORIA_ENDPOINT, telemetryFailLoudStartup = false, enableModuleFederationSSR = true } = options;
-    const server = {};
-    const releaseIdentity = deliveryUnit ? (0, release_identity_namespaceObject.resolveUltramodernReleaseIdentity)({
-        generationBuildMarker: deliveryUnit.buildMarker,
-        unitId: deliveryUnit.unitId
-    }) : void 0;
-    const bundledReleaseIdentity = releaseIdentity ? {
-        ...releaseIdentity,
-        releaseVersion: deliveryUnit.version
-    } : void 0;
-    if (enableTelemetry) {
-        server.telemetry = {
-            enabled: true,
-            failLoudStartup: telemetryFailLoudStartup
-        };
-        if (false !== enableTelemetryExporters) {
-            const exporters = {};
-            if (true === enableTelemetryExporters || otlpEndpoint) exporters.otlp = {
-                enabled: true,
-                endpoint: otlpEndpoint || DEFAULT_OTLP_ENDPOINT
-            };
-            if (true === enableTelemetryExporters || victoriaMetricsEndpoint) exporters.victoriaMetrics = {
-                enabled: true,
-                endpoint: victoriaMetricsEndpoint || DEFAULT_VICTORIA_METRICS_ENDPOINT
-            };
-            if (Object.keys(exporters).length > 0) server.telemetry.exporters = exporters;
-        }
-    }
-    if (enableModuleFederationSSR) server.ssr = {
-        mode: 'stream',
-        moduleFederationAppSSR: true
-    };
-    const presetConfig = {
-        output: {
-            precompress: true
-        },
-        server,
-        source: {
-            reactCompiler: true,
-            ...deliveryUnit ? {
-                globalVars: {
-                    ULTRAMODERN_BUILD_MARKER: releaseIdentity?.buildMarker,
-                    ULTRAMODERN_RELEASE_VERSION: deliveryUnit.version,
-                    ULTRAMODERN_SOURCE_REVISION: releaseIdentity?.sourceRevision
-                }
-            } : {}
-        },
-        tools: {
-            bundlerChain: (chain, utils)=>{
-                setReactRouterBridgeSafeAliases(chain, utils);
-                (0, native_type_checker_namespaceObject.configureUltramodernTypeChecker)(chain, utils.CHAIN_ID.PLUGIN.TS_CHECKER, (from)=>(0, build_environment_js_namespaceObject.resolveEffectTsgoCompiler)({
-                        from
-                    }));
-            },
-            lightningcssLoader: true,
-            ...bundledReleaseIdentity ? {
-                rspack: (config)=>{
-                    config.plugins ??= [];
-                    config.plugins.push(new core_namespaceObject.rspack.BannerPlugin({
-                        banner: `void ${JSON.stringify(bundledReleaseIdentity.buildMarker)};void ${JSON.stringify(bundledReleaseIdentity.sourceRevision)};void ${JSON.stringify(bundledReleaseIdentity.releaseVersion)};`,
-                        raw: true,
-                        stage: core_namespaceObject.rspack.Compilation.PROCESS_ASSETS_STAGE_SUMMARIZE,
-                        test: /\.(?:c|m)?js$/u
-                    }));
-                    return config;
-                }
-            } : {}
-        }
-    };
-    if (enableBffRequestId) presetConfig.bff = {
-        requestId: appId
-    };
-    return presetConfig;
-};
-const presetUltramodern = (config, options = {})=>(0, cli_namespaceObject.mergeConfig)([
-        createPresetUltramodernConfig(options),
-        config
-    ]);
-exports.createPresetUltramodernConfig = __webpack_exports__.createPresetUltramodernConfig;
-exports.presetUltramodern = __webpack_exports__.presetUltramodern;
-exports.ultramodernReleaseEnvelopePlugin = __webpack_exports__.ultramodernReleaseEnvelopePlugin;
-for(var __rspack_i in __webpack_exports__)if (-1 === [
-    "createPresetUltramodernConfig",
-    "presetUltramodern",
-    "ultramodernReleaseEnvelopePlugin"
-].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
-Object.defineProperty(exports, '__esModule', {
-    value: true
-});

package/dist/cjs/types/config/precompress.js

@@ -1,18 +0,0 @@
-"use strict";
-var __webpack_require__ = {};
-(()=>{
-    __webpack_require__.r = (exports1)=>{
-        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
-            value: 'Module'
-        });
-        Object.defineProperty(exports1, '__esModule', {
-            value: true
-        });
-    };
-})();
-var __webpack_exports__ = {};
-__webpack_require__.r(__webpack_exports__);
-for(var __rspack_i in __webpack_exports__)exports[__rspack_i] = __webpack_exports__[__rspack_i];
-Object.defineProperty(exports, '__esModule', {
-    value: true
-});

package/dist/esm/builder/shared/builderPlugins/adapterPrecompress.mjs

@@ -1,77 +0,0 @@
-import { constants } from "node:zlib";
-import compression_webpack_plugin from "compression-webpack-plugin";
-const DEFAULT_PRECOMPRESS_TEST = /\.(js|mjs|cjs|css|html|svg|json|map)$/i;
-const DEFAULT_PRECOMPRESS_THRESHOLD = 10240;
-const DEFAULT_PRECOMPRESS_MIN_RATIO = 0.8;
-const createDefaultGzipOptions = ()=>({
-        algorithm: 'gzip',
-        filename: '[path][base].gz',
-        test: DEFAULT_PRECOMPRESS_TEST,
-        threshold: DEFAULT_PRECOMPRESS_THRESHOLD,
-        minRatio: DEFAULT_PRECOMPRESS_MIN_RATIO,
-        compressionOptions: {
-            level: 6
-        }
-    });
-const createDefaultBrotliOptions = ()=>({
-        algorithm: 'brotliCompress',
-        filename: '[path][base].br',
-        test: DEFAULT_PRECOMPRESS_TEST,
-        threshold: DEFAULT_PRECOMPRESS_THRESHOLD,
-        minRatio: DEFAULT_PRECOMPRESS_MIN_RATIO,
-        compressionOptions: {
-            params: {
-                [constants.BROTLI_PARAM_QUALITY]: 9
-            }
-        }
-    });
-const mergeCompressionOptions = (base, next)=>{
-    const merged = {
-        ...base,
-        ...next
-    };
-    if (base.compressionOptions || next.compressionOptions) {
-        const baseCompressionOptions = base.compressionOptions;
-        const nextCompressionOptions = next.compressionOptions;
-        const mergedCompressionOptions = {
-            ...baseCompressionOptions,
-            ...nextCompressionOptions
-        };
-        if (baseCompressionOptions?.params || nextCompressionOptions?.params) mergedCompressionOptions.params = {
-            ...baseCompressionOptions?.params,
-            ...nextCompressionOptions?.params
-        };
-        merged.compressionOptions = mergedCompressionOptions;
-    }
-    return merged;
-};
-const resolveCodecOptions = (codecConfig, createDefaultOptions)=>{
-    if (false === codecConfig) return null;
-    if (void 0 === codecConfig || true === codecConfig) return createDefaultOptions();
-    return mergeCompressionOptions(createDefaultOptions(), codecConfig);
-};
-const resolvePrecompressConfig = (normalizedConfig)=>{
-    const precompress = normalizedConfig.output.precompress;
-    if (false === precompress || void 0 === precompress) return false;
-    if (true === precompress) return {};
-    return precompress;
-};
-const builderPluginAdapterPrecompress = (options)=>({
-        name: 'builder-plugin-adapter-modern-precompress',
-        setup (api) {
-            api.modifyBundlerChain((chain, { isProd, target })=>{
-                if (!isProd || 'web' !== target) return;
-                const precompressConfig = resolvePrecompressConfig(options.normalizedConfig);
-                if (false === precompressConfig) return;
-                const gzipOptions = resolveCodecOptions(precompressConfig.gzip, createDefaultGzipOptions);
-                if (gzipOptions) chain.plugin('modern-precompress-gzip').use(compression_webpack_plugin, [
-                    gzipOptions
-                ]);
-                const brotliOptions = resolveCodecOptions(precompressConfig.brotli, createDefaultBrotliOptions);
-                if (brotliOptions) chain.plugin('modern-precompress-brotli').use(compression_webpack_plugin, [
-                    brotliOptions
-                ]);
-            });
-        }
-    });
-export { builderPluginAdapterPrecompress };