@plaudit/webpack-extensions 3.21.2 → 4.0.0-rc.1

package/dist/wordpress-scripts-wrapper.js

@@ -1,698 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-const node_fs_1 = require("node:fs");
-const promises_1 = require("node:fs/promises");
-const node_path_1 = require("node:path");
-const shared_1 = require("./shared");
-const entrypoint_resolution_logic_1 = require("./utils/entrypoint-resolution-logic");
-const common_config_helpers_1 = require("./utils/common-config-helpers");
-const path_query_and_related_helpers_1 = require("./utils/path-query-and-related-helpers");
-const AdditionalDependencyInjectorPlugin_1 = require("./plugins/AdditionalDependencyInjectorPlugin");
-const dependency_extraction_webpack_plugin_config_builder_1 = require("./plugins/dependency-extraction-webpack-plugin-config-builder");
-const EnhancedDynamicEntryPlugin_1 = require("./plugins/EnhancedDynamicEntryPlugin");
-const ExtensionsConfigFileGeneratorPlugin_1 = require("./plugins/ExtensionsConfigFileGeneratorPlugin");
-const ExtensionsConfigFileGeneratorPluginV1_1 = require("./plugins/ExtensionsConfigFileGeneratorPluginV1");
-const MiniCSSExtractPluginErrorCleaner_1 = require("./plugins/MiniCSSExtractPluginErrorCleaner");
-const PackageConfigSanityChecker_1 = require("./plugins/PackageConfigSanityChecker");
-const PlainEntrypointsConfigFileGeneratorPlugin_1 = require("./plugins/PlainEntrypointsConfigFileGeneratorPlugin");
-const EnhancedBlockJSONPlugin_1 = require("./plugins/EnhancedBlockJSONPlugin");
-const SpecialAssetHandlingPlugin_1 = require("./plugins/SpecialAssetHandlingPlugin");
-const VariablesJSMonitorPlugin_1 = require("./plugins/VariablesJSMonitorPlugin");
-const WPMLConfigBuilder_1 = require("./plugins/WPMLConfigBuilder");
-const static_configs_1 = require("./plugins/static-configs");
-const UnifiedLoaderGenerator_1 = require("./plugins/UnifiedLoaderGenerator");
-const copy_webpack_plugin_1 = __importDefault(require("copy-webpack-plugin"));
-const fork_ts_checker_webpack_plugin_1 = __importDefault(require("fork-ts-checker-webpack-plugin"));
-const webpack_remove_empty_scripts_1 = __importDefault(require("webpack-remove-empty-scripts"));
-const location_encoding_filename_parser_1 = require("./utils/location-encoding-filename-parser");
-function testForDuplicatedEntryPaths(sources) {
-    const seenPaths = (0, common_config_helpers_1.groupEntrypointsByAssetFile)(Array.isArray(sources)
-        ? sources.map(s => typeof s === 'string' ? s : s[1].destination)
-        : Object.values(sources).map(bn => typeof bn === 'string' ? bn : bn.destination), bn => bn);
-    let projectPrefix = undefined;
-    let duplicatedPaths = "";
-    for (const sameNamePaths of seenPaths.values()) {
-        if (sameNamePaths.length > 1) {
-            if (projectPrefix === undefined) {
-                for (let p = process.cwd(); p.length > 1; p = (0, node_path_1.dirname)(p)) {
-                    if ((0, node_fs_1.existsSync)((0, node_path_1.join)(p, "docker-compose.yml"))) {
-                        projectPrefix = new RegExp(`^${p}`);
-                        break;
-                    }
-                }
-                if (projectPrefix === undefined) {
-                    projectPrefix = /^/;
-                }
-            }
-            duplicatedPaths += `\n* ${(0, node_path_1.dirname)(sameNamePaths[0]).replace(projectPrefix, '')}/[${sameNamePaths.map(p => (0, node_path_1.basename)(p)).join(', ')}]`;
-        }
-    }
-    if (duplicatedPaths.length !== 0) {
-        console.error(`Encountered multiple paths that produce the same effective bundle name:${duplicatedPaths}`);
-        process.exit(1);
-    }
-}
-function replaceDefaultURLProcessing(useWebpackResourceFiltering) {
-    return (rules) => {
-        const cssLoader = require.resolve('css-loader');
-        if (cssLoader) {
-            return rules.map(rule => {
-                if (rule && typeof rule === 'object' && "use" in rule && Array.isArray(rule.use)) {
-                    return {
-                        ...rule,
-                        use: rule.use.map(useElement => {
-                            if (useElement && typeof useElement === 'object' && useElement.loader === cssLoader && typeof useElement.options === 'object') {
-                                return {
-                                    ...useElement,
-                                    options: {
-                                        ...useElement.options,
-                                        url: {
-                                            filter(url) {
-                                                return (useWebpackResourceFiltering || !url.startsWith("/"))
-                                                    && !!url.match(/\.(woff2?|eot|ttf|otf|png|jpe?g|svg|webp|avif|gif|bmp)[^.]*?(\?.*)?/i);
-                                            }
-                                        }
-                                    }
-                                };
-                            }
-                            return useElement;
-                        })
-                    };
-                }
-                return rule;
-            });
-        }
-        return rules;
-    };
-}
-function injectPostcssConfigOverrides(rules, config, variables, postcssFunctionsConfig) {
-    const postcssConfig = (0, static_configs_1.postcssConfigBuilder)(name => variables(name) ?? (name === 'ENV' ? '' : undefined), postcssFunctionsConfig);
-    return rules.map(rule => {
-        if (rule && typeof rule === 'object') {
-            if (Array.isArray(rule.use)) {
-                for (const useItem of rule.use) {
-                    if (useItem && typeof useItem === 'object' && typeof useItem.options === 'object') {
-                        if (useItem.options["sourceMap"] === false) {
-                            useItem.options["sourceMap"] = true;
-                        }
-                        if (useItem.loader?.includes('postcss-loader')) {
-                            if (useItem.options["postcssOptions"]) {
-                                useItem.options["postcssOptions"] = { ...useItem.options["postcssOptions"], ...postcssConfig, sourceMap: true, config: false };
-                            }
-                            else {
-                                useItem.options["postcssOptions"] = { ...postcssConfig, sourceMap: true, config: false };
-                            }
-                        }
-                    }
-                }
-                if (rule.test instanceof RegExp) {
-                    if (rule.test.test("index.ts") || rule.test.test("index.mts")) { // Then this is the JavaScript and TypeScript rule
-                        rule.test = /\.m?[jt]sx?$/; // This hacks in support for mjs and mts files
-                    }
-                    if (config.onlyRunPostCSSOnPCSS && rule.test.test("test.css") && !rule.test.test("test.pcss")) {
-                        // We remove PostCSS processing from the .css file handling pipeline
-                        rule.use = rule.use.filter(useItem => !useItem || typeof useItem !== 'object' || !useItem.loader?.includes('postcss-loader'));
-                    }
-                }
-            }
-            if (rule.type === "asset/inline" && rule.test instanceof RegExp && rule.issuer instanceof RegExp && rule.test.test("test.svg") && rule.issuer.test("test.pcss")) {
-                const { type: originalType, ...commonRuleParams } = rule;
-                return {
-                    ...commonRuleParams,
-                    oneOf: [
-                        { type: originalType, resourceQuery: /string|inline/i },
-                        { type: "asset/resource", generator: { filename: "images/[name].[hash:8][ext]" } }
-                    ]
-                };
-            }
-        }
-        return rule;
-    });
-}
-function injectSupportForInliningSVGsAsStrings(rules) {
-    const svgRLoader = require.resolve('@svgr/webpack');
-    return rules.map(rule => {
-        if (rule && typeof rule === 'object' && "use" in rule && Array.isArray(rule.use) && (rule.use.includes('@svgr/webpack') || rule.use.includes(svgRLoader))) {
-            const { test, issuer, ...reactSpecific } = rule;
-            return { test, issuer, oneOf: [
-                    { type: 'asset/source', resourceQuery: /string/ }, // *.svg?string
-                    reactSpecific
-                ] };
-        }
-        return rule;
-    });
-}
-function buildVerifiedConfig(config) {
-    config = (0, shared_1.applyStandards)(config);
-    const { standaloneBlocks = false, stats = 'errors-warnings', variables: rawVariables, verbose = process.argv.includes('--verbose') || process.env['VERBOSE'] === 'true', postcss = {}, externals, assumeGlobalizedPlauditLibraries = true, useWebpackResourceFiltering = true, plainEntrypointsVersion = 1, srcDir = "", useUnifiedLoader = false, includePostInitFallback = false, omitDistDev = false, onlyRunPostCSSOnPCSS = false, useBlockSupportsAsThemeJsonDefaults = true, } = config;
-    let outputDir = config.outputDir ?? "";
-    if ((0, shared_1.shouldWriteDistDev)({ outputDir, useUnifiedLoader, omitDistDev })) {
-        outputDir += "-dev";
-    }
-    let srcPrefixes;
-    const trailingSlashedSrcDir = srcDir && !srcDir.endsWith("/") ? srcDir + "/" : srcDir;
-    if (config.srcPrefixes === undefined) {
-        srcPrefixes = srcDir ? [trailingSlashedSrcDir] : ["src/"];
-    }
-    else {
-        srcPrefixes = (srcDir && !config.srcPrefixes.includes(trailingSlashedSrcDir) ? [...config.srcPrefixes, trailingSlashedSrcDir] : config.srcPrefixes);
-    }
-    let targetHandlePrefix = config.targetHandlePrefix ?? config.plainEntrypointsHandlePrefix ?? "";
-    if (plainEntrypointsVersion > 1) {
-        if (!targetHandlePrefix) {
-            targetHandlePrefix = deriveDefaultHandlePrefixFromComposerJsonOrThemeName(shared_1.kebabCase) ?? "";
-            if (!targetHandlePrefix) {
-                throw new Error("Plain Entrypoints V2 and higher require either 'targetHandlePrefix' to be set or an adjacent composer.json or style.css file to be present");
-            }
-        }
-        if (!outputDir) {
-            throw new Error("Plain Entrypoints V2 and higher require 'outputDir' to be set");
-        }
-    }
-    // Only the lazyLoader emitters read this, so an absence of package metadata is not worth failing a build
-    // over: php-writer treats an empty namespace as "emit no namespace", which is what we did before 3.10.0
-    const targetNamespace = config.targetNamespace || deriveDefaultHandlePrefixFromComposerJsonOrThemeName(shared_1.camelCaseForPHPLabels, true) || "";
-    const { staticEntrypoints, dynamicEntrypoints } = (0, entrypoint_resolution_logic_1.resolveAllConfigLevelEntrypoints)(config);
-    const rawSources = [...staticEntrypoints, ...dynamicEntrypoints];
-    let variablesFilePath = undefined;
-    const currentVariables = rawVariables ?? {};
-    if (!rawVariables) {
-        variablesFilePath = ["variables.js", "src/site/variables.js"].map(p => (0, node_path_1.join)(process.cwd(), p)).filter(p => (0, node_fs_1.existsSync)(p))[0];
-    }
-    let extensionsVersion = config.extensionsVersion ?? 1;
-    if (extensionsVersion === 2) {
-        extensionsVersion = 3; // Version 3 is a backwards-compatible upgrade of version 2, so we can automatically upgrade everything
-    }
-    const cfg = {
-        currentVariables, postcss, standaloneBlocks, stats, variablesFilePath, verbose, externals, assumeGlobalizedPlauditLibraries,
-        useWebpackResourceFiltering, outputDir, extensionsVersion, plainEntrypointsVersion, srcDir, srcPrefixes, targetHandlePrefix,
-        useUnifiedLoader, includePostInitFallback, omitDistDev, onlyRunPostCSSOnPCSS, targetNamespace, useBlockSupportsAsThemeJsonDefaults
-    };
-    // Destination -> source map
-    const allocatedDestinations = {};
-    const partiallyVerifiedSources = rawSources.map(([src, config]) => {
-        const { destination, additionalDependencies = [], assumeGlobalizedPlauditLibraries = cfg.assumeGlobalizedPlauditLibraries, bundleAnalyzer = false, directoryLayout, externalize, withLegacyBlocksIn = false, lazyLoader, pathQueryParameters: rawPathQueryParameters, enqueuingFlags: rawEnqueuingFlags, locations: rawSourceLocations, } = config;
-        // This guards against a crash later on down the line due to trying to run a spread on a boolean
-        if (externalize && typeof externalize !== 'string' && typeof externalize !== 'object') {
-            throw new TypeError(`externalize must be a string, an array or an object, but "${src}" set externalize to a ${typeof externalize}`);
-        }
-        const { flags: queryEnqueuingFlags, remainder: pathQueryParameters, handle: pathQueryHandle } = (0, path_query_and_related_helpers_1.unpackEnqueuingControlFlagsFromPathQueryParameters)(rawPathQueryParameters, src, 'path query parameters');
-        const enqueuingFlags = (0, path_query_and_related_helpers_1.mergeTwoEnqueuingControlFlagSets)(src, rawEnqueuingFlags, queryEnqueuingFlags);
-        const normalizedParts = { additionalDependencies, assumeGlobalizedPlauditLibraries, bundleAnalyzer, directoryLayout, externalize, withLegacyBlocksIn, lazyLoader };
-        let locations;
-        if (pathQueryHandle === undefined) {
-            locations = typeof rawSourceLocations === 'string' || typeof rawSourceLocations === 'function' || (rawSourceLocations !== undefined && 'niceName' in rawSourceLocations)
-                ? { handle: rawSourceLocations } : rawSourceLocations ?? {};
-        }
-        else {
-            const rawSourceHandle = typeof rawSourceLocations === 'string' || typeof rawSourceLocations === 'function' || (rawSourceLocations !== undefined && 'niceName' in rawSourceLocations)
-                ? rawSourceLocations : rawSourceLocations?.handle;
-            if (rawSourceHandle === undefined) {
-                locations = { handle: pathQueryHandle };
-            }
-            else if (typeof rawSourceHandle === 'string') {
-                if (rawSourceHandle !== pathQueryHandle) {
-                    throw new ReferenceError(`Encountered mismatched handles "${rawSourceHandle}" and "${pathQueryHandle}" when preparing "${src}"`);
-                }
-                locations = { handle: pathQueryHandle };
-            }
-            else {
-                throw new ReferenceError(`Encountered a function handle and a path query handle when preparing "${src}"`);
-            }
-            // This is just a means of merging the new handle into the rawSourceLocations config without mutating the base config
-            if (rawSourceLocations !== undefined && typeof rawSourceLocations !== 'function' && typeof rawSourceLocations !== 'string') {
-                locations = { ...rawSourceLocations, ...locations };
-            }
-        }
-        if (typeof locations.registerScriptArgs === 'string' && !['lazy', 'eager', 'inline'].includes(locations.registerScriptArgs)) {
-            throw new ReferenceError("The only supported string values for registerScriptArgs are 'lazy', 'eager', and 'inline'");
-        }
-        if (destination !== undefined) {
-            const effectiveDestination = toEffectiveWebpackDestination(destination);
-            allocatedDestinations[effectiveDestination] = src; // We need to pre-populate the allocatedDestinations map with statically declared destinations
-            return [src, { ...normalizedParts, locations, destination, effectiveDestination, staticallyDeclaredDestination: true, pathQueryParameters, enqueuingFlags }];
-        }
-        else {
-            const naiveDestination = deriveNaiveDestinationFromUnverifiedSourceEntry(src, destination, srcPrefixes);
-            const effectiveDestination = toEffectiveWebpackDestination(naiveDestination);
-            return [src, { ...normalizedParts, locations, destination: naiveDestination, effectiveDestination, staticallyDeclaredDestination: false, pathQueryParameters, enqueuingFlags }];
-        }
-    });
-    const dynamicEffectiveDestinationsWithExpectedNaiveDuplicates = partiallyVerifiedSources
-        .filter(entry => !entry[1].staticallyDeclaredDestination)
-        .map(entry => entry[1].effectiveDestination)
-        .reduce((a, dest) => {
-        a[dest] = (a[dest] !== undefined); // If it's undefined, then this is the first instance, otherwise, it's not the first instance and, therefore, is expected to be a duplicate
-        return a;
-    }, {});
-    const sources = partiallyVerifiedSources
-        .map(entry => finalizeEntryDestination(entry, dynamicEffectiveDestinationsWithExpectedNaiveDuplicates, allocatedDestinations));
-    testForDuplicatedEntryPaths(sources);
-    return cfg.outputDir ? { cfg, sources } : withDerivedOutputDir(cfg, sources);
-}
-function toEffectiveWebpackDestination(destination) {
-    const pathParts = (0, node_path_1.parse)(destination);
-    return (0, node_path_1.join)(pathParts.dir, pathParts.name);
-}
-function deriveNaiveDestinationFromUnverifiedSourceEntry(src, destination, srcPrefixes) {
-    if (destination !== undefined) {
-        return destination;
-    }
-    const commaIndex = src.indexOf(',');
-    const primarySource = stripSrcPrefix(commaIndex > -1 ? src.substring(0, commaIndex).trim() : src, srcPrefixes);
-    const scriptParts = shared_1.scriptExtension.exec(primarySource);
-    if (scriptParts !== null) {
-        return `${scriptParts.groups['filename']}.js`; // filename is always defined here
-    }
-    const styleParts = shared_1.styleExtension.exec(primarySource);
-    if (styleParts !== null) {
-        return `${styleParts.groups['filename']}.css`; // filename is always defined here
-    }
-    return primarySource;
-}
-function stripSrcPrefix(src, srcPrefixes) {
-    const prefix = srcPrefixes.find(sp => src.startsWith(sp));
-    if (!prefix) {
-        return src;
-    }
-    return src[prefix.length] === '/' ? src.substring(prefix.length + 1) : src.substring(prefix.length);
-}
-function finalizeEntryDestination(entry, dynamicEffectiveDestinationsWithExpectedNaiveDuplicates, allocatedDestinations) {
-    if (entry[1].staticallyDeclaredDestination) {
-        return entry;
-    }
-    const extension = (0, node_path_1.extname)(entry[1].destination);
-    const filename = dynamicEffectiveDestinationsWithExpectedNaiveDuplicates[entry[1].effectiveDestination]
-        ? entry[1].effectiveDestination + (extension === '.css' ? "_style" : "_script")
-        : entry[1].effectiveDestination;
-    let count = 0, derivedDestination = filename + extension;
-    while (derivedDestination in allocatedDestinations && allocatedDestinations[derivedDestination] !== entry[0]) {
-        derivedDestination = `${filename}_${++count}${extension}`; // We don't want to add deduplication indexes unless absolutely necessary
-    }
-    entry[1].additionalDependencies?.sort();
-    allocatedDestinations[derivedDestination] = entry[0];
-    return [entry[0], { ...entry[1], destination: derivedDestination }];
-}
-/**
- * TODO: WTF is the bot on about here?
- * Derives a prefix from whichever piece of package metadata sits next to the config. Returns undefined
- * when there is nothing to derive from at all — a caller that cannot proceed without one says so itself,
- * because the ones that can (see `targetNamespace`) would otherwise fail builds that never needed it. A
- * file that *is* present but unusable still throws, since that is a misconfiguration rather than an absence.
- */
-function deriveDefaultHandlePrefixFromComposerJsonOrThemeName(stringTransformer, keepPlauditSep = false) {
-    let composerJson;
-    try {
-        composerJson = JSON.parse((0, node_fs_1.readFileSync)((0, node_path_1.join)(process.cwd(), "composer.json"), 'utf-8'));
-    }
-    catch {
-        // Then composer.json doesn't exist
-        return deriveDefaultHandlePrefixFromThemeName(stringTransformer);
-    }
-    if (typeof composerJson !== 'object' || typeof composerJson.name !== 'string' || !composerJson.name) {
-        throw new ReferenceError("targetHandlePrefix was not set and the adjacent composer.json file does not have a valid name in it");
-    }
-    return stringTransformer(keepPlauditSep ? composerJson.name.replace(/plaudit\/plaudit-/, 'plaudit/') : composerJson.name.replace(/plaudit\/plaudit/, 'plaudit'));
-}
-function deriveDefaultHandlePrefixFromThemeName(stringTransformer) {
-    const styleFilePath = (0, node_path_1.join)(process.cwd(), "style.css");
-    if (!(0, node_fs_1.existsSync)(styleFilePath)) {
-        // Then there is no package metadata to derive anything from
-        return undefined;
-    }
-    const styleFileContents = (0, node_fs_1.readFileSync)(styleFilePath, 'utf-8');
-    const themeName = /^\W*Theme\s*Name:\s*(.+)$/im.exec(styleFileContents)?.[1]?.trim();
-    if (!themeName) {
-        throw new ReferenceError("targetHandlePrefix was not set and the adjacent style.css file does not have a valid name in it");
-    }
-    return stringTransformer(themeName);
-}
-function withDerivedOutputDir(cfg, sources) {
-    const destinations = sources.map(([_, { destination }]) => destination.split(/[\/\\]/g));
-    if (destinations.length < 2) {
-        return { cfg, sources };
-    }
-    const commonParent = destinations[0][0];
-    for (const destination of destinations) {
-        if (destination[0] !== commonParent) {
-            return { cfg, sources };
-        }
-    }
-    return {
-        cfg: { ...cfg, outputDir: commonParent },
-        sources: sources.map(([src, dest]) => {
-            return [src, { ...dest, destination: dest.destination.substring(commonParent.length + 1) }];
-        })
-    };
-}
-let forkTsCheckerInstalled = false;
-function isTypeScriptSourceFile(file) {
-    return /\.[cm]?tsx?$/i.test(file.split('?')[0] ?? '');
-}
-const prefixes = ['c', 'm', ''];
-const suffixes = ['x', ''];
-const tsExtensions = prefixes.map(prefix => prefix + "ts").flatMap(name => suffixes.map(suffix => name + suffix));
-function handleDisablingTSCheckerIfNecessary(srcRoot, scriptExtension, plugins) {
-    if (process.env["NO_TS_CHECKER"] === "true" || forkTsCheckerInstalled) {
-        return;
-    }
-    const include = [];
-    for (const sr of (Array.isArray(srcRoot) ? srcRoot : [srcRoot])) {
-        if ((0, node_path_1.extname)(sr).length === 0) {
-            include.push(...tsExtensions.map(tsExt => (0, node_path_1.join)(sr, "**", `*.${tsExt}`)));
-        }
-        else if ((0, shared_1.scriptOrStyleTest)(sr, scriptExtension) === "script") {
-            include.push(sr);
-        }
-    }
-    if (include.length === 0) {
-        return;
-    }
-    forkTsCheckerInstalled = true;
-    let logTsStatus = true;
-    plugins.push({
-        apply(compiler) {
-            compiler.hooks.watchRun.tap('PlauditForkTsCheckerCssQuiet', watchingCompiler => {
-                const changed = [
-                    ...(watchingCompiler.modifiedFiles ?? []),
-                    ...(watchingCompiler.removedFiles ?? [])
-                ];
-                logTsStatus = changed.length === 0 || changed.some(isTypeScriptSourceFile);
-            });
-        }
-    });
-    plugins.push(new fork_ts_checker_webpack_plugin_1.default({
-        async: true,
-        logger: {
-            log(message) {
-                if (!logTsStatus) {
-                    return;
-                }
-                console.log(message);
-            },
-            error(message) {
-                console.error(message);
-            }
-        },
-        typescript: {
-            diagnosticOptions: {
-                semantic: true,
-                syntactic: true,
-            },
-            configOverwrite: {
-                include,
-                compilerOptions: {
-                    skipLibCheck: true
-                }
-            }
-        },
-        issue: {
-            exclude(issue) {
-                return issue.code === 'TS18003';
-            }
-        }
-    }));
-}
-function buildCommonPluginConfig(webpackConfig, config, bundleAnalyzer, assumeGlobalizedPlauditLibraries, externalize) {
-    const plugins = webpackConfig.plugins?.filter(v => !!v)
-        .filter(plugin => plugin.constructor.name !== 'RtlCssPlugin')
-        .filter(plugin => plugin.constructor.name !== 'CopyPlugin' && plugin.constructor.name !== 'CleanWebpackPlugin')
-        .map(plugin => {
-        if (plugin.constructor.name === 'MiniCssExtractPlugin') {
-            return new plugin.constructor({
-                filename(pd) {
-                    const name = pd.chunk?.name?.replaceAll(/__[a-zA-Z0-9]+__/g, ""); // This removes the prefix that the cache group adds
-                    return name ? `${name}.css` : "[name].css";
-                }
-            });
-        }
-        return plugin;
-    })
-        ?? [];
-    plugins.splice(0, 0, new PackageConfigSanityChecker_1.PackageConfigSanityChecker());
-    if (bundleAnalyzer) {
-        plugins.splice(0, 0, new (require("webpack-bundle-analyzer").BundleAnalyzerPlugin)({ analyzerMode: 'static', openAnalyzer: bundleAnalyzer !== 'no-auto-open' }));
-    }
-    const removeEmptyScriptsPlugin = new webpack_remove_empty_scripts_1.default({
-        stage: webpack_remove_empty_scripts_1.default.STAGE_AFTER_PROCESS_PLUGINS,
-        extensions: ['css', 'scss', 'sass', 'less', 'styl', 'pcss'],
-        ignore: /block\.json/
-    });
-    plugins.push(removeEmptyScriptsPlugin, new MiniCSSExtractPluginErrorCleaner_1.MiniCSSExtractPluginErrorCleaner());
-    if (config.useWebpackResourceFiltering) {
-        plugins.push(new SpecialAssetHandlingPlugin_1.SpecialAssetHandlingPlugin(config));
-    }
-    plugins.push(new VariablesJSMonitorPlugin_1.VariablesJSMonitorPlugin(config));
-    // We have to use constructor.name here the version desyncs can result in multiple equivalent versions kicking around
-    const dependencyExtractionPluginIndex = plugins.findIndex(plugin => plugin.constructor.name === 'DependencyExtractionWebpackPlugin');
-    if (dependencyExtractionPluginIndex === -1) {
-        console.error((0, shared_1.dedent) `
-			Unable to find the DependencyExtractionWebpackPlugin.
-			If this is your first time seeing this error, please run: pnpm up && pnpm dedupe && pnpm up
-			Once those commands have finished, re-run whichever command had this error. If it still doesn't work, report the issue immediately.
-			`);
-        console.error("Once those commands have finished, re-run whichever command had this error. If it still doesn't work, report the issue immediately.");
-        throw new Error("Cannot apply externals when they have been disabled via CLI flag. This will greatly increase bundle size and will likely cause the build to fail");
-    }
-    const builtDependencyExtractionWebpackPlugin = (0, dependency_extraction_webpack_plugin_config_builder_1.makeDependencyExtractionPlugin)(config.externals, assumeGlobalizedPlauditLibraries, externalize);
-    plugins[dependencyExtractionPluginIndex] = builtDependencyExtractionWebpackPlugin;
-    try {
-        const { PlauditDevPlugin } = require("@plaudit/dev-webpack-plugin");
-        plugins.push(new PlauditDevPlugin(config));
-    }
-    catch { }
-    return {
-        plugins, removeEmptyScriptsPlugin,
-        makeAdditionalDependencyInjectorPlugin(referencePlugin) {
-            return new AdditionalDependencyInjectorPlugin_1.AdditionalDependencyInjectorPlugin(webpackConfig.output?.module, builtDependencyExtractionWebpackPlugin.addExternalizedDep, referencePlugin);
-        }
-    };
-}
-function commonConfigProcessingPrep(config, webpackConfig) {
-    let scriptExtension; // This is only used in non-block contexts. It might not actually be necessary, but it is good to have
-    let entrypointFields;
-    const processingModules = webpackConfig.output?.module ?? false;
-    if (processingModules) {
-        scriptExtension = shared_1.scriptWithModuleExtension;
-        entrypointFields = ["viewScriptModule"];
-    }
-    else {
-        scriptExtension = shared_1.scriptWithoutModuleExtension;
-        entrypointFields = ["editorStyle", "viewStyle", "style", "editorScript", "viewScript", "script"];
-    }
-    let currentVariables = config.currentVariables;
-    const fixedRules = [
-        replaceDefaultURLProcessing(config.useWebpackResourceFiltering),
-        (rules) => {
-            return injectPostcssConfigOverrides(rules, config, name => currentVariables[name], config.postcss.functions ?? (() => ({})));
-        },
-        injectSupportForInliningSVGsAsStrings
-    ].reduce((r, a) => a(r), webpackConfig.module?.rules ?? []);
-    fixedRules.push({
-        test: /wpml-config\.xml$/i,
-        type: 'asset/resource',
-        generator: {
-            filename: '[name][ext]',
-            emit: false
-        }
-    });
-    return {
-        entrypointFields, fixedRules, processingModules, scriptExtension,
-        updateCurrentVariables: (value) => currentVariables = value
-    };
-}
-function destToKey(dest) {
-    const externalize = typeof dest.externalize === 'object' && dest.externalize !== undefined
-        ? (Array.isArray(dest.externalize) ? dest.externalize.join("_") : (dest.externalize ? Object.entries(dest.externalize).flat().sort().join() : "undefined"))
-        : dest.externalize?.toString() ?? "undefined";
-    return [dest.assumeGlobalizedPlauditLibraries, dest.bundleAnalyzer, externalize].join("~");
-}
-function processIndividualWebpackConfig(config, webpackConfig, sources, canClean, preferNonModuleTsChecker) {
-    if (webpackConfig.output?.module) {
-        // This ensures that module files are emitted as module files
-        webpackConfig = {
-            ...webpackConfig,
-            output: {
-                ...webpackConfig.output,
-                filename: '[name].mjs',
-                chunkFilename: '[name].mjs?ver=[chunkhash]',
-            }
-        };
-    }
-    const commonConfig = commonConfigProcessingPrep(config, webpackConfig);
-    const { processingModules, scriptExtension } = commonConfig;
-    const allSrcRoots = sources.map(([src, dest]) => {
-        const srcRoots = (dest.withLegacyBlocksIn
-            ? [...src.split(','), ...(0, shared_1.resolveLegacyBlockScriptsInFolder)((0, node_path_1.join)(config.srcDir, dest.withLegacyBlocksIn))]
-            : src.split(',')).filter(s => s.endsWith(".json") || !s.substring(s.lastIndexOf('/')).includes('.') || processingModules === shared_1.scriptWithModuleExtension.test(s));
-        const srcRoot = srcRoots.length < 2 ? (0, common_config_helpers_1.joinPossiblyAbsolutePaths)(process.cwd(), src) : srcRoots.map(s => (0, common_config_helpers_1.joinPossiblyAbsolutePaths)(process.cwd(), s));
-        const srcIsDirectory = !Array.isArray(srcRoot) && (0, node_fs_1.lstatSync)(srcRoot, { throwIfNoEntry: false })?.isDirectory();
-        if (srcIsDirectory === undefined) {
-            return undefined;
-        }
-        return { srcRoots, src, dest, srcRoot, srcIsDirectory };
-    }).filter(a => a !== undefined);
-    const groupedSrcRoots = {};
-    for (const entry of allSrcRoots) {
-        const key = destToKey(entry.dest);
-        (groupedSrcRoots[key] ?? (groupedSrcRoots[key] = [])).push(entry);
-    }
-    const batches = Object.values(groupedSrcRoots).filter(shared_1.hasAtLeastOneItem);
-    return batches.map(currentBatch => {
-        const { bundleAnalyzer, assumeGlobalizedPlauditLibraries, externalize } = currentBatch[0].dest;
-        const { plugins, removeEmptyScriptsPlugin, makeAdditionalDependencyInjectorPlugin } = buildCommonPluginConfig(webpackConfig, config, bundleAnalyzer, assumeGlobalizedPlauditLibraries, externalize);
-        if (!processingModules || !preferNonModuleTsChecker) {
-            handleDisablingTSCheckerIfNecessary(currentBatch.flatMap(a => a.srcRoots), scriptExtension, plugins);
-        }
-        const applicableExtensionTest = (name) => {
-            return commonConfig.scriptExtension.test(name) || (!processingModules && shared_1.styleExtension.test(name));
-        };
-        const contextPath = webpackConfig.context ?? process.cwd();
-        for (const { dest, src, srcIsDirectory, srcRoot } of currentBatch) {
-            let plugin;
-            const sourceType = (0, shared_1.determineCurrentSourceType)(dest, srcIsDirectory);
-            if (sourceType === "blocks" /* SourceType.blocks */) {
-                if (!srcIsDirectory) {
-                    continue;
-                }
-                plugin = new EnhancedBlockJSONPlugin_1.EnhancedBlockJSONPlugin(config, dest, removeEmptyScriptsPlugin, contextPath, (0, common_config_helpers_1.resolveEntryFromDirectory)(commonConfig, srcRoot, dest));
-                plugins.push(plugin);
-                if (!processingModules) {
-                    plugins.push(new WPMLConfigBuilder_1.WPMLConfigBuilderPlugin(dest.destination, plugin));
-                }
-            }
-            else if (sourceType === "extensions" /* SourceType.extensions */) {
-                if (!srcIsDirectory) {
-                    continue;
-                }
-                const entry = async () => {
-                    const rawEntrypoints = [];
-                    for await (const dirent of await (0, promises_1.opendir)(srcRoot)) {
-                        if ((0, shared_1.shouldBeSkipped)(dirent.name)) {
-                            continue;
-                        }
-                        if (dirent.isFile()) {
-                            if (applicableExtensionTest(dirent.name)) {
-                                const absoluteSrc = (0, common_config_helpers_1.joinPossiblyAbsolutePaths)(srcRoot, dirent.name);
-                                const extensionId = (0, node_path_1.parse)(dirent.name).name;
-                                rawEntrypoints.push([(0, node_path_1.join)(dest.destination, (0, node_path_1.basename)(absoluteSrc, (0, node_path_1.extname)(absoluteSrc))), {
-                                        import: [absoluteSrc],
-                                        plauditMetadata: { dest, absoluteSrc, extensionId }
-                                    }]);
-                            }
-                        }
-                        else if (dirent.isDirectory()) {
-                            rawEntrypoints.push(...await walkExtensionsTree((0, node_path_1.join)(srcRoot, dirent.name), dest, applicableExtensionTest, [dirent.name]));
-                        }
-                    }
-                    return Object.fromEntries(rawEntrypoints);
-                };
-                plugin = config.extensionsVersion > 1
-                    ? new ExtensionsConfigFileGeneratorPlugin_1.ExtensionsConfigFileGeneratorPlugin(config, srcRoot, dest, contextPath, entry)
-                    : new ExtensionsConfigFileGeneratorPluginV1_1.ExtensionsConfigFileGeneratorPluginV1(dest.destination, contextPath, entry);
-                plugins.push(plugin);
-            }
-            else if (sourceType === "plain" /* SourceType.plain */) {
-                const absoluteSrc = typeof srcRoot === 'string' ? srcRoot : srcRoot[0];
-                if (!srcIsDirectory && !applicableExtensionTest(absoluteSrc)) {
-                    continue;
-                }
-                const baseDest = stripExtension(dest.destination);
-                if (config.plainEntrypointsVersion > 1) {
-                    const entry = srcIsDirectory // This being true implies that srcRoot is not an array
-                        ? (0, common_config_helpers_1.resolveEntryFromDirectory)(commonConfig, srcRoot, dest)
-                        : () => ({ [baseDest]: { import: Array.isArray(srcRoot) ? srcRoot : [srcRoot], plauditMetadata: { purpose: "plain-entrypoint", dest, absoluteSrc } } });
-                    plugin = new PlainEntrypointsConfigFileGeneratorPlugin_1.PlainEntrypointsConfigFileGeneratorPlugin(config, process.cwd(), config.outputDir, dest, config.useUnifiedLoader, contextPath, entry);
-                }
-                else {
-                    if (srcIsDirectory) {
-                        console.error("Using directory mode with legacy plain entrypoint handling is not supported");
-                        continue;
-                    }
-                    plugin = new EnhancedDynamicEntryPlugin_1.EnhancedDynamicEntryPlugin(contextPath, () => ({ [baseDest]: { import: Array.isArray(srcRoot) ? srcRoot : [srcRoot], plauditMetadata: { purpose: "plain-entrypoint", dest, absoluteSrc } } }));
-                }
-                plugins.push(plugin);
-            }
-            else {
-                console.error("Unrecognized sourceType");
-                continue;
-            }
-            plugins.push(makeAdditionalDependencyInjectorPlugin(plugin));
-            const canCopyFiles = srcIsDirectory && src !== dest.destination;
-            if (canCopyFiles) {
-                plugins.push(new copy_webpack_plugin_1.default({
-                    patterns: [{
-                            from: config.standaloneBlocks ? '**/*.(php|twig|svg)' : '**/*.(asset\.php|svg)', //TODO: I'm pretty sure that the dots need proper escaping
-                            to: dest.destination,
-                            context: srcRoot /* canCopyFiles can only be true if srcRoot is a string, so this is safe  */, noErrorOnMissing: true
-                        }]
-                }));
-            }
-        }
-        plugins.push(new UnifiedLoaderGenerator_1.UnifiedLoaderGenerator(config));
-        return (0, common_config_helpers_1.commonMakeWebpackConfig)(config, commonConfig, webpackConfig, externalize, plugins, canClean && batches.length < 2);
-    }).filter(cfg => cfg !== undefined);
-}
-async function walkExtensionsTree(srcRoot, dest, applicableExtensionTest, parents) {
-    const res = [];
-    for await (const dirent of await (0, promises_1.opendir)(srcRoot)) {
-        if ((0, shared_1.shouldBeSkipped)(dirent.name)) {
-            continue;
-        }
-        if (dirent.isFile()) {
-            if (!applicableExtensionTest(dirent.name)) {
-                continue;
-            }
-            const parsedFilename = (0, location_encoding_filename_parser_1.parseLocationEncodingFilename)(dirent.name);
-            if (parsedFilename === undefined) {
-                continue;
-            }
-            const absoluteSrc = (0, common_config_helpers_1.joinPossiblyAbsolutePaths)(srcRoot, dirent.name);
-            let destFile;
-            if (Object.keys(parsedFilename.locations).length === 1) {
-                if (parsedFilename.locations.clientView) {
-                    destFile = `view-${parsedFilename.type}`;
-                }
-                else if (parsedFilename.locations.clientEditor) {
-                    destFile = `editor-${parsedFilename.type}`;
-                }
-                else {
-                    destFile = (0, node_path_1.basename)(absoluteSrc, (0, node_path_1.extname)(absoluteSrc));
-                }
-            }
-            else {
-                destFile = (0, node_path_1.basename)(absoluteSrc, (0, node_path_1.extname)(absoluteSrc));
-            }
-            const extensionId = parents.join("-") + "-" + destFile;
-            res.push([(0, node_path_1.join)(dest.destination, ...parents, destFile), {
-                    import: [absoluteSrc],
-                    plauditMetadata: { dest, absoluteSrc, extensionId }
-                }]);
-        }
-        else if (dirent.isDirectory()) {
-            res.push(...await walkExtensionsTree((0, node_path_1.join)(srcRoot, dirent.name), dest, applicableExtensionTest, [...parents, dirent.name]));
-        }
-    }
-    return res;
-}
-function stripExtension(filepath) {
-    return (0, node_path_1.join)((0, node_path_1.dirname)(filepath), (0, node_path_1.basename)(filepath, (0, node_path_1.extname)(filepath)));
-}
-module.exports = function (config, webpackConfig = require("@wordpress/scripts/config/webpack.config")) {
-    const { cfg, sources } = buildVerifiedConfig(config);
-    if (Array.isArray(webpackConfig) && (0, shared_1.arrayIsLength)(webpackConfig, 1)) {
-        webpackConfig = webpackConfig[0];
-    }
-    if (Array.isArray(webpackConfig)) {
-        const hasNonModuleCompiler = webpackConfig.some(cfg => !cfg.output?.module);
-        return webpackConfig.toSorted((a, b) => {
-            if (a.output?.module) {
-                return b.output?.module ? 0 : -1;
-            }
-            return b.output?.module ? 1 : 0;
-        }).flatMap(wpCfg => processIndividualWebpackConfig(cfg, wpCfg, sources, false, hasNonModuleCompiler));
-    }
-    return processIndividualWebpackConfig(cfg, webpackConfig, sources, true, false);
-};