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

package/{dist → build}/plugins/PlainEntrypointsConfigFileGeneratorPlugin.js

@@ -1,12 +1,14 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PlainEntrypointsConfigFileGeneratorPlugin = void 0;
-const node_path_1 = require("node:path");
+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 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");
@@ -24,10 +26,9 @@ class PlainEntrypointsConfigFileGeneratorPlugin extends AbstractBiPhasicGroupAnd
         this.useUnifiedLoader = useUnifiedLoader;
     }
     generatePlainEntrypointsLoader(compilation, assets) {
-        const emitDir = (0, node_path_1.join)(this.buildRoot, this.outputDir);
+        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
@@ -40,21 +41,21 @@ 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, ...otherProps } of handles) {
-                const cleanBasename = (0, node_path_1.basename)(src).replace(/_(?:script(?:-\d+)?\.js|style(?:-\d+)?\.css)$|(?<!_(script|style))\.(js|css)$/, "");
+            for (const { src, rest, locations, type, handleName, lazyLoader } 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') {
-                    finalHandleName = (0, shared_1.convertUsageLocationsHandleToEmittableHandle)(handleName, cleanBasename);
+                    finalHandleName = (0, shared_1.convertUsageLocationsHandleToEmittableHandle)(handleName, basename);
                 }
                 else {
                     const handleNameMap = usedHandleNames[type];
-                    const baseFinalHandleName = finalHandleName = `${handlePrefix}.${(0, shared_1.convertUsageLocationsHandleToEmittableHandle)((0, shared_1.kebabCase)(cleanBasename), cleanBasename)}`;
+                    const baseFinalHandleName = finalHandleName = `${handlePrefix}.${(0, shared_1.convertUsageLocationsHandleToEmittableHandle)((0, shared_1.kebabCase)(basename), basename)}`;
                     for (let count = 0; finalHandleName in handleNameMap && handleNameMap[finalHandleName] !== src;) {
                         finalHandleName = `${baseFinalHandleName}-${++count}`;
                     }
                     handleNameMap[finalHandleName] = src;
                 }
-                plainEntrypointsConfig[`${type}Handles`][finalHandleName] = { src, rest, locations, type, lazyLoader, ...otherProps };
+                plainEntrypointsConfig[`${type}Handles`][finalHandleName] = { src, rest, locations, type, lazyLoader };
             }
         }
         PlainEntrypointsConfigFileGeneratorPlugin.addHandlesToHandleLists('script', Object.entries(plainEntrypointsConfig.scriptHandles)
@@ -78,26 +79,7 @@ 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) {
-                        const { inlinedAsset, rest, src } = data;
-                        const emittedSrc = inlinedAsset === undefined
-                            ? expressions_1.Op.concat(baseUriVar, (0, node_path_1.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);
-                        }
+                        writer.call(`wp_register_${type}`, [handle, expressions_1.Op.concat(baseUriVar, node_path_1.default.relative(emitDir, data.src)), ...data.rest]);
                     }
                 }, { priority, accountForAlreadyDoing: this.config.includePostInitFallback });
             }
@@ -114,7 +96,7 @@ class PlainEntrypointsConfigFileGeneratorPlugin extends AbstractBiPhasicGroupAnd
         if (sortedEditorStyleHandles.length > 0) {
             writer.linebreak();
             for (const handleSrc of sortedEditorStyleHandles) {
-                const handlePath = (0, node_path_1.join)(this.outputDir, (0, node_path_1.relative)(emitDir, handleSrc));
+                const handlePath = node_path_1.default.join(this.outputDir, node_path_1.default.relative(emitDir, handleSrc));
                 writer.call("add_editor_style", [(0, shared_1.leadingSlashIt)(handlePath)]);
             }
         }
@@ -145,9 +127,6 @@ 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];
@@ -294,23 +273,18 @@ class PlainEntrypointsConfigFileGeneratorPlugin extends AbstractBiPhasicGroupAnd
                 chunkFiles[0][1] = true;
             }
             for (const [file, useHandleName] of chunkFiles) {
-                const extension = (0, node_path_1.extname)(file).toLowerCase();
+                const extension = node_path_1.default.extname(file).toLowerCase();
                 const type = extension === ".js" ? 'script' : (extension === ".mjs" ? 'script_module' : 'style');
                 const isScript = type !== 'style';
                 const dependencies = isScript === entrypointChunkIsScript ? assetData.dependencies : [];
-                const { lazyLoader, locations } = this.dest;
-                const { flags } = (0, path_query_and_related_helpers_1.unpackEnqueuingControlFlagsFromPathQueryParameters)(typeof locations.registerScriptArgs === 'object' ? locations.registerScriptArgs : { strategy: locations.registerScriptArgs }, file, "registerScriptArgs");
-                const { inlinedAsset, scriptArgsObject } = (0, path_query_and_related_helpers_1.convertEnqueuingControlFlagsToScriptArgsObject)(compilation, file, (0, path_query_and_related_helpers_1.mergeTwoEnqueuingControlFlagSets)(file, flags, this.dest.enqueuingFlags));
-                const rest = isScript && scriptArgsObject !== undefined ? [dependencies, assetData.version, scriptArgsObject] : [dependencies, assetData.version];
-                const destPath = (0, node_path_1.join)(compilation.outputOptions.path, file);
+                const { registerScriptArgs } = this.dest.locations;
+                const rest = isScript && registerScriptArgs !== undefined ? [dependencies, assetData.version, registerScriptArgs] : [dependencies, assetData.version];
+                const destPath = node_path_1.default.join(compilation.outputOptions.path, file);
                 handles.push({
-                    src: destPath,
-                    rest,
-                    type,
-                    locations,
-                    handleName: useHandleName ? locations.handle : undefined,
-                    lazyLoader,
-                    inlinedAsset
+                    src: destPath, rest, type,
+                    locations: this.dest.locations,
+                    handleName: useHandleName ? this.dest.locations.handle : undefined,
+                    lazyLoader: this.dest.lazyLoader
                 });
             }
             myAssetHandles.push({ handles, handlePrefix: this.config.targetHandlePrefix });

package/{dist → build}/plugins/UnifiedLoaderGenerator.d.ts

@@ -3,7 +3,7 @@ import { AbstractBiPhasicGroupPlugin } from "./AbstractBiPhasicGroupPlugin";
 import type { VerifiedPlauditWordpressWebpackConfig } from "../utils/common-config-helpers";
 import { PseudoSemaphore } from "../utils/pseduo-semaphore";
 import { Compilation } from "webpack";
-export type LoaderInfo = {
+type LoaderInfo = {
     group: string;
     action(writer: PHPWriter): void;
     requiresBaseURI: boolean;
@@ -18,3 +18,4 @@ export declare class UnifiedLoaderGenerator extends AbstractBiPhasicGroupPlugin
     private withDistDevLoader;
     private ensureDistExists;
 }
+export {};

package/build/plugins/static-configs.d.ts

@@ -0,0 +1,3 @@
+import type { Options as PostcssFunctionsOptions } from "postcss-functions";
+import type { PostCSSLoaderOptions } from "postcss-loader/dist/config";
+export declare function postcssConfigBuilder(variables: (name: string) => string | number | undefined, postCSSFunctions: (variables: (name: string) => unknown) => PostcssFunctionsOptions['functions']): PostCSSLoaderOptions;

package/build/plugins/static-configs.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.postcssConfigBuilder = postcssConfigBuilder;
+// Options: calc
+const calcOptions = { precision: 4, mediaQueries: true, selectors: true };
+// Options: autoprefixerOptions
+const autoprefixerOptions = { grid: "autoplace" };
+function makeDefaultPostCSSFunctions(variables) {
+    const magnitude = new Intl.NumberFormat("en-US", { maximumFractionDigits: 4 });
+    return {
+        pxAsRem(value) {
+            return value ? `${magnitude.format(parseFloat(value.toString()) / (variables("font_size") || 16))}rem` : "1rem";
+        }
+    };
+}
+function postcssConfigBuilder(variables, postCSSFunctions) {
+    return {
+        plugins: [
+            require("postcss-import")(), // Once
+            require("postcss-mixins")(), // Once
+            require("@plaudit/postcss-variables")({ variables }), // Once
+            require("postcss-functions")({ functions: { ...makeDefaultPostCSSFunctions(variables), ...postCSSFunctions(variables) } }),
+            require("postcss-property-lookup")({ logLevel: "warn" }), // Rule
+            require("@plaudit/postcss-strip-units")(), // AtRule, Declaration
+            require("postcss-nested")(), // Rule
+            require("postcss-url")(),
+            require("postcss-calc")(calcOptions), // OnceExit
+            require("@plaudit/postcss-color-function")(), // OnceExit
+            require("autoprefixer")(autoprefixerOptions), // OnceExit
+            require("postcss-reporter")({ clearReportedMessages: true }), // OnceExit
+        ]
+    };
+}

package/{dist → build}/shared.d.ts

@@ -1,28 +1,20 @@
 import { PHPWriter } from "@plaudit/php-writer";
 import type { Options as PostcssFunctionsOptions } from "postcss-functions";
-import { type AssetInfo, type Compilation, type Configuration, type Entrypoint, WebpackError, type Compiler } from "webpack";
-import { SourceType } from "./utils/entrypoint-resolution-logic";
-import type { NormalizedEnqueuingControlFlags } from "./utils/path-query-and-related-helpers";
-export * from "./utils/entrypoint-resolution-logic";
+import { AssetInfo, Compilation, Configuration, Entrypoint, WebpackError, Compiler } from "webpack";
 export type ParsedAssetsJson = Record<string, {
     dependencies: string[];
     version: string;
 }>;
 export declare function isParsedAssetsJson(thing: any): thing is ParsedAssetsJson;
-export type ScriptArgsObject = {
+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];
-    inlinedAsset?: InlinedAsset;
+    rest: BaseRestType | [...BaseRestType, ScriptArgsObject | boolean];
 };
 export declare const standardLocationNamesMeta: {
     readonly clientView: {
@@ -57,34 +49,34 @@ export type StandardLocationNameMeta = {
     };
 };
 export type StandardLocationNames = keyof typeof standardLocationNamesMeta;
-export declare function isStandardLocationName(name: string): name is StandardLocationNames;
 type LocationWithHookNameSupport = boolean | number | string | string[] | {
     hook_name?: string | string[];
     priority?: number;
 };
-type InputRegisterScriptArgs = ScriptArgsObject | boolean | 'lazy' | 'eager' | 'inline';
-export declare function isRegisterScriptArgsShorthandName(name: string): name is Extract<InputRegisterScriptArgs, string>;
-export type RealUsageLocations = {
+export type UsageLocations = {
     [K in StandardLocationNames]?: typeof standardLocationNamesMeta[K] extends {
         supports_hook_name: true;
     } ? LocationWithHookNameSupport : boolean | number;
-};
-export type UsageLocations = RealUsageLocations & {
+} & {
     register?: boolean | number;
-    inline?: number;
     handle?: string | ((generatedHandle: string) => string);
-    registerScriptArgs?: InputRegisterScriptArgs;
+    registerScriptArgs?: ScriptArgsObject | boolean | 'lazy';
 };
 export type NormalizedUsageLocations = Omit<UsageLocations, 'registerScriptArgs'> & {
-    registerScriptArgs?: InputRegisterScriptArgs;
+    registerScriptArgs?: ScriptArgsObject | boolean;
 };
 export declare function isNormalizedUsageLocations(usageLocations: UsageLocations): usageLocations is NormalizedUsageLocations;
 export declare function constantKeys<K extends string, V>(object: {
-    [k in K]?: V;
+    [k in K]: V;
 }): K[];
 export declare function constantEntries<K extends string, V>(object: {
     [k in K]: V;
 }): [K, V][];
+export declare const enum SourceType {
+    blocks = "blocks",
+    extensions = "extensions",
+    plain = "plain"
+}
 export declare function determineCurrentSourceType(dest: string | AdvancedOutputConfig, srcIsDirectory: boolean): SourceType;
 export interface WebpackPlugin {
     apply(compiler: Compiler): void;
@@ -107,21 +99,17 @@ export type AdvancedOutputConfig = {
     bundleAnalyzer?: boolean;
     locations?: UsageLocations | UsageLocations['handle'];
     lazyLoader?: string;
-    pathQueryParameters?: PathQueryParameters;
-    enqueuingFlags?: NormalizedEnqueuingControlFlags;
 };
-type OptionalCfgFields = 'directoryLayout' | 'externalize' | 'lazyLoader' | 'pathQueryParameters';
-export type VerifiedAdvancedOutputConfig = Required<Omit<AdvancedOutputConfig, 'locations' | 'enqueuingFlags' | OptionalCfgFields>> & Pick<AdvancedOutputConfig, OptionalCfgFields> & {
-    enqueuingFlags: NormalizedEnqueuingControlFlags | undefined;
+type OptionalCfgFields = 'directoryLayout' | 'externalize' | 'lazyLoader';
+export type VerifiedAdvancedOutputConfig = Required<Omit<AdvancedOutputConfig, 'locations' | OptionalCfgFields>> & Pick<AdvancedOutputConfig, OptionalCfgFields> & {
     locations: NormalizedUsageLocations;
 };
 export type SourcesObject = Record<string, string | AdvancedOutputConfig | boolean>;
 export type PlauditWordpressWebpackConfig = {
-    standard?: '2026-03-13';
     standaloneBlocks?: boolean;
     variables?: Record<string, any>;
     verbose?: boolean;
-    src?: string[] | SourcesObject;
+    src: string[] | SourcesObject;
     stats?: Configuration['stats'];
     postcss?: {
         functions?: (variables: (name: string) => unknown) => PostcssFunctionsOptions['functions'];
@@ -142,41 +130,6 @@ export type PlauditWordpressWebpackConfig = {
     omitDistDev?: boolean;
     onlyRunPostCSSOnPCSS?: boolean;
 };
-export declare function applyStandards(config: PlauditWordpressWebpackConfig): {
-    readonly standard?: "2026-03-13";
-    readonly standaloneBlocks?: boolean;
-    readonly variables?: Record<string, any>;
-    readonly verbose?: boolean;
-    readonly src?: string[] | SourcesObject;
-    readonly stats?: Configuration["stats"];
-    readonly postcss?: {
-        functions?: (variables: (name: string) => unknown) => PostcssFunctionsOptions["functions"];
-    };
-    readonly externals?: Externals;
-    readonly assumeGlobalizedPlauditLibraries?: boolean;
-    readonly processTranslationConfigs?: boolean;
-    readonly combineAssetMetadata?: boolean;
-    useWebpackResourceFiltering?: boolean;
-    outputDir?: string;
-    extensionsVersion?: 1 | 2 | 3;
-    readonly targetHandlePrefix?: string;
-    plainEntrypointsVersion?: 1 | 2;
-    srcDir?: string;
-    readonly srcPrefixes?: string[];
-    useUnifiedLoader?: boolean;
-    readonly includePostInitFallback?: boolean;
-    readonly omitDistDev?: boolean;
-    onlyRunPostCSSOnPCSS?: boolean;
-};
-export declare function resolveStandard(standard: PlauditWordpressWebpackConfig['standard']): {
-    readonly useWebpackResourceFiltering: true;
-    readonly extensionsVersion: 3;
-    readonly plainEntrypointsVersion: 2;
-    readonly srcDir: "src";
-    readonly outputDir: "dist";
-    readonly useUnifiedLoader: true;
-    readonly onlyRunPostCSSOnPCSS: true;
-} | undefined;
 export type FileSegmentBlockEntrypointInfo = {
     blockJsonOrigin: string;
     entrypointField: EntrypointFields[number];
@@ -186,10 +139,7 @@ export type FileSegmentBlockEntrypointInfo = {
     handle: string;
     dest: VerifiedAdvancedOutputConfig;
     absoluteSrc: string;
-    pathQueryParameters: PathQueryParameters | undefined;
-    enqueuingFlags: NormalizedEnqueuingControlFlags | undefined;
 };
-export type PathQueryParameters = Record<string, unknown | [unknown, ...unknown[]]>;
 export type BlockEntrypointInfo = FileSegmentBlockEntrypointInfo | {
     dest: VerifiedAdvancedOutputConfig;
     purpose: string;
@@ -209,11 +159,10 @@ export declare const scriptExtension: RegExp;
 export declare const scriptWithoutModuleExtension: RegExp;
 export declare const scriptWithModuleExtension: RegExp;
 export declare const styleExtension: RegExp;
-export declare function scriptOrStyleTest(entryPath: string, scriptExtension: RegExp): "script" | "style" | "";
+export declare function scriptOrStyleTest(entryPath: string, scriptExtension: RegExp): "style" | "script" | "";
 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]>;
@@ -221,7 +170,6 @@ export declare function arrayIsLength<T, N extends number>(arr: T[] | null | und
 export declare function kebabCase(value: string): string;
 export declare function loadEnvFile(filePath: string): Promise<Record<string, string>>;
 export declare function parseEnvFile(contents: string): Record<string, string>;
-export declare function newCleanWebpackError(error: string | ConstructorParameters<typeof WebpackError>): WebpackError;
 export declare function newWebpackErrorForFile(error: string | ConstructorParameters<typeof WebpackError>, file: string): WebpackError;
 /**
  * The primary benefit of emitting a function instead of baking its contents into each function that uses it is that it allows us to avoid recomputing the base uri multiple times
@@ -239,13 +187,4 @@ 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/{dist → build}/shared.js

@@ -1,32 +1,14 @@
 "use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __exportStar = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
-};
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.styleExtension = exports.scriptWithModuleExtension = exports.scriptWithoutModuleExtension = exports.scriptExtension = exports.entrypointFields = exports.standardLocationNamesMeta = void 0;
 exports.isParsedAssetsJson = isParsedAssetsJson;
-exports.isStandardLocationName = isStandardLocationName;
-exports.isRegisterScriptArgsShorthandName = isRegisterScriptArgsShorthandName;
 exports.isNormalizedUsageLocations = isNormalizedUsageLocations;
 exports.constantKeys = constantKeys;
 exports.constantEntries = constantEntries;
 exports.determineCurrentSourceType = determineCurrentSourceType;
-exports.applyStandards = applyStandards;
-exports.resolveStandard = resolveStandard;
 exports.convertUsageLocationsHandleToEmittableHandle = convertUsageLocationsHandleToEmittableHandle;
 exports.makeEmittableConfigPHP = makeEmittableConfigPHP;
 exports.convertEntrypointFieldForAssetType = convertEntrypointFieldForAssetType;
@@ -40,7 +22,6 @@ exports.arrayIsLength = arrayIsLength;
 exports.kebabCase = kebabCase;
 exports.loadEnvFile = loadEnvFile;
 exports.parseEnvFile = parseEnvFile;
-exports.newCleanWebpackError = newCleanWebpackError;
 exports.newWebpackErrorForFile = newWebpackErrorForFile;
 exports.emitResolveBaseUriFunction = emitResolveBaseUriFunction;
 exports.getAssetsJson = getAssetsJson;
@@ -48,15 +29,12 @@ exports.getParsedAssetsJsonDataForEntrypoint = getParsedAssetsJsonDataForEntrypo
 exports.emitPHPWriterAsAsset = emitPHPWriterAsAsset;
 exports.dedent = dedent;
 exports.resolveLegacyBlockScriptsInFolder = resolveLegacyBlockScriptsInFolder;
-exports.appendAddInlineAssetCall = appendAddInlineAssetCall;
-const node_crypto_1 = require("node:crypto");
 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");
-__exportStar(require("./utils/entrypoint-resolution-logic"), exports);
 function isParsedAssetsJson(thing) {
     if (!thing || typeof thing !== 'object') {
         return false;
@@ -79,12 +57,6 @@ exports.standardLocationNamesMeta = {
     customizer: { action: "customize_controls_enqueue_scripts" },
     analytics: { action: "plaudit_enqueue_analytics" },
 };
-function isStandardLocationName(name) {
-    return name in exports.standardLocationNamesMeta;
-}
-function isRegisterScriptArgsShorthandName(name) {
-    return ['lazy', 'eager', 'inline'].includes(name);
-}
 function isNormalizedUsageLocations(usageLocations) {
     return typeof usageLocations.registerScriptArgs !== 'string';
 }
@@ -110,35 +82,6 @@ function determineCurrentSourceType(dest, srcIsDirectory) {
         return dest.directoryLayout;
     }
 }
-function applyStandards(config) {
-    switch (config.standard) {
-        case '2026-03-13':
-            return {
-                ...resolveStandard('2026-03-13'),
-                ...config
-            };
-        case undefined:
-            return config;
-        default:
-            throw `Invalid standard: ${config.standard}`;
-    }
-}
-function resolveStandard(standard) {
-    switch (standard) {
-        case "2026-03-13":
-            return {
-                useWebpackResourceFiltering: true,
-                extensionsVersion: 3,
-                plainEntrypointsVersion: 2,
-                srcDir: "src",
-                outputDir: "dist",
-                useUnifiedLoader: true,
-                onlyRunPostCSSOnPCSS: true,
-            };
-        default:
-            return undefined;
-    }
-}
 function convertUsageLocationsHandleToEmittableHandle(handle, generatedHandle) {
     const emittableHandle = typeof handle === 'string' ? handle : handle?.(generatedHandle) ?? generatedHandle;
     return emittableHandle.replaceAll("{basename}", generatedHandle);
@@ -160,9 +103,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>\.([ps]?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" : "");
 }
@@ -202,13 +145,9 @@ function parseEnvFile(contents) {
         return equalsPos === -1 ? [line, ""] : [line.substring(0, equalsPos), line.substring(equalsPos + 1)];
     }));
 }
-function newCleanWebpackError(error) {
+function newWebpackErrorForFile(error, file) {
     const res = typeof error === 'string' ? new webpack_1.WebpackError(error) : new webpack_1.WebpackError(...error);
     res.hideStack = true;
-    return res;
-}
-function newWebpackErrorForFile(error, file) {
-    const res = newCleanWebpackError(error);
     res.file = file;
     return res;
 }
@@ -311,32 +250,3 @@ 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));
-    }
-    let contents;
-    if (compilation.outputOptions.path?.endsWith("-dev")) {
-        contents = inlinedAsset.contents;
-    }
-    else {
-        contents = inlinedAsset.contents.replaceAll(/\/\*#\s+sourceMappingURL=.*?\*\/|\/\/#\s+sourceMappingURL=[^\r\n]*?([\r\n]|$)/gis, "$1");
-    }
-    const args = [handle, new expressions_1.HereOrNowDoc(`plaudit_inlined_${type}_${(0, node_crypto_1.createHash)('md5').update(handle).digest("hex")}`, contents.trim(), false)];
-    if (type === 'script' && inlinedAsset.position === 'before') {
-        args.push('before');
-    }
-    writer.call(`wp_add_inline_${type}`, args);
-}

package/{dist → build}/utils/common-config-helpers.d.ts

@@ -3,7 +3,7 @@ import type { AdditionalDependencyInjectorPlugin } from "../plugins/AdditionalDe
 import { EntrypointFields, PlauditWordpressWebpackConfig, BlockEntrypointInfo, VerifiedAdvancedOutputConfig, MinimumViableMetadata, WebpackPlugin } from "../shared";
 import type { Compiler, Configuration, DynamicEntryPlugin, WebpackPluginInstance } from "webpack";
 import type WebpackRemoveEmptyScriptsPlugin from "webpack-remove-empty-scripts";
-export type VerifiedPlauditWordpressWebpackConfig = Required<Omit<PlauditWordpressWebpackConfig, 'variables' | 'src' | 'externals' | 'standard'>> & {
+export type VerifiedPlauditWordpressWebpackConfig = Required<Omit<PlauditWordpressWebpackConfig, 'variables' | 'src' | 'externals'>> & {
     variablesFilePath?: string;
     currentVariables: Record<string, any>;
 } & Pick<PlauditWordpressWebpackConfig, 'externals'>;