@plaudit/webpack-extensions 2.95.0 → 2.96.1

package/CHANGELOG.md

@@ -60,6 +60,26 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - Legacy PostCSS features that have been integrated into modern CSS
 - `@extends` support
 
+## [2.96.1] - 2026-08-10
+### Fixed
+- An error in how externalized dependencies were resolved that caused jquery to never be emitted as a depenedency
+
+## [2.96.0] - 2026-08-07
+### Added
+- A port of WordPress's Dependency Extraction Webpack Plugin because they keep breaking it
+- Warnings and additional info for entrypoints that are lazy-loaded and assigned to actual locations
+
+### Removed
+- "combineAssetMetadata" - it has never actually been a valid prop
+
+### Fixed
+- Path-query handle handling
+- Double emission of CSS from entrypoint.json files when module processing is enabled
+- A bug that could result in writes outside the webpack context root
+
+### Changed
+- Backported the hook_name fix from the 3.x branch
+
 ## [2.95.0] - 2026-08-04
 ### Added
 - Logic so that files and directories with names equal to "example" or "examples" or that include "example" as a name segment are skipped
@@ -295,7 +315,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [2.72.1] - 2025-10-29
 ### Fixed
-- The wrapper being unable to find the `DependencyExtractionWebpackPlugin` due to version desyncs
+- The wrapper being unable to find the `EnhancedDependencyExtractionWebpackPlugin` due to version desyncs
   - This isn't so much a "fix" as it is a "mitigation" - version desyncs are not fixable at the library level
 
 ## [2.72.0] - 2025-10-13

package/USER-GUIDE.md

@@ -314,7 +314,7 @@ src: {
 | `srcDir`                           | `string`  | `""`    | Source directory (**Required** on new sites)                                                                                                                                                 |
 | `outputDir`                        | `string`  | `""`    | Output directory (**Required** on new sites)                                                                                                                                                 |
 | `useUnifiedLoader`                 | `boolean` | `false` | Generate unified-loader.php (always set to `true` on new sites!)                                                                                                                             |
-| `useWebpackResourceFiltering`      | `boolean` | `false` | Generates versioned copies of images, fonts, etc (always set to `true` on new sites!)                                                                                                        |
+| `useWebpackResourceFiltering`      | `boolean` | `true`  | Generates versioned copies of images, fonts, etc (always set to `true` on new sites!)                                                                                                        |
 | `plainEntrypointsVersion`          | `1\|2`    | `1`     | Use 2 for new sites                                                                                                                                                                          |
 | `extensionsVersion`                | `1\|2\|3` | `1`     | Use 3 for new sites                                                                                                                                                                          |
 | `verbose`                          | `boolean` | `false` | Verbose logging                                                                                                                                                                              |

package/dist/plugins/AbstractBiPhasicGroupAndEntryPlugin.d.ts

@@ -2,7 +2,7 @@ import { MinimumViableMetadata, ParsedAssetJsonProvider, ParsedAssetsJson } from
 import type { ExtensibleEntryObject, VerifiedPlauditWordpressWebpackConfig } from "../utils/common-config-helpers";
 import { PseudoSemaphore } from "../utils/pseduo-semaphore";
 import { AbstractBiPhasicGroupPlugin } from "./AbstractBiPhasicGroupPlugin";
-import { Compilation, Compiler, Entrypoint } from "webpack";
+import { type Compilation, type Compiler, type Entrypoint } from "webpack";
 export type EntryProvider<M extends MinimumViableMetadata = MinimumViableMetadata> = () => ExtensibleEntryObject<M> | Promise<ExtensibleEntryObject<M>>;
 export declare abstract class AbstractBiPhasicGroupAndEntryPlugin<M extends MinimumViableMetadata = MinimumViableMetadata> extends AbstractBiPhasicGroupPlugin {
     private readonly context;

package/dist/plugins/EnhancedBlockJSONPlugin.d.ts

@@ -24,6 +24,7 @@ export declare class EnhancedBlockJSONPlugin extends AbstractBiPhasicGroupAndEnt
     constructor(config: VerifiedPlauditWordpressWebpackConfig, dest: VerifiedAdvancedOutputConfig, webpackRemoveEmptyScriptsPlugin: WebpackRemoveEmptyScriptsPlugin, context: string, entry: EntryProvider<BlockEntrypointInfo>);
     protected processAssets(compilation: Compilation, parsedAssetJsonProvider: ParsedAssetJsonProvider): Promise<void>;
     private emitBlockLoaderFile;
+    private static readonly THEME_JSON_FLAG_PROPS;
     private static pickOutFlagPropsFromBlockSupports;
     private callRegisterFunction;
     private transformBlocks;

package/dist/plugins/EnhancedBlockJSONPlugin.js

@@ -226,37 +226,48 @@ class EnhancedBlockJSONPlugin extends AbstractBiPhasicGroupAndEntryPlugin_1.Abst
             compilation.emitAsset((0, node_path_1.join)(this.dest.destination, "blockdir.config.php"), new webpack_1.sources.RawSource((0, shared_1.makeEmittableConfigPHP)(blockDirConfig, true)));
         }
     }
-    // This isn't strictly necessary, but it allows us to trivially eliminate commonly-used block supports flags that aren't used in theme.json
-    // private static readonly IGNORED_THEME_JSON_FLAG_PROPS = ['align', 'alignWide', 'anchor', 'contentRole', 'inserter', 'interactivity', 'listView', 'plaudit'];
+    /*
+     * The block supports that have a boolean counterpart under theme.json's settings, as
+     * `settings key -> {support prop: settings prop}`. This is an allow-list rather than an ignore-list
+     * because most supports (align, alignWide, anchor, contentRole, inserter, interactivity, listView,
+     * plaudit, ...) have no theme.json settings equivalent at all, and the ones that do don't always
+     * share a name: typography's fontSize is settings.typography.customFontSize, and Gutenberg still
+     * ships several of these under an __experimental prefix.
+     */
+    static THEME_JSON_FLAG_PROPS = {
+        color: { background: 'background', link: 'link', text: 'text' },
+        dimensions: { aspectRatio: 'aspectRatio', minHeight: 'minHeight' },
+        spacing: { blockGap: 'blockGap', margin: 'margin', padding: 'padding' },
+        typography: {
+            fontSize: 'customFontSize',
+            lineHeight: 'lineHeight',
+            textAlign: 'textAlign',
+            fontStyle: 'fontStyle', __experimentalFontStyle: 'fontStyle',
+            fontWeight: 'fontWeight', __experimentalFontWeight: 'fontWeight',
+            letterSpacing: 'letterSpacing', __experimentalLetterSpacing: 'letterSpacing',
+            textDecoration: 'textDecoration', __experimentalTextDecoration: 'textDecoration',
+            textTransform: 'textTransform', __experimentalTextTransform: 'textTransform',
+            writingMode: 'writingMode', __experimentalWritingMode: 'writingMode'
+        }
+    };
     static pickOutFlagPropsFromBlockSupports(supports) {
         function isRecord(value) {
             return typeof value === 'object' && !!value && !Array.isArray(value);
         }
         let addedProp = false;
         const res = {};
-        if ('color' in supports) {
-            const color = supports.color;
-            if (isRecord(color)) {
-                const colorFlags = {};
-                for (const prop of ['background', 'link', 'text']) {
-                    if (supports[prop]) {
-                        colorFlags[prop] = true;
-                        res.color = colorFlags;
-                        addedProp = true;
-                    }
-                }
+        for (const [settingsKey, props] of Object.entries(EnhancedBlockJSONPlugin.THEME_JSON_FLAG_PROPS)) {
+            const support = supports[settingsKey];
+            if (!isRecord(support)) {
+                continue;
             }
-        }
-        if ('dimensions' in supports) {
-            const dimensions = supports.dimensions;
-            if (isRecord(dimensions)) {
-                const dimensionsFlags = {};
-                for (const prop of ['aspectRatio']) {
-                    if (supports[prop]) {
-                        dimensionsFlags[prop] = true;
-                        res.color = dimensionsFlags;
-                        addedProp = true;
-                    }
+            const flags = {};
+            for (const [supportProp, settingsProp] of Object.entries(props)) {
+                // A sided support such as `"margin": ["top", "bottom"]` is still just "on" as far as theme.json is concerned
+                if (support[supportProp]) {
+                    flags[settingsProp] = true;
+                    res[settingsKey] = flags;
+                    addedProp = true;
                 }
             }
         }

package/dist/plugins/PlainEntrypointsConfigFileGeneratorPlugin.js

@@ -43,7 +43,7 @@ class PlainEntrypointsConfigFileGeneratorPlugin extends AbstractBiPhasicGroupAnd
             for (const { src, rest, locations, type, handleName, lazyLoader, ...otherProps } of handles) {
                 const cleanBasename = (0, node_path_1.basename)(src).replace(/_(?:script(?:-\d+)?\.js|style(?:-\d+)?\.css)$|(?<!_(script|style))\.(js|css)$/, "");
                 let finalHandleName;
-                if (typeof handleName === 'string') {
+                if (handleName !== undefined) {
                     finalHandleName = (0, shared_1.convertUsageLocationsHandleToEmittableHandle)(handleName, cleanBasename);
                 }
                 else {
@@ -57,13 +57,13 @@ class PlainEntrypointsConfigFileGeneratorPlugin extends AbstractBiPhasicGroupAnd
                 plainEntrypointsConfig[`${type}Handles`][finalHandleName] = { src, rest, locations, type, lazyLoader, ...otherProps };
             }
         }
-        PlainEntrypointsConfigFileGeneratorPlugin.addHandlesToHandleLists('script', Object.entries(plainEntrypointsConfig.scriptHandles)
+        PlainEntrypointsConfigFileGeneratorPlugin.addHandlesToHandleLists(compilation, 'script', Object.entries(plainEntrypointsConfig.scriptHandles)
             .toSorted(([a], [b]) => a.localeCompare(b)), handleLists);
-        PlainEntrypointsConfigFileGeneratorPlugin.addHandlesToHandleLists('script_module', Object.entries(plainEntrypointsConfig.script_moduleHandles)
+        PlainEntrypointsConfigFileGeneratorPlugin.addHandlesToHandleLists(compilation, 'script_module', Object.entries(plainEntrypointsConfig.script_moduleHandles)
             .toSorted(([a], [b]) => a.localeCompare(b)), handleLists);
         const sortedStyleHandles = Object.entries(plainEntrypointsConfig.styleHandles)
             .toSorted(([a], [b]) => a.localeCompare(b));
-        PlainEntrypointsConfigFileGeneratorPlugin.addHandlesToHandleLists('style', sortedStyleHandles, handleLists);
+        PlainEntrypointsConfigFileGeneratorPlugin.addHandlesToHandleLists(compilation, 'style', sortedStyleHandles, handleLists);
         const callItemSorter = (a, b) => a.handle.localeCompare(b.handle);
         for (const list of Object.values(handleLists)) {
             list.sort(callItemSorter);
@@ -121,8 +121,10 @@ class PlainEntrypointsConfigFileGeneratorPlugin extends AbstractBiPhasicGroupAnd
                 writer.return(editorSettings);
             }, { functionArgParameters: [editorSettings], accountForAlreadyDoing: false });
         }
-        const lazyLoadedHandles = Object.values(handleLists)
-            .flatMap(handleList => handleList.map(handle => [handle.data.lazyLoader, handle]))
+        // Only the register and inline lists, which are mutually exclusive, so each handle is collected
+        // exactly once. Flattening every list instead would collect a handle once per location it declares.
+        const lazyLoadedHandles = [...handleLists.register, ...handleLists.inline]
+            .map(handle => [handle.data.lazyLoader, handle])
             .filter((entry) => entry[0] !== undefined)
             .sort((a, b) => a[0].localeCompare(b[0]) || a[1].priority - b[1].priority);
         if (lazyLoadedHandles.length > 0) {
@@ -142,7 +144,7 @@ class PlainEntrypointsConfigFileGeneratorPlugin extends AbstractBiPhasicGroupAnd
         }
         (0, shared_1.emitPHPWriterAsAsset)(writer, compilation, "plain-entrypoints-loader.php");
     }
-    static addHandlesToHandleLists(type, handles, handleLists) {
+    static addHandlesToHandleLists(compilation, type, handles, handleLists) {
         const defaultPriority = 10;
         for (const [handle, data] of handles) {
             if (data.locations.register !== false) {
@@ -151,6 +153,19 @@ class PlainEntrypointsConfigFileGeneratorPlugin extends AbstractBiPhasicGroupAnd
             else if (data.inlinedAsset !== undefined) {
                 handleLists.inline.push({ handle, type, data, priority: typeof data.locations.inline === 'number' ? data.locations.inline : 10 });
             }
+            if (data.lazyLoader !== undefined) {
+                // A lazily loaded handle is enqueued by its generated function and never by an action, so it
+                // is deliberately kept out of the location lists. Those lists are also what the lazy function
+                // is built from, and a handle present in several of them would be enqueued once per list.
+                const declaredLocations = (0, shared_1.constantKeys)(shared_1.standardLocationNamesMeta)
+                    .filter(location => data.locations[location] || typeof data.locations[location] === 'number');
+                if (declaredLocations.length > 0) {
+                    const locText = declaredLocations.length === 1 ? "location" : "locations";
+                    compilation.warnings.push((0, shared_1.newWebpackErrorForFile)(`The handle "${handle}" declares both a lazyLoader (${data.lazyLoader}) and the ${declaredLocations.join(", ")} ${locText}.`
+                        + ` It will only be enqueued by ${data.lazyLoader}(); remove either the ${locText} or the lazyLoader.`, data.src));
+                }
+                continue;
+            }
             for (const location of (0, shared_1.constantKeys)(shared_1.standardLocationNamesMeta)) {
                 let priority, hook_name;
                 const dataLocation = data.locations[location];
@@ -194,7 +209,6 @@ class PlainEntrypointsConfigFileGeneratorPlugin extends AbstractBiPhasicGroupAnd
         }
     }
     static appendEnqueuingHandleLists(writer, handleLists) {
-        const lazyLoadableHandles = {};
         for (const [sln, { action, supports_hook_name, additional_action_code }] of (0, shared_1.constantEntries)(shared_1.standardLocationNamesMeta)) {
             const handleList = handleLists[sln];
             if (handleList.length > 0) {
@@ -202,11 +216,14 @@ class PlainEntrypointsConfigFileGeneratorPlugin extends AbstractBiPhasicGroupAnd
                 for (const [priority, prioritizedHandleList] of PlainEntrypointsConfigFileGeneratorPlugin.separateHandleListByPriority(handleList)) {
                     if (supports_hook_name) {
                         const hookNamedHandleLists = PlainEntrypointsConfigFileGeneratorPlugin.separateHandleListByHookName(prioritizedHandleList);
-                        if (!(0, shared_1.arrayIsLength)(hookNamedHandleLists, 1) || hookNamedHandleLists[0][0] !== "") {
+                        if (hookNamedHandleLists.named.length > 0) {
                             const hook_name_var = new expressions_1.Var("hook_name", "?string");
                             writer.action(action, writer => {
                                 additional_action_code?.before?.(writer);
-                                for (const [hook_name, handles] of hookNamedHandleLists) {
+                                for (const handle of hookNamedHandleLists.global) {
+                                    writer.call(`wp_enqueue_${handle.type}`, [handle.handle]);
+                                }
+                                for (const [hook_name, handles] of hookNamedHandleLists.named) {
                                     writer.if(expressions_1.Op.binary(hook_name_var, " === ", hook_name));
                                     for (const handle of handles) {
                                         writer.call(`wp_enqueue_${handle.type}`, [handle.handle]);
@@ -228,7 +245,6 @@ class PlainEntrypointsConfigFileGeneratorPlugin extends AbstractBiPhasicGroupAnd
                 }
             }
         }
-        return lazyLoadableHandles;
     }
     static separateHandleListByPriority(handleItems) {
         const lists = new Map();
@@ -249,9 +265,16 @@ class PlainEntrypointsConfigFileGeneratorPlugin extends AbstractBiPhasicGroupAnd
      * @private
      */
     static separateHandleListByHookName(handleItems) {
+        const global = [];
         const lists = new Map();
         for (const handleItem of handleItems) {
             const hook_name = handleItem.hook_name ?? "";
+            if (hook_name === "" || (Array.isArray(hook_name) && hook_name.includes(""))) {
+                // We're going to be handling global hooks (aka those without a name restriction) separately anyway,
+                // so there's no sense in mixing them in with the non-global ones
+                global.push(handleItem);
+                continue;
+            }
             for (const hn of Array.isArray(hook_name) ? hook_name : [hook_name]) {
                 const list = lists.get(hn);
                 if (list) {
@@ -262,15 +285,7 @@ class PlainEntrypointsConfigFileGeneratorPlugin extends AbstractBiPhasicGroupAnd
                 }
             }
         }
-        return lists.entries().toArray().sort((a, b) => {
-            if (a[0] === "") {
-                return b[0] === "" ? 0 : -1;
-            }
-            else if (b[0] === "") {
-                return 1;
-            }
-            return a[0].localeCompare(b[0]);
-        });
+        return { global, named: lists.entries().toArray().sort((a, b) => a[0].localeCompare(b[0])) };
     }
     attachUniquePhase(compilation) {
         compilation.hooks.processAssets.tapPromise({ name: this.constructor.name, stage: webpack_1.Compilation.PROCESS_ASSETS_STAGE_REPORT }, async () => {

package/dist/plugins/dependency-extraction-webpack-plugin-config-builder.d.ts

@@ -1,7 +1,4 @@
-import DependencyExtractionWebpackPlugin from "@wordpress/dependency-extraction-webpack-plugin";
-import { Externals } from "../shared";
+import type { Externals } from "../shared";
+import { EnhancedDependencyExtractionWebpackPlugin } from "../wordpress-ports/dependency-extraction-webpack-plugin";
 import type { Configuration } from "webpack";
-export declare function makeDependencyExtractionPlugin(externals: Externals | undefined, assumeGlobalizedPlauditLibraries: boolean, wantsGroupedDepData: boolean, externalizing: Required<Configuration>['output']['library']): {
-    instance: DependencyExtractionWebpackPlugin;
-    addExternalizedDep: (dep: string) => void;
-};
+export declare function makeDependencyExtractionPlugin(externals: Externals | undefined, assumeGlobalizedPlauditLibraries: boolean, externalizing: Required<Configuration>['output']['library']): EnhancedDependencyExtractionWebpackPlugin;

package/dist/plugins/dependency-extraction-webpack-plugin-config-builder.js

@@ -1,19 +1,10 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.makeDependencyExtractionPlugin = makeDependencyExtractionPlugin;
-const dependency_extraction_webpack_plugin_1 = __importDefault(require("@wordpress/dependency-extraction-webpack-plugin"));
-function makeDependencyExtractionPlugin(externals, assumeGlobalizedPlauditLibraries, wantsGroupedDepData, externalizing) {
-    const baseProps = makeDependencyExtractionPluginProps(externals, assumeGlobalizedPlauditLibraries, externalizing);
-    const instance = new dependency_extraction_webpack_plugin_1.default(wantsGroupedDepData ? { ...baseProps, outputFormat: "json", combineAssets: true } : baseProps);
-    return {
-        instance,
-        addExternalizedDep: (dep) => {
-            instance.externalizedDeps.add(dep);
-        }
-    };
+const dependency_extraction_webpack_plugin_1 = require("../wordpress-ports/dependency-extraction-webpack-plugin");
+const util_1 = require("../wordpress-ports/dependency-extraction-webpack-plugin/util");
+function makeDependencyExtractionPlugin(externals, assumeGlobalizedPlauditLibraries, externalizing) {
+    return new dependency_extraction_webpack_plugin_1.EnhancedDependencyExtractionWebpackPlugin(makeDependencyExtractionPluginProps(externals, assumeGlobalizedPlauditLibraries, externalizing));
 }
 function makeDependencyExtractionPluginProps(externals, assumeGlobalizedPlauditLibraries, externalizing) {
     if (!externals) {
@@ -93,7 +84,7 @@ const EXTERNALIZABLE_PLAUDIT_LIBRARIES = {
     ...Object.fromEntries(['@plaudit/frontend-apis', '@plaudit/library-extensions', '@plaudit/block-supports', '@plaudit/gutenberg-api-extensions']
         .map(req => {
         return [req, {
-                import: ['plaudit', camelCaseDash(req.substring(PLAUDIT_NAMESPACE.length))],
+                import: ['plaudit', (0, util_1.camelCaseDash)(req.substring(PLAUDIT_NAMESPACE.length))],
                 handle: `plaudit-${req.substring(PLAUDIT_NAMESPACE.length)}`
             }];
     })),
@@ -116,12 +107,6 @@ function normalizeRequest(request) {
 function curryRequestHandlers(primary, secondary) {
     return (...args) => primary(...args) ?? secondary(...args);
 }
-/**
- * Copied from @wordpress/dependency-extraction-webpack-plugin for consistency
- */
-function camelCaseDash(string) {
-    return string.replace(/-([a-z])/g, (_, letter) => letter.toUpperCase());
-}
 function handleExternalizingEqualsPossibleExternal(possibleExternal, ext) {
     if (!ext || !possibleExternal) {
         return possibleExternal;
@@ -151,7 +136,9 @@ function handleExternalizingEqualsPossibleExternal(possibleExternal, ext) {
     }
     else {
         for (const key of ['amd', 'commonjs', 'root']) {
-            if (key in ext && handleExternalizingEqualsPossibleExternal(possibleExternal, ext[key])) {
+            // The recursion returns the external when it should be kept and undefined when it matched, so
+            // only an undefined result means this umd name is the thing being built and must not externalize.
+            if (key in ext && handleExternalizingEqualsPossibleExternal(possibleExternal, ext[key]) === undefined) {
                 return undefined;
             }
         }

package/dist/shared.d.ts

@@ -5,17 +5,20 @@ import { type AssetInfo, type Compilation, type Configuration, type Entrypoint,
 import { SourceType } from "./utils/entrypoint-resolution-logic";
 import type { NormalizedEnqueuingControlFlags } from "./utils/path-query-and-related-helpers";
 export * from "./utils/entrypoint-resolution-logic";
-export type WPModuleDependency = {
+export type WPModuleDependency = string | {
     id: string;
     import?: string;
 };
-export type ParsedAssetsJson = Record<string, {
-    dependencies: string[];
+export type ParsedAssetJson = {
+    dependencies: WPModuleDependency[];
+    module_dependencies?: WPModuleDependency[];
     version: string;
-    module_dependencies?: (string | WPModuleDependency)[];
-}>;
+    type?: 'module';
+    handle?: string;
+};
+export type ParsedAssetsJson = Record<string, ParsedAssetJson>;
 export declare function isParsedAssetsJson(thing: any): thing is ParsedAssetsJson;
-type BaseRestType = [/* dependencies: */ string[], /* version: */ string];
+type BaseRestType = [/* dependencies: */ WPModuleDependency[], /* version: */ string];
 export type AssetMetaSegment = {
     inlinedAsset: InlinedAsset;
     assetContents: string;
@@ -28,7 +31,7 @@ export type ScriptArgsObject = {
     strategy?: 'defer' | 'async';
     in_footer?: boolean;
     fetchpriority?: 'auto' | 'low' | 'high';
-    module_dependencies?: (string | WPModuleDependency)[];
+    module_dependencies?: WPModuleDependency[];
 };
 export type InlinedAsset = {
     position?: 'before' | 'after';
@@ -118,7 +121,7 @@ export type AdvancedOutputConfig = {
     directoryLayout?: SourceType;
     assumeGlobalizedPlauditLibraries?: boolean;
     externalize?: Required<Configuration>['output']['library'];
-    bundleAnalyzer?: boolean;
+    bundleAnalyzer?: boolean | 'no-auto-open';
     locations?: UsageLocations | UsageLocations['handle'];
     lazyLoader?: string;
     pathQueryParameters?: PathQueryParameters;
@@ -143,7 +146,6 @@ export type PlauditWordpressWebpackConfig = {
     externals?: Externals;
     assumeGlobalizedPlauditLibraries?: boolean;
     processTranslationConfigs?: boolean;
-    combineAssetMetadata?: boolean;
     useWebpackResourceFiltering?: boolean;
     outputDir?: string;
     extensionsVersion?: 1 | 2 | 3;
@@ -170,7 +172,6 @@ export declare function applyStandards(config: PlauditWordpressWebpackConfig): {
     readonly externals?: Externals;
     readonly assumeGlobalizedPlauditLibraries?: boolean;
     readonly processTranslationConfigs?: boolean;
-    readonly combineAssetMetadata?: boolean;
     useWebpackResourceFiltering?: boolean;
     outputDir?: string;
     extensionsVersion?: 1 | 2 | 3;
@@ -228,7 +229,7 @@ export declare const styleExtension: RegExp;
 export declare function scriptOrStyleTest(entryPath: string, scriptExtension: RegExp): "script" | "style" | "";
 export declare function isStyleField(field: string): field is 'style' | 'viewStyle' | 'editorStyle';
 export declare function isScriptModuleField(field: string): field is 'viewScriptModule';
-export declare function mergeModuleDependencyArrays(a: (string | WPModuleDependency)[] | undefined, b: (string | WPModuleDependency)[] | undefined): (string | WPModuleDependency)[] | undefined;
+export declare function mergeModuleDependencyArrays(a: WPModuleDependency[] | undefined, b: WPModuleDependency[] | undefined): WPModuleDependency[] | undefined;
 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[]];
@@ -254,7 +255,7 @@ export declare function getParsedAssetsJsonDataForEntrypoint(compilation: Compil
     assetData: ParsedAssetsJson[string];
 } | undefined;
 export declare function emitPHPWriterAsAsset(writer: PHPWriter, compilation: Compilation, file: string, assetInfo?: AssetInfo): void;
-export declare function dedent(text: TemplateStringsArray): string;
+export declare function dedent(text: TemplateStringsArray, ...values: unknown[]): string;
 export declare function resolveLegacyBlockScriptsInFolder(folder: string): string[];
 /**
  * @param compilation

package/dist/shared.js

@@ -85,7 +85,7 @@ exports.standardLocationNamesMeta = {
     analytics: { action: "plaudit_enqueue_analytics" },
 };
 function isStandardLocationName(name) {
-    return name in exports.standardLocationNamesMeta;
+    return Object.hasOwn(exports.standardLocationNamesMeta, name);
 }
 function isRegisterScriptArgsShorthandName(name) {
     return ['lazy', 'eager', 'inline'].includes(name);
@@ -271,18 +271,10 @@ function emitResolveBaseUriFunction(writer) {
 }
 function getAssetsJson(compilation) {
     const asset = compilation.getAsset("assets.json");
-    if (!asset) {
-        throw new Error("assets.json is unexpectedly missing");
-    }
-    if (isParsedAssetsJson(asset.info["parsed-assets-json"])) {
+    if (asset && isParsedAssetsJson(asset.info["parsed-assets-json"])) {
         return asset.info["parsed-assets-json"];
     }
-    const parsedAssetJson = JSON.parse(asset.source.source().toString('utf-8'));
-    if (!isParsedAssetsJson(parsedAssetJson)) {
-        throw new Error("assets.json is does not match the RawAssetData format");
-    }
-    compilation.updateAsset("assets.json", s => s, a => ({ ...a, "parsed-assets-json": parsedAssetJson }));
-    return parsedAssetJson;
+    throw new Error("assets.json is unexpectedly missing");
 }
 function getParsedAssetsJsonDataForEntrypoint(compilation, entrypoint, metadata) {
     const dest = metadata.dest;
@@ -322,13 +314,24 @@ function emitPHPWriterAsAsset(writer, compilation, file, assetInfo) {
     const contents = writer.toString() + "\n";
     compilation[file in compilation.assets ? 'updateAsset' : 'emitAsset'](file, new webpack_1.sources.RawSource(contents), { size: Buffer.byteLength(contents), ...assetInfo });
 }
-function dedent(text) {
-    const actualText = text.join("\n");
-    const firstLineIndent = actualText.split("\r?\n").find(line => line.length > 0)?.match(/^\s+/)?.[0];
-    if (!firstLineIndent) {
-        return actualText;
+function dedent(text, ...values) {
+    const lines = text.reduce((result, part, i) => result + String(values[i - 1]) + part).split(/\r?\n/);
+    // A template that opens and closes on its own line frames the content with two throwaway lines
+    if (lines[0]?.trim() === "") {
+        lines.shift();
+    }
+    if (lines.length > 1 && lines.at(-1)?.trim() === "") {
+        lines.pop();
     }
-    return actualText.replaceAll(new RegExp("^" + firstLineIndent, 'mg'), "").replace(/\n{2}$/, "\n");
+    // Only the lines with content get a say in the indent, and a line break must never count as one
+    const indent = lines.filter(line => line.trim() !== "")
+        .reduce((shortest, line) => {
+        const lineIndent = /^[ \t]*/.exec(line)?.[0] ?? "";
+        return shortest === undefined || lineIndent.length < shortest.length ? lineIndent : shortest;
+    }, undefined);
+    return indent
+        ? lines.map(line => line.startsWith(indent) ? line.substring(indent.length) : line).join("\n")
+        : lines.join("\n");
 }
 function resolveLegacyBlockScriptsInFolder(folder) {
     const blockScriptEntrypoints = [];

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

@@ -233,7 +233,10 @@ function resolveEntryFromDirectory(commonConfig, srcRoot, dest) {
                     const resolvedBlockEntrypoints = presentEntrypoints
                         .map(presentEntrypoint => {
                         const overallSource = (0, node_path_1.dirname)(blockJsonOrigin);
-                        const overallSourceRelativeName = (0, node_path_1.relative)(overallSource, (0, node_path_1.normalize)((0, node_path_1.join)(blockJsonOrigin, (0, node_path_1.relative)(overallSource, presentEntrypoint.extensionlessExpectedSrc))));
+                        // The handle suffix is the asset's extensionless name relative to its own block, so it
+                        // has to come off the real on-disk path rather than the destination-relative expected src.
+                        const parsedAbsoluteSrc = (0, node_path_1.parse)(presentEntrypoint.absoluteSrc);
+                        const overallSourceRelativeName = (0, node_path_1.normalize)((0, node_path_1.join)((0, node_path_1.relative)(overallSource, parsedAbsoluteSrc.dir), parsedAbsoluteSrc.name));
                         const handleSuffix = (0, shared_1.convertUsageLocationsHandleToEmittableHandle)(dest.locations.handle, overallSourceRelativeName);
                         const handleGroup = (0, shared_1.getHandleGroup)(presentEntrypoint.entrypointField);
                         if (presentEntrypoint.handle) {
@@ -277,15 +280,15 @@ function resolveEntryFromDirectory(commonConfig, srcRoot, dest) {
                         const packageJsonOrigin = (0, node_path_1.join)(dir, 'package.json');
                         const packageJson = JSON.parse(await (0, promises_1.readFile)(packageJsonOrigin, 'utf8'));
                         if (packageJson['main']) {
-                            rawEntrypoints.push(...mapToRealEntrypoints(packageJson['main'], dir, commonConfig.scriptExtension.test, { dest, entrypointJsonOrigin: packageJsonOrigin }));
+                            rawEntrypoints.push(...mapToRealEntrypoints(packageJson['main'], dir, s => commonConfig.scriptExtension.test(s), { dest, entrypointJsonOrigin: packageJsonOrigin }));
                         }
                         if (!processingModules && packageJson['style']) {
-                            rawEntrypoints.push(...mapToRealEntrypoints(packageJson['style'], dir, shared_1.styleExtension.test, { dest, entrypointJsonOrigin: packageJsonOrigin }));
+                            rawEntrypoints.push(...mapToRealEntrypoints(packageJson['style'], dir, s => shared_1.styleExtension.test(s), { dest, entrypointJsonOrigin: packageJsonOrigin }));
                         }
                     }
                     catch (e) {
                         try {
-                            rawEntrypoints.push(...parseEntrypointsJSON(dir, dest, ep => commonConfig.scriptExtension.test(ep) || shared_1.styleExtension.test(ep)));
+                            rawEntrypoints.push(...parseEntrypointsJSON(dir, dest, ep => commonConfig.scriptExtension.test(ep) || (!processingModules && shared_1.styleExtension.test(ep))));
                         }
                         catch (e) {
                             // This just means that the directory doesn't contain any declared entrypoints.

package/dist/utils/css-writer.js

@@ -9,7 +9,7 @@ function convertToCSS(writableCSSObject, pretty = true) {
         return convertToCSSPretty(writableCSSObject, "");
     }
     else {
-        return convertToCSS(writableCSSObject);
+        return convertToCSSUgly(writableCSSObject);
     }
 }
 function convertToCSSPretty(writableCSSObject, indentation) {
@@ -23,7 +23,7 @@ function convertToCSSPretty(writableCSSObject, indentation) {
         }
         else {
             res += " {\n";
-            res += convertToCSSPretty(writableCSSObject, indentation + "\t");
+            res += convertToCSSPretty(value, indentation + "\t");
             res += indentation + "}\n";
         }
     }
@@ -39,7 +39,7 @@ function convertToCSSUgly(writableCSSObject) {
             res += `:${value};`;
         }
         else {
-            res += "{" + convertToCSSUgly(writableCSSObject) + "}";
+            res += "{" + convertToCSSUgly(value) + "}";
         }
     }
     return res;

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

@@ -84,7 +84,7 @@ function parseLocationEncodingFilenameForBlock(filename, errorBuilder = shared_1
     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);
+            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(parsedFilename.locations).some(value => typeof value === 'number')) {
             throw errorBuilder(`Block assets cannot be enqueued with a priority`, filename);

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

@@ -15,7 +15,6 @@ export declare function unpackPotentiallyPrefixedFilePath(filePath: string): [st
  */
 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;

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

@@ -3,7 +3,6 @@ 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;
@@ -78,9 +77,6 @@ function unpackPathQuery(pathQuery) {
     }, {});
 }
 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);
 }