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

package/dist/plugins/RootCoordinatorPluginImpl.js

@@ -0,0 +1,767 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RootCoordinatorPluginImpl = void 0;
+exports.canMergeHandles = canMergeHandles;
+const node_crypto_1 = require("node:crypto");
+const node_path_1 = require("node:path");
+const php_writer_1 = require("@plaudit/php-writer");
+const webpack_1 = require("webpack");
+const api_1 = require("../api");
+const shared_1 = require("../shared");
+const utils_1 = require("../utils");
+/**
+ * NOTE: You MUST use a SINGLE instance of this plugin across all compilers (both module and non-module) in order for things to work correctly
+ */
+class RootCoordinatorPluginImpl {
+    /**
+     * Maps from the path to the coordinated asset to a mapping of plugin -> available data. False means that the plugin should be providing data
+     */
+    coordinatedEmitterData = Object.create(null);
+    compiledAssets = new Map();
+    // This is kept separate to allow us to avoid recomputing handles on every change
+    internalHandlesCache = undefined;
+    // This is what gets passed to logic that emits files like blockdir-loader.php
+    unifiedAssetsCache = undefined;
+    isStaticallyLoadedByEmitterName = Object.create(null);
+    constructor() { }
+    enableAssetPhpFileEmission(coordinatedLoaderName) {
+        this.isStaticallyLoadedByEmitterName[coordinatedLoaderName] = true;
+    }
+    apply(compiler) {
+        compiler.hooks.thisCompilation.tap(this.constructor.name, compilation => {
+            const priorCompiledAssets = this.compiledAssets.get(compiler)?.value ?? Object.create(null);
+            const insertionTarget = (0, shared_1.promiseWithResolversAndValue)();
+            this.compiledAssets.set(compiler, insertionTarget);
+            compilation.hooks.processAssets.tapPromise({ name: this.constructor.name, stage: webpack_1.Compilation.PROCESS_ASSETS_STAGE_REPORT + 1000 }, async () => {
+                const assetsJson = (0, shared_1.getAssetsJson)(compilation);
+                let isDifferent = false;
+                const existingEntryOptions = priorCompiledAssets;
+                const entryOptions = Object.create(null);
+                for (const entrypoint of compilation.entrypoints.values()) {
+                    const plauditOptions = (0, api_1.getPlauditEntryOptions)(entrypoint);
+                    if (!plauditOptions) {
+                        continue;
+                    }
+                    const entrypointChunkIsScript = api_1.isScriptExtensionRegex.test(plauditOptions.absoluteSrc);
+                    for (const chunk of entrypoint.chunks) {
+                        for (const file of chunk.files) {
+                            const isScript = api_1.isScriptExtensionRegex.test(file);
+                            const isPrimary = isScript === entrypointChunkIsScript ? 1 : 0; //TODO: Confirm that this is correct (ex: auxiliary CSS files should not be primary)
+                            const assetData = assetsJson[file] ?? assetsJson[file.replace(/\.css$/, ".js")]; //TODO: Confirm that assuming all files we need to emit will be in assets.json won't cause issues
+                            if (assetData && (entrypointChunkIsScript || !isScript)) {
+                                //TODO: Fix fetchpriority for CSS files - it currently attempts to write an array to the $media property, which is incorrect
+                                let scriptArgsObject;
+                                if (isScript) {
+                                    if (plauditOptions.flags.strategy !== undefined) {
+                                        scriptArgsObject = { strategy: plauditOptions.flags.strategy };
+                                    }
+                                    if (plauditOptions.flags.in_footer !== undefined) {
+                                        (scriptArgsObject ??= {}).in_footer = plauditOptions.flags.in_footer;
+                                    }
+                                    if (isPrimary && assetData.module_dependencies?.length) {
+                                        (scriptArgsObject ??= {}).module_dependencies = assetData.module_dependencies;
+                                    }
+                                    if (plauditOptions.flags.fetchpriority !== undefined) {
+                                        (scriptArgsObject ??= {}).fetchpriority = plauditOptions.flags.fetchpriority;
+                                    }
+                                }
+                                const type = isPrimary ? plauditOptions.type : (0, api_1.getAssetType)(file);
+                                if (!type) {
+                                    continue;
+                                }
+                                const options = {
+                                    isPrimary,
+                                    finalizedHandleMetadata: {
+                                        src: file,
+                                        dependencies: isPrimary ? assetData.dependencies : [],
+                                        version: assetData.version,
+                                        scriptArgsObject,
+                                    },
+                                    options: plauditOptions,
+                                    type
+                                };
+                                if (plauditOptions.flags.inline ?? plauditOptions.mayInline?.(file, plauditOptions) ?? false) {
+                                    options.finalizedHandleMetadata.contents = compilation.getAsset(file)?.source.source().toString('utf-8') ?? "";
+                                    if (!(plauditOptions.writeToDisk?.(file, plauditOptions) ?? false)) {
+                                        compilation.deleteAsset(file);
+                                    }
+                                }
+                                else if (!(plauditOptions.writeToDisk?.(file, plauditOptions) ?? true)) {
+                                    compilation.deleteAsset(file);
+                                }
+                                entryOptions[file] = options;
+                                if (!isDifferent) {
+                                    const eeo = existingEntryOptions[file];
+                                    if (eeo === undefined ||
+                                        eeo.options.absoluteSrc !== plauditOptions.absoluteSrc) {
+                                        isDifferent = true;
+                                    }
+                                    else {
+                                        const eeoInitialHandleName = eeo.options.initialHandleName;
+                                        const newInitialHandleName = plauditOptions.initialHandleName;
+                                        if (newInitialHandleName === false) {
+                                            if (eeoInitialHandleName !== false) {
+                                                isDifferent = true;
+                                            }
+                                        }
+                                        else if (eeoInitialHandleName === false ||
+                                            eeoInitialHandleName.handle !== newInitialHandleName.handle ||
+                                            eeoInitialHandleName.derivation !== newInitialHandleName.derivation) {
+                                            isDifferent = true;
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+                if (isDifferent || Object.keys(entryOptions).length !== Object.keys(existingEntryOptions).length) { // The length check also takes care of "in prior but not in current"-like differences
+                    this.internalHandlesCache = undefined; // Recomputing this is expensive
+                }
+                this.unifiedAssetsCache = undefined; // Recomputing this is relatively cheap
+                insertionTarget.resolve(entryOptions);
+            });
+            compilation.hooks.afterProcessAssets.tap(this.constructor.name, () => {
+                const rawStaticallyLoadedEntrypoints = [];
+                for (const entrypoint of compilation.entrypoints.values()) {
+                    const options = (0, api_1.getPlauditEntryOptions)(entrypoint);
+                    if (options?.staticallyLoaded ?? (options?.coordinatedLoaderName === undefined || !this.isStaticallyLoadedByEmitterName[options.coordinatedLoaderName])) {
+                        rawStaticallyLoadedEntrypoints.push(...entrypoint.getEntrypointChunk().files);
+                    }
+                }
+                const staticallyLoadedEntrypoints = new Set(rawStaticallyLoadedEntrypoints);
+                for (const [file, assetData] of Object.entries((0, shared_1.getAssetsJson)(compilation))) {
+                    if (staticallyLoadedEntrypoints.has(file) || !compilation.getAsset(file)) {
+                        continue;
+                    }
+                    if (file.endsWith(".css") && staticallyLoadedEntrypoints.has(file.slice(0, -4) + ".js")) {
+                        continue;
+                    }
+                    if (file.endsWith(".js") && staticallyLoadedEntrypoints.has(file.slice(0, -3) + ".css")) {
+                        continue;
+                    }
+                    const parsedPath = (0, node_path_1.parse)(file);
+                    const contents = `<?php return ${(0, php_writer_1.json2php)(assetData)};\n`;
+                    const assetName = (0, node_path_1.join)(parsedPath.dir, parsedPath.name) + ".asset.php";
+                    compilation[assetName in compilation.assets ? 'updateAsset' : 'emitAsset'](assetName, new webpack_1.sources.RawSource(contents), { size: Buffer.byteLength(contents) });
+                }
+                compilation.deleteAsset("assets.json");
+            });
+        });
+        compiler.hooks.shutdown.tap(this.constructor.name, () => {
+            this.compiledAssets.delete(compiler);
+            for (const map of Object.values(this.coordinatedEmitterData)) {
+                map.delete(compiler);
+            }
+            this.internalHandlesCache = undefined;
+            this.unifiedAssetsCache = undefined;
+        });
+    }
+    registerDataEmitter(compiler, emitter, ...emissionTargets) {
+        if (emissionTargets.length === 0) {
+            return;
+        }
+        compiler.hooks.thisCompilation.tap(`${this.constructor.name}_EmittedDataCleaner`, () => {
+            for (const emissionTarget of emissionTargets) {
+                const items = (this.coordinatedEmitterData[emissionTarget] ??= new Map())
+                    .getOrInsert(compiler, new Map());
+                items.set(emitter, false);
+            }
+        });
+    }
+    reportData(compilation, emitter, emissionTarget, data) {
+        const map = this.coordinatedEmitterData[emissionTarget]?.get(compilation.compiler);
+        if (map?.has(emitter)) {
+            map.set(emitter, data);
+        }
+        else {
+            (0, utils_1.emitError)(`Attempted to report data from an emitter to "${emissionTarget}" that was not pre-registered`, { compilation });
+        }
+    }
+    async getCompiledAssets() {
+        const res = {};
+        for (const compiledAssetsSegment of await Promise.all(this.compiledAssets.values().map(v => v.promise))) {
+            for (const [key, value] of Object.entries(compiledAssetsSegment)) {
+                if (res[key]) {
+                    (0, utils_1.emitError)("Encountered a duplicate compilation request for file", { rawIdentifier: key });
+                }
+                res[key] = value;
+            }
+        }
+        return res;
+    }
+    /**
+     * This MUST NOT be called from within plugins associated with compilers that produce basic assets
+     *
+     * @param compilation
+     */
+    async getHandles(compilation) {
+        if (this.internalHandlesCache === undefined) {
+            const allTypeGroupedHandlesItems = [];
+            const combinedCompiledAssets = await this.getCompiledAssets();
+            for (const [asset, { options, isPrimary, finalizedHandleMetadata, type }] of Object.entries(combinedCompiledAssets)) {
+                const { initialHandleName } = options;
+                if (initialHandleName) {
+                    const use = { asset, ...initialHandleName, isPrimary, options, finalizedHandleMetadata, type, originalHandle: initialHandleName.handle };
+                    allTypeGroupedHandlesItems.push(use);
+                }
+            }
+            let isFirstPass = true;
+            let handlesNeedingFallbackNameApplication = [];
+            do {
+                if (handlesNeedingFallbackNameApplication.length > 0) {
+                    for (const use of handlesNeedingFallbackNameApplication) {
+                        const res = use.fallbackHandleProducer?.();
+                        delete use.fallbackHandleProducer;
+                        if (res !== undefined) {
+                            use.originalHandle = use.handle = res.handle;
+                            use.fallbackHandleProducer = res.fallbackHandleProducer;
+                            use.derivation = res.derivation;
+                            if (use.associatedAssets) {
+                                for (const aa of use.associatedAssets) {
+                                    if (aa.associationMechanism === 'merged') {
+                                        use.originalHandle = aa.handle = res.handle;
+                                        aa.fallbackHandleProducer = res.fallbackHandleProducer;
+                                        aa.derivation = res.derivation;
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+                handlesNeedingFallbackNameApplication = [];
+                const typeGroupedHandles = {
+                    script: {},
+                    script_module: {},
+                    style: {},
+                };
+                for (const use of allTypeGroupedHandlesItems) {
+                    const { type, originalHandle } = use;
+                    const existing = typeGroupedHandles[type][originalHandle];
+                    if (existing) {
+                        existing.push(use);
+                    }
+                    else {
+                        typeGroupedHandles[type][originalHandle] = [use];
+                    }
+                }
+                const remainingHopefullyModifiableHandles = {
+                    script: {},
+                    script_module: {},
+                    style: {},
+                };
+                const usedHandlesForFancyPrinting = {
+                    script: new Map(),
+                    script_module: new Map(),
+                    style: new Map(),
+                };
+                for (const [type, handleGroups] of (0, utils_1.constantEntries)(typeGroupedHandles)) {
+                    for (const [handleName, uncondensedUses] of Object.entries(handleGroups).sort(([a], [b]) => a.localeCompare(b))) {
+                        let uses;
+                        if (uncondensedUses.length === 1 || !uncondensedUses.some(u => u.options.flags.inline !== undefined)) {
+                            uses = uncondensedUses;
+                        }
+                        else {
+                            const tempUses = [];
+                            const usesByParentDirectory = {};
+                            for (const use of uncondensedUses) {
+                                (usesByParentDirectory[(0, node_path_1.dirname)(use.options.absoluteSrc)] ??= []).push(use);
+                            }
+                            for (const potentiallyCollatableUses of Object.values(usesByParentDirectory)) {
+                                if (isFirstPass) {
+                                    const nonInlinedUses = potentiallyCollatableUses.filter(use => use.options.flags.inline === undefined);
+                                    if ((0, utils_1.arrayIsLength)(nonInlinedUses, 1)) {
+                                        const primaryUse = nonInlinedUses[0];
+                                        tempUses.push(primaryUse);
+                                        for (const inlinedUse of potentiallyCollatableUses.filter(use => use.options.flags.inline !== undefined)) {
+                                            const mechanism = canMergeHandles(primaryUse, inlinedUse);
+                                            inlinedUse.associationMechanism = mechanism;
+                                            if (mechanism === 'merged') {
+                                                inlinedUse.omitRegistration = true;
+                                                (primaryUse.associatedAssets ??= []).push(inlinedUse);
+                                            }
+                                            else {
+                                                if (mechanism) {
+                                                    (primaryUse.associatedAssets ??= []).push(inlinedUse);
+                                                }
+                                                tempUses.push(inlinedUse);
+                                            }
+                                        }
+                                    }
+                                    else {
+                                        tempUses.push(...potentiallyCollatableUses);
+                                    }
+                                }
+                                else {
+                                    tempUses.push(...potentiallyCollatableUses.filter(use => use.associationMechanism !== 'merged'));
+                                }
+                            }
+                            if (!(0, utils_1.hasAtLeastOneItem)(tempUses)) {
+                                continue;
+                            }
+                            uses = tempUses;
+                        }
+                        if (uses.length === 1) {
+                            checkAndApplyOrEnqueueHandleNameInstances(compilation, usedHandlesForFancyPrinting, remainingHopefullyModifiableHandles, type, handleName, uses);
+                        }
+                        else {
+                            const unmodifiable = [];
+                            const modifiable = [];
+                            for (const use of uses) {
+                                if ((0, api_1.handleCannotBeModifiedForConflictAvoidance)(use)) {
+                                    unmodifiable.push(use);
+                                }
+                                else {
+                                    modifiable.push(use);
+                                }
+                            }
+                            if ((0, utils_1.hasAtLeastOneItem)(unmodifiable)) {
+                                checkAndApplyOrEnqueueHandleNameInstances(compilation, usedHandlesForFancyPrinting, remainingHopefullyModifiableHandles, type, handleName, unmodifiable);
+                            }
+                            if ((0, utils_1.hasAtLeastOneItem)(modifiable)) {
+                                const batch = remainingHopefullyModifiableHandles[type][handleName];
+                                if (batch) {
+                                    batch.push(...modifiable);
+                                }
+                                else {
+                                    remainingHopefullyModifiableHandles[type][handleName] = [...modifiable];
+                                }
+                            }
+                        }
+                    }
+                }
+                // This applies deduping logic to hooks that were either generated (aka not user-specified) or that we have no choice but to dedupe.
+                // It doesn't do any further checking because that has already been done in the prior steps
+                const usedHandles = {
+                    script: new Set(usedHandlesForFancyPrinting.script.keys()),
+                    script_module: new Set(usedHandlesForFancyPrinting.script_module.keys()),
+                    style: new Set(usedHandlesForFancyPrinting.style.keys()),
+                };
+                const firstOfEachUsedHandle = {
+                    script: {},
+                    script_module: {},
+                    style: {},
+                };
+                for (const [type, handleGroups] of (0, utils_1.constantEntries)(remainingHopefullyModifiableHandles)) {
+                    for (const [handleName, uses] of Object.entries(handleGroups).sort(([a], [b]) => a.localeCompare(b))) {
+                        let dedupedHandle, count = 0;
+                        for (const use of uses.sort(compareTypeGroupedHandlesItems)) {
+                            if (!usedHandles[type].has(handleName)) {
+                                dedupedHandle = handleName;
+                            }
+                            else {
+                                if (firstOfEachUsedHandle[type][handleName]?.fallbackHandleProducer) {
+                                    handlesNeedingFallbackNameApplication.push(firstOfEachUsedHandle[type][handleName]);
+                                    delete firstOfEachUsedHandle[type][handleName];
+                                }
+                                if (use.fallbackHandleProducer !== undefined) {
+                                    handlesNeedingFallbackNameApplication.push(use);
+                                    continue;
+                                }
+                                do {
+                                    count++;
+                                } while (usedHandles[type].has(dedupedHandle = `${handleName}-${count}`));
+                            }
+                            usedHandles[type].add(dedupedHandle);
+                            firstOfEachUsedHandle[type][dedupedHandle] ??= use;
+                            use.handle = dedupedHandle;
+                            if (use.associatedAssets) {
+                                for (const associated of use.associatedAssets) {
+                                    if (associated.associationMechanism === 'merged') {
+                                        associated.handle = dedupedHandle;
+                                        associated.omitRegistration = true;
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+                isFirstPass = false;
+            } while (handlesNeedingFallbackNameApplication.length > 0);
+            const internalHandlesCache = Object.create(null);
+            const unifiedAssetsCache = Object.create(null);
+            const buildUnifiedAssetsCacheEntry = (item) => {
+                const { asset, associatedAssets, associationMechanism, finalizedHandleMetadata, handle, omitRegistration, options, type } = item;
+                if (handle === undefined) {
+                    throw (0, utils_1.newWebpackErrorForFile)("Encountered a TypeGroupedHandlesItem instance that was not compatible with the CachedHandleData type", asset);
+                }
+                let res = unifiedAssetsCache[asset];
+                if (res === undefined) {
+                    res = unifiedAssetsCache[asset] = {
+                        handle,
+                        omitRegistration,
+                        associationMechanism,
+                        finalizedHandleMetadata,
+                        options,
+                        type,
+                    };
+                    if (associatedAssets) {
+                        res.associatedAssets = associatedAssets.map(buildUnifiedAssetsCacheEntry);
+                    }
+                }
+                return res;
+            };
+            for (const use of allTypeGroupedHandlesItems) {
+                const { associatedAssets, handle, ...rest } = use;
+                if (handle === undefined) {
+                    throw (0, utils_1.newWebpackErrorForFile)("Encountered a TypeGroupedHandlesItem instance that was not compatible with the CachedHandleData type", use.asset);
+                }
+                internalHandlesCache[use.asset] = { ...rest, handle, associatedAssets: associatedAssets?.map(a => a.asset) };
+                buildUnifiedAssetsCacheEntry(use);
+            }
+            this.internalHandlesCache = internalHandlesCache;
+            this.unifiedAssetsCache = unifiedAssetsCache;
+        }
+        else if (this.unifiedAssetsCache === undefined) {
+            const compiledAssets = await this.getCompiledAssets();
+            const unifiedAssetsCache = Object.create(null);
+            const internalHandlesCache = this.internalHandlesCache;
+            const buildUnifiedAssetsCacheEntry = (asset) => {
+                // biome-ignore lint/style/noNonNullAssertion: We set up compiledAssets in a way that guarantees that this will always be valid
+                const { finalizedHandleMetadata, options, type } = compiledAssets[asset];
+                // biome-ignore lint/style/noNonNullAssertion: We set up internalHandlesCache in a way that guarantees that this will always be valid
+                const { handle, omitRegistration, associatedAssets, associationMechanism } = internalHandlesCache[asset];
+                let res = unifiedAssetsCache[asset];
+                if (res === undefined) {
+                    res = unifiedAssetsCache[asset] = {
+                        handle,
+                        omitRegistration,
+                        associationMechanism,
+                        finalizedHandleMetadata,
+                        options,
+                        type,
+                    };
+                    if (associatedAssets) {
+                        res.associatedAssets = associatedAssets.map(buildUnifiedAssetsCacheEntry);
+                    }
+                }
+                return res;
+            };
+            Object.keys(compiledAssets).forEach(buildUnifiedAssetsCacheEntry);
+            this.unifiedAssetsCache = unifiedAssetsCache;
+        }
+        return this.unifiedAssetsCache;
+    }
+    static make() {
+        const coordinator = new RootCoordinatorPluginImpl();
+        return {
+            coordinator,
+            finalizer: (configs) => {
+                const usedConfigNames = new Set();
+                const res = configs.map(config => {
+                    if (config.name !== undefined) {
+                        if (usedConfigNames.has(config.name)) {
+                            let count = 0, name;
+                            do {
+                                name = `${config.name}-${++count}`;
+                            } while (usedConfigNames.has(name));
+                            usedConfigNames.add(name);
+                            return { ...config, name };
+                        }
+                        else {
+                            usedConfigNames.add(config.name);
+                        }
+                    }
+                    return config;
+                });
+                const allocateName = (config) => {
+                    // Yes, this is a lot, but it is to ensure that the output is trivially-readable
+                    const hasBase = (dep) => dep.includes(":base:") || dep.startsWith("base:");
+                    const namedDep = config.dependencies?.find(dep => hasBase(dep) && !dep.endsWith(":modules")) ?? config.dependencies?.find(hasBase);
+                    const availableNames = config.plugins
+                        ?.map(plugin => plugin instanceof api_1.CoordinatableEmitter ? plugin.defaultCompilationName : undefined)
+                        .filter(name => name !== undefined)
+                        .map(name => namedDep?.replaceAll(/(^|:)base(:)?(?:modules|non-modules)?/gi, "$1base:" + name.replaceAll("$", "\\$") + "$2") ?? name)
+                        .map(name => name.endsWith(":") ? name.slice(0, -1) : name);
+                    let name;
+                    if ((0, utils_1.hasAtLeastOneItem)(availableNames)) {
+                        name = availableNames.find(name => !usedConfigNames.has(name));
+                        if (name === undefined) {
+                            let count = 0;
+                            do {
+                                name = `${availableNames[0]}-${++count}`;
+                            } while (usedConfigNames.has(name));
+                        }
+                    }
+                    if (name === undefined) {
+                        do {
+                            name = (0, node_crypto_1.randomUUID)();
+                        } while (usedConfigNames.has(name));
+                    }
+                    usedConfigNames.add(name);
+                    return name;
+                };
+                const makeGeneratedCfgSafe = (cfg) => {
+                    if (cfg.output?.clean) {
+                        cfg.output = {
+                            ...cfg.output,
+                            clean: false,
+                        };
+                    }
+                    if (cfg.name !== undefined) {
+                        if (usedConfigNames.has(cfg.name)) {
+                            delete cfg.name;
+                        }
+                        else {
+                            usedConfigNames.add(cfg.name);
+                        }
+                    }
+                    if (cfg.dependencies !== undefined) {
+                        cfg.dependencies = [...cfg.dependencies];
+                    }
+                    return cfg;
+                };
+                const allCreatedConfigs = Object.create(null);
+                let novelConfigs = configs;
+                while (novelConfigs.length > 0) {
+                    const iter = novelConfigs.values();
+                    novelConfigs = [];
+                    for (const config of iter) {
+                        const coordinatableEmitters = config.plugins?.filter(p => p instanceof api_1.CoordinatableEmitter);
+                        if (!coordinatableEmitters?.length) {
+                            continue;
+                        }
+                        config.name ??= allocateName(config);
+                        for (const emitter of coordinatableEmitters) {
+                            for (const [target, configBuilder] of emitter.getCoordinatedEmissionTargets()) {
+                                if (!allCreatedConfigs[target]) {
+                                    const cfg = makeGeneratedCfgSafe(configBuilder(config, coordinator));
+                                    allCreatedConfigs[target] = cfg;
+                                    novelConfigs.push(cfg);
+                                    res.push(cfg);
+                                }
+                                if (allCreatedConfigs[target].name !== config.name) {
+                                    (allCreatedConfigs[target].dependencies ??= []).push(config.name);
+                                }
+                            }
+                        }
+                    }
+                }
+                let verifiedConfigs = res;
+                let configProvisionAndRequirements;
+                let changed;
+                do {
+                    const iter = verifiedConfigs.values();
+                    verifiedConfigs = [];
+                    changed = false;
+                    configProvisionAndRequirements = [];
+                    for (const config of iter) {
+                        const provides = [];
+                        const requires = [];
+                        const emitters = config.plugins?.filter(p => p instanceof api_1.CoordinatableEmitter);
+                        if (emitters?.length) {
+                            for (const emitter of emitters) {
+                                provides.push(...emitter.provides.filter(p => !provides.includes(p)));
+                                requires.push(...emitter.requires.filter(p => !requires.includes(p)));
+                            }
+                        }
+                        configProvisionAndRequirements.push({ config, provides, requires });
+                    }
+                    for (const { config, provides, requires } of configProvisionAndRequirements) {
+                        verifiedConfigs.push(config);
+                        if (!config.plugins) {
+                            continue;
+                        }
+                        if (provides.some(p => requires.includes(p))) {
+                            const retainablePlugins = config.plugins.filter(plugin => {
+                                return !(plugin instanceof api_1.CoordinatableEmitter) || !plugin.requires.some(r => provides.includes(r));
+                            });
+                            if (retainablePlugins.find(p => p instanceof api_1.CoordinatableEmitter) === undefined) {
+                                throw new Error("Encountered an infinite dependency loop");
+                            }
+                            const otherPlugins = config.plugins.filter(plugin => {
+                                return plugin instanceof api_1.CoordinatableEmitter && plugin.requires.some(r => provides.includes(r));
+                            });
+                            config.plugins = retainablePlugins;
+                            verifiedConfigs.push(makeGeneratedCfgSafe({ ...config, plugins: otherPlugins, dependencies: [config.name ??= allocateName(config)] }));
+                            changed = true;
+                        }
+                    }
+                } while (changed);
+                const requirementToCompilerNames = Object.create(null);
+                for (const { config, provides } of configProvisionAndRequirements) {
+                    config.name ??= allocateName(config);
+                    for (const provide of provides) {
+                        (requirementToCompilerNames[provide] ??= []).push(config.name);
+                    }
+                }
+                for (const { config, requires } of configProvisionAndRequirements) {
+                    for (const req of requires) {
+                        if (requirementToCompilerNames[req]) {
+                            const cfgDeps = config.dependencies ??= [];
+                            config.dependencies.push(...requirementToCompilerNames[req].filter(dep => !cfgDeps.includes(dep)));
+                        }
+                    }
+                }
+                return configProvisionAndRequirements.map(item => item.config);
+            }
+        };
+    }
+    getData(emissionTarget) {
+        return (this.coordinatedEmitterData[emissionTarget]?.values().flatMap(m => {
+            return m.values().filter((v) => v !== false);
+        }).toArray() ?? []);
+    }
+}
+exports.RootCoordinatorPluginImpl = RootCoordinatorPluginImpl;
+/**
+ * Only call this with items that are user-specified OR generated, but not a mix of both
+ */
+function checkAndApplyOrEnqueueHandleNameInstances(compilation, usedHandles, remainingHopefullyModifiableHandles, type, handleName, items) {
+    if (!items.some(api_1.handleCannotBeModifiedForConflictAvoidance)) {
+        const batch = remainingHopefullyModifiableHandles[type][handleName];
+        if (batch) {
+            batch.push(...items);
+        }
+        else {
+            remainingHopefullyModifiableHandles[type][handleName] = [...items];
+        }
+        return;
+    }
+    let existing = usedHandles[type].get(handleName);
+    if (existing) {
+        existing.push(...items.map(item => item.asset));
+        if (items.some(api_1.handleCannotBeModifiedForConflictAvoidance)) {
+            (0, utils_1.emitError)(`Encountered multiple assets with the same user-specified handle ("${handleName}"). The emitted assets will have unstable handle names.`, { rawIdentifier: existing.join(", "), compilation });
+        }
+        const batch = remainingHopefullyModifiableHandles[type][handleName];
+        if (batch) {
+            batch.push(...items);
+        }
+        else {
+            remainingHopefullyModifiableHandles[type][handleName] = [...items];
+        }
+    }
+    else {
+        const [valid, ...invalid] = items.sort(compareTypeGroupedHandlesItems);
+        valid.handle = handleName;
+        if (valid.associatedAssets) {
+            for (const associated of valid.associatedAssets) {
+                if (associated.associationMechanism === 'merged') {
+                    associated.handle = handleName;
+                    associated.omitRegistration = true;
+                }
+            }
+        }
+        usedHandles[type].set(handleName, existing = [valid.asset]);
+        if ((0, utils_1.hasAtLeastOneItem)(invalid)) {
+            existing.push(...invalid.map(item => item.asset));
+            (0, utils_1.emitError)(`Encountered multiple assets with the same user-specified handle ("${handleName}"). The emitted assets will have unstable handle names.`, { rawIdentifier: existing.join(", "), compilation });
+            const batch = remainingHopefullyModifiableHandles[type][handleName];
+            if (batch) {
+                batch.push(...invalid);
+            }
+            else {
+                remainingHopefullyModifiableHandles[type][handleName] = invalid;
+            }
+        }
+    }
+}
+const compareTypeGroupedHandlesItems = (a, b) => {
+    return (a.derivation - b.derivation) || (b.isPrimary - a.isPrimary) || a.asset.localeCompare(b.asset);
+};
+/**
+ * @return {@code 'merged'} -> "can share the same handle", {@code false} -> "cannot be merged", {@code 'dependent'} -> "one handle can be listed as a dependency of the other"
+ */
+function canMergeHandles(handleA, handleB) {
+    const optionsA = handleA.options, optionsB = handleB.options;
+    if (optionsA.flags.inline === undefined && optionsB.flags.inline === undefined) {
+        return undefined; // We cannot merge handles for two non-inlined assets
+    }
+    if ((0, node_path_1.dirname)(optionsA.absoluteSrc) !== (0, node_path_1.dirname)(optionsB.absoluteSrc)) {
+        return undefined; // We don't want assets from different locations to be able to have their handles overlap
+    }
+    if (optionsA.flags.in_footer !== optionsB.flags.in_footer) {
+        return 'dependent';
+    }
+    if ((0, api_1.isDeferringLoadingStrategy)(optionsA.flags.strategy) && optionsB.flags.inline === 'after') {
+        return undefined;
+    }
+    if ((0, api_1.isDeferringLoadingStrategy)(optionsB.flags.strategy) && optionsA.flags.inline === 'after') {
+        return undefined;
+    }
+    if (!optionsA.computedHandleArguments || !optionsB.computedHandleArguments) {
+        return undefined; //TODO: Print an error or something?
+    }
+    const additionalArgsA = optionsA.computedHandleArguments.length === 3 ? optionsA.computedHandleArguments[2] : {};
+    const additionalArgsB = optionsB.computedHandleArguments.length === 3 ? optionsB.computedHandleArguments[2] : {};
+    if (typeof additionalArgsA !== 'string') {
+        if (typeof additionalArgsB === 'string') {
+            return undefined;
+        }
+        if (additionalArgsA.module_dependencies !== additionalArgsB.module_dependencies) {
+            if (additionalArgsA.module_dependencies === undefined) {
+                return undefined;
+            }
+            if (additionalArgsB.module_dependencies === undefined) {
+                return undefined;
+            }
+            if (additionalArgsA.module_dependencies.length !== additionalArgsB.module_dependencies.length) {
+                return undefined;
+            }
+            for (const modDep of additionalArgsA.module_dependencies) {
+                if (!additionalArgsB.module_dependencies.includes(modDep)) {
+                    return undefined;
+                }
+            }
+        }
+    }
+    else if (typeof additionalArgsB !== 'string' || additionalArgsA !== additionalArgsB) {
+        return undefined;
+    }
+    const depsA = optionsA.computedHandleArguments[0];
+    const depsB = optionsB.computedHandleArguments[0];
+    if (depsA.length !== depsB.length) {
+        return undefined;
+    }
+    //TODO: Maybe account for import potentially being undefined?
+    for (const dep of depsA) {
+        if (typeof dep === 'string') {
+            if (!depsB.includes(dep)) {
+                return undefined;
+            }
+        }
+        else {
+            if (!depsB.find(v => v === dep || (typeof v !== 'string' && dep.id === v.id && dep.import === v.import))) {
+                return undefined;
+            }
+        }
+    }
+    if (optionsA.locations.register !== optionsB.locations.register) {
+        return undefined; //TODO: Maybe make this more granular?
+    }
+    for (const standardLocation of (0, utils_1.constantKeys)(api_1.standardLocationNamesMeta)) {
+        if (!(0, api_1.isLocationNameWithActionSupport)(standardLocation)) {
+            if (optionsA.locations[standardLocation] !== optionsB.locations[standardLocation]) {
+                return undefined;
+            }
+            continue;
+        }
+        const locA = optionsA.locations[standardLocation];
+        const locB = optionsB.locations[standardLocation];
+        if (locA === locB) {
+            continue;
+        }
+        // This works because if they were BOTH undefined, the prior condition would have been hit, and this, therefore, would have been skipped
+        if (locA === undefined || locB === undefined) {
+            return undefined;
+        }
+        const [locAHookNames, locAPriority] = (0, api_1.convertHookLocationToNamesAndPriority)(locA);
+        const [locBHookNames, locBPriority] = (0, api_1.convertHookLocationToNamesAndPriority)(locB);
+        if (locAHookNames.length !== locBHookNames.length) {
+            return undefined;
+        }
+        if (locAHookNames.length > 0) {
+            for (const hookName of locAHookNames) {
+                if (!locBHookNames.includes(hookName)) {
+                    return undefined;
+                }
+            }
+        }
+        if (locAPriority !== locBPriority) {
+            return 'dependent'; // We cannot merge hooks across priority boundaries, but we can have one require the other
+        }
+    }
+    return 'merged';
+}
+//# sourceMappingURL=RootCoordinatorPluginImpl.js.map