@plaudit/webpack-extensions 2.62.3 → 2.63.1

package/build/shared.d.ts

@@ -20,7 +20,7 @@ export type UsageLocations = {
     [K in StandardLocationNames]?: boolean | number;
 } & {
     register?: boolean | number;
-    handle?: string;
+    handle?: string | ((generatedHandle: string) => string);
     registerScriptArgs?: {
         strategy?: 'defer' | 'async';
         in_footer?: boolean;
@@ -47,9 +47,11 @@ export type AdvancedOutputConfig = {
     assumeGlobalizedPlauditLibraries?: boolean;
     externalize?: Required<Configuration>['output']['library'];
     bundleAnalyzer?: boolean;
-    locations?: UsageLocations | string;
+    locations?: UsageLocations | UsageLocations['handle'];
+};
+export type VerifiedAdvancedOutputConfig = Omit<AdvancedOutputConfig, 'destination' | 'locations'> & Required<Pick<AdvancedOutputConfig, 'destination'>> & {
+    locations: UsageLocations;
 };
-export type VerifiedAdvancedOutputConfig = Omit<AdvancedOutputConfig, 'destination'> & Required<Pick<AdvancedOutputConfig, 'destination'>>;
 export type PlauditWordpressWebpackConfig = {
     standaloneBlocks?: boolean;
     variables?: Record<string, any>;
@@ -87,8 +89,9 @@ export type UnpackedBlockEntrypointInfo = {
     handle: string;
 };
 export declare function packBlockEntrypointInfoForSmuggling(info: UnpackedBlockEntrypointInfo): SmuggledBlockEntrypointInfo;
-export declare function unpackSmuggledBlockEntrypointInfo(library: EntryOptions['library']): UnpackedBlockEntrypointInfo | undefined;
-export declare function isSmuggledLibraryInfo(libraryName: NonNullable<EntryOptions['library']>['name'] | undefined): libraryName is SmuggledBlockEntrypointInfo;
+export declare function unpackSmuggledBlockEntrypointInfo(library: EntryOptions['library'], allowedEndings?: string[] | false): UnpackedBlockEntrypointInfo | undefined;
+export declare function isSmuggledLibraryInfo(libraryName: NonNullable<EntryOptions['library']>['name'] | undefined, allowedEndings?: string[] | false): libraryName is SmuggledBlockEntrypointInfo;
+export declare function convertUsageLocationsHandleToEmittableHandle(handle: UsageLocations['handle'], generatedHandle: string): string;
 export declare function makeEmittableConfigPHP(data: any, asFullFile: boolean, parentIndent?: string): string;
 export type EntrypointFields = ["viewScriptModule", "scriptModule"] | ["editorStyle", "viewStyle", "style", "editorScript", "viewScript", "script"];
 export declare const entrypointFields: ReadonlyArray<EntrypointFields[number]>;
@@ -108,7 +111,7 @@ 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 newWebpackErrorForFile(error: string, file: string): 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
  */

package/build/shared.js

@@ -9,6 +9,7 @@ exports.determineCurrentSourceType = determineCurrentSourceType;
 exports.packBlockEntrypointInfoForSmuggling = packBlockEntrypointInfoForSmuggling;
 exports.unpackSmuggledBlockEntrypointInfo = unpackSmuggledBlockEntrypointInfo;
 exports.isSmuggledLibraryInfo = isSmuggledLibraryInfo;
+exports.convertUsageLocationsHandleToEmittableHandle = convertUsageLocationsHandleToEmittableHandle;
 exports.makeEmittableConfigPHP = makeEmittableConfigPHP;
 exports.convertEntrypointFieldForAssetType = convertEntrypointFieldForAssetType;
 exports.leadingSlashIt = leadingSlashIt;
@@ -59,18 +60,23 @@ function determineCurrentSourceType(dest, srcIsDirectory) {
 function packBlockEntrypointInfoForSmuggling(info) {
     return [info.blockJsonOrigin, info.entrypointField, info.originalValue, info.entrypointName, info.handle];
 }
-function unpackSmuggledBlockEntrypointInfo(library) {
+const defaultAllowedEndings = ["/block.json", "/entrypoints.json", "/package.json"];
+function unpackSmuggledBlockEntrypointInfo(library, allowedEndings) {
     const libraryName = library?.name;
-    if (!isSmuggledLibraryInfo(libraryName)) {
+    if (!isSmuggledLibraryInfo(libraryName, allowedEndings)) {
         return undefined;
     }
     return { blockJsonOrigin: libraryName[0], entrypointField: libraryName[1], originalValue: libraryName[2], entrypointName: libraryName[3], handle: libraryName[4] };
 }
-function isSmuggledLibraryInfo(libraryName) {
+function isSmuggledLibraryInfo(libraryName, allowedEndings = defaultAllowedEndings) {
     if (!Array.isArray(libraryName) || !arrayIsLength(libraryName, 5) || libraryName.some(item => typeof item !== 'string')) {
         return false;
     }
-    return libraryName[0].endsWith("/block.json") && exports.entrypointFields.includes(libraryName[1]);
+    return (!allowedEndings || allowedEndings.some(s => libraryName[0].endsWith(s))) && exports.entrypointFields.includes(libraryName[1]);
+}
+function convertUsageLocationsHandleToEmittableHandle(handle, generatedHandle) {
+    const emittableHandle = typeof handle === 'string' ? handle : handle?.(generatedHandle) ?? generatedHandle;
+    return emittableHandle.replaceAll("{basename}", generatedHandle);
 }
 function makeEmittableConfigPHP(data, asFullFile, parentIndent = "") {
     const prettyPrintedMetadata = json_to_php_but_with____injection_1.default.make({ indent: "\t", linebreak: "\n", shortArraySyntax: true })(data, parentIndent)
@@ -125,7 +131,7 @@ function parseEnvFile(contents) {
     }));
 }
 function newWebpackErrorForFile(error, file) {
-    const res = new webpack_1.WebpackError(error);
+    const res = typeof error === 'string' ? new webpack_1.WebpackError(error) : new webpack_1.WebpackError(...error);
     res.hideStack = true;
     res.file = file;
     return res;

package/build/utils/common-config-helpers.d.ts

@@ -1,5 +1,6 @@
-import { EntrypointFields, PlauditWordpressWebpackConfig, VerifiedAdvancedOutputConfig } from "../shared";
-import type { Compiler, Configuration, EntryObject, WebpackPluginInstance } from "webpack";
+import type { EntryProvider } from "../plugins/AbstractMultiPhaseLibraryAndEntryPlugin";
+import { EntrypointFields, PlauditWordpressWebpackConfig, UnpackedBlockEntrypointInfo, VerifiedAdvancedOutputConfig } from "../shared";
+import type { Compiler, Configuration, DynamicEntryPlugin, EntryObject, WebpackPluginInstance } from "webpack";
 import type WebpackRemoveEmptyScriptsPlugin from "webpack-remove-empty-scripts";
 export type VerifiedPlauditWordpressWebpackConfig = Required<Omit<PlauditWordpressWebpackConfig, 'variables' | 'src' | 'externals'>> & {
     variablesFilePath?: string;
@@ -18,5 +19,12 @@ export type CommonConfigProcessingResult = {
 };
 export declare function joinPossiblyAbsolutePaths(...paths: (string | undefined)[]): string;
 export declare function groupEntrypointsByAssetFile<T>(entrypoints: T[], entrypointNameExtractor: (t: T) => string): Map<string, T[]>;
-export declare function resolveEntryFromDirectory(commonConfig: CommonConfigProcessingResult, srcRoot: string, dest: VerifiedAdvancedOutputConfig): () => Promise<EntryObject>;
-export declare function commonMakeWebpackConfig(config: VerifiedPlauditWordpressWebpackConfig, commonConfig: CommonConfigProcessingResult, webpackConfig: Configuration, srcIsDirectory: boolean, dest: VerifiedAdvancedOutputConfig, src: string, srcRoot: string | string[], entry: () => Promise<EntryObject> | EntryObject, plugins: CommonPluginConfig['plugins']): Configuration;
+export type BlockJsonExtensibleEntryObject = ExtensibleEntryObject<UnpackedBlockEntrypointInfo | string>;
+export type EntryStaticNormalized = Awaited<ReturnType<ConstructorParameters<typeof DynamicEntryPlugin>[1]>>;
+export type ExtensibleEntryObject<M> = {
+    [index: string]: Omit<EntryStaticNormalized[string], 'import'> & Required<NonNullable<Pick<EntryStaticNormalized[string], 'import'>>> & {
+        plauditMetadata: M;
+    };
+};
+export declare function resolveEntryFromDirectory(commonConfig: CommonConfigProcessingResult, srcRoot: string, dest: VerifiedAdvancedOutputConfig): EntryProvider<UnpackedBlockEntrypointInfo | string>;
+export declare function commonMakeWebpackConfig(config: VerifiedPlauditWordpressWebpackConfig, commonConfig: CommonConfigProcessingResult, webpackConfig: Configuration, srcIsDirectory: boolean, dest: VerifiedAdvancedOutputConfig, src: string, srcRoot: string | string[], entry: (() => Promise<EntryObject> | EntryObject) | EntryObject, plugins: CommonPluginConfig['plugins']): Configuration;

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

@@ -33,37 +33,45 @@ function groupEntrypointsByAssetFile(entrypoints, entrypointNameExtractor) {
     }
     return seenPaths;
 }
-function mapToRealEntrypoints(entrypoint, dir, supportedExtensions, args = {}) {
-    const { mapper = ep => ep, destDir } = args;
+function mapToRealEntrypoints(entrypoint, dir, supportedExtensions, args) {
+    const { mapper = ep => ep, dest } = args;
     return (Array.isArray(entrypoint) ? entrypoint : [entrypoint])
         .map(ep => joinPossiblyAbsolutePaths(dir, mapper(ep)))
         .filter(ep => supportedExtensions(ep) && node_fs_1.default.statSync(ep, { throwIfNoEntry: false })?.isFile())
         .map(ep => {
         const parsedEntrypoint = node_path_1.default.parse(ep);
-        return [joinPossiblyAbsolutePaths(destDir, node_path_1.default.basename(parsedEntrypoint.dir), parsedEntrypoint.name), { import: ep }];
+        const fakeEntrypointInfo = {
+            blockJsonOrigin: args.entrypointJsonOrigin,
+            entrypointField: shared_1.styleExtension.test(ep) ? 'style' : shared_1.scriptWithModuleExtension.test(ep) ? 'scriptModule' : 'script',
+            originalValue: ep,
+            entrypointName: parsedEntrypoint.name,
+            handle: (0, shared_1.convertUsageLocationsHandleToEmittableHandle)(dest.locations.handle, parsedEntrypoint.name)
+        };
+        return [joinPossiblyAbsolutePaths(dest.destination, node_path_1.default.basename(parsedEntrypoint.dir), parsedEntrypoint.name),
+            { import: [ep], plauditMetadata: fakeEntrypointInfo }];
     });
 }
 function parseEntrypointsJSON(dir, dest, supportedExtensions) {
-    const entrypointsJSON = JSON.parse(node_fs_1.default.readFileSync(node_path_1.default.join(dir, 'entrypoints.json'), 'utf8'));
+    const entrypointJsonOrigin = node_path_1.default.join(dir, 'entrypoints.json');
+    const entrypointsJSON = JSON.parse(node_fs_1.default.readFileSync(entrypointJsonOrigin, 'utf8'));
     if (Array.isArray(entrypointsJSON)) {
-        return mapToRealEntrypoints(entrypointsJSON, dir, supportedExtensions, { destDir: dest.destination });
+        return mapToRealEntrypoints(entrypointsJSON, dir, supportedExtensions, { dest, entrypointJsonOrigin });
     }
     else {
-        return Object.entries(entrypointsJSON).map(([name, config]) => {
-            if (typeof config === 'string') {
-                return [name, joinPossiblyAbsolutePaths(dir, config)];
-            }
-            else if (Array.isArray(config)) {
-                return [name, config.map(c => joinPossiblyAbsolutePaths(dir, c))];
+        return Object.entries(entrypointsJSON).flatMap(([name, config]) => {
+            if (Array.isArray(config)) {
+                return config.flatMap(c => mapToRealEntrypoints(c, dir, supportedExtensions, { dest, entrypointJsonOrigin }));
             }
             else {
+                return [[name, config]];
+                /* TODO: Fix compat with entrypoints.json in object mode
                 if (typeof config.import === 'string') {
                     config.import = joinPossiblyAbsolutePaths(dir, config.import);
-                }
-                else {
+                } else {
                     config.import = config.import.map(c => joinPossiblyAbsolutePaths(dir, c));
                 }
                 return [name, config];
+                */
             }
         });
     }
@@ -158,8 +166,12 @@ function resolveEntryFromDirectory(commonConfig, srcRoot, dest) {
                         .map(presentEntrypoint => {
                         const overallSource = node_path_1.default.dirname(blockJsonOrigin);
                         const overallSourceRelativeName = node_path_1.default.relative(overallSource, node_path_1.default.normalize(node_path_1.default.join(blockJsonOrigin, node_path_1.default.relative(overallSource, presentEntrypoint.extensionlessExpectedSrc))));
+                        const handleSuffix = (0, shared_1.convertUsageLocationsHandleToEmittableHandle)(dest.locations.handle, overallSourceRelativeName);
                         if (!entrypointNamesWithEffectiveDuplicates[presentEntrypoint.entrypointName]) {
-                            return { blockJsonOrigin, ...presentEntrypoint, handle: `${handlePrefix}/${overallSourceRelativeName}` };
+                            return {
+                                blockJsonOrigin, ...presentEntrypoint,
+                                handle: `${handlePrefix}/${handleSuffix}`
+                            };
                         }
                         const baseSuffix = `_${(0, shared_1.isStyleField)(presentEntrypoint.entrypointField) ? "style" : "script"}`;
                         let count = 0, suffix = baseSuffix, deduplicatedEntrypointName;
@@ -174,7 +186,7 @@ function resolveEntryFromDirectory(commonConfig, srcRoot, dest) {
                             ...presentEntrypoint,
                             entrypointName: deduplicatedEntrypointName,
                             extensionlessExpectedSrc: deduplicatedExtensionlessExpectedSrc,
-                            handle: `${handlePrefix}/${count ? overallSourceRelativeName + "_" + count : overallSourceRelativeName}`
+                            handle: `${handlePrefix}/${count ? handleSuffix + "_" + count : handleSuffix}`
                         };
                     });
                     rawEntrypoints.push(...resolvedBlockEntrypoints
@@ -182,22 +194,23 @@ function resolveEntryFromDirectory(commonConfig, srcRoot, dest) {
                         return [
                             resolvedBlockEntrypoint.entrypointName,
                             {
-                                import: resolvedBlockEntrypoint.absoluteSrc,
-                                library: { name: (0, shared_1.packBlockEntrypointInfoForSmuggling)(resolvedBlockEntrypoint), type: `block-json-${dest.destination}` }
+                                import: [resolvedBlockEntrypoint.absoluteSrc],
+                                plauditMetadata: resolvedBlockEntrypoint
                             }
                         ];
                     }));
-                    rawEntrypoints.push([blockJsonChunkName, { import: blockJsonOrigin, library: { name: "block-json-inclusion-assurance", type: `block-json-${dest.destination}` } }]);
+                    rawEntrypoints.push([blockJsonChunkName, { import: [blockJsonOrigin], plauditMetadata: "block-json-inclusion-assurance" }]);
                     wpmlFiles.push(node_path_1.default.join(dir, 'block.json'));
                 }
                 catch (e) {
                     try {
-                        const packageJSON = JSON.parse(await promises_1.default.readFile(node_path_1.default.join(dir, 'package.json'), 'utf8'));
-                        if (packageJSON['main']) {
-                            rawEntrypoints.push(...mapToRealEntrypoints(packageJSON['main'], dir, commonConfig.scriptExtension.test, { destDir: dest.destination }));
+                        const packageJsonOrigin = node_path_1.default.join(dir, 'package.json');
+                        const packageJson = JSON.parse(await promises_1.default.readFile(packageJsonOrigin, 'utf8'));
+                        if (packageJson['main']) {
+                            rawEntrypoints.push(...mapToRealEntrypoints(packageJson['main'], dir, commonConfig.scriptExtension.test, { dest, entrypointJsonOrigin: packageJsonOrigin }));
                         }
-                        if (!processingModules && packageJSON['style']) {
-                            rawEntrypoints.push(...mapToRealEntrypoints(packageJSON['style'], dir, shared_1.styleExtension.test, { destDir: dest.destination }));
+                        if (!processingModules && packageJson['style']) {
+                            rawEntrypoints.push(...mapToRealEntrypoints(packageJson['style'], dir, shared_1.styleExtension.test, { dest, entrypointJsonOrigin: packageJsonOrigin }));
                         }
                     }
                     catch (e) {
@@ -240,12 +253,12 @@ function resolveEntryFromDirectory(commonConfig, srcRoot, dest) {
             const wpmlEntrypointFiles = allEntrypoints.flatMap(e => e[1]);
             try {
                 await promises_1.default.access(node_path_1.default.join(srcRoot, "wpml-config.xml"));
-                currentEntry["wpml-config.xml"] = { import: [node_path_1.default.join(srcRoot, "wpml-config.xml"), ...wpmlEntrypointFiles], library: { type: `block-json-${dest.destination}` } };
+                currentEntry["wpml-config.xml"] = { import: [node_path_1.default.join(srcRoot, "wpml-config.xml"), ...wpmlEntrypointFiles], plauditMetadata: "wpml-config-xml" };
             }
             catch (e) {
                 // If the wpml-config.xml file does not exist, just "import" the other files that will be used to build the emitted version
                 if (wpmlEntrypointFiles.length) {
-                    currentEntry["wpml-config.xml"] = { import: wpmlEntrypointFiles, library: { type: `block-json-${dest.destination}` } };
+                    currentEntry["wpml-config.xml"] = { import: wpmlEntrypointFiles, plauditMetadata: "wpml-config-xml" };
                 }
             }
         }
@@ -374,7 +387,7 @@ function commonMakeWebpackConfig(config, commonConfig, webpackConfig, srcIsDirec
                 delete require.cache[require.resolve(variablesFilePath)];
                 updateCurrentVariables(require(variablesFilePath));
             }
-            return entry();
+            return typeof entry === 'function' ? entry() : entry;
         },
         performance: {
             ...webpackConfig.performance,

package/build/utils/php-writer.d.ts

@@ -18,6 +18,11 @@ export interface PotentiallyWriteableExpression extends EnclosableExpression {
 export declare function isEnclosableExpression(a: unknown): a is EnclosableExpression;
 export declare function isPotentiallyWriteableExpression(a: unknown): a is PotentiallyWriteableExpression;
 export declare abstract class AbstractEnclosableExpression extends Expr implements EnclosableExpression {
+    static readonly closers: Readonly<{
+        "(": ")";
+        "[": "]";
+        "{": "}";
+    }>;
     abstract toEnclosedForm(): string;
     not(): Not;
 }
@@ -31,9 +36,10 @@ export declare class Literal extends Expr {
     readonly expression: string;
     constructor(expression: string);
     toString(): string;
-    static make(expression: string, enclosed: true): EnclosedLiteral;
-    static make(expression: string, enclosureOpen: string, encloserClose: string): EnclosableLiteral;
-    static make(expression: string, enclosed?: false | undefined): Literal;
+    static of(expression: string | PHPWriter, enclosed: true): EnclosedLiteral;
+    static of(expression: string | PHPWriter, enclosureOpen: keyof typeof AbstractEnclosableExpression.closers, encloserClose?: string): EnclosableLiteral;
+    static of(expression: string | PHPWriter, enclosureOpen: string, encloserClose: string): EnclosableLiteral;
+    static of(expression: string | PHPWriter, enclosed?: false | undefined): Literal;
     static name(expression: string): EnclosedLiteral;
 }
 export declare class EnclosedLiteral extends Literal implements EnclosableExpression {
@@ -97,6 +103,19 @@ export declare class Call extends EnclosedExpression implements PotentiallyWrite
     constructor(callee: string | EnclosableExpression, args: readonly unknown[]);
     toString(): string;
 }
+export declare class Parameter extends Expr {
+    readonly value: unknown;
+    readonly name?: string | undefined;
+    constructor(value: unknown, name?: string | undefined);
+    toString(): string;
+}
+export declare class FirstClassCallable extends ParenthesesEnclosableExpression {
+    readonly name: EnclosableExpression;
+    constructor(name: EnclosableExpression);
+    static from(literal: string): FirstClassCallable;
+    toString(): string;
+}
+export declare const validPHPLabel: RegExp;
 type Assignable = EnclosedExpression & PotentiallyWriteableExpression;
 export declare class Assignment extends ParenthesesEnclosableExpression {
     readonly value: unknown;
@@ -140,7 +159,18 @@ export declare class PHPWriter {
     indent(): this;
     outdent(): this;
     setIndentation(level: number): this;
+    /**
+     * @param lines These are treated as literal *regardless of their types*
+     */
     append(...lines: (string | Expr)[]): this;
+    /**
+     * @param expr This is treated as literal *regardless of its type*
+     * @param opts flags to add additional markup around the expression
+     */
+    appendExpr(expr: string | Expr, opts?: {
+        chain?: boolean;
+        return?: boolean;
+    }): this;
     assign(assignee: ConstructorParameters<typeof Assignment>[0] | string, expression: unknown, opts?: {
         chain?: boolean;
         return?: boolean;
@@ -151,6 +181,11 @@ export declare class PHPWriter {
         withTest?: boolean | 'chainable';
     }): this;
     linebreak(): this;
+    /**
+     * @param func This is treated as literal *regardless of its type*
+     * @param args
+     * @param opts
+     */
     call(func: string | EnclosableExpression, args: unknown[], opts?: {
         chain?: boolean;
         assignTo?: ConstructorParameters<typeof Assignment>[0];
@@ -195,11 +230,5 @@ export declare class PHPWriter {
         includeNamespaceAndUse?: boolean;
     }): string;
     emitAsset(compilation: Compilation, file: string, assetInfo?: AssetInfo): void;
-    /**
-     * @param expr Unlike most other methods on this class, this is treated as literal *regardless of the argument's type*
-     * @param opts
-     * @private
-     */
-    private appendWithPossibleReturnAndChain;
 }
 export {};

package/build/utils/php-writer.js

@@ -3,7 +3,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.PHPWriter = exports.Constants = exports.Assignment = exports.Call = exports.ObjectAccess = exports.ArrayAccess = exports.Access = exports.Not = exports.Op = exports.Var = exports.EnclosableLiteral = exports.EnclosedLiteral = exports.Literal = exports.EnclosedExpression = exports.ParenthesesEnclosableExpression = exports.AbstractEnclosableExpression = exports.Expr = void 0;
+exports.PHPWriter = exports.Constants = exports.Assignment = exports.validPHPLabel = exports.FirstClassCallable = exports.Parameter = exports.Call = exports.ObjectAccess = exports.ArrayAccess = exports.Access = exports.Not = exports.Op = exports.Var = exports.EnclosableLiteral = exports.EnclosedLiteral = exports.Literal = exports.EnclosedExpression = exports.ParenthesesEnclosableExpression = exports.AbstractEnclosableExpression = exports.Expr = void 0;
 exports.isEnclosableExpression = isEnclosableExpression;
 exports.isPotentiallyWriteableExpression = isPotentiallyWriteableExpression;
 const json_to_php_but_with____injection_1 = __importDefault(require("./json-to-php-but-with-__-injection"));
@@ -30,6 +30,7 @@ function isPotentiallyWriteableExpression(a) {
     return isEnclosableExpression(a) && 'potentiallyWritable' in a && a.potentiallyWritable === true;
 }
 class AbstractEnclosableExpression extends Expr {
+    static closers = Object.freeze({ "(": ")", "[": "]", "{": "}" });
     not() {
         return new Not(this);
     }
@@ -56,9 +57,12 @@ class Literal extends Expr {
     toString() {
         return this.expression;
     }
-    static make(expression, enclosed = false, enclosureClose) {
+    static of(expression, enclosed = false, enclosureClose) {
+        if (expression instanceof PHPWriter) {
+            expression = expression.toString({ includeOpenPHP: false, includeNamespaceAndUse: false }).trim();
+        }
         if (typeof enclosed === 'string') {
-            return new EnclosableLiteral(expression, enclosed, enclosureClose ?? enclosed);
+            return new EnclosableLiteral(expression, enclosed, enclosureClose ?? AbstractEnclosableExpression.closers[enclosed] ?? enclosed);
         }
         if (enclosed) {
             return new EnclosedLiteral(expression);
@@ -198,6 +202,34 @@ class Call extends EnclosedExpression {
     }
 }
 exports.Call = Call;
+class Parameter extends Expr {
+    value;
+    name;
+    constructor(value, name) {
+        super();
+        this.value = value;
+        this.name = name;
+    }
+    toString() {
+        return this.name ? `${this.name}: ${Expr.convertJsonToPHP(this.value)}` : Expr.convertJsonToPHP(this.value);
+    }
+}
+exports.Parameter = Parameter;
+class FirstClassCallable extends ParenthesesEnclosableExpression {
+    name;
+    constructor(name) {
+        super();
+        this.name = name;
+    }
+    static from(literal) {
+        return new FirstClassCallable(Literal.name(literal));
+    }
+    toString() {
+        return this.name.toEnclosedForm() + "(...)";
+    }
+}
+exports.FirstClassCallable = FirstClassCallable;
+exports.validPHPLabel = /^[a-zA-Z_\x80-\xff][a-zA-Z0-9_\x80-\xff]*$/; // This is from https://www.php.net/manual/en/functions.user-defined.php
 class Assignment extends ParenthesesEnclosableExpression {
     value;
     push;
@@ -265,12 +297,23 @@ class PHPWriter {
         this.indentation = "\t".repeat(level);
         return this;
     }
+    /**
+     * @param lines These are treated as literal *regardless of their types*
+     */
     append(...lines) {
         for (const line of lines) {
             this.buffer.push(`${this.indentation}${line}`);
         }
         return this;
     }
+    /**
+     * @param expr This is treated as literal *regardless of its type*
+     * @param opts flags to add additional markup around the expression
+     */
+    appendExpr(expr, opts = {}) {
+        const res = (opts.return ? "return " : "") + expr.toString();
+        return this.append(!opts.chain ? res + ';' : res);
+    }
     assign(assignee, expression, opts = {}) {
         if (typeof assignee === 'string') {
             assignee = new Var(assignee);
@@ -285,10 +328,10 @@ class PHPWriter {
                 this.scopeStack[this.scopeStack.length - 1].push(assignee.name);
             }
         }
-        return this.appendWithPossibleReturnAndChain(new Assignment(assignee, expression), opts);
+        return this.appendExpr(new Assignment(assignee, expression), opts);
     }
     return(expression) {
-        return this.append(`return ${Expr.convertJsonToPHP(expression)};`);
+        return this.appendExpr(Expr.convertJsonToPHP(expression), { return: true });
     }
     static(variable, opts = {}) {
         if (typeof variable === 'string') {
@@ -309,12 +352,17 @@ class PHPWriter {
         this.buffer.push("");
         return this;
     }
+    /**
+     * @param func This is treated as literal *regardless of its type*
+     * @param args
+     * @param opts
+     */
     call(func, args, opts = {}) {
         const functionCall = new Call(typeof func === 'string' ? Literal.name(func) : func, args);
         if (opts.assignTo) {
             return this.assign(opts.assignTo, functionCall, opts);
         }
-        return this.appendWithPossibleReturnAndChain(functionCall, opts);
+        return this.appendExpr(functionCall, opts);
     }
     action(name, contents, args = {}) {
         return this.actionOrFilter('action', name, contents, args);
@@ -325,7 +373,7 @@ class PHPWriter {
     actionOrFilter(type, name, contents, args) {
         const { priority = 10, functionArgParameters = [], useVars = [], accountForAlreadyDoing } = args;
         const functionWriter = this.createSubwriter();
-        let declarationFunctionText;
+        let declarationFunction;
         if (accountForAlreadyDoing) {
             if (functionArgParameters.length > 0 && accountForAlreadyDoing === true) {
                 console.trace(`The accountForAlreadyDoing flag must be set to a list of default parameters when applied to ${type}s that take arguments`);
@@ -333,35 +381,35 @@ class PHPWriter {
             this.openPHP().openScope();
             const functionName = functionWriter.function(true, functionArgParameters, contents, { useVars, scopeActionDescription: `closing the function call for the ${name} ${type}.`, assignToName: true });
             this.append(functionWriter.toString().trim());
-            declarationFunctionText = functionName + "(...)";
+            declarationFunction = new FirstClassCallable(functionName);
             this.if(Expr.call(`doing_${type}`, [name]))
                 .call(functionName, accountForAlreadyDoing === true ? [] : accountForAlreadyDoing);
         }
         else {
             functionWriter.function(false, functionArgParameters, contents, { useVars, scopeActionDescription: `closing the function call for the ${name} ${type}.` });
-            declarationFunctionText = functionWriter.toString().trim();
+            declarationFunction = Literal.of(functionWriter);
         }
         // The trailing comma inside the first item is necessary
-        const declarationComponents = [`${Expr.convertJsonToPHP(name)}`, declarationFunctionText];
+        const additionArgs = [name, declarationFunction];
         const accepted_args = Math.max(functionArgParameters.length, 1); // This avoids us unnecessarily setting the accepted_args value to 0 for actions
         if (priority !== 10) {
-            declarationComponents.push(priority.toString());
+            additionArgs.push(priority);
             if (accepted_args !== 1) {
-                declarationComponents.push(accepted_args.toString());
+                additionArgs.push(accepted_args);
             }
         }
         else if (accepted_args !== 1) {
-            declarationComponents.push(`accepted_args: ${accepted_args}`);
+            additionArgs.push(new Parameter(accepted_args, "accepted_args"));
         }
-        const line = `add_${type}(${declarationComponents.join(", ")});`;
+        const line = Expr.call(`add_${type}`, additionArgs);
         if (accountForAlreadyDoing) {
             return this
                 .else()
-                .append(line)
+                .appendExpr(line)
                 .endIf()
                 .closeScope();
         }
-        return this.openPHP().append(line);
+        return this.openPHP().appendExpr(line);
     }
     if(condition) {
         return this.openPHP().append(`if (${condition}) {`).indent();
@@ -384,6 +432,11 @@ class PHPWriter {
                 console.trace('Anonymous functions cannot be assigned to a name');
             }
         }
+        if (typeof name === 'string') {
+            if (!exports.validPHPLabel.test(name)) {
+                throw new Error(`'${name}' is not a valid function name. Please see https://www.php.net/manual/en/functions.user-defined.php for what constitutes one`);
+            }
+        }
         const returningString = name === true;
         if (name === true) {
             name = this.generateFunctionName(args.assignToName);
@@ -550,14 +603,5 @@ class PHPWriter {
         const contents = this.toString() + "\n";
         compilation[file in compilation.assets ? 'updateAsset' : 'emitAsset'](file, new webpack_1.sources.RawSource(contents), { size: Buffer.byteLength(contents), ...assetInfo });
     }
-    /**
-     * @param expr Unlike most other methods on this class, this is treated as literal *regardless of the argument's type*
-     * @param opts
-     * @private
-     */
-    appendWithPossibleReturnAndChain(expr, opts) {
-        const res = (opts.return ? "return " : "") + expr.toString();
-        return this.append(!opts.chain ? res + ';' : res);
-    }
 }
 exports.PHPWriter = PHPWriter;