@plaudit/webpack-extensions 2.89.2 → 3.0.0-rc.1

package/dist/plugins/static-configs.js

@@ -1,91 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.postcssConfigBuilder = postcssConfigBuilder;
-const cssnano_1 = __importDefault(require("cssnano"));
-// Options: calc
-const calcOptions = { precision: 4, mediaQueries: true, selectors: true };
-// Options: autoprefixerOptions
-const autoprefixerOptions = { grid: "autoplace" };
-// Nano Config
-// http://cssnano.co/guides/optimisations/  For the value to use click on one and then
-const nanoConfig = {
-    preset: [
-        'cssnano-preset-default',
-        {
-            safe: true,
-            autoprefixer: false, // Unsafe
-            calc: false,
-            colormin: true,
-            convertValues: false,
-            discardComments: {
-                remove(comment) {
-                    const commentKeepRegexp = /^!|@cms|@preserve|@cc_on|\bMIT\b|\bMPL\b|\bGPL\b|\bBSD\b|\bISCL\b|\(c\)|\bLicense\b|\bCopyright\b/i;
-                    return !commentKeepRegexp.test(comment);
-                }
-            },
-            discardDuplicates: true,
-            discardEmpty: true,
-            discardOverridden: true,
-            discardUnused: false, // Unsafe
-            mergeIdents: false, // Unsafe
-            mergeLonghand: true,
-            mergeRules: false, // Off for speed
-            minifyFontValues: true,
-            minifyGradients: true,
-            minifyParams: true,
-            minifySelectors: true,
-            normalizeCharset: true,
-            normalizeDisplayValues: true,
-            normalizePositions: true,
-            normalizeRepeatStyle: true,
-            normalizeString: true,
-            normalizeTimingFunctions: true,
-            normalizeUnicode: true,
-            normalizeUrl: true,
-            normalizeWhitespace: true,
-            orderedValues: true,
-            reduceIdents: false, // Unsafe
-            reduceInitial: true,
-            reduceTransforms: true,
-            svgo: false, // Off for speed
-            uniqueSelectors: true,
-            zindex: false, // Unsafe
-            filterPlugins: false // I don't know where this one came from. It is not listed in the documentation.
-        }
-    ]
-};
-function makeDefaultPostCSSFunctions(variables) {
-    const magnitude = new Intl.NumberFormat("en-US", { maximumFractionDigits: 4 });
-    return {
-        pxAsRem(value) {
-            return value ? `${magnitude.format(parseFloat(value.toString()) / (variables("font_size") || 16))}rem` : "1rem";
-        }
-    };
-}
-function postcssConfigBuilder(verbose, variables, postCSSFunctions) {
-    return {
-        plugins: [
-            require("postcss-import")(), // Once
-            require("@plaudit/postcss-silent-extend")({ warnOfUnused: verbose }), // Once (marks), OnceExit (apply)
-            require("postcss-mixins")(), // There is a PostCSS 8 version, but we're forced to use the old one because the new one uses AtRule, which is too late in the process
-            require("@plaudit/postcss-variables")({ variables }), // Once
-            require("postcss-functions")({ functions: { ...makeDefaultPostCSSFunctions(variables), ...postCSSFunctions(variables) } }),
-            require("@plaudit/postcss-legacy-shorthand/position")(), // Legacy
-            require("@plaudit/postcss-legacy-shorthand/size")(), // Legacy
-            require("@plaudit/postcss-legacy-shorthand/spacing")(), // Legacy
-            require("postcss-property-lookup")({ logLevel: "warn" }), // Rule
-            require("@plaudit/postcss-strip-units")(), // AtRule, Declaration
-            require("postcss-media-minmax")(), // AtRule
-            require("postcss-nested")(), // Rule
-            require("postcss-url")(),
-            require("postcss-calc")(calcOptions), // OnceExit
-            require("@plaudit/postcss-color-function")(), // OnceExit
-            require("autoprefixer")(autoprefixerOptions), // OnceExit
-            require("postcss-reporter")({ clearReportedMessages: true }), // OnceExit
-            (0, cssnano_1.default)(nanoConfig)
-        ]
-    };
-}

package/dist/utils/entrypoint-resolution-logic.d.ts

@@ -1,10 +0,0 @@
-import { type AdvancedOutputConfig, type PlauditWordpressWebpackConfig } from "../shared";
-export declare const enum SourceType {
-    blocks = "blocks",
-    extensions = "extensions",
-    plain = "plain"
-}
-export declare function isSourceType(str: string): str is SourceType;
-type Entrypoints = [string, AdvancedOutputConfig][];
-export declare function resolveAllConfigLevelEntrypoints(config: PlauditWordpressWebpackConfig, projectRoot?: string): Record<'staticEntrypoints' | 'dynamicEntrypoints', Entrypoints>;
-export {};

package/dist/utils/entrypoint-resolution-logic.js

@@ -1,82 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.isSourceType = isSourceType;
-exports.resolveAllConfigLevelEntrypoints = resolveAllConfigLevelEntrypoints;
-const node_path_1 = require("node:path");
-const location_encoding_filename_parser_1 = require("./location-encoding-filename-parser");
-const path_query_and_related_helpers_1 = require("./path-query-and-related-helpers");
-const shared_1 = require("../shared");
-function isSourceType(str) {
-    return str === "blocks" /* SourceType.blocks */ || str === "extensions" /* SourceType.extensions */ || str === "plain" /* SourceType.plain */;
-}
-function resolveAllConfigLevelEntrypoints(config, projectRoot = process.cwd()) {
-    const srcDir = config.srcDir ?? "";
-    const normalizeSrcAndDestination = ([rawSrc, dest]) => {
-        let [src, pathQueryParameters] = (0, path_query_and_related_helpers_1.unpackPotentiallyPrefixedFilePath)(rawSrc);
-        if (srcDir) {
-            src = (0, node_path_1.join)(srcDir, src);
-        }
-        src = (0, node_path_1.isAbsolute)(src) ? (0, node_path_1.relative)(projectRoot, src) : src;
-        let resultObject;
-        if (dest.destination !== undefined && (0, node_path_1.isAbsolute)(dest.destination)) {
-            resultObject = { ...dest, destination: (0, node_path_1.relative)(projectRoot, dest.destination) };
-        }
-        else {
-            resultObject = { ...dest };
-        }
-        return [src, pathQueryParameters ? { ...resultObject, pathQueryParameters } : resultObject];
-    };
-    if (Array.isArray(config.src)) {
-        return {
-            staticEntrypoints: config.src.map(s => normalizeSrcAndDestination([s, { destination: s }])),
-            dynamicEntrypoints: []
-        };
-    }
-    else {
-        const configSrc = config.src ?? {};
-        // We check for files with location-encoding filenames and add the pertinent ones to the sources
-        const dynamicallyIncludedEntrypoints = [];
-        if (srcDir) { // This will only work if we have a unified src root
-            const dynamicallyIncludedEntrypointsRoot = (0, node_path_1.isAbsolute)(srcDir) ? srcDir : (0, node_path_1.join)(projectRoot, srcDir);
-            for (const dirent of (0, shared_1.synchronousDirIterator)(dynamicallyIncludedEntrypointsRoot)) {
-                if (dirent.name in configSrc || `./${dirent.name}` in configSrc) {
-                    continue;
-                }
-                if (dirent.isDirectory()) {
-                    // If it's a directory that does not have an existing config entry, but does correspond to one of the non-plain SourceTypes, assume that it matches that source type
-                    if (isSourceType(dirent.name) && dirent.name !== "plain" /* SourceType.plain */) {
-                        dynamicallyIncludedEntrypoints.push([dirent.name, { directoryLayout: dirent.name }]);
-                        continue;
-                    }
-                    for (const nestedDirent of (0, shared_1.synchronousDirIterator)((0, node_path_1.join)(dynamicallyIncludedEntrypointsRoot, dirent.name))) {
-                        if (!nestedDirent.isFile()) {
-                            continue;
-                        }
-                        const cfgName = (0, node_path_1.join)(dirent.name, nestedDirent.name);
-                        if (cfgName in configSrc || `./${cfgName}` in configSrc) {
-                            continue;
-                        }
-                        const parsedFilename = (0, location_encoding_filename_parser_1.parseLocationEncodingFilename)(cfgName);
-                        if (parsedFilename === undefined) {
-                            continue;
-                        }
-                        dynamicallyIncludedEntrypoints.push([cfgName, { locations: parsedFilename.locations, enqueuingFlags: parsedFilename.flags }]);
-                    }
-                }
-                else if (dirent.isFile()) {
-                    const parsedFilename = (0, location_encoding_filename_parser_1.parseLocationEncodingFilename)(dirent.name);
-                    if (parsedFilename === undefined) {
-                        continue;
-                    }
-                    dynamicallyIncludedEntrypoints.push([dirent.name, { locations: parsedFilename.locations, enqueuingFlags: parsedFilename.flags }]);
-                }
-            }
-        }
-        return {
-            staticEntrypoints: Object.entries(configSrc).map(([k, v]) => {
-                return normalizeSrcAndDestination([k, typeof v === 'boolean' ? {} : (typeof v === 'string' ? { destination: v } : v)]);
-            }),
-            dynamicEntrypoints: dynamicallyIncludedEntrypoints.map(normalizeSrcAndDestination)
-        };
-    }
-}

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

@@ -1,26 +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;
-    };
-    flags: NormalizedEnqueuingControlFlags;
-    niceName?: string;
-};
-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'>;
-} | undefined;
-/**
- * This handles detecting all keys of standardLocationNamesMeta as well as "view", "client-view", "editor", "client-editor", and "block-assets".
- * It MUST be kept in sync with standardLocationNamesMeta
- * @param segment
- */
-export declare function extractLocationFromPropertyEncodingFilenameSegment(segment: string): {
-    readonly locationName: "clientView" | "clientEditor" | "blockAssets" | "admin" | "login" | "customizer" | "analytics" | "register";
-    readonly priority: number | true;
-} | {
-    readonly locationName: false;
-    readonly priority?: undefined;
-};

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

@@ -1,118 +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 (name.startsWith("~")) {
-        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;
-    }
-    return { type, locations, flags, niceName };
-}
-function parseLocationEncodingFilenameForBlock(filename, errorBuilder = shared_1.newWebpackErrorForFile) {
-    const parsedFilename = parseLocationEncodingFilename(filename);
-    if (parsedFilename !== undefined) {
-        if ((0, shared_1.constantKeys)(parsedFilename.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).join(", ")}`, filename);
-        }
-        if (Object.values(parsedFilename.locations).some(value => typeof value === 'number')) {
-            throw errorBuilder(`Block assets cannot be enqueued with a priority`, filename);
-        }
-    }
-    return parsedFilename;
-}
-const standardLocationNamesAndPriorityPatternInFilenameSegment = /^(?:(?<view>clientView|client-view|view)|(?<editor>clientEditor|client-editor|editor)|(?<blockAssets>blockAssets|block-assets)|(?<locationName>admin|login|customizer|analytics|register))(?:[-=](?<priority>-?\d+))?$/;
-/**
- * This handles detecting all keys of standardLocationNamesMeta as well as "view", "client-view", "editor", "client-editor", and "block-assets".
- * It MUST be kept in sync with standardLocationNamesMeta
- * @param segment
- */
-function extractLocationFromPropertyEncodingFilenameSegment(segment) {
-    const { view, editor, blockAssets, locationName, priority: rawPriority } = standardLocationNamesAndPriorityPatternInFilenameSegment.exec(segment)
-        ?.groups ?? {};
-    const priority = rawPriority !== undefined ? parseInt(rawPriority) : true;
-    if (view) {
-        return { locationName: "clientView", priority };
-    }
-    if (editor) {
-        return { locationName: "clientEditor", priority };
-    }
-    if (blockAssets) {
-        return { locationName: "blockAssets", priority };
-    }
-    if (locationName) {
-        return { locationName, priority };
-    }
-    return { locationName: false };
-}

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

@@ -1,58 +0,0 @@
-import type { Compilation } from "webpack";
-import { type InlinedAsset, type PathQueryParameters, type ScriptArgsObject } 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 isValidLoadingStrategy(strategy: any): strategy is LoadingStrategy | undefined;
-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?: string;
-    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
- */
-export declare function convertEnqueuingControlFlagsToScriptArgsObject(compilation: Compilation, file: string, flags: NormalizedEnqueuingControlFlags | undefined): {
-    scriptArgsObject?: ScriptArgsObject;
-    inlinedAsset?: InlinedAsset;
-};

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

@@ -1,263 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getAssetFileContents = getAssetFileContents;
-exports.unpackPotentiallyPrefixedFilePath = unpackPotentiallyPrefixedFilePath;
-exports.unpackPathQuery = unpackPathQuery;
-exports.isValidLoadingStrategy = isValidLoadingStrategy;
-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 isValidLoadingStrategy(strategy) {
-    return strategy === undefined || (typeof strategy === 'string' && namedStrategies.includes(strategy));
-}
-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
- */
-function convertEnqueuingControlFlagsToScriptArgsObject(compilation, file, flags) {
-    if (flags === undefined) {
-        return {};
-    }
-    const { strategy, in_footer, inline, position, fetchpriority } = flags;
-    const scriptArgsObject = {};
-    let inlinedAsset = 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 = { contents: 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;
-        }
-    }
-    if (fetchpriority !== undefined) {
-        if (!isValidFetchPriority(fetchpriority)) {
-            throw newInvalidFetchPriorityError(fetchpriority, file);
-        }
-        if (inlinedAsset !== undefined) {
-            compilation.warnings.push((0, shared_1.newWebpackErrorForFile)("Fetchpriority has no effect on inlined assets", file));
-        }
-        scriptArgsObject.fetchpriority = fetchpriority;
-    }
-    return Object.keys(scriptArgsObject).length > 0 ? { scriptArgsObject, inlinedAsset } : { inlinedAsset };
-}
-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);
-}