@plaudit/webpack-extensions 2.84.1 → 2.85.1

package/CHANGELOG.md

@@ -5,6 +5,15 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [2.85.1] - 2026-03-06
+### Fixed
+- Inlined scripts without any other path query parameters not being placed in the footer by default
+
+## [2.85.0] - 2026-03-05
+### Added
+- Support for inlining (and otherwise controlling the enqueuing of) assets
+  - This only applies to plain entrypoints and assets declared within block.json files at present
+
 ## [2.84.1] - 2026-02-11
 ### Fixed
 - Typedef compatibility issues with Webpack 5.105.0

package/USER-GUIDE.md

@@ -186,6 +186,10 @@ module.exports = require("@plaudit/webpack-extensions/wordpress-scripts-wrapper"
 	  // A script that can be enqueued via its handle, but is not autoloaded
 	  "site/manually-loaded.ts": {
 		  locations: "plaudit-theme/manually-loaded-script"
+	  },
+	  // A script that will be inlined into the footer
+	  "site/inlined-script.ts?inline=true": {
+		  locations: "plaudit-theme/inlined-script"
 	  }
 	},
 	useWebpackResourceFiltering: true, // Always use this!
@@ -373,6 +377,11 @@ src: {
 ## Per-Entrypoint Options
 This section covers the shared options for entrypoints. See the [Entrypoint Types](#entrypoint-types) section for options specific to individual types
 
+### Path Queries
+- These are URL-style queries added to the end of entrypoint *source* paths and are used to set entrypoint-specific properties in Plain and Block contexts.
+  - At present, this is only being used to configure inlining, but expansion to other systems is being considered
+  - The available options are: `strategy`, `inline`, `in_footer`, `fetchpriority`, and `position`
+
 ### Boolean-form
 - This is only available if `outputDir` has been set
 - The only supported value is `true` and only works for `blocks` and `plain` entrypoints. It means that every value will have its default value

package/build/plugins/EnhancedBlockJSONPlugin.d.ts

@@ -1,12 +1,14 @@
 import { AbstractBiPhasicGroupAndEntryPlugin, EntryProvider } from "./AbstractBiPhasicGroupAndEntryPlugin";
-import { ParsedAssetsJson, BlockEntrypointInfo, FileSegmentBlockEntrypointInfo, VerifiedAdvancedOutputConfig, ParsedAssetJsonProvider } from "../shared";
+import { ParsedAssetsJson, BlockEntrypointInfo, FileSegmentBlockEntrypointInfo, VerifiedAdvancedOutputConfig, ParsedAssetJsonProvider, ScriptArgsObject, InlinedAsset } from "../shared";
 import type { VerifiedPlauditWordpressWebpackConfig } from "../utils/common-config-helpers";
 import { Compilation } from "webpack";
 import type WebpackRemoveEmptyScriptsPlugin from "webpack-remove-empty-scripts";
-type WorkableBlockEntrypointInfo = Omit<FileSegmentBlockEntrypointInfo, 'originalValue'> & Partial<Pick<FileSegmentBlockEntrypointInfo, 'originalValue'>> & {
+type WorkableBlockEntrypointInfo = Omit<FileSegmentBlockEntrypointInfo, 'originalValue' | 'pathQueryParameters'> & Partial<Pick<FileSegmentBlockEntrypointInfo, 'originalValue'>> & {
     outputPath: string;
     assetData: ParsedAssetsJson[string];
     hash: string;
+    scriptArgsObject: ScriptArgsObject | undefined;
+    inlinedAsset: InlinedAsset | undefined;
 };
 type CollatedWorkableBlockInfo = Record<string, {
     sourcePath?: string;

package/build/plugins/EnhancedBlockJSONPlugin.js

@@ -13,6 +13,7 @@ const UnifiedLoaderGenerator_1 = require("./UnifiedLoaderGenerator");
 const php_writer_1 = require("@plaudit/php-writer");
 const expressions_1 = require("@plaudit/php-writer/expressions");
 const shared_1 = require("../shared");
+const path_query_and_related_helpers_1 = require("../utils/path-query-and-related-helpers");
 const pseduo_semaphore_1 = require("../utils/pseduo-semaphore");
 const webpack_1 = require("webpack");
 class EnhancedBlockJSONPlugin extends AbstractBiPhasicGroupAndEntryPlugin_1.AbstractBiPhasicGroupAndEntryPlugin {
@@ -34,7 +35,6 @@ class EnhancedBlockJSONPlugin extends AbstractBiPhasicGroupAndEntryPlugin_1.Abst
             }
             const asset = [...compilation.chunkGraph.getChunkEntryModulesIterable(entrypoint.getEntrypointChunk())][0]?.originalSource();
             if (asset) {
-                //TODO: Can we guarantee that entrypoint.name is always non-null?
                 const epBlockJson = entrypoint.name + ".json";
                 if (!applicableBlockJsonFiles[epBlockJson]) {
                     const blockJsonText = EnhancedBlockJSONPlugin.extractAssetSource(compilation, epBlockJson)
@@ -62,20 +62,24 @@ class EnhancedBlockJSONPlugin extends AbstractBiPhasicGroupAndEntryPlugin_1.Abst
                     continue;
                 }
                 const workableBlockEntrypointsInfo = entrypoint.getFiles()
-                    .map(file => this.stripOffBlocksDestPrefix(file))
-                    .filter(file => !this.webpackRemoveEmptyScriptsPlugin['trash'].includes(node_path_1.default.join(this.dest.destination, file)))
+                    .filter(file => !this.webpackRemoveEmptyScriptsPlugin['trash'].includes(file))
                     .map(file => [file, (0, shared_1.scriptOrStyleTest)(file, shared_1.scriptExtension)])
                     .filter((item) => item[1] !== '')
                     .map(([file, assetType]) => {
+                    const pathQueryParameters = metadata.pathQueryParameters !== undefined || this.dest.pathQueryParameters !== undefined
+                        ? { ...metadata.pathQueryParameters, ...this.dest.pathQueryParameters }
+                        : undefined;
+                    const { scriptArgsObject, inlinedAsset } = (0, path_query_and_related_helpers_1.parseScriptArgsObjectFromPathQueryParameters)(compilation, file, pathQueryParameters);
                     const wasOriginallyAStyleField = (0, shared_1.isStyleField)(metadata.entrypointField);
+                    const outputPath = this.stripOffBlocksDestPrefix(file);
                     if (wasOriginallyAStyleField !== (assetType === "style")) { // This means that the file is extracted
                         const entrypointField = (0, shared_1.convertEntrypointFieldForAssetType)(metadata.entrypointField, assetType);
                         return {
-                            ...metadata, outputPath: file, assetData, originalValue: undefined, hash: entrypointChunk.hash ?? "",
-                            entrypointField, handleGroup: (0, shared_1.getHandleGroup)(entrypointField)
+                            ...metadata, outputPath, assetData, originalValue: undefined, hash: entrypointChunk.hash ?? "",
+                            entrypointField, handleGroup: (0, shared_1.getHandleGroup)(entrypointField), scriptArgsObject, inlinedAsset
                         };
                     }
-                    return ({ ...metadata, outputPath: file, assetData, hash: entrypointChunk.hash ?? "" });
+                    return { ...metadata, outputPath, assetData, hash: entrypointChunk.hash ?? "", scriptArgsObject, inlinedAsset };
                 });
                 if (applicableBlockJsonFiles[epBlockJson]) {
                     applicableBlockJsonFiles[epBlockJson].workableBlockEntrypointsInfo.push(...workableBlockEntrypointsInfo);
@@ -114,18 +118,54 @@ class EnhancedBlockJSONPlugin extends AbstractBiPhasicGroupAndEntryPlugin_1.Abst
             action
         } : undefined);
     }
-    emitBlockLoaderFile(compilation, blockData) {
+    emitBlockLoaderFile(compilation, blockDirConfig) {
         if (this.config.useUnifiedLoader) {
-            const metadata = blockData['__metadata'];
-            delete blockData['__metadata'];
-            (0, shared_1.emitPHPWriterAsAsset)(new php_writer_1.PHPWriter()
+            const { '__metadata': metadata, ...blockData } = blockDirConfig;
+            const splitOutInlinedAssets = (handles, type) => {
+                const registerableHandles = {};
+                const inlinedAssets = [];
+                for (const [handle, handleData] of Object.entries(handles)) {
+                    const { inlinedAsset, ...finalizedHandle } = handleData;
+                    if (inlinedAsset !== undefined) {
+                        finalizedHandle.src = false;
+                        inlinedAssets.push([handle, type, inlinedAsset, handleData, handleData.src]);
+                    }
+                    registerableHandles[handle] = finalizedHandle;
+                }
+                return [registerableHandles, inlinedAssets];
+            };
+            const [finalizedScriptHandles, inlinableScripts] = splitOutInlinedAssets(metadata.scriptHandles, 'script');
+            const [finalizedStyleHandles, inlinableStyles] = splitOutInlinedAssets(metadata.styleHandles, 'style');
+            const finalizedMetadata = Object.fromEntries(Object.entries(metadata)
+                .map(([key, value]) => {
+                if (key === 'scriptHandles') {
+                    return [key, finalizedScriptHandles];
+                }
+                if (key === 'styleHandles') {
+                    return [key, finalizedStyleHandles];
+                }
+                return [key, value];
+            }));
+            const writer = new php_writer_1.PHPWriter()
                 .action("init", writer => {
-                writer.call("\\Plaudit\\Common\\ACF\\BlockManager::autoloadSubfoldersV3", [expressions_1.Constants.__DIR__, new expressions_1.EnclosedLiteral((0, shared_1.makeEmittableConfigPHP)(blockData, false, "\t")),
-                    expressions_1.Constants.__FILE__, new expressions_1.EnclosedLiteral((0, shared_1.makeEmittableConfigPHP)(metadata, false, "\t")), null]);
-            }, { accountForAlreadyDoing: this.config.includePostInitFallback }), compilation, node_path_1.default.join(this.dest.destination, "blockdir-loader.php"));
+                writer.call("\\Plaudit\\Common\\ACF\\BlockManager::autoloadSubfoldersV3", [
+                    expressions_1.Constants.__DIR__, // string $dir
+                    new expressions_1.EnclosedLiteral((0, shared_1.makeEmittableConfigPHP)(blockData, false, "\t")), // array $blockdirConfig
+                    expressions_1.Constants.__FILE__, // string $blockdirConfigFile
+                    new expressions_1.EnclosedLiteral((0, shared_1.makeEmittableConfigPHP)(finalizedMetadata, false, "\t")), // array $metadata
+                    null // ?string $urlPrefix
+                ]);
+                for (const inlinableScript of inlinableScripts) {
+                    (0, shared_1.appendAddInlineAssetCall)(compilation, writer, ...inlinableScript);
+                }
+                for (const inlinableStyle of inlinableStyles) {
+                    (0, shared_1.appendAddInlineAssetCall)(compilation, writer, ...inlinableStyle);
+                }
+            }, { accountForAlreadyDoing: this.config.includePostInitFallback });
+            (0, shared_1.emitPHPWriterAsAsset)(writer, compilation, node_path_1.default.join(this.dest.destination, "blockdir-loader.php"));
         }
         else {
-            compilation.emitAsset(node_path_1.default.join(this.dest.destination, "blockdir.config.php"), new webpack_1.sources.RawSource((0, shared_1.makeEmittableConfigPHP)(blockData, true)));
+            compilation.emitAsset(node_path_1.default.join(this.dest.destination, "blockdir.config.php"), new webpack_1.sources.RawSource((0, shared_1.makeEmittableConfigPHP)(blockDirConfig, true)));
         }
     }
     transformBlocks(compilation, collatedWorkableBlockInfo, emittingWpmlXml) {
@@ -173,7 +213,7 @@ class EnhancedBlockJSONPlugin extends AbstractBiPhasicGroupAndEntryPlugin_1.Abst
                     .convertToScriptHandles(handleData.filter(hd => !(0, shared_1.isStyleField)(hd.entrypointField) && (0, shared_1.isScriptModuleField)(hd.entrypointField)))),
                 styleHandles: Object.fromEntries(handleData.filter(hd => (0, shared_1.isStyleField)(hd.entrypointField))
                     .map(hd => {
-                    return [hd.handle, { src: hd.outputPath, rest: [hd.originalValue !== undefined ? hd.assetData.dependencies : [], hd.assetData.version] }];
+                    return [hd.handle, { src: hd.outputPath, rest: [hd.originalValue !== undefined ? hd.assetData.dependencies : [], hd.assetData.version], inlinedAsset: hd.inlinedAsset }];
                 }))
             },
             ...Object.fromEntries(Object.entries(blockData).sort((a, b) => a[0].localeCompare(b[0])))
@@ -186,7 +226,20 @@ class EnhancedBlockJSONPlugin extends AbstractBiPhasicGroupAndEntryPlugin_1.Abst
     static convertToScriptHandles(handleData) {
         return handleData.map(hd => {
             const deps = hd.originalValue !== undefined ? hd.assetData.dependencies : [];
-            return [hd.handle, { src: hd.outputPath, rest: hd.entrypointField.startsWith("editor") ? [deps, hd.assetData.version] : [deps, hd.assetData.version, { strategy: "defer" }] }];
+            let scriptArgsObject;
+            if (hd.scriptArgsObject !== undefined) {
+                scriptArgsObject = hd.scriptArgsObject;
+            }
+            else if (hd.inlinedAsset !== undefined) {
+                scriptArgsObject = hd.inlinedAsset.position === 'before' ? { strategy: "defer" } : undefined;
+            }
+            else if (!hd.entrypointField.startsWith("editor")) {
+                scriptArgsObject = { strategy: "defer" };
+            }
+            else {
+                scriptArgsObject = undefined;
+            }
+            return [hd.handle, { src: hd.outputPath, rest: scriptArgsObject !== undefined ? [deps, hd.assetData.version, scriptArgsObject] : [deps, hd.assetData.version], inlinedAsset: hd.inlinedAsset }];
         });
     }
     static doFileOrHandleReplacements(compilation, blockJson, workableBlockEntrypointsInfo, getter) {

package/build/plugins/ExtensionsConfigFileGeneratorPluginV1.d.ts

@@ -1,5 +1,5 @@
 import { AbstractBiPhasicGroupAndEntryPlugin, EntryProvider } from "./AbstractBiPhasicGroupAndEntryPlugin";
-import { ParsedAssetJsonProvider } from "../shared";
+import type { ParsedAssetJsonProvider } from "../shared";
 import type { VerifiedPlauditWordpressWebpackConfig } from "../utils/common-config-helpers";
 import { Compilation } from "webpack";
 export declare class ExtensionsConfigFileGeneratorPluginV1 extends AbstractBiPhasicGroupAndEntryPlugin {

package/build/plugins/PlainEntrypointsConfigFileGeneratorPlugin.js

@@ -9,6 +9,7 @@ const php_writer_1 = require("@plaudit/php-writer");
 const expressions_1 = require("@plaudit/php-writer/expressions");
 const shared_1 = require("../shared");
 const pseduo_semaphore_1 = require("../utils/pseduo-semaphore");
+const path_query_and_related_helpers_1 = require("../utils/path-query-and-related-helpers");
 const AbstractBiPhasicGroupAndEntryPlugin_1 = require("./AbstractBiPhasicGroupAndEntryPlugin");
 const UnifiedLoaderGenerator_1 = require("./UnifiedLoaderGenerator");
 const webpack_1 = require("webpack");
@@ -29,6 +30,7 @@ class PlainEntrypointsConfigFileGeneratorPlugin extends AbstractBiPhasicGroupAnd
         const emitDir = node_path_1.default.join(this.buildRoot, this.outputDir);
         const handleLists = {
             register: [],
+            inline: [],
             ...Object.fromEntries((0, shared_1.constantKeys)(shared_1.standardLocationNamesMeta).map(sln => [sln, []]))
         };
         const allNamedHandles = assets
@@ -41,7 +43,7 @@ class PlainEntrypointsConfigFileGeneratorPlugin extends AbstractBiPhasicGroupAnd
                 .map(handle => [handle.handleName, handle.src]))]));
         const plainEntrypointsConfig = { scriptHandles: {}, script_moduleHandles: {}, styleHandles: {} };
         for (const { handles, handlePrefix } of assets) {
-            for (const { src, rest, locations, type, handleName, lazyLoader } of handles) {
+            for (const { src, rest, locations, type, handleName, lazyLoader, ...otherProps } of handles) {
                 const basename = node_path_1.default.basename(src).replace(/_(?:script(?:-\d+)?\.js|style(?:-\d+)?\.css)$|(?<!_(script|style))\.(js|css)$/, "");
                 let finalHandleName;
                 if (typeof handleName === 'string') {
@@ -55,7 +57,7 @@ class PlainEntrypointsConfigFileGeneratorPlugin extends AbstractBiPhasicGroupAnd
                     }
                     handleNameMap[finalHandleName] = src;
                 }
-                plainEntrypointsConfig[`${type}Handles`][finalHandleName] = { src, rest, locations, type, lazyLoader };
+                plainEntrypointsConfig[`${type}Handles`][finalHandleName] = { src, rest, locations, type, lazyLoader, ...otherProps };
             }
         }
         PlainEntrypointsConfigFileGeneratorPlugin.addHandlesToHandleLists('script', Object.entries(plainEntrypointsConfig.scriptHandles)
@@ -79,7 +81,26 @@ class PlainEntrypointsConfigFileGeneratorPlugin extends AbstractBiPhasicGroupAnd
                 writer.action("init", writer => {
                     writer.call("plaudit_webpack_extensions__resolve_base_uri", [expressions_1.Constants.__DIR__], { assignTo: baseUriVar });
                     for (const { handle, type, data } of prioritizedHandleList) {
-                        writer.call(`wp_register_${type}`, [handle, expressions_1.Op.concat(baseUriVar, node_path_1.default.relative(emitDir, data.src)), ...data.rest]);
+                        const { inlinedAsset, rest, src } = data;
+                        const emittedSrc = inlinedAsset === undefined
+                            ? expressions_1.Op.concat(baseUriVar, node_path_1.default.relative(emitDir, src))
+                            : false;
+                        writer.call(`wp_register_${type}`, [handle, emittedSrc, ...rest]);
+                        if (inlinedAsset !== undefined) {
+                            (0, shared_1.appendAddInlineAssetCall)(compilation, writer, handle, type, inlinedAsset, data, src);
+                        }
+                    }
+                }, { priority, accountForAlreadyDoing: this.config.includePostInitFallback });
+            }
+            for (const [priority, prioritizedHandleList] of PlainEntrypointsConfigFileGeneratorPlugin.separateHandleListByPriority(handleLists.inline)) {
+                writer.action("init", writer => {
+                    writer.call("plaudit_webpack_extensions__resolve_base_uri", [expressions_1.Constants.__DIR__], { assignTo: baseUriVar });
+                    for (const { handle, type, data } of prioritizedHandleList) {
+                        const { inlinedAsset, rest, src } = data;
+                        writer.call(`wp_register_${type}`, [handle, false, ...rest]);
+                        if (inlinedAsset !== undefined) {
+                            (0, shared_1.appendAddInlineAssetCall)(compilation, writer, handle, type, inlinedAsset, data, src);
+                        }
                     }
                 }, { priority, accountForAlreadyDoing: this.config.includePostInitFallback });
             }
@@ -127,6 +148,9 @@ class PlainEntrypointsConfigFileGeneratorPlugin extends AbstractBiPhasicGroupAnd
             if (data.locations.register !== false) {
                 handleLists.register.push({ handle, type, data, priority: typeof data.locations.register === 'number' ? data.locations.register : 10 });
             }
+            else if (data.inlinedAsset !== undefined) {
+                handleLists.inline.push({ handle, type, data, priority: typeof data.locations.inline === 'number' ? data.locations.inline : 10 });
+            }
             for (const location of (0, shared_1.constantKeys)(shared_1.standardLocationNamesMeta)) {
                 let priority, hook_name;
                 const dataLocation = data.locations[location];
@@ -277,14 +301,18 @@ class PlainEntrypointsConfigFileGeneratorPlugin extends AbstractBiPhasicGroupAnd
                 const type = extension === ".js" ? 'script' : (extension === ".mjs" ? 'script_module' : 'style');
                 const isScript = type !== 'style';
                 const dependencies = isScript === entrypointChunkIsScript ? assetData.dependencies : [];
-                const { registerScriptArgs } = this.dest.locations;
-                const rest = isScript && registerScriptArgs !== undefined ? [dependencies, assetData.version, registerScriptArgs] : [dependencies, assetData.version];
+                const { lazyLoader, locations } = this.dest;
+                const { inlinedAsset, scriptArgsObject } = (0, path_query_and_related_helpers_1.parseScriptArgsObjectFromPathQueryParameters)(compilation, file, (0, path_query_and_related_helpers_1.mergeInPathQueryParameters)(file, locations.registerScriptArgs, this.dest.pathQueryParameters));
+                const rest = isScript && scriptArgsObject !== undefined ? [dependencies, assetData.version, scriptArgsObject] : [dependencies, assetData.version];
                 const destPath = node_path_1.default.join(compilation.outputOptions.path, file);
                 handles.push({
-                    src: destPath, rest, type,
-                    locations: this.dest.locations,
-                    handleName: useHandleName ? this.dest.locations.handle : undefined,
-                    lazyLoader: this.dest.lazyLoader
+                    src: destPath,
+                    rest,
+                    type,
+                    locations,
+                    handleName: useHandleName ? locations.handle : undefined,
+                    lazyLoader,
+                    inlinedAsset
                 });
             }
             myAssetHandles.push({ handles, handlePrefix: this.config.targetHandlePrefix });

package/build/shared.d.ts

@@ -6,15 +6,20 @@ export type ParsedAssetsJson = Record<string, {
     version: string;
 }>;
 export declare function isParsedAssetsJson(thing: any): thing is ParsedAssetsJson;
-type ScriptArgsObject = {
+export type ScriptArgsObject = {
     strategy?: 'defer' | 'async';
     in_footer?: boolean;
     fetchpriority?: 'auto' | 'low' | 'high';
 };
 type BaseRestType = [/* dependencies: */ string[], /* version: */ string];
+export type InlinedAsset = {
+    contents: string;
+    position?: 'before' | 'after';
+};
 export type HandleData = {
     src: string;
-    rest: BaseRestType | [...BaseRestType, ScriptArgsObject | boolean];
+    rest: BaseRestType | [...BaseRestType, ScriptArgsObject];
+    inlinedAsset?: InlinedAsset;
 };
 export declare const standardLocationNamesMeta: {
     readonly clientView: {
@@ -53,17 +58,19 @@ type LocationWithHookNameSupport = boolean | number | string | string[] | {
     hook_name?: string | string[];
     priority?: number;
 };
+type InputRegisterScriptArgs = ScriptArgsObject | boolean | 'lazy' | 'eager' | 'inline';
 export type UsageLocations = {
     [K in StandardLocationNames]?: typeof standardLocationNamesMeta[K] extends {
         supports_hook_name: true;
     } ? LocationWithHookNameSupport : boolean | number;
 } & {
     register?: boolean | number;
+    inline?: number;
     handle?: string | ((generatedHandle: string) => string);
-    registerScriptArgs?: ScriptArgsObject | boolean | 'lazy';
+    registerScriptArgs?: InputRegisterScriptArgs;
 };
 export type NormalizedUsageLocations = Omit<UsageLocations, 'registerScriptArgs'> & {
-    registerScriptArgs?: ScriptArgsObject | boolean;
+    registerScriptArgs?: InputRegisterScriptArgs;
 };
 export declare function isNormalizedUsageLocations(usageLocations: UsageLocations): usageLocations is NormalizedUsageLocations;
 export declare function constantKeys<K extends string, V>(object: {
@@ -99,8 +106,9 @@ export type AdvancedOutputConfig = {
     bundleAnalyzer?: boolean;
     locations?: UsageLocations | UsageLocations['handle'];
     lazyLoader?: string;
+    pathQueryParameters?: PathQueryParameters;
 };
-type OptionalCfgFields = 'directoryLayout' | 'externalize' | 'lazyLoader';
+type OptionalCfgFields = 'directoryLayout' | 'externalize' | 'lazyLoader' | 'pathQueryParameters';
 export type VerifiedAdvancedOutputConfig = Required<Omit<AdvancedOutputConfig, 'locations' | OptionalCfgFields>> & Pick<AdvancedOutputConfig, OptionalCfgFields> & {
     locations: NormalizedUsageLocations;
 };
@@ -139,7 +147,9 @@ export type FileSegmentBlockEntrypointInfo = {
     handle: string;
     dest: VerifiedAdvancedOutputConfig;
     absoluteSrc: string;
+    pathQueryParameters: PathQueryParameters | undefined;
 };
+export type PathQueryParameters = Record<string, unknown | [unknown, ...unknown[]]>;
 export type BlockEntrypointInfo = FileSegmentBlockEntrypointInfo | {
     dest: VerifiedAdvancedOutputConfig;
     purpose: string;
@@ -163,6 +173,7 @@ export declare function scriptOrStyleTest(entryPath: string, scriptExtension: Re
 export declare function isStyleField(field: string): field is 'style' | 'viewStyle' | 'editorStyle';
 export declare function isScriptModuleField(field: string): field is 'viewScriptModule';
 export declare function getHandleGroup(field: string): 'styleHandles' | 'scriptHandles' | 'scriptModuleHandles';
+export type StripFirstTwoItems<A extends any[]> = A extends [any, any, ...rest: infer R] ? R : never;
 export declare function hasAtLeastOneItem<T>(list: T[]): list is [T, ...T[]];
 export type TupleOf<T, N extends number> = N extends N ? number extends N ? T[] : _TupleOf<T, N, []> : never;
 type _TupleOf<T, N extends number, R extends unknown[]> = R['length'] extends N ? R : _TupleOf<T, N, [T, ...R]>;
@@ -187,4 +198,14 @@ export declare function getParsedAssetsJsonDataForEntrypoint(compilation: Compil
 export declare function emitPHPWriterAsAsset(writer: PHPWriter, compilation: Compilation, file: string, assetInfo?: AssetInfo): void;
 export declare function dedent(text: TemplateStringsArray): string;
 export declare function resolveLegacyBlockScriptsInFolder(folder: string): string[];
+/**
+ * @param compilation
+ * @param writer
+ * @param handle
+ * @param type 'script_module' is NOT supported at this time; however, it is *handled* in this function
+ * @param inlinedAsset
+ * @param handleData
+ * @param file something that represents the file that is being inlined (this is purely for error-reporting purposes)
+ */
+export declare function appendAddInlineAssetCall(compilation: Compilation, writer: PHPWriter, handle: string, type: 'script' | 'style' | 'script_module', inlinedAsset: InlinedAsset, handleData: HandleData, file: string): void;
 export {};

package/build/shared.js

@@ -29,12 +29,14 @@ exports.getParsedAssetsJsonDataForEntrypoint = getParsedAssetsJsonDataForEntrypo
 exports.emitPHPWriterAsAsset = emitPHPWriterAsAsset;
 exports.dedent = dedent;
 exports.resolveLegacyBlockScriptsInFolder = resolveLegacyBlockScriptsInFolder;
+exports.appendAddInlineAssetCall = appendAddInlineAssetCall;
 const node_fs_1 = __importDefault(require("node:fs"));
 const promises_1 = __importDefault(require("node:fs/promises"));
 const node_path_1 = __importDefault(require("node:path"));
 const php_writer_1 = require("@plaudit/php-writer");
 const expressions_1 = require("@plaudit/php-writer/expressions");
 const webpack_1 = require("webpack");
+const node_crypto_1 = require("node:crypto");
 function isParsedAssetsJson(thing) {
     if (!thing || typeof thing !== 'object') {
         return false;
@@ -103,9 +105,9 @@ function leadingSlashIt(pathOrSomething) {
     return pathOrSomething.startsWith('/') ? pathOrSomething : ('/' + pathOrSomething);
 }
 exports.scriptExtension = /(?<filename>.+)(?<extension>\.m?[jt]sx?)$/i;
-exports.scriptWithoutModuleExtension = /(?<filename>.+)(?<extension>\.[jt]sx?)$/i;
-exports.scriptWithModuleExtension = /(?<filename>.+)(?<extension>\.m[jt]sx?)$/i;
-exports.styleExtension = /(?<filename>.+)(?<extension>\.(p?c|sa)ss)$/i;
+exports.scriptWithoutModuleExtension = /(?<filename>.+)(?<extension>\.[jt]sx?)($|\?)/i;
+exports.scriptWithModuleExtension = /(?<filename>.+)(?<extension>\.m[jt]sx?)($|\?)/i;
+exports.styleExtension = /(?<filename>.+)(?<extension>\.(p?c|sa)ss)($|\?)/i;
 function scriptOrStyleTest(entryPath, scriptExtension) {
     return scriptExtension.test(entryPath) ? "script" : (exports.styleExtension.test(entryPath) ? "style" : "");
 }
@@ -250,3 +252,25 @@ function resolveLegacyBlockScriptsInFolder(folder) {
     }
     return blockScriptEntrypoints;
 }
+/**
+ * @param compilation
+ * @param writer
+ * @param handle
+ * @param type 'script_module' is NOT supported at this time; however, it is *handled* in this function
+ * @param inlinedAsset
+ * @param handleData
+ * @param file something that represents the file that is being inlined (this is purely for error-reporting purposes)
+ */
+function appendAddInlineAssetCall(compilation, writer, handle, type, inlinedAsset, handleData, file) {
+    if (type === 'script_module') {
+        throw newWebpackErrorForFile("WordPress does not support inlined script modules", file);
+    }
+    if (handleData.rest[0]?.length) { // If there are any dependencies
+        compilation.errors.push(newWebpackErrorForFile("Inlined scripts MUST NOT have dependencies. It WILL cause runtime inconsistencies and potentially cause sever performance issues", handleData.src));
+    }
+    const args = [handle, new expressions_1.HereOrNowDoc(`plaudit_inlined_${type}_${(0, node_crypto_1.createHash)('md5').update(handle).digest("hex")}`, inlinedAsset.contents, false)];
+    if (type === 'script' && inlinedAsset.position === 'before') {
+        args.push('before');
+    }
+    writer.call(`wp_add_inline_${type}`, args);
+}

package/build/utils/common-config-helpers.js

@@ -10,6 +10,7 @@ exports.commonMakeWebpackConfig = commonMakeWebpackConfig;
 const node_fs_1 = __importDefault(require("node:fs"));
 const promises_1 = __importDefault(require("node:fs/promises"));
 const node_path_1 = __importDefault(require("node:path"));
+const path_query_and_related_helpers_1 = require("./path-query-and-related-helpers");
 const shared_1 = require("../shared");
 const css_minimizer_webpack_plugin_1 = __importDefault(require("css-minimizer-webpack-plugin"));
 function joinPossiblyAbsolutePaths(...paths) {
@@ -34,7 +35,8 @@ function mapToRealEntrypoints(entrypoint, dir, supportedExtensions, args) {
     return (Array.isArray(entrypoint) ? entrypoint : [entrypoint])
         .map(ep => joinPossiblyAbsolutePaths(dir, mapper(ep)))
         .filter(ep => supportedExtensions(ep) && node_fs_1.default.statSync(ep, { throwIfNoEntry: false })?.isFile())
-        .map(ep => {
+        .map(path_query_and_related_helpers_1.unpackPotentiallyPrefixedFilePath)
+        .map(([ep, pathQueryParameters]) => {
         const parsedEntrypoint = node_path_1.default.parse(ep);
         const entrypointField = shared_1.styleExtension.test(ep) ? 'style' : shared_1.scriptWithModuleExtension.test(ep) ? 'viewScriptModule' : 'script';
         const fakeEntrypointInfo = {
@@ -45,7 +47,8 @@ function mapToRealEntrypoints(entrypoint, dir, supportedExtensions, args) {
             handle: (0, shared_1.convertUsageLocationsHandleToEmittableHandle)(dest.locations.handle, parsedEntrypoint.name),
             handleGroup: (0, shared_1.getHandleGroup)(entrypointField),
             dest,
-            absoluteSrc: ep
+            absoluteSrc: ep,
+            pathQueryParameters
         };
         return [joinPossiblyAbsolutePaths(dest.destination, node_path_1.default.basename(parsedEntrypoint.dir), parsedEntrypoint.name),
             { import: [ep], plauditMetadata: fakeEntrypointInfo }];
@@ -134,17 +137,19 @@ function resolveEntryFromDirectory(commonConfig, srcRoot, dest) {
                         .filter(entrypointField => entrypointField in blockJson)
                         .flatMap(entrypointField => {
                         return (Array.isArray(blockJson[entrypointField]) ? blockJson[entrypointField] : [blockJson[entrypointField]])
-                            .filter(originalValue => originalValue.startsWith("file:"))
+                            .filter(originalValue => typeof originalValue === 'string')
+                            .filter(originalValue => originalValue?.startsWith("file:"))
                             .map(originalValue => {
-                            const entrypointPath = originalValue.substring(5);
+                            const [entrypointPath, localPathQueryParameters] = (0, path_query_and_related_helpers_1.unpackPotentiallyPrefixedFilePath)(originalValue);
                             const absoluteSrc = node_path_1.default.normalize(node_path_1.default.join(dir, entrypointPath));
+                            const pathQueryParameters = (0, path_query_and_related_helpers_1.mergeInPathQueryParameters)(absoluteSrc, localPathQueryParameters, dest.pathQueryParameters);
                             return promises_1.default.stat(absoluteSrc)
                                 .then(stats => {
                                 if (stats.isFile()) {
                                     const parsedEntrypoint = node_path_1.default.parse(node_path_1.default.normalize(node_path_1.default.join(dest.destination, node_path_1.default.relative(srcRoot, dir), entrypointPath)));
                                     const extensionlessExpectedSrc = node_path_1.default.normalize(node_path_1.default.join(parsedEntrypoint.dir, parsedEntrypoint.name));
                                     const entrypointName = node_path_1.default.normalize(joinPossiblyAbsolutePaths(parsedEntrypoint.dir, parsedEntrypoint.name));
-                                    return { entrypointField, originalValue, entrypointName, extensionlessExpectedSrc, absoluteSrc };
+                                    return { entrypointField, originalValue, entrypointName, extensionlessExpectedSrc, absoluteSrc, pathQueryParameters };
                                 }
                                 else {
                                     return undefined;
@@ -196,7 +201,7 @@ function resolveEntryFromDirectory(commonConfig, srcRoot, dest) {
                             }
                         ];
                     }));
-                    rawEntrypoints.push([blockJsonChunkName, { import: [blockJsonOrigin], plauditMetadata: { purpose: "block-json-inclusion-assurance", dest, absoluteSrc: blockJsonOrigin } }]);
+                    rawEntrypoints.push([blockJsonChunkName, { import: [blockJsonOrigin], plauditMetadata: { purpose: "block-json-inclusion-assurance", dest, absoluteSrc: blockJsonOrigin, pathQueryParameters: undefined } }]);
                     wpmlFiles.push(node_path_1.default.join(dir, 'block.json'));
                 }
                 catch (e) {

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

@@ -0,0 +1,53 @@
+import { Compilation } from "webpack";
+import { InlinedAsset, PathQueryParameters, ScriptArgsObject, 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 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;
+export declare function mergeInPathQueryParameters(file: string, registerScriptArgs: UsageLocations['registerScriptArgs'], pathQueryParameters: PathQueryParameters | undefined): NormalizedScriptEnqueuingControlFlags | undefined;
+/**
+ * This function ensures that the passed pathQueryParameters are normalized for the config-loading step, NOT the emission step
+ */
+export type NormalizedScriptEnqueuingControlFlags = {
+    strategy?: Exclude<LoadingStrategy, 'inline'>;
+    in_footer?: InFooter;
+    inline?: boolean;
+    fetchpriority?: FetchPriority;
+    position?: 'before' | 'after';
+};
+/**
+ * This function does a few things:
+ * <ol>
+ *     <li>It extracts strategy, in_footer, and fetchpriority from pathQueryParameters</li>
+ *     <li>If the strategy is, 'inline', it records the contents of the asset for later injection inline and removes the asset from the compilation output</li>
+ * </ol>
+ * @param compilation
+ * @param file
+ * @param pathQueryParameters
+ */
+export declare function parseScriptArgsObjectFromPathQueryParameters(compilation: Compilation, file: string, pathQueryParameters: PathQueryParameters | undefined): {
+    scriptArgsObject?: ScriptArgsObject;
+    inlinedAsset?: InlinedAsset;
+};

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

@@ -0,0 +1,278 @@
+"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.mergeInPathQueryParameters = mergeInPathQueryParameters;
+exports.parseScriptArgsObjectFromPathQueryParameters = parseScriptArgsObjectFromPathQueryParameters;
+const shared_1 = require("../shared");
+const node_path_1 = require("node:path");
+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 mergeInPathQueryParameters(file, registerScriptArgs, pathQueryParameters) {
+    const baseArgs = unpackRegisterScriptArgsFromPathQueryParameters(typeof registerScriptArgs === 'object' ? registerScriptArgs : { strategy: registerScriptArgs }, file, 'registerScriptArgs');
+    const pathQueryArgs = unpackRegisterScriptArgsFromPathQueryParameters(pathQueryParameters, file, 'path query parameters');
+    if (baseArgs === undefined) {
+        return pathQueryArgs;
+    }
+    if (pathQueryArgs === undefined) {
+        return baseArgs;
+    }
+    for (const key of ['strategy', 'in_footer', 'fetchpriority', 'inline', 'position']) {
+        if (key in baseArgs) {
+            if (key in pathQueryArgs && pathQueryArgs[key] !== baseArgs[key]) {
+                throw (0, shared_1.newWebpackErrorForFile)(`The ${key} values in the registerScriptArgs and the pathQueryParameters for the file conflict`, file);
+            }
+        }
+        else if (key in pathQueryArgs) {
+            baseArgs[key] = pathQueryArgs[key];
+        }
+    }
+    return baseArgs;
+}
+function unpackRegisterScriptArgsFromPathQueryParameters(pathQueryParameters, file, sourceType) {
+    if (pathQueryParameters === undefined) {
+        return undefined;
+    }
+    let hasAnyKeys = false;
+    let baseArgs;
+    const strategy = pathQueryParameters['strategy'];
+    switch (strategy) {
+        case 'eager':
+            hasAnyKeys = true;
+            baseArgs = { strategy: 'eager' };
+            break;
+        case 'lazy':
+            hasAnyKeys = true;
+            baseArgs = { strategy: 'defer', in_footer: true };
+            break;
+        case 'inline':
+            hasAnyKeys = true;
+            baseArgs = { inline: true };
+            break;
+        case true:
+        case false:
+            hasAnyKeys = true;
+            baseArgs = { in_footer: strategy };
+            break;
+        case null:
+        case undefined:
+            baseArgs = {};
+            break;
+        default:
+            throw newInvalidLoadingStrategyError(strategy, file);
+    }
+    if (baseArgs.inline === undefined && pathQueryParameters['inline'] !== undefined) {
+        baseArgs.inline = !!pathQueryParameters['inline'];
+    }
+    const in_footer = pathQueryParameters['in_footer'] ?? pathQueryParameters['in-footer'];
+    if (in_footer !== undefined) {
+        if (!isValidInFooter(in_footer)) {
+            throw newInvalidInFooterError(in_footer, file);
+        }
+        hasAnyKeys = true;
+        baseArgs.in_footer = in_footer;
+    }
+    if (pathQueryParameters['fetchpriority'] !== undefined) {
+        if (!isValidFetchPriority(pathQueryParameters['fetchpriority'])) {
+            throw newInvalidFetchPriorityError(pathQueryParameters['fetchpriority'], file);
+        }
+        if (baseArgs.fetchpriority !== undefined && baseArgs.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);
+        }
+        hasAnyKeys = true;
+        baseArgs.fetchpriority = pathQueryParameters['fetchpriority'];
+    }
+    if (pathQueryParameters['inline'] !== undefined) {
+    }
+    return hasAnyKeys ? baseArgs : undefined;
+}
+/**
+ * This function does a few things:
+ * <ol>
+ *     <li>It extracts strategy, in_footer, and fetchpriority from pathQueryParameters</li>
+ *     <li>If the strategy is, 'inline', it records the contents of the asset for later injection inline and removes the asset from the compilation output</li>
+ * </ol>
+ * @param compilation
+ * @param file
+ * @param pathQueryParameters
+ */
+function parseScriptArgsObjectFromPathQueryParameters(compilation, file, pathQueryParameters) {
+    if (pathQueryParameters === undefined) {
+        return {};
+    }
+    const scriptArgsObject = {};
+    let inlinedAsset = undefined;
+    let hasAnyKeys = false;
+    const strategy = pathQueryParameters['strategy'];
+    switch (strategy) {
+        case 'async':
+        case 'defer':
+            hasAnyKeys = true;
+            scriptArgsObject.strategy = strategy;
+            break;
+        case 'eager':
+            hasAnyKeys = true;
+            scriptArgsObject.in_footer = false;
+            break;
+        case 'lazy':
+            hasAnyKeys = true;
+            scriptArgsObject.strategy = 'defer';
+            scriptArgsObject.in_footer = true;
+            break;
+        case 'inline':
+            inlinedAsset = { contents: getAssetFileContents(compilation, file) };
+            removeFileAndAssetPHP(compilation, file);
+            if ('inline' in pathQueryParameters) {
+                compilation.warnings.push((0, shared_1.newWebpackErrorForFile)("The inline parameter should not be set when setting strategy to 'inline'", file));
+            }
+            break;
+        case true:
+        case false:
+            hasAnyKeys = true;
+            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);
+    }
+    const in_footer = pathQueryParameters['in_footer'] ?? pathQueryParameters['in-footer'];
+    if (in_footer !== undefined) {
+        if (!isValidInFooter(in_footer)) {
+            throw newInvalidInFooterError(in_footer, file);
+        }
+        hasAnyKeys = true;
+        scriptArgsObject.in_footer = in_footer;
+    }
+    if (inlinedAsset === undefined && pathQueryParameters['inline']) {
+        inlinedAsset = { contents: getAssetFileContents(compilation, file) };
+        removeFileAndAssetPHP(compilation, file);
+    }
+    if (inlinedAsset !== undefined) {
+        if (pathQueryParameters['position'] !== undefined) {
+            if (!isValidPositionForInlineStrategy(pathQueryParameters['position'])) {
+                throw newInvalidPositionForInlineStrategyError(pathQueryParameters['position'], file);
+            }
+            inlinedAsset.position = pathQueryParameters['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) {
+            hasAnyKeys = true;
+            scriptArgsObject.in_footer = true;
+        }
+    }
+    const fetchpriority = pathQueryParameters['fetchpriority'];
+    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));
+        }
+        hasAnyKeys = true;
+        scriptArgsObject.fetchpriority = fetchpriority;
+    }
+    return hasAnyKeys ? { 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);
+}

package/build/wordpress-scripts-wrapper.js

@@ -25,6 +25,7 @@ const UnifiedLoaderGenerator_1 = require("./plugins/UnifiedLoaderGenerator");
 const copy_webpack_plugin_1 = __importDefault(require("copy-webpack-plugin"));
 const fork_ts_checker_webpack_plugin_1 = __importDefault(require("fork-ts-checker-webpack-plugin"));
 const webpack_remove_empty_scripts_1 = __importDefault(require("webpack-remove-empty-scripts"));
+const path_query_and_related_helpers_1 = require("./utils/path-query-and-related-helpers");
 function testForDuplicatedEntryPaths(sources) {
     const seenPaths = (0, common_config_helpers_1.groupEntrypointsByAssetFile)(Array.isArray(sources)
         ? sources.map(s => typeof s === 'string' ? s : s[1].destination)
@@ -188,15 +189,16 @@ function buildVerifiedConfig(config) {
             throw new Error("Plain Entrypoints V2 and higher require 'outputDir' to be set");
         }
     }
-    const normalizeSrcAndDestination = ([src, dest]) => {
+    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)(process.cwd(), src) : src;
         if (dest.destination !== undefined && (0, node_path_1.isAbsolute)(dest.destination)) {
-            dest = { ...dest, destination: (0, node_path_1.relative)(process.cwd(), dest.destination) };
+            return [src, { ...dest, destination: (0, node_path_1.relative)(process.cwd(), dest.destination), pathQueryParameters }];
         }
-        return [src, dest];
+        return [src, { ...dest, pathQueryParameters }];
     };
     const rawSources = Array.isArray(config.src)
         ? config.src.map(s => normalizeSrcAndDestination([s, { destination: s }]))
@@ -221,29 +223,22 @@ function buildVerifiedConfig(config) {
     // Destination -> source map
     const allocatedDestinations = {};
     const partiallyVerifiedSources = rawSources.map(rawSource => {
-        const { destination, additionalDependencies = [], assumeGlobalizedPlauditLibraries = cfg.assumeGlobalizedPlauditLibraries, bundleAnalyzer = false, directoryLayout, externalize, withLegacyBlocksIn = false, lazyLoader } = rawSource[1];
+        const { destination, additionalDependencies = [], assumeGlobalizedPlauditLibraries = cfg.assumeGlobalizedPlauditLibraries, bundleAnalyzer = false, directoryLayout, externalize, withLegacyBlocksIn = false, lazyLoader, pathQueryParameters } = rawSource[1];
         const normalizedParts = { additionalDependencies, assumeGlobalizedPlauditLibraries, bundleAnalyzer, directoryLayout, externalize, withLegacyBlocksIn, lazyLoader };
         const locations = typeof rawSource[1].locations === 'string' || typeof rawSource[1].locations === 'function'
             ? { handle: rawSource[1].locations } : rawSource[1].locations ?? {};
-        let normalizedLocations;
-        if ((0, shared_1.isNormalizedUsageLocations)(locations)) {
-            normalizedLocations = locations;
-        }
-        else if (locations.registerScriptArgs === 'lazy') {
-            normalizedLocations = { ...locations, registerScriptArgs: { strategy: 'defer', in_footer: true } };
-        }
-        else {
-            throw new ReferenceError("The only supported string value for registerScript args is 'lazy'");
+        if (typeof locations.registerScriptArgs === 'string' && !['lazy', 'eager', 'inline'].includes(locations.registerScriptArgs)) {
+            throw new ReferenceError("The only supported string values for registerScriptArgs are 'lazy', 'eager', and 'inline'");
         }
         if (destination !== undefined) {
             const effectiveDestination = toEffectiveWebpackDestination(destination);
-            allocatedDestinations[effectiveDestination] = rawSource[0]; // We need to pre-populate the allocatedDestinations map with statically-declared destinations
-            return [rawSource[0], { ...normalizedParts, locations: normalizedLocations, destination, effectiveDestination, staticallyDeclaredDestination: true }];
+            allocatedDestinations[effectiveDestination] = rawSource[0]; // We need to pre-populate the allocatedDestinations map with statically declared destinations
+            return [rawSource[0], { ...normalizedParts, locations, destination, effectiveDestination, staticallyDeclaredDestination: true, pathQueryParameters }];
         }
         else {
             const naiveDestination = deriveNaiveDestinationFromUnverifiedSourceEntry(rawSource, srcPrefixes);
             const effectiveDestination = toEffectiveWebpackDestination(naiveDestination);
-            return [rawSource[0], { ...normalizedParts, locations: normalizedLocations, destination: naiveDestination, effectiveDestination, staticallyDeclaredDestination: false }];
+            return [rawSource[0], { ...normalizedParts, locations, destination: naiveDestination, effectiveDestination, staticallyDeclaredDestination: false, pathQueryParameters }];
         }
     });
     const dynamicEffectiveDestinationsWithExpectedNaiveDuplicates = partiallyVerifiedSources

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@plaudit/webpack-extensions",
-  "version": "2.84.1",
+  "version": "2.85.1",
   "license": "SEE LICENSE IN LICENSE.md",
   "files": [
     "/build",
@@ -24,9 +24,9 @@
     }
   },
   "devDependencies": {
-    "@plaudit/gutenberg-api-extensions": "^2.85.0",
+    "@plaudit/gutenberg-api-extensions": "^2.87.0",
     "@types/browser-sync-webpack-plugin": "^2.2.5",
-    "@types/node": "^25.2.3",
+    "@types/node": "^25.3.5",
     "@types/postcss-functions": "^4.0.4",
     "@types/tapable": "^2.3.0",
     "@types/webpack-sources": "^3.2.3",
@@ -36,22 +36,22 @@
     "webpack-bundle-analyzer": "^4.10.2"
   },
   "dependencies": {
-    "@plaudit/php-writer": "^1.3.3",
+    "@plaudit/php-writer": "^1.4.1",
     "@plaudit/postcss-color-function": "^5.0.0",
     "@plaudit/postcss-legacy-shorthand": "^1.0.0",
     "@plaudit/postcss-silent-extend": "^3.0.0",
     "@plaudit/postcss-strip-units": "^3.0.0",
     "@plaudit/postcss-variables": "^1.1.0",
-    "@wordpress/dependency-extraction-webpack-plugin": "^6.39.0",
-    "@wordpress/scripts": "^31.4.0",
-    "autoprefixer": "^10.4.24",
+    "@wordpress/dependency-extraction-webpack-plugin": "^6.41.0",
+    "@wordpress/scripts": "^31.6.0",
+    "autoprefixer": "^10.4.27",
     "browser-sync": "^3.0.4",
     "copy-webpack-plugin": "10.2.4",
     "css-minimizer-webpack-plugin": "^6.0.0",
     "fork-ts-checker-webpack-plugin": "^9.1.0",
     "http-proxy-middleware": "^3.0.5",
     "json2php": "^0.0.12",
-    "postcss": "^8.5.6",
+    "postcss": "^8.5.8",
     "postcss-calc": "^9.0.1",
     "postcss-discard-comments": "^6.0.2",
     "postcss-functions": "^4.0.2",
@@ -63,7 +63,7 @@
     "postcss-reporter": "^7.1.0",
     "postcss-simple-vars": "^7.0.1",
     "postcss-url": "^10.1.3",
-    "webpack": "^5.105.1",
+    "webpack": "^5.105.4",
     "webpack-remove-empty-scripts": "^1.1.1",
     "xml-formatter": "^3.6.7"
   },