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

package/dist/utils/location-encoding-filename-parser.d.ts

@@ -1,30 +0,0 @@
-import { RealUsageLocations } from "../shared";
-import { NormalizedEnqueuingControlFlags } from "./path-query-and-related-helpers";
-export type ParsedLocationEncodingFilename = {
-    type: 'script' | 'style' | 'script-module';
-    locations: RealUsageLocations & {
-        register?: boolean | number;
-    } & {
-        handle?: {
-            niceName: string;
-        };
-    };
-    flags: NormalizedEnqueuingControlFlags;
-};
-export declare function parseLocationEncodingFilename(filename: string): ParsedLocationEncodingFilename | undefined;
-export declare function parseLocationEncodingFilenameForBlock(filename: string, errorBuilder?: (message: string, filename: string) => unknown): (Omit<ParsedLocationEncodingFilename, 'locations'> & {
-    locations: Pick<RealUsageLocations, 'clientEditor' | 'clientView'>;
-    handle: ParsedLocationEncodingFilename['locations']['handle'];
-}) | undefined;
-/**
- * This handles detecting all keys of standardLocationNamesMeta as well as the values listed in their associated alternate_names properties
- * It MUST be kept in sync with standardLocationNamesMeta
- * @param segment
- */
-export declare function extractLocationFromPropertyEncodingFilenameSegment(segment: string): {
-    readonly locationName: false;
-    readonly priority?: undefined;
-} | {
-    readonly locationName: "admin" | "analytics" | "blockAssets" | "clientEditor" | "clientView" | "customizer" | "login" | "register";
-    readonly priority: number | true;
-};

package/dist/utils/location-encoding-filename-parser.js

@@ -1,120 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.parseLocationEncodingFilename = parseLocationEncodingFilename;
-exports.parseLocationEncodingFilenameForBlock = parseLocationEncodingFilenameForBlock;
-exports.extractLocationFromPropertyEncodingFilenameSegment = extractLocationFromPropertyEncodingFilenameSegment;
-const node_path_1 = require("node:path");
-const shared_1 = require("../shared");
-function parseLocationEncodingFilename(filename) {
-    const { name, ext } = (0, node_path_1.parse)(filename);
-    if ((0, shared_1.shouldBeSkipped)(name)) {
-        return undefined;
-    }
-    let type = /^\.(?:s[ac]|p?c)ss$/i.test(ext) ? 'style' : /^\.m[jt]sx?/i.test(ext) ? 'script-module' : /^\.[jt]sx?/i.test(ext) ? 'script' : false;
-    if (type === false) {
-        return undefined;
-    }
-    const locations = {};
-    const flags = {};
-    const nameSegments = name.split("."); //Split always returns at least one string
-    const typeOverrideMatch = /^(?<enqueuePosition>.+)-(?<typeOverride>script|style|script-module)$|^(?<typeOverride>script|style|script-module)$/.exec(nameSegments[0]);
-    if (typeOverrideMatch) {
-        nameSegments[0] = typeOverrideMatch.groups?.["enqueuePosition"] ?? "both"; // We override the first segment with the version without the type override
-        type = typeOverrideMatch.groups?.["typeOverride"];
-    }
-    const inlinePattern = /^(?<inline>inline)(?:[-=](?<position>before|after))?$|^strategy[-=](?<inline>inline)(?:-(?<position>before|after))?$/;
-    const strategyPattern = /^strategy[-=](?<strategy>eager|lazy|defer|async)$|^(?<strategy>lazy|eager)$/;
-    const fetchpriorityPattern = /^fetchpriority[-=](auto|low|high)$/;
-    const bothViewAndEditorLocationPattern = /^(?:client-)?(?<both>both)(?:[-=](?<priority>-?\d+))?$/;
-    let niceName = undefined;
-    for (const segment of nameSegments) {
-        const { locationName, priority } = extractLocationFromPropertyEncodingFilenameSegment(segment);
-        if (locationName) {
-            locations[locationName] = priority;
-            continue;
-        }
-        const lcSegment = segment.toLowerCase();
-        const { both, priority: bothPriority } = bothViewAndEditorLocationPattern.exec(lcSegment)?.groups ?? {};
-        if (both) {
-            const priority = bothPriority !== undefined ? parseInt(bothPriority) : true;
-            locations.clientView = priority;
-            locations.clientEditor = priority;
-            continue;
-        }
-        const { inline, position: inlinePosition } = (inlinePattern.exec(lcSegment)?.groups ?? {});
-        if (inline) {
-            flags.inline = true;
-            flags.position = inlinePosition;
-            continue;
-        }
-        const strategy = strategyPattern.exec(lcSegment)?.groups?.['strategy']?.toLowerCase();
-        if (strategy) {
-            flags.strategy = strategy;
-            continue;
-        }
-        const fetchpriority = fetchpriorityPattern.exec(lcSegment)?.[1];
-        if (fetchpriority !== undefined) {
-            flags.fetchpriority = fetchpriority;
-            continue;
-        }
-        switch (segment.toLowerCase()) {
-            // Loading flags
-            case "in-footer":
-            case "in_footer":
-                flags.in_footer = true;
-                break;
-            case "in-header":
-            case "in_header":
-                flags.in_footer = false;
-                break;
-            default:
-                if (niceName === undefined) {
-                    niceName = segment;
-                }
-                break;
-        }
-    }
-    // This means that it wasn't a location-encoding filename
-    if (Object.values(locations).length === 0) {
-        return undefined;
-    }
-    if (niceName !== undefined) {
-        // We need to kebab-case the nice name value for web-safety
-        locations.handle = { niceName: (0, shared_1.kebabCase)(niceName) };
-    }
-    return { type, locations, flags };
-}
-function parseLocationEncodingFilenameForBlock(filename, errorBuilder = shared_1.newWebpackErrorForFile) {
-    const parsedFilename = parseLocationEncodingFilename(filename);
-    if (parsedFilename !== undefined) {
-        const { handle, ...locations } = parsedFilename.locations;
-        if ((0, shared_1.constantKeys)(locations).some(value => value !== 'clientView' && value !== 'clientEditor')) {
-            throw errorBuilder(`Block assets cannot be enqueued anywhere other than view, editor, or both. Saw: ${(0, shared_1.constantKeys)(parsedFilename.locations).join(", ")}`, filename);
-        }
-        if (Object.values(locations).some(value => typeof value === 'number')) {
-            throw errorBuilder(`Block assets cannot be enqueued with a priority`, filename);
-        }
-        return { ...parsedFilename, handle, locations };
-    }
-    return parsedFilename;
-}
-let standardLocationNamesAndPriorityPatternInFilenameSegment;
-/**
- * This handles detecting all keys of standardLocationNamesMeta as well as the values listed in their associated alternate_names properties
- * It MUST be kept in sync with standardLocationNamesMeta
- * @param segment
- */
-function extractLocationFromPropertyEncodingFilenameSegment(segment) {
-    if (!standardLocationNamesAndPriorityPatternInFilenameSegment) {
-        const matchableLocationNames = (0, shared_1.iterableStandardLocationNamesMeta)()
-            .flatMap(([standardName, { alternate_names = [] }]) => [standardName, ...alternate_names])
-            .join("|");
-        standardLocationNamesAndPriorityPatternInFilenameSegment = new RegExp(`^(?<locationName>${matchableLocationNames}|register)(?:[-=](?<priority>-?\\d+))?$`);
-    }
-    const { locationName, priority: rawPriority } = standardLocationNamesAndPriorityPatternInFilenameSegment.exec(segment)?.groups ?? {};
-    if (!locationName) {
-        return { locationName: false };
-    }
-    const priority = rawPriority !== undefined ? parseInt(rawPriority) : true;
-    return { locationName: (0, shared_1.normalizeLocationName)(locationName), priority };
-}

package/dist/utils/path-query-and-related-helpers.d.ts

@@ -1,64 +0,0 @@
-import type { Compilation } from "webpack";
-import { type InlinedAsset, type PathQueryParameters, type ScriptArgsObject, type UsageLocations } from "../shared";
-export declare function getAssetFileContents(compilation: Compilation, name: string): string;
-export declare function unpackPotentiallyPrefixedFilePath(filePath: string): [string, PathQueryParameters | undefined];
-/**
- * The following substitutions are performed:
- * <ul>
- *     <li>parameters without an assigned value -> a boolean parameter set to true</li>
- *     <li>true and false -> their boolean equivalents</li>
- *     <li>numeric values -> their number equivalents</li>
- * </ul>
- *
- * @param pathQuery the part after the "?" in a webpack inclusion path
- * @return the query as an object with common string -> JS type conversions already performed
- */
-export declare function unpackPathQuery(pathQuery: string): PathQueryParameters | undefined;
-export type LoadingStrategy = boolean | 'defer' | 'async' | 'eager' | 'lazy' | 'inline';
-export declare function newInvalidLoadingStrategyError(strategy: unknown, file: string): import("webpack").WebpackError;
-export type InFooter = boolean;
-export declare function isValidInFooter(in_footer: unknown): in_footer is InFooter;
-export declare function newInvalidInFooterError(in_footer: unknown, file: string): import("webpack").WebpackError;
-export type FetchPriority = 'auto' | 'low' | 'high';
-export declare function isValidFetchPriority(fetchpriority: unknown): fetchpriority is FetchPriority;
-export declare function newInvalidFetchPriorityError(fetchpriority: unknown, file: string): import("webpack").WebpackError;
-export type PositionForInlineStrategy = 'before' | 'after';
-export declare function isValidPositionForInlineStrategy(position: unknown): position is PositionForInlineStrategy;
-export declare function newInvalidPositionForInlineStrategyError(position: unknown, file: string): import("webpack").WebpackError;
-/**
- * This function ensures that the passed pathQueryParameters are normalized for the config-loading step, NOT the emission step
- */
-export type NormalizedEnqueuingControlFlags = {
-    strategy?: Exclude<LoadingStrategy, 'inline'>;
-    in_footer?: InFooter;
-    inline?: boolean;
-    fetchpriority?: FetchPriority;
-    position?: 'before' | 'after';
-};
-export declare function mergeTwoEnqueuingControlFlagSets(file: string, ...argsBlocks: (NormalizedEnqueuingControlFlags | undefined)[]): NormalizedEnqueuingControlFlags | undefined;
-export declare function unpackEnqueuingControlFlagsFromPathQueryParameters(pathQueryParameters: PathQueryParameters | undefined, file: string, sourceType: 'registerScriptArgs' | 'path query parameters'): {
-    flags?: NormalizedEnqueuingControlFlags;
-    handle?: UsageLocations['handle'];
-    remainder?: PathQueryParameters;
-};
-/**
- * This function does a few things:
- * <ol>
- *     <li>It converts the strategy, in_footer, and fetchpriority flags into a valid script args object</li>
- *     <li>If inline is true, it records the contents of the asset and the value of the position flag for later injection and removes the asset from the compilation output</li>
- * </ol>
- * @param compilation
- * @param file
- * @param flags
- * @param forceRecordContents
- */
-export declare function convertEnqueuingControlFlagsToScriptArgsObject(compilation: Compilation, file: string, flags: NormalizedEnqueuingControlFlags | undefined, forceRecordContents?: boolean): {
-    scriptArgsObject?: ScriptArgsObject;
-    assetMeta?: {
-        inlinedAsset: InlinedAsset;
-        assetContents: string;
-    } | {
-        inlinedAsset?: undefined;
-        assetContents: string | undefined;
-    };
-};

package/dist/utils/path-query-and-related-helpers.js

@@ -1,269 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getAssetFileContents = getAssetFileContents;
-exports.unpackPotentiallyPrefixedFilePath = unpackPotentiallyPrefixedFilePath;
-exports.unpackPathQuery = unpackPathQuery;
-exports.newInvalidLoadingStrategyError = newInvalidLoadingStrategyError;
-exports.isValidInFooter = isValidInFooter;
-exports.newInvalidInFooterError = newInvalidInFooterError;
-exports.isValidFetchPriority = isValidFetchPriority;
-exports.newInvalidFetchPriorityError = newInvalidFetchPriorityError;
-exports.isValidPositionForInlineStrategy = isValidPositionForInlineStrategy;
-exports.newInvalidPositionForInlineStrategyError = newInvalidPositionForInlineStrategyError;
-exports.mergeTwoEnqueuingControlFlagSets = mergeTwoEnqueuingControlFlagSets;
-exports.unpackEnqueuingControlFlagsFromPathQueryParameters = unpackEnqueuingControlFlagsFromPathQueryParameters;
-exports.convertEnqueuingControlFlagsToScriptArgsObject = convertEnqueuingControlFlagsToScriptArgsObject;
-const node_path_1 = require("node:path");
-const shared_1 = require("../shared");
-function getAssetFileContents(compilation, name) {
-    const asset = compilation.getAsset(name);
-    if (!asset) {
-        throw new Error(`${name} is unexpectedly missing`);
-    }
-    const assetSource = asset.source.source();
-    return typeof assetSource === 'string' ? assetSource : assetSource?.toString('utf-8');
-}
-function unpackPotentiallyPrefixedFilePath(filePath) {
-    if (filePath.startsWith("file:")) {
-        filePath = filePath.substring(5);
-    }
-    const queryStart = filePath.indexOf("?");
-    if (queryStart === -1) {
-        return [filePath, undefined];
-    }
-    else {
-        return [filePath.substring(0, queryStart), unpackPathQuery(filePath.substring(queryStart + 1))];
-    }
-}
-/**
- * The following substitutions are performed:
- * <ul>
- *     <li>parameters without an assigned value -> a boolean parameter set to true</li>
- *     <li>true and false -> their boolean equivalents</li>
- *     <li>numeric values -> their number equivalents</li>
- * </ul>
- *
- * @param pathQuery the part after the "?" in a webpack inclusion path
- * @return the query as an object with common string -> JS type conversions already performed
- */
-function unpackPathQuery(pathQuery) {
-    if (!pathQuery) {
-        return undefined;
-    }
-    return new URLSearchParams(pathQuery.replaceAll(/((?:[&?]|^)\w+)(&|$)/g, "$1=true$2")).entries()
-        .map(([key, value]) => {
-        if (value === 'true') {
-            return [key, true];
-        }
-        if (value === 'false') {
-            return [key, false];
-        }
-        if (Number.isFinite(+value)) {
-            return [key, +value];
-        }
-        return [key, value];
-    })
-        .reduce((collector, [key, value]) => {
-        if (collector[key] instanceof Array) {
-            collector[key].push(value);
-        }
-        else if (key in collector) {
-            collector[key] = [collector[key], value];
-        }
-        else {
-            collector[key] = value;
-        }
-        return collector;
-    }, {});
-}
-const namedStrategies = ['defer', 'async', 'eager', 'lazy', 'inline'];
-function newInvalidLoadingStrategyError(strategy, file) {
-    return (0, shared_1.newWebpackErrorForFile)(`The strategy was invalid. Received: ${strategy}, Expected: undefined|boolean|'${namedStrategies.join("'|'")}'`, file);
-}
-function isValidInFooter(in_footer) {
-    return typeof in_footer === 'boolean';
-}
-function newInvalidInFooterError(in_footer, file) {
-    return (0, shared_1.newWebpackErrorForFile)(`The in_footer value was invalid. Received: ${in_footer}, Expected: undefined|boolean`, file);
-}
-function isValidFetchPriority(fetchpriority) {
-    return typeof fetchpriority === 'string' && ["auto", "low", "high"].includes(fetchpriority);
-}
-function newInvalidFetchPriorityError(fetchpriority, file) {
-    return (0, shared_1.newWebpackErrorForFile)(`The fetchpriority value was invalid. Received: ${fetchpriority}, Expected: undefined|'auto'|'low'|'high'`, file);
-}
-function isValidPositionForInlineStrategy(position) {
-    return typeof position === 'string' && ["before", "after"].includes(position);
-}
-function newInvalidPositionForInlineStrategyError(position, file) {
-    return (0, shared_1.newWebpackErrorForFile)(`The position value for the inlined asset was invalid. Received: ${position}, Expected: undefined|'before'|'after'`, file);
-}
-function mergeTwoEnqueuingControlFlagSets(file, ...argsBlocks) {
-    const filteredArgsBlocks = argsBlocks.filter(argsBlock => argsBlock !== undefined);
-    if (filteredArgsBlocks.length === 0) {
-        return undefined;
-    }
-    if ((0, shared_1.arrayIsLength)(filteredArgsBlocks, 1)) {
-        return filteredArgsBlocks[0];
-    }
-    const res = {};
-    for (const key of ['strategy', 'in_footer', 'fetchpriority', 'inline', 'position']) {
-        for (const argsBlock of filteredArgsBlocks) {
-            if (key in argsBlock) {
-                if (!(key in res)) {
-                    res[key] = argsBlock[key];
-                }
-                else if (argsBlock[key] !== res[key]) {
-                    throw (0, shared_1.newWebpackErrorForFile)(`The ${key} values in the control flag sets for the file conflict`, file);
-                }
-            }
-        }
-    }
-    return res;
-}
-function unpackEnqueuingControlFlagsFromPathQueryParameters(pathQueryParameters, file, sourceType) {
-    if (pathQueryParameters === undefined) {
-        return {};
-    }
-    const { strategy, in_footer: normalizedInFooter, 'in-footer': alternateInFooter, fetchpriority, position, handle, ...remainder } = pathQueryParameters;
-    let flags;
-    switch (strategy) {
-        case 'defer':
-        case 'async':
-            flags = { strategy };
-            break;
-        case 'eager':
-            flags = { strategy: 'eager' };
-            break;
-        case 'lazy':
-            flags = { strategy: 'defer', in_footer: true };
-            break;
-        case 'inline':
-            flags = { inline: true };
-            break;
-        case true:
-        case false:
-            flags = { in_footer: strategy };
-            break;
-        case null:
-        case undefined:
-            flags = {};
-            break;
-        default:
-            throw newInvalidLoadingStrategyError(strategy, file);
-    }
-    if (flags.inline === undefined && pathQueryParameters['inline'] !== undefined) {
-        flags.inline = !!pathQueryParameters['inline'];
-    }
-    const in_footer = normalizedInFooter ?? alternateInFooter;
-    if (in_footer !== undefined) {
-        if (!isValidInFooter(in_footer)) {
-            throw newInvalidInFooterError(in_footer, file);
-        }
-        flags.in_footer = in_footer;
-    }
-    if (pathQueryParameters['fetchpriority'] !== undefined) {
-        if (!isValidFetchPriority(pathQueryParameters['fetchpriority'])) {
-            throw newInvalidFetchPriorityError(pathQueryParameters['fetchpriority'], file);
-        }
-        if (flags.fetchpriority !== undefined && flags.fetchpriority !== pathQueryParameters['fetchpriority']) {
-            throw (0, shared_1.newWebpackErrorForFile)(`The strategy and fetchpriority values in the ${sourceType} for the file conflict. Got ${strategy} and ${pathQueryParameters['fetchpriority']}`, file);
-        }
-        flags.fetchpriority = pathQueryParameters['fetchpriority'];
-    }
-    if (flags.inline && (pathQueryParameters['position'] === 'before' || pathQueryParameters['position'] === 'after')) {
-        flags.position = pathQueryParameters['position'];
-    }
-    if (handle !== undefined && (typeof handle !== 'string' || handle.length < 5)) {
-        throw (0, shared_1.newWebpackErrorForFile)(`The handle was invalid. Received: ${handle}. Expected: a string that is at least 5 characters long`, file);
-    }
-    return Object.keys(flags).length > 0 ? { flags, handle, remainder } : { handle, remainder };
-}
-/**
- * This function does a few things:
- * <ol>
- *     <li>It converts the strategy, in_footer, and fetchpriority flags into a valid script args object</li>
- *     <li>If inline is true, it records the contents of the asset and the value of the position flag for later injection and removes the asset from the compilation output</li>
- * </ol>
- * @param compilation
- * @param file
- * @param flags
- * @param forceRecordContents
- */
-function convertEnqueuingControlFlagsToScriptArgsObject(compilation, file, flags, forceRecordContents = false) {
-    if (flags === undefined) {
-        if (forceRecordContents) {
-            return { assetMeta: { assetContents: getAssetFileContents(compilation, file) } };
-        }
-        return {};
-    }
-    const { strategy, in_footer, inline, position, fetchpriority } = flags;
-    const scriptArgsObject = {};
-    let inlinedAsset = undefined;
-    let assetContents = undefined;
-    switch (strategy) {
-        case 'async':
-        case 'defer':
-            scriptArgsObject.strategy = strategy;
-            break;
-        case 'eager':
-            scriptArgsObject.in_footer = false;
-            break;
-        case 'lazy':
-            scriptArgsObject.strategy = 'defer';
-            scriptArgsObject.in_footer = true;
-            break;
-        case true:
-        case false:
-            scriptArgsObject.in_footer = strategy;
-            break;
-        case null:
-        case undefined:
-            // This is included because are effectively validating the strategy value with this switch statement, and "not defined" is a valid state
-            break;
-        default:
-            throw newInvalidLoadingStrategyError(strategy, file);
-    }
-    if (in_footer !== undefined) {
-        if (!isValidInFooter(in_footer)) {
-            throw newInvalidInFooterError(in_footer, file);
-        }
-        scriptArgsObject.in_footer = in_footer;
-    }
-    if (inline) {
-        inlinedAsset = {};
-        assetContents = getAssetFileContents(compilation, file);
-        removeFileAndAssetPHP(compilation, file);
-        if (position !== undefined) {
-            if (!isValidPositionForInlineStrategy(position)) {
-                throw newInvalidPositionForInlineStrategyError(position, file);
-            }
-            inlinedAsset.position = position;
-        }
-        if (inlinedAsset.position !== 'before' && scriptArgsObject.strategy !== undefined) {
-            compilation.warnings.push((0, shared_1.newWebpackErrorForFile)("Deferred and async scripts that have inlined JS attached in the 'after' position will cause WordPress to convert all of their dependencies to eager scripts at runtime", file));
-        }
-        if (scriptArgsObject.in_footer === undefined) {
-            scriptArgsObject.in_footer = true;
-        }
-    }
-    else if (forceRecordContents) {
-        assetContents = getAssetFileContents(compilation, file);
-    }
-    if (fetchpriority !== undefined) {
-        if (!isValidFetchPriority(fetchpriority)) {
-            throw newInvalidFetchPriorityError(fetchpriority, file);
-        }
-        if (inline) {
-            compilation.warnings.push((0, shared_1.newWebpackErrorForFile)("Fetchpriority has no effect on inlined assets", file));
-        }
-        scriptArgsObject.fetchpriority = fetchpriority;
-    }
-    const assetMeta = inlinedAsset ? { inlinedAsset, assetContents: assetContents } : { assetContents };
-    return Object.keys(scriptArgsObject).length > 0 ? { scriptArgsObject, assetMeta } : { assetMeta };
-}
-function removeFileAndAssetPHP(compilation, file) {
-    const pathParts = (0, node_path_1.parse)(file);
-    compilation.deleteAsset((0, node_path_1.join)(pathParts.dir, pathParts.name) + ".asset.php");
-    compilation.deleteAsset(file);
-}

package/dist/utils/pseudo-semaphore.d.ts

@@ -1,14 +0,0 @@
-export declare class PseudoSemaphore<T> {
-    private readonly name;
-    private flagSet;
-    private readonly flags;
-    private readonly debugMode;
-    constructor(name: string);
-    register(id: string): void;
-    resolve(id: string, value: T | undefined): void;
-    reject(id: string): void;
-    reset(id: string): void;
-    private getFlag;
-    private initializeFlag;
-    wait(): Promise<T[]>;
-}

package/dist/utils/pseudo-semaphore.js

@@ -1,79 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.PseudoSemaphore = void 0;
-class PseudoSemaphore {
-    name;
-    flagSet = 0;
-    flags = new Map();
-    debugMode = false;
-    constructor(name) {
-        this.name = name;
-    }
-    register(id) {
-        if (this.flags.has(id)) {
-            throw new Error(`A semaphore with an id of "${id}" already exists`);
-        }
-        this.initializeFlag(id);
-        this.resolve(id, undefined);
-    }
-    resolve(id, value) {
-        if (this.debugMode) {
-            console.error("RESOLVED:", this.name, id);
-        }
-        const flag = this.getFlag(id);
-        flag[1].resolve(value); // This is deliberately unsafe - I would rather see a cascading failure than a silent one
-        flag[2] = true;
-    }
-    reject(id) {
-        if (this.debugMode) {
-            console.error("REJECTED:", this.name, id);
-        }
-        const flag = this.getFlag(id);
-        flag[1].reject(); // This is deliberately unsafe - I would rather see a cascading failure than a silent one
-        flag[2] = true;
-    }
-    reset(id) {
-        if (this.debugMode) {
-            console.error("RESET:", this.name, id);
-        }
-        const flag = this.getFlag(id);
-        // We reject if we reset early to avoid any permanently-hanging promises
-        if (!flag[2]) {
-            flag[1].reject(); // This is deliberately unsafe - I would rather see a cascading failure than a silent one
-        }
-        this.initializeFlag(id);
-    }
-    getFlag(id) {
-        const flag = this.flags.get(id);
-        if (flag === undefined) {
-            throw new Error(`A semaphore with an id of "${id}" does not exist`);
-        }
-        return flag;
-    }
-    initializeFlag(id) {
-        const controller = {};
-        const promise = new Promise((resolve, reject) => {
-            controller.resolve = resolve;
-            controller.reject = reject;
-        });
-        this.flags.set(id, [promise, controller, false]);
-        this.flagSet++;
-        promise.catch(() => { });
-    }
-    async wait() {
-        let currentFlagSet;
-        let res;
-        do {
-            currentFlagSet = this.flagSet;
-            if (this.debugMode) {
-                console.log("WAITING FOR:", this.name, currentFlagSet);
-            }
-            res = (await Promise.all(this.flags.values().map(flag => flag[0]))).filter(r => r !== undefined);
-            if (this.debugMode) {
-                console.log("POSSIBLY FINISHED WAITING FOR:", this.name, currentFlagSet);
-            }
-        } while (currentFlagSet !== this.flagSet);
-        return res;
-    }
-}
-exports.PseudoSemaphore = PseudoSemaphore;

package/dist/wordpress-ports/dependency-extraction-webpack-plugin/index.d.ts

@@ -1,72 +0,0 @@
-import type LegacyDependencyExtractionWebpackPlugin from "@wordpress/dependency-extraction-webpack-plugin";
-import { Compilation, Compiler, Module, type TemplatePath } from "webpack";
-export interface EnhancedDependencyExtractionWebpackPluginOptions {
-    injectPolyfill?: boolean;
-    useDefaults?: boolean;
-    outputFilename?: TemplatePath;
-    requestToExternal?: (request: string) => string | string[] | undefined;
-    requestToExternalModule?: (request: string) => string | boolean | undefined;
-    requestToHandle?: (request: string) => string | undefined;
-    requestToScriptModule?: (request: string) => string | boolean | Error | undefined;
-    externalizedReport?: string | boolean;
-}
-export declare class EnhancedDependencyExtractionWebpackPlugin {
-    /**
-     * Track requests that are externalized.
-     *
-     * Because we don't have a closed set of dependencies, we need to track what has
-     * been externalized so we can recognize them in a later phase when the dependency
-     * lists are generated.
-     */
-    private readonly externalizedDeps;
-    private readonly options;
-    /**
-     * Track requests that a script build externalizes as script modules.
-     *
-     * These can only be reached through a runtime `import()`, which requires
-     * support for dynamic import in the output environment. The set is used
-     * to report an actionable error when that support is missing.
-     */
-    private readonly scriptModuleDepsInScript;
-    /**
-     * Whether we should use modules. This will be set later to match webpack's `output.module` option.
-     */
-    private useModules;
-    constructor(options: EnhancedDependencyExtractionWebpackPluginOptions | LegacyDependencyExtractionWebpackPlugin | EnhancedDependencyExtractionWebpackPlugin);
-    /**
-     * Convert a script module request to an external suitable for a script
-     * build.
-     *
-     * A classic script cannot contain a static `import`, so the `module`
-     * external type is not usable here: the script module has to be reached
-     * through a runtime `import()`, which is the `import` external type. The
-     * bare specifier is resolved by the import map that WordPress prints for
-     * enqueued script modules.
-     *
-     * @param {string}                request  Original module request.
-     * @param {string|boolean|Error=} external Result of a script module external resolution.
-     * @return {string|undefined} The resulting external definition.
-     */
-    static toScriptModuleExternalInScript(request: string, external?: string | boolean | Error): string | undefined;
-    private readonly externalizeWpDeps;
-    /**
-     * @param {string} request
-     * @return {string} Mapped dependency name
-     */
-    protected mapRequestToDependency(request: string): string;
-    apply(compiler: Compiler): void;
-    /**
-     * Check for magic comments before minification, so minification doesn't have to preserve them.
-     */
-    checkForMagicComments(compilation: Compilation): void;
-    addAssets(compilation: Compilation): void;
-    private static readonly staticDepsCurrent;
-    private static readonly staticDepsCache;
-    /**
-     * Can we trace a line of static dependencies from an entry to a module
-     *
-     * @return {boolean} True if there is a static import path to the root
-     */
-    static hasStaticDependencyPathToRoot(compilation: Compilation, block: Module): boolean;
-    readonly addExternalizedDep: (value: string) => Set<string>;
-}