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

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

@@ -1,147 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.makeDependencyExtractionPlugin = makeDependencyExtractionPlugin;
-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) {
-        if (assumeGlobalizedPlauditLibraries) {
-            return {
-                requestToExternal: plauditRequestToExternal(externalizing),
-                requestToHandle: plauditRequestToHandle
-            };
-        }
-        return {};
-    }
-    const exactExternals = {};
-    const suffixExternals = [];
-    for (const [key, value] of Object.entries(externals)) {
-        const normalizedValue = typeof value !== 'string' && value.import === undefined ? { ...value, import: key } : value;
-        if (key.startsWith("*/")) {
-            suffixExternals.push([key.substring(1), typeof normalizedValue === 'string' ? { import: normalizedValue, handle: key.substring(2) } : normalizedValue]);
-        }
-        else {
-            exactExternals[key] = normalizedValue;
-        }
-    }
-    const resolvePossibleExternal = (request) => {
-        if (request in exactExternals) {
-            return handleExternalizingEqualsPossibleExternal(exactExternals[request], externalizing);
-        }
-        for (const [key, value] of suffixExternals) {
-            if (request.endsWith(key)) {
-                return handleExternalizingEqualsPossibleExternal(value, externalizing);
-            }
-        }
-        return undefined;
-    };
-    const baselineRequestToExternal = request => {
-        const possibleExternal = resolvePossibleExternal(request);
-        if (typeof possibleExternal === 'string') {
-            return possibleExternal;
-        }
-        else if (possibleExternal !== undefined) {
-            return possibleExternal['import'];
-        }
-        return undefined;
-    };
-    const baselineRequestToHandle = request => {
-        const possibleExternal = resolvePossibleExternal(request);
-        if (possibleExternal !== undefined && typeof possibleExternal !== 'string') {
-            return possibleExternal.handle;
-        }
-        return undefined;
-    };
-    if (assumeGlobalizedPlauditLibraries) {
-        return {
-            requestToExternal: curryRequestHandlers(baselineRequestToExternal, plauditRequestToExternal(externalizing)),
-            requestToHandle: curryRequestHandlers(baselineRequestToHandle, plauditRequestToHandle),
-        };
-    }
-    else {
-        return {
-            requestToExternal: baselineRequestToExternal,
-            requestToHandle: baselineRequestToHandle,
-        };
-    }
-}
-function firstLayersEqual(first, second) {
-    if (first.length !== second.length) {
-        return false;
-    }
-    for (let i = 0; i < first.length; i++) {
-        if (first[i] !== second[i]) {
-            return false;
-        }
-    }
-    return true;
-}
-const PLAUDIT_NAMESPACE = '@plaudit/';
-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', (0, util_1.camelCaseDash)(req.substring(PLAUDIT_NAMESPACE.length))],
-                handle: `plaudit-${req.substring(PLAUDIT_NAMESPACE.length)}`
-            }];
-    })),
-    "@plaudit/wp-consent-api": { handle: "wp-consent-api", import: ['plaudit'] },
-    "@plaudit/analytics-integrations-api": { handle: "plaudit/analytics-integrations/api", import: ['plaudit', 'analyticsIntegrations', 'api'] },
-    "google.maps": { handle: "plaudit-base/google-maps-api", import: 'google.maps' } // This import is completely fake. As a result, it must be a single string in order to prevent a NPE
-};
-function plauditRequestToExternal(ext) {
-    return function (request) {
-        const req = EXTERNALIZABLE_PLAUDIT_LIBRARIES[normalizeRequest(request)];
-        return req ? handleExternalizingEqualsPossibleExternal(req, ext)?.import : undefined;
-    };
-}
-function plauditRequestToHandle(request) {
-    return EXTERNALIZABLE_PLAUDIT_LIBRARIES[normalizeRequest(request)]?.handle;
-}
-function normalizeRequest(request) {
-    return request.startsWith("@plaudit/gutenberg-api-extensions/") ? "@plaudit/gutenberg-api-extensions" : request;
-}
-function curryRequestHandlers(primary, secondary) {
-    return (...args) => primary(...args) ?? secondary(...args);
-}
-function handleExternalizingEqualsPossibleExternal(possibleExternal, ext) {
-    if (!ext || !possibleExternal) {
-        return possibleExternal;
-    }
-    const possibleImport = typeof possibleExternal === 'string' ? possibleExternal : possibleExternal['import'];
-    if (!possibleImport) {
-        return possibleExternal;
-    }
-    if (typeof ext === 'string') {
-        if (typeof possibleImport === 'string') {
-            return ext !== possibleImport ? possibleExternal : undefined;
-        }
-        else {
-            return possibleImport.length !== 1 || ext !== possibleImport[0] ? possibleExternal : undefined;
-        }
-    }
-    else if (Array.isArray(ext)) {
-        if (typeof possibleImport === 'string') {
-            return ext.length !== 1 || ext[0] !== possibleImport ? possibleExternal : undefined;
-        }
-        else {
-            return !firstLayersEqual(ext, possibleImport) ? possibleExternal : undefined;
-        }
-    }
-    else if ('name' in ext) {
-        return handleExternalizingEqualsPossibleExternal(possibleExternal, ext.name);
-    }
-    else {
-        for (const key of ['amd', 'commonjs', 'root']) {
-            // 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;
-            }
-        }
-    }
-    return possibleExternal;
-}

package/dist/plugins/index.d.ts

@@ -1,8 +0,0 @@
-export * from "./AbstractBiPhasicGroupAndEntryPlugin";
-export * from "./AbstractBiPhasicGroupPlugin";
-export * from "./EnhancedBlockJSONPlugin";
-export * from "./ExtensionsConfigFileGeneratorPlugin";
-export * from "./MixableBiPhasicGroupAndEntryPlugin";
-export * from "./MixableBiPhasicGroupPlugin";
-export * from "./PlainEntrypointsConfigFileGeneratorPlugin";
-export * from "./UnifiedLoaderGenerator";

package/dist/plugins/index.js

@@ -1,24 +0,0 @@
-"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);
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("./AbstractBiPhasicGroupAndEntryPlugin"), exports);
-__exportStar(require("./AbstractBiPhasicGroupPlugin"), exports);
-__exportStar(require("./EnhancedBlockJSONPlugin"), exports);
-__exportStar(require("./ExtensionsConfigFileGeneratorPlugin"), exports);
-__exportStar(require("./MixableBiPhasicGroupAndEntryPlugin"), exports);
-__exportStar(require("./MixableBiPhasicGroupPlugin"), exports);
-__exportStar(require("./PlainEntrypointsConfigFileGeneratorPlugin"), exports);
-__exportStar(require("./UnifiedLoaderGenerator"), exports);

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

@@ -1,3 +0,0 @@
-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/dist/plugins/static-configs.js

@@ -1,44 +0,0 @@
-"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 unsafeRequire(id) {
-    try {
-        return require(id);
-    }
-    catch (e) {
-        if (typeof e === 'object' && !!e && 'code' in e && e.code === 'MODULE_NOT_FOUND') {
-            return undefined;
-        }
-        throw e;
-    }
-}
-function postcssConfigBuilder(variables, postCSSFunctions) {
-    return {
-        plugins: [
-            unsafeRequire("postcss-import")(), // Once
-            unsafeRequire("postcss-mixins")(), // Once
-            unsafeRequire("@plaudit/postcss-variables")?.({ variables }), // Once
-            unsafeRequire("postcss-functions")({ functions: { ...makeDefaultPostCSSFunctions(variables), ...postCSSFunctions(variables) } }),
-            unsafeRequire("postcss-property-lookup")({ logLevel: "warn" }), // Rule
-            unsafeRequire("@plaudit/postcss-strip-units")?.(), // AtRule, Declaration
-            unsafeRequire("postcss-nested")(), // Rule
-            unsafeRequire("postcss-url")(), // This is needed because PostCSS flattens everything to a single file, which break's WebPack's URL resolution unless PostCSS updates the URLs to account for the flattening itself
-            unsafeRequire("postcss-calc")(calcOptions), // OnceExit
-            unsafeRequire("@plaudit/postcss-color-function")?.(), // OnceExit
-            unsafeRequire("autoprefixer")(autoprefixerOptions), // OnceExit
-            unsafeRequire("postcss-reporter")({ clearReportedMessages: true }), // OnceExit
-        ].filter(plugin => plugin !== undefined)
-    };
-}

package/dist/shared.d.ts

@@ -1,311 +0,0 @@
-import { PHPFile, PHPWriter } from "@plaudit/php-writer";
-import { HereOrNowDoc } from "@plaudit/php-writer/expressions";
-import type { Options as PostcssFunctionsOptions } from "postcss-functions";
-import { type AssetInfo, type Compilation, type Configuration, type Entrypoint, WebpackError } 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";
-export type WPModuleDependency = string | {
-    id: string;
-    import?: string;
-};
-export type ParsedAssetJson = {
-    dependencies: WPModuleDependency[];
-    module_dependencies?: WPModuleDependency[];
-    version: string;
-    type?: 'module';
-    handle?: string;
-};
-export type ParsedAssetsJson = Record<string, ParsedAssetJson>;
-export declare function isParsedAssetsJson(thing: any): thing is ParsedAssetsJson;
-type BaseRestType = [/* dependencies: */ WPModuleDependency[], /* version: */ string];
-export type AssetMetaSegment = {
-    inlinedAsset: InlinedAsset;
-    assetContents: string;
-};
-export type BaseHandleData = {
-    src: string;
-    rest: BaseRestType | [...BaseRestType, ScriptArgsObject];
-};
-export type ScriptArgsObject = {
-    strategy?: 'defer' | 'async';
-    in_footer?: boolean;
-    fetchpriority?: 'auto' | 'low' | 'high';
-    module_dependencies?: WPModuleDependency[];
-};
-export type InlinedAsset = {
-    position?: 'before' | 'after';
-    omitRegistration?: boolean;
-};
-export type IAHandleData = BaseHandleData & AssetMetaSegment;
-export type HandleData = BaseHandleData & (AssetMetaSegment | {
-    inlinedAsset?: undefined;
-    assetContents?: string;
-});
-type OptionalLocationMeta = {
-    supports_hook_name?: boolean;
-    additional_action_code?: {
-        before?(writer: PHPWriter): unknown;
-        after?(writer: PHPWriter): unknown;
-    };
-    alternate_names?: [string, ...string[]];
-};
-export declare const standardLocationNamesMeta: {
-    readonly clientView: {
-        readonly action: "wp_enqueue_scripts";
-        readonly alternate_names: ["client-view", "view"];
-    };
-    readonly clientEditor: {
-        readonly action: "enqueue_block_editor_assets";
-        readonly alternate_names: ["client-editor", "editor"];
-    };
-    readonly blockAssets: {
-        readonly action: "enqueue_block_assets";
-        readonly alternate_names: ["block-assets"];
-    };
-    readonly admin: {
-        readonly action: "admin_enqueue_scripts";
-        readonly supports_hook_name: true;
-    };
-    readonly login: {
-        readonly action: "login_enqueue_scripts";
-    };
-    readonly customizer: {
-        readonly action: "customize_controls_enqueue_scripts";
-    };
-    readonly analytics: {
-        readonly action: "plaudit_enqueue_analytics";
-    };
-};
-export type StandardLocationNameMeta = {
-    action: typeof standardLocationNamesMeta[keyof typeof standardLocationNamesMeta]['action'];
-} & OptionalLocationMeta;
-export type StandardLocationNames = keyof typeof standardLocationNamesMeta;
-export declare function isStandardLocationName(name: string): name is StandardLocationNames;
-export declare function iterableStandardLocationNamesMeta(): [StandardLocationNames, StandardLocationNameMeta][];
-export declare function normalizeLocationName(name: string): StandardLocationNames | 'register';
-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 = {
-    [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) | {
-        niceName: string;
-    };
-    registerScriptArgs?: InputRegisterScriptArgs;
-};
-export type NormalizedUsageLocations = Omit<UsageLocations, 'registerScriptArgs'> & {
-    registerScriptArgs?: InputRegisterScriptArgs;
-};
-export declare function isNormalizedUsageLocations(usageLocations: UsageLocations): usageLocations is NormalizedUsageLocations;
-export type EnqueuedAssetType = 'script' | 'script_module' | 'style';
-export type ExtendedHandleData = HandleData & {
-    locations: UsageLocations;
-    handleName?: UsageLocations['handle'];
-    lazyLoader: string | undefined;
-    type: EnqueuedAssetType;
-    associatedInlinedHandles?: ExtendedHandleData[];
-};
-export declare function convertHookLocationToNamesAndPriority(hookLocation: NonNullable<Exclude<UsageLocations[keyof typeof standardLocationNamesMeta], false>>): [string[], number];
-export declare function hasDeferringStrategy(handle: HandleData): boolean;
-/**
- * @return {@code true} -> "can share the same handle", {@code false} -> "cannot be merged", {@code 'dependent'} -> "one handle can be listed as a dependency of the other"
- */
-export declare function canMergeHandles(handleA: ExtendedHandleData, handleB: ExtendedHandleData): boolean | 'dependent';
-export declare function constantKeys<K extends string, V>(object: {
-    [k in K]?: V;
-}): K[];
-export declare function constantEntries<K extends string, V>(object: {
-    [k in K]: V;
-}): [K, V][];
-export declare function determineCurrentSourceType(dest: string | AdvancedOutputConfig, srcIsDirectory: boolean): SourceType;
-export type ObjectIndividualExternalDepConfig = {
-    import?: string | [string, ...string[]];
-    handle: string;
-};
-export type IndividualExternalDepConfig = string | ObjectIndividualExternalDepConfig;
-export type Externals = {
-    [dep: string]: IndividualExternalDepConfig;
-};
-export type AdvancedOutputConfig = {
-    destination?: string;
-    withLegacyBlocksIn?: string | undefined | false;
-    additionalDependencies?: string[];
-    directoryLayout?: SourceType;
-    assumeGlobalizedPlauditLibraries?: boolean;
-    externalize?: Required<Configuration>['output']['library'];
-    bundleAnalyzer?: boolean | 'no-auto-open';
-    locations?: UsageLocations | UsageLocations['handle'];
-    lazyLoader?: string;
-    enqueuingFlags?: NormalizedEnqueuingControlFlags;
-};
-type OptionalCfgFields = 'directoryLayout' | 'externalize' | 'lazyLoader';
-export type VerifiedAdvancedOutputConfig = Required<Omit<AdvancedOutputConfig, 'locations' | 'enqueuingFlags' | OptionalCfgFields>> & Pick<AdvancedOutputConfig, OptionalCfgFields> & {
-    enqueuingFlags: NormalizedEnqueuingControlFlags | undefined;
-    locations: NormalizedUsageLocations;
-    pathQueryParameters?: PathQueryParameters;
-};
-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;
-    stats?: Configuration['stats'];
-    postcss?: {
-        functions?: (variables: (name: string) => unknown) => PostcssFunctionsOptions['functions'];
-    };
-    externals?: Externals;
-    assumeGlobalizedPlauditLibraries?: boolean;
-    useWebpackResourceFiltering?: boolean;
-    outputDir?: string;
-    extensionsVersion?: 1 | 2 | 3;
-    targetHandlePrefix?: string;
-    plainEntrypointsVersion?: 1 | 2;
-    srcDir?: string;
-    srcPrefixes?: string[];
-    useUnifiedLoader?: boolean;
-    includePostInitFallback?: boolean;
-    omitDistDev?: boolean;
-    onlyRunPostCSSOnPCSS?: boolean;
-    targetNamespace?: string;
-    useBlockSupportsAsThemeJsonDefaults?: boolean;
-};
-export type VerifiedPlauditWordpressWebpackConfig = Required<Omit<PlauditWordpressWebpackConfig, 'variables' | 'src' | 'externals' | 'standard'>> & {
-    variablesFilePath?: string;
-    currentVariables: Record<string, any>;
-} & Pick<PlauditWordpressWebpackConfig, 'externals'>;
-/** Unified-loader watch output: `dist` → `dist-dev` when SERVER_MODE is development. */
-export declare function shouldWriteDistDev(config: Pick<PlauditWordpressWebpackConfig, 'outputDir' | 'useUnifiedLoader' | 'omitDistDev'>): boolean;
-/**
- * This MUST be kept in sync with the copy in @plaudit/dev-webpack-plugin
- * @returns true for `dist-dev` (or any `*-dev` output folder produced by {@link shouldWriteDistDev}).
- */
-export declare function isDistDevOutputPath(outputPath: string): 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 targetHandlePrefix?: string;
-    readonly srcPrefixes?: string[];
-    readonly includePostInitFallback?: boolean;
-    readonly omitDistDev?: boolean;
-    readonly targetNamespace?: string;
-    readonly useBlockSupportsAsThemeJsonDefaults?: boolean;
-    useWebpackResourceFiltering?: boolean | undefined;
-    extensionsVersion?: 1 | 2 | 3 | undefined;
-    plainEntrypointsVersion?: 1 | 2 | undefined;
-    srcDir?: string | undefined;
-    outputDir?: string | undefined;
-    useUnifiedLoader?: boolean | undefined;
-    onlyRunPostCSSOnPCSS?: boolean | undefined;
-};
-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];
-    handleGroup: ReturnType<typeof getHandleGroup>;
-    originalValue: string;
-    entrypointName: string;
-    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;
-    absoluteSrc: string;
-};
-export type MinimumViableMetadata = {
-    dest: VerifiedAdvancedOutputConfig;
-    absoluteSrc: string;
-};
-export declare function convertUsageLocationsHandleToEmittableHandle(handle: UsageLocations['handle'], handlePrefix: string, handleSuffix: string): string;
-export declare function makeEmittableConfigPHP(data: any, asFullFile: boolean, parentIndent?: string): string;
-export declare const entrypointFields: readonly ["editorStyle", "viewStyle", "style", "editorScript", "viewScript", "script", "viewScriptModule"];
-export type EntrypointFields = (typeof entrypointFields[number])[];
-export declare function convertEntrypointFieldForAssetType(entrypointField: EntrypointFields[number], assetType: 'script' | 'style'): EntrypointFields[number];
-export declare function leadingSlashIt(pathOrSomething: string): string;
-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 isStyleField(field: string): field is 'style' | 'viewStyle' | 'editorStyle';
-export declare function isScriptModuleField(field: string): field is 'viewScriptModule';
-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[]];
-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]>;
-export declare function arrayIsLength<T, N extends number>(arr: T[] | null | undefined, length: N): arr is TupleOf<T, N>;
-export declare function kebabCase(value: string): string;
-export declare function camelCaseForPHPLabels(value: 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
- */
-export declare function emitResolveBaseUriFunction(writer: PHPFile | PHPWriter): void;
-export declare function getAssetsJson(compilation: Compilation): ParsedAssetsJson;
-export type ParsedAssetJsonProvider = (entrypoint: Entrypoint, metadata: MinimumViableMetadata) => {
-    assetName: string;
-    assetData: ParsedAssetsJson[string];
-} | undefined;
-export declare function getParsedAssetsJsonDataForEntrypoint(compilation: Compilation, entrypoint: Entrypoint, metadata: MinimumViableMetadata): {
-    assetName: string;
-    assetData: ParsedAssetsJson[string];
-} | undefined;
-export declare function emitPHPWriterAsAsset(writer: PHPWriter | PHPFile, compilation: Compilation, file: string, assetInfo?: AssetInfo): void;
-export declare function dedent(text: TemplateStringsArray, ...values: unknown[]): 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 handleData
- */
-export declare function appendAddInlineAssetCall(compilation: Compilation, writer: PHPWriter, handle: string, type: EnqueuedAssetType, handleData: IAHandleData): void;
-export declare function wrapInlineAssetContents(compilation: Compilation, wrapperIdPrefix: string, handle: string, contents: string): HereOrNowDoc;
-export declare function synchronousDirIterator(dirPath: string): Generator<import("node:fs").Dirent<string>, void, unknown>;
-/**
- * A type-guarded version of `instanceof Error` for Node.js.
- * @author Joseph JDBar Barron
- * @link https://dev.to/jdbar
- */
-export declare function instanceOfNodeError<T extends new (...args: any) => Error>(value: unknown, errorType: T): value is InstanceType<T> & NodeJS.ErrnoException;
-/**
- * This tests if the name starts with a "~", is equal to "example" or "examples", or includes "example" as a name segment
- */
-export declare function shouldBeSkipped(name: string): boolean;