@plaudit/webpack-extensions 2.71.0 → 2.72.0

package/build/plugins/ExtensionsConfigFileGeneratorPlugin.js

@@ -6,10 +6,11 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.ExtensionsConfigFileGeneratorPlugin = void 0;
 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 AbstractBiPhasicGroupAndEntryPlugin_1 = require("./AbstractBiPhasicGroupAndEntryPlugin");
 const UnifiedLoaderGenerator_1 = require("./UnifiedLoaderGenerator");
 const shared_1 = require("../shared");
-const php_writer_1 = require("../utils/php-writer");
 const pseduo_semaphore_1 = require("../utils/pseduo-semaphore");
 const webpack_1 = require("webpack");
 class ExtensionsConfigFileGeneratorPlugin extends AbstractBiPhasicGroupAndEntryPlugin_1.AbstractBiPhasicGroupAndEntryPlugin {
@@ -98,10 +99,9 @@ class ExtensionsConfigFileGeneratorPlugin extends AbstractBiPhasicGroupAndEntryP
             return [block[0], Object.fromEntries(Object.entries(block[1]).toSorted(([a], [b]) => a.localeCompare(b)))];
         })
             .toSorted(([a], [b]) => a.localeCompare(b)));
-        new php_writer_1.PHPWriter()
-            .call("Plaudit\\Common\\Lib\\GutenbergUtils::loadExtensionsV3", [new php_writer_1.EnclosedLiteral((0, shared_1.makeEmittableConfigPHP)(blockExtensionsConfig, false)), php_writer_1.Op.concat(php_writer_1.Constants.__DIR__, '/'),
-            php_writer_1.Expr.call("plaudit_webpack_extensions__resolve_base_uri", [php_writer_1.Constants.__DIR__])])
-            .emitAsset(compilation, node_path_1.default.join(this.dest.destination, "extensions-loader.php"));
+        (0, shared_1.emitPHPWriterAsAsset)(new php_writer_1.PHPWriter()
+            .call("Plaudit\\Common\\Lib\\GutenbergUtils::loadExtensionsV3", [new expressions_1.EnclosedLiteral((0, shared_1.makeEmittableConfigPHP)(blockExtensionsConfig, false)), expressions_1.Op.concat(expressions_1.Constants.__DIR__, '/'),
+            expressions_1.Expr.call("plaudit_webpack_extensions__resolve_base_uri", [expressions_1.Constants.__DIR__])]), compilation, node_path_1.default.join(this.dest.destination, "extensions-loader.php"));
     }
     attachUniquePhase(compilation) {
         compilation.hooks.processAssets.tapPromise({ name: this.constructor.name, stage: webpack_1.Compilation.PROCESS_ASSETS_STAGE_REPORT }, async () => {

package/build/plugins/ExtensionsConfigFileGeneratorPluginV1.js

@@ -5,10 +5,10 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ExtensionsConfigFileGeneratorPluginV1 = void 0;
 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 AbstractBiPhasicGroupAndEntryPlugin_1 = require("./AbstractBiPhasicGroupAndEntryPlugin");
 const UnifiedLoaderGenerator_1 = require("./UnifiedLoaderGenerator");
-const php_serializer_1 = require("../utils/php-serializer");
-const php_writer_1 = require("../utils/php-writer");
 const webpack_1 = require("webpack");
 class ExtensionsConfigFileGeneratorPluginV1 extends AbstractBiPhasicGroupAndEntryPlugin_1.AbstractBiPhasicGroupAndEntryPlugin {
     extensionsDest;
@@ -28,11 +28,11 @@ class ExtensionsConfigFileGeneratorPluginV1 extends AbstractBiPhasicGroupAndEntr
                 (resourceInfo[key] ?? (resourceInfo[key] = [])).push([`plaudit_block-extension_${match[1]}-${match[2]}`, fileWithAssetData]);
             }
         }
-        compilation.emitAsset(node_path_1.default.join(this.extensionsDest, "mapping.config"), new webpack_1.sources.RawSource((0, php_serializer_1.phpSerialize)(mapping)));
+        compilation.emitAsset(node_path_1.default.join(this.extensionsDest, "mapping.config"), new webpack_1.sources.RawSource((0, php_writer_1.phpSerialize)(mapping)));
         UnifiedLoaderGenerator_1.UnifiedLoaderGenerator.semaphore.resolve(this.id, { group: `extensions-config-v1-${this.extensionsDest}`, requiresBaseURI: false, action: writer => {
                 writer
                     .use("Plaudit\\Common\\Lib\\GutenbergUtils")
-                    .call("GutenbergUtils::installExtensionsSupport", [php_writer_1.Op.concat(php_writer_1.Constants.__DIR__, this.extensionsDest)]);
+                    .call("GutenbergUtils::installExtensionsSupport", [expressions_1.Op.concat(expressions_1.Constants.__DIR__, this.extensionsDest)]);
             } });
     }
 }

package/build/plugins/PlainEntrypointsConfigFileGeneratorPlugin.js

@@ -5,8 +5,9 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PlainEntrypointsConfigFileGeneratorPlugin = void 0;
 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 php_writer_1 = require("../utils/php-writer");
 const pseduo_semaphore_1 = require("../utils/pseduo-semaphore");
 const AbstractBiPhasicGroupAndEntryPlugin_1 = require("./AbstractBiPhasicGroupAndEntryPlugin");
 const UnifiedLoaderGenerator_1 = require("./UnifiedLoaderGenerator");
@@ -78,12 +79,12 @@ class PlainEntrypointsConfigFileGeneratorPlugin extends AbstractBiPhasicGroupAnd
             if (!this.useUnifiedLoader) {
                 (0, shared_1.emitResolveBaseUriFunction)(writer);
             }
-            const baseUriVar = new php_writer_1.Var("base_uri");
+            const baseUriVar = new expressions_1.Var("base_uri");
             for (const [priority, prioritizedHandleList] of PlainEntrypointsConfigFileGeneratorPlugin.separateHandleListByPriority(handleLists.register)) {
                 writer.action("init", writer => {
-                    writer.call("plaudit_webpack_extensions__resolve_base_uri", [php_writer_1.Constants.__DIR__], { assignTo: baseUriVar });
+                    writer.call("plaudit_webpack_extensions__resolve_base_uri", [expressions_1.Constants.__DIR__], { assignTo: baseUriVar });
                     for (const { handle, type, data } of prioritizedHandleList) {
-                        writer.call(`wp_register_${type}`, [handle, php_writer_1.Op.concat(baseUriVar, node_path_1.default.relative(emitDir, data.src)), ...data.rest]);
+                        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 });
             }
@@ -100,7 +101,7 @@ class PlainEntrypointsConfigFileGeneratorPlugin extends AbstractBiPhasicGroupAnd
             }
         }
         PlainEntrypointsConfigFileGeneratorPlugin.appendEnqueuingHandleLists(writer, handleLists);
-        writer.emitAsset(compilation, "plain-entrypoints-loader.php");
+        (0, shared_1.emitPHPWriterAsAsset)(writer, compilation, "plain-entrypoints-loader.php");
     }
     static addHandlesToHandleLists(type, handles, handleLists) {
         for (const [handle, data] of handles) {

package/build/plugins/PlainEntrypointsStyleBlockJSONPlugin.js

@@ -10,8 +10,9 @@ const node_fs_1 = __importDefault(require("node:fs"));
 const node_path_1 = __importDefault(require("node:path"));
 const AbstractBiPhasicGroupAndEntryPlugin_1 = require("./AbstractBiPhasicGroupAndEntryPlugin");
 const UnifiedLoaderGenerator_1 = require("./UnifiedLoaderGenerator");
+const php_writer_1 = require("@plaudit/php-writer");
+const expressions_1 = require("@plaudit/php-writer/expressions");
 const shared_1 = require("../shared");
-const php_writer_1 = require("../utils/php-writer");
 const pseduo_semaphore_1 = require("../utils/pseduo-semaphore");
 const webpack_1 = require("webpack");
 class PlainEntrypointsStyleBlockJSONPlugin extends AbstractBiPhasicGroupAndEntryPlugin_1.AbstractBiPhasicGroupAndEntryPlugin {
@@ -119,12 +120,11 @@ class PlainEntrypointsStyleBlockJSONPlugin extends AbstractBiPhasicGroupAndEntry
         if (this.config.useUnifiedLoader) {
             const metadata = blockData['__metadata'];
             delete blockData['__metadata'];
-            new php_writer_1.PHPWriter()
+            (0, shared_1.emitPHPWriterAsAsset)(new php_writer_1.PHPWriter()
                 .action("init", writer => {
-                writer.call("\\Plaudit\\Common\\ACF\\BlockManager::autoloadSubfoldersV3", [php_writer_1.Constants.__DIR__, new php_writer_1.EnclosedLiteral((0, shared_1.makeEmittableConfigPHP)(blockData, false, "\t")),
-                    php_writer_1.Constants.__FILE__, new php_writer_1.EnclosedLiteral((0, shared_1.makeEmittableConfigPHP)(metadata, false, "\t")), null]);
-            }, { accountForAlreadyDoing: this.config.includePostInitFallback })
-                .emitAsset(compilation, node_path_1.default.join(this.dest.destination, "blockdir-loader.php"));
+                writer.call("\\Plaudit\\Common\\ACF\\BlockManager::autoloadSubfoldersV3", [expressions_1.Constants.__DIR__, new expressions_1.EnclosedLiteral((0, shared_1.makeEmittableConfigPHP)(blockData, false, "\t")),
+                    expressions_1.Constants.__FILE__, new expressions_1.EnclosedLiteral((0, shared_1.makeEmittableConfigPHP)(metadata, false, "\t")), null]);
+            }, { accountForAlreadyDoing: this.config.includePostInitFallback }), compilation, node_path_1.default.join(this.dest.destination, "blockdir-loader.php"));
         }
         else {
             compilation.emitAsset(node_path_1.default.join(this.dest.destination, "blockdir.config.php"), new webpack_1.sources.RawSource((0, shared_1.makeEmittableConfigPHP)(blockData, true)));

package/build/plugins/SpecialAssetHandlingPlugin.js

@@ -5,8 +5,9 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SpecialAssetHandlingPlugin = void 0;
 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 php_writer_1 = require("../utils/php-writer");
 const pseduo_semaphore_1 = require("../utils/pseduo-semaphore");
 const AbstractBiPhasicGroupPlugin_1 = require("./AbstractBiPhasicGroupPlugin");
 const UnifiedLoaderGenerator_1 = require("./UnifiedLoaderGenerator");
@@ -68,7 +69,7 @@ class SpecialAssetHandlingPlugin extends AbstractBiPhasicGroupPlugin_1.AbstractB
         const writer = new php_writer_1.PHPWriter();
         if (!preloadedAssets.length) {
             if (!this.config.useUnifiedLoader) {
-                writer.emitAsset(compilation, outputFile);
+                (0, shared_1.emitPHPWriterAsAsset)(writer, compilation, outputFile);
             }
             return;
         }
@@ -76,8 +77,8 @@ class SpecialAssetHandlingPlugin extends AbstractBiPhasicGroupPlugin_1.AbstractB
             (0, shared_1.emitResolveBaseUriFunction)(writer);
         }
         writer.action("wp_head", writer => {
-            const baseUriVar = new php_writer_1.Var("base_uri");
-            writer.call("plaudit_webpack_extensions__resolve_base_uri", [php_writer_1.Constants.__DIR__], { assignTo: baseUriVar }).closePHP();
+            const baseUriVar = new expressions_1.Var("base_uri");
+            writer.call("plaudit_webpack_extensions__resolve_base_uri", [expressions_1.Constants.__DIR__], { assignTo: baseUriVar }).closePHP();
             for (let [filename, { preload, fetchpriority, crossorigin }] of preloadedAssets) {
                 if (!preload) {
                     continue;
@@ -116,11 +117,11 @@ class SpecialAssetHandlingPlugin extends AbstractBiPhasicGroupPlugin_1.AbstractB
                     attributes.push(["crossorigin", crossorigin]);
                 }
                 const dynamicAttrs = attributes.map(([k, v]) => v ? `${k}="${v}"` : k).join(" ");
-                writer.append(`<link rel="preload" href="<?= ${php_writer_1.Expr.call("esc_url", [php_writer_1.Op.concat(baseUriVar, filename)])} ?>" ${dynamicAttrs}>`);
+                writer.append(`<link rel="preload" href="<?= ${expressions_1.Expr.call("esc_url", [expressions_1.Op.concat(baseUriVar, filename)])} ?>" ${dynamicAttrs}>`);
             }
             writer.openPHP();
         });
-        writer.emitAsset(compilation, outputFile);
+        (0, shared_1.emitPHPWriterAsAsset)(writer, compilation, outputFile);
     }
     attachUniquePhase(compilation) {
         compilation.hooks.processAssets.tapPromise({ name: this.constructor.name, stage: webpack_1.Compilation.PROCESS_ASSETS_STAGE_REPORT }, async () => {

package/build/plugins/UnifiedLoaderGenerator.d.ts

@@ -1,6 +1,6 @@
+import { PHPWriter } from "@plaudit/php-writer";
 import { AbstractBiPhasicGroupPlugin } from "./AbstractBiPhasicGroupPlugin";
 import type { VerifiedPlauditWordpressWebpackConfig } from "../utils/common-config-helpers";
-import { PHPWriter } from "../utils/php-writer";
 import { PseudoSemaphore } from "../utils/pseduo-semaphore";
 import { Compilation } from "webpack";
 type LoaderInfo = {

package/build/plugins/UnifiedLoaderGenerator.js

@@ -5,10 +5,9 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.UnifiedLoaderGenerator = void 0;
 const node_path_1 = __importDefault(require("node:path"));
+const php_writer_1 = require("@plaudit/php-writer");
 const AbstractBiPhasicGroupPlugin_1 = require("./AbstractBiPhasicGroupPlugin");
 const shared_1 = require("../shared");
-const json_to_php_but_with____injection_1 = __importDefault(require("../utils/json-to-php-but-with-__-injection"));
-const php_writer_1 = require("../utils/php-writer");
 const pseduo_semaphore_1 = require("../utils/pseduo-semaphore");
 const webpack_1 = require("webpack");
 class UnifiedLoaderGenerator extends AbstractBiPhasicGroupPlugin_1.AbstractBiPhasicGroupPlugin {
@@ -53,7 +52,7 @@ class UnifiedLoaderGenerator extends AbstractBiPhasicGroupPlugin_1.AbstractBiPha
                     continue;
                 }
                 const parsedPath = node_path_1.default.parse(file);
-                const contents = `<?php return ${(0, json_to_php_but_with____injection_1.default)(assetData)};\n`;
+                const contents = `<?php return ${(0, php_writer_1.json2php)(assetData)};\n`;
                 compilation.emitAsset(node_path_1.default.join(parsedPath.dir, parsedPath.name) + ".asset.php", new webpack_1.sources.RawSource(contents), { size: Buffer.byteLength(contents) });
             }
             if (this.config.useUnifiedLoader) {
@@ -65,7 +64,7 @@ class UnifiedLoaderGenerator extends AbstractBiPhasicGroupPlugin_1.AbstractBiPha
                     for (const { action } of groupedLoaderInfo) {
                         action(writer);
                     }
-                    writer.emitAsset(compilation, "unified-loader.php");
+                    (0, shared_1.emitPHPWriterAsAsset)(writer, compilation, "unified-loader.php");
                 });
             }
         });

package/build/shared.d.ts

@@ -1,6 +1,6 @@
-import { PHPWriter } from "./utils/php-writer";
+import { PHPWriter } from "@plaudit/php-writer";
 import type { Options as PostcssFunctionsOptions } from "postcss-functions";
-import { Compilation, type Configuration, WebpackError } from "webpack";
+import { AssetInfo, Compilation, type Configuration, WebpackError } from "webpack";
 export type ParsedAssetsJson = Record<string, {
     dependencies: string[];
     version: string;
@@ -146,4 +146,5 @@ export declare function newWebpackErrorForFile(error: string | ConstructorParame
  */
 export declare function emitResolveBaseUriFunction(writer: PHPWriter): void;
 export declare function getAssetsJson(compilation: Compilation): ParsedAssetsJson;
+export declare function emitPHPWriterAsAsset(writer: PHPWriter, compilation: Compilation, file: string, assetInfo?: AssetInfo): void;
 export {};

package/build/shared.js

@@ -24,9 +24,10 @@ exports.parseEnvFile = parseEnvFile;
 exports.newWebpackErrorForFile = newWebpackErrorForFile;
 exports.emitResolveBaseUriFunction = emitResolveBaseUriFunction;
 exports.getAssetsJson = getAssetsJson;
+exports.emitPHPWriterAsAsset = emitPHPWriterAsAsset;
 const promises_1 = __importDefault(require("node:fs/promises"));
-const json_to_php_but_with____injection_1 = __importDefault(require("./utils/json-to-php-but-with-__-injection"));
-const php_writer_1 = require("./utils/php-writer");
+const php_writer_1 = require("@plaudit/php-writer");
+const expressions_1 = require("@plaudit/php-writer/expressions");
 const webpack_1 = require("webpack");
 function isParsedAssetsJson(thing) {
     if (!thing || typeof thing !== 'object') {
@@ -73,7 +74,7 @@ function convertUsageLocationsHandleToEmittableHandle(handle, 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)
+    const prettyPrintedMetadata = php_writer_1.json2php.make({ indent: "\t", linebreak: "\n", shortArraySyntax: true })(data, parentIndent)
         .replaceAll(/(\n\t*)\[\s+],/gs, "$1[],")
         .replaceAll(/\[\n\t+([^\n]+)\n\t+]/gs, (_, inner) => `[${inner.trim()}]`)
         .replaceAll(/'rest' => \[\n\t+(\[(?:'[^']+')?]),\n\t+('[^']+')(?:,\n\t+(\[[^\n]+]))?\n\t+]/gs, (_, deps, hash, args) => `'rest' => [${[deps, hash, args].filter(value => !!value).join(", ")}]`);
@@ -143,24 +144,24 @@ function newWebpackErrorForFile(error, file) {
  * 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
  */
 function emitResolveBaseUriFunction(writer) {
-    const dir = new php_writer_1.Var("dir");
-    const baseUris = new php_writer_1.Var("base_uris");
-    const assignmentTarget = new php_writer_1.ArrayAccess(baseUris, dir);
-    const path = new php_writer_1.Var("path");
+    const dir = new expressions_1.Var("dir");
+    const baseUris = new expressions_1.Var("base_uris");
+    const assignmentTarget = new expressions_1.ArrayAccess(baseUris, dir);
+    const path = new expressions_1.Var("path");
     writer.function("plaudit_webpack_extensions__resolve_base_uri", [dir], writer => {
         writer
             .static(baseUris, { initializer: [] })
-            .if(php_writer_1.Expr.isset(assignmentTarget))
+            .if(expressions_1.Expr.isset(assignmentTarget))
             .return(assignmentTarget)
-            .elseIf(php_writer_1.Expr.call("str_starts_with", [dir, php_writer_1.Constants.ABSPATH]))
-            .assign(path, php_writer_1.Expr.call("ltrim", [php_writer_1.Expr.call("substr", [dir, php_writer_1.Expr.call("strlen", [php_writer_1.Constants.ABSPATH])]), "/"]))
-            .elseIf(php_writer_1.Expr.call("str_starts_with", [dir, "/workspace/website"]))
-            .assign(path, php_writer_1.Expr.call("ltrim", [php_writer_1.Expr.call("substr", [dir, 18]), "/"]))
+            .elseIf(expressions_1.Expr.call("str_starts_with", [dir, expressions_1.Constants.ABSPATH]))
+            .assign(path, expressions_1.Expr.call("ltrim", [expressions_1.Expr.call("substr", [dir, expressions_1.Expr.call("strlen", [expressions_1.Constants.ABSPATH])]), "/"]))
+            .elseIf(expressions_1.Expr.call("str_starts_with", [dir, "/workspace/website"]))
+            .assign(path, expressions_1.Expr.call("ltrim", [expressions_1.Expr.call("substr", [dir, 18]), "/"]))
             .else()
             .call("error_log", ["UNABLE TO FIGURE OUT WHAT THE RELATIVE PATH TO THE BUILT FILES DIRECTORY SHOULD BE"])
             .assign(path, "")
             .endIf()
-            .call("trailingslashit", [php_writer_1.Expr.call("home_url", [path])], { return: true, assignTo: assignmentTarget });
+            .call("trailingslashit", [expressions_1.Expr.call("home_url", [path])], { return: true, assignTo: assignmentTarget });
     }, { returnType: "string", includeExistenceCheck: true });
 }
 function getAssetsJson(compilation) {
@@ -178,3 +179,7 @@ function getAssetsJson(compilation) {
     compilation.updateAsset("assets.json", s => s, a => ({ ...a, "parsed-assets-json": parsedAssetJson }));
     return parsedAssetJson;
 }
+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 });
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@plaudit/webpack-extensions",
-  "version": "2.71.0",
+  "version": "2.72.0",
   "license": "SEE LICENSE IN LICENSE.md",
   "files": [
     "/build"
@@ -22,7 +22,7 @@
   "devDependencies": {
     "@plaudit/gutenberg-api-extensions": "^2.77.2",
     "@types/browser-sync-webpack-plugin": "^2.2.5",
-    "@types/node": "^24.7.1",
+    "@types/node": "^24.7.2",
     "@types/postcss-functions": "^4.0.4",
     "@types/tapable": "^2.3.0",
     "@types/webpack": "^5.28.5",
@@ -34,6 +34,7 @@
     "webpack-bundle-analyzer": "^4.10.2"
   },
   "dependencies": {
+    "@plaudit/php-writer": "^1.0.0",
     "@plaudit/postcss-color-function": "^5.0.0",
     "@plaudit/postcss-legacy-shorthand": "^1.0.0",
     "@plaudit/postcss-silent-extend": "^3.0.0",

package/build/utils/json-to-php-but-with-__-injection.d.ts

@@ -1,11 +0,0 @@
-type MakeProps = {
-    linebreak?: string;
-    indent?: string;
-    shortArraySyntax?: boolean;
-    stripSpaces?: boolean;
-};
-declare const make: (props?: MakeProps) => (obj: unknown, parentIndent?: string) => string;
-declare const json2php: ReturnType<typeof make> & {
-    make: typeof make;
-};
-export default json2php;

package/build/utils/json-to-php-but-with-__-injection.js

@@ -1,53 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const acceptedObjectTypes = ['[object Array]', '[object Object]'];
-const make = (props = {}) => {
-    const linebreak = props.linebreak ?? '';
-    const indent = props.indent ?? '';
-    const stripSpaces = props.stripSpaces ?? false;
-    const shortArraySyntax = props.shortArraySyntax ?? true;
-    const arrOpen = shortArraySyntax ? '[' : 'array(';
-    const arrClose = shortArraySyntax ? ']' : ')';
-    const arrow = stripSpaces ? '=>' : ' => ';
-    function transformInner(obj, parentIndent, state) {
-        switch (typeof obj) {
-            case 'undefined':
-                return 'null';
-            case 'bigint':
-            case 'number':
-            case 'boolean':
-                return obj.toString();
-            case 'string':
-                const res = obj.replace("\\", '\\\\').replaceAll("'", "\\'");
-                if (!/\s*/.test(res) && !state.isKey && state.path.length === 4 && state.path[1] === 'attributes' && state.path[3] === 'default' && state.parent?.['translatable']) {
-                    return `__('${res}')`;
-                }
-                return `'${res}'`;
-            case 'object':
-                if (obj === null)
-                    return 'null';
-                const objType = Object.prototype.toString.call(obj);
-                if (objType === '[object Date]')
-                    return obj.toISOString();
-                if (!acceptedObjectTypes.includes(objType))
-                    return 'null';
-                const nestIndent = parentIndent + indent;
-                const items = Array.isArray(obj)
-                    ? obj.map((item, i) => transformInner(item, nestIndent, { path: [...state.path, i], parent: obj }))
-                    : Object.entries(obj).map(([key, value]) => {
-                        return transformInner(key, nestIndent, { path: [...state.path, key], parent: obj, isKey: true })
-                            + arrow + transformInner(value, nestIndent, { path: [...state.path, key], parent: obj });
-                    });
-                const itemStr = items.join(`,${linebreak === '' && !stripSpaces ? ' ' : linebreak + nestIndent}`);
-                return `${arrOpen}${linebreak + nestIndent}${itemStr}${linebreak + parentIndent}${arrClose}`;
-            default:
-                return 'null';
-        }
-    }
-    return function transform(obj, parentIndent = '') {
-        return transformInner(obj, parentIndent, { path: [] });
-    };
-};
-const json2php = make();
-json2php.make = make;
-exports.default = json2php;

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

@@ -1,6 +0,0 @@
-type Config = {
-    objectsAsArrays?: boolean;
-    excludedKeys?: string[];
-};
-export declare function phpSerialize(value: any, config?: Config): string;
-export {};

package/build/utils/php-serializer.js

@@ -1,53 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.phpSerialize = phpSerialize;
-function phpSerialize(value, config) {
-    switch (typeof value) {
-        case "undefined":
-            return "N;";
-        case "object":
-            if (value === null) {
-                return "N;"; // Yep. Null is an "object" in JavaScript
-            }
-            else if (Array.isArray(value)) {
-                let res = `a:${value.length}:{`;
-                for (let i = 0; i < value.length; i++) {
-                    res += `i:${i};${phpSerialize(value[i], config)}`;
-                }
-                return (res.endsWith('};') ? res.substring(0, res.length - 1) : res) + "}";
-            }
-            return entriesInArrayAndObjectFormat(config?.objectsAsArrays ?? true ? 'a' : 'O:8:"stdClass"', Object.entries(value), config);
-        case "boolean":
-            return `b:${value ? 1 : 0};`;
-        case "number":
-            return Number.isInteger(value) ? serializeInteger(value) : `d:${value};`;
-        case "string":
-            return `s:${Buffer.byteLength(value, 'utf8')}:"${value}";`;
-        case "function":
-            throw new Error(`We are unable to serialize functions into a form readable by PHP.`);
-        case "symbol":
-            value = value.toString();
-            return `s:${Buffer.byteLength(value, 'utf8')}:"${value}";`;
-        case "bigint":
-            return serializeInteger(value);
-    }
-}
-function serializeInteger(value) {
-    const str = value.toString();
-    if (str.includes("e") || str.includes("E")) {
-        return `d:${str.replace(/e/i, ".0e")};`;
-    }
-    return `i:${str};`;
-}
-function entriesInArrayAndObjectFormat(prefix, entries, config) {
-    const excludedKeys = config?.excludedKeys ?? [];
-    let res = "";
-    let count = 0;
-    for (const [k, v] of entries) {
-        if (!excludedKeys.includes(k)) {
-            count++;
-            res += `${phpSerialize(k, config)}${phpSerialize(v, config)}`;
-        }
-    }
-    return `${prefix}:${count}:{` + (res.endsWith('};') ? res.substring(0, res.length - 1) : res) + "}";
-}

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

@@ -1,237 +0,0 @@
-import { AssetInfo, Compilation } from "webpack";
-export declare abstract class Expr {
-    static readonly jsonToPHPConverter: (obj: unknown, parentIndent?: string) => string;
-    static readonly convertJsonToPHP: (obj: unknown) => string;
-    protected constructor();
-    abstract toString(): string;
-    typeName(): string;
-    static isset(...checks: (Var | ArrayAccess | ObjectAccess)[]): Call;
-    static call(name: string, args: ConstructorParameters<typeof Call>[1]): Call;
-}
-export interface EnclosableExpression extends Expr {
-    toEnclosedForm(): string;
-    not(): Not;
-}
-export interface PotentiallyWriteableExpression extends EnclosableExpression {
-    readonly potentiallyWritable: true;
-}
-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;
-}
-export declare abstract class ParenthesesEnclosableExpression extends AbstractEnclosableExpression {
-    toEnclosedForm(): string;
-}
-export declare abstract class EnclosedExpression extends AbstractEnclosableExpression {
-    toEnclosedForm(): string;
-}
-export declare class Literal extends Expr {
-    readonly expression: string;
-    constructor(expression: string);
-    toString(): string;
-    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 {
-    constructor(expression: string);
-    toEnclosedForm(): string;
-    not(): Not;
-}
-export declare class EnclosableLiteral extends Literal implements EnclosableExpression {
-    private readonly enclosureOpen;
-    private readonly enclosureClose;
-    constructor(expression: string, enclosureOpen: string, enclosureClose: string);
-    toEnclosedForm(): string;
-    not(): Not;
-}
-export declare class Var extends EnclosedExpression implements PotentiallyWriteableExpression {
-    readonly name: string;
-    readonly potentiallyWritable = true;
-    constructor(name: string);
-    toString(): string;
-}
-export declare class Op extends ParenthesesEnclosableExpression {
-    readonly operator: string;
-    readonly args: readonly unknown[];
-    constructor(operator: string, ...args: unknown[]);
-    toString(): string;
-    static binary(left: unknown, operator: string, right: unknown): Op;
-    static concat(...args: unknown[]): Op;
-}
-export declare class Not extends ParenthesesEnclosableExpression {
-    readonly expression: EnclosableExpression;
-    constructor(expression: EnclosableExpression);
-    toString(): string;
-}
-type AtLeastOneArray<T> = [T, ...T[]];
-type ReadonlyAtLeastOneArray<T> = readonly [T, ...T[]];
-export type Accessor = Expr | string | number;
-export type AccessorOrAccessorArray = Accessor | AtLeastOneArray<Accessor>;
-export declare abstract class Access extends EnclosedExpression implements PotentiallyWriteableExpression {
-    readonly target: EnclosableExpression;
-    readonly potentiallyWritable = true;
-    readonly accesses: ReadonlyAtLeastOneArray<Accessor>;
-    constructor(target: EnclosableExpression, accesses: AccessorOrAccessorArray);
-    abstract endsWithCall(): boolean;
-    abstract endsWithPotentiallyWritableExpression(): boolean;
-}
-export declare class ArrayAccess extends Access {
-    toString(): string;
-    endsWithCall(): boolean;
-    endsWithPotentiallyWritableExpression(): boolean;
-}
-export declare class ObjectAccess extends Access {
-    static readonly validObjectKey: RegExp;
-    toString(): string;
-    endsWithCall(): boolean;
-    endsWithPotentiallyWritableExpression(): boolean;
-}
-export declare class Call extends EnclosedExpression implements PotentiallyWriteableExpression {
-    readonly callee: string | EnclosableExpression;
-    readonly args: readonly unknown[];
-    readonly potentiallyWritable = true;
-    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;
-    readonly push: boolean;
-    readonly assignees: ReadonlyAtLeastOneArray<Assignable>;
-    constructor(assignees: Assignable, value: unknown, push: true);
-    constructor(assignees: Assignable | AtLeastOneArray<Assignable>, value: unknown, push?: false | undefined);
-    toString(): string;
-}
-export declare abstract class Constants {
-    static readonly __FILE__: EnclosedLiteral;
-    static readonly __DIR__: EnclosedLiteral;
-    static readonly ABSPATH: EnclosedLiteral;
-}
-export type AppendExprArgs = {
-    chain?: boolean;
-    return?: boolean;
-};
-export type ActionOrFilterArgs = {
-    priority?: number | Expr;
-    functionArgParameters?: string[];
-    useVars?: Var[];
-    accountForAlreadyDoing?: boolean | Parameters<PHPWriter['call']>[1];
-};
-export type FunctionCreationArgs = {
-    includeExistenceCheck?: boolean;
-    useVars?: Var[];
-    returnType?: string;
-    assignToName?: boolean;
-    scopeActionDescription?: string;
-};
-export type RequireOrIncludeArgs = {
-    dirRelative?: boolean;
-    once?: boolean;
-} & AppendExprArgs;
-export declare class PHPWriter {
-    private readonly inlineFirstLine;
-    private readonly scopeStack;
-    private readonly useList;
-    private readonly allocatedGeneratedFunctionNames;
-    private readonly isSubwriter;
-    private printingInPHP;
-    private buffer;
-    private indentation;
-    private fileNamespace;
-    private myOpenedScopes;
-    constructor(inlineFirstLine?: boolean, scopeStack?: string[][], useList?: string[], allocatedGeneratedFunctionNames?: Set<string>, isSubwriter?: boolean, printingInPHP?: boolean, initialIndentation?: number);
-    createSubwriter(): 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?: AppendExprArgs): this;
-    assign(assignee: ConstructorParameters<typeof Assignment>[0] | string, expression: unknown, opts?: AppendExprArgs): this;
-    return(expression: unknown | Expr): this;
-    static(variable: Var | string, opts?: {
-        initializer?: unknown | Literal;
-        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?: {
-        assignTo?: ConstructorParameters<typeof Assignment>[0];
-    } & AppendExprArgs): this;
-    action(name: string | Expr, contents: (writer: PHPWriter) => void, args?: ActionOrFilterArgs): this;
-    filter(name: string | Expr, contents: (writer: PHPWriter) => void, args?: ActionOrFilterArgs): this;
-    actionOrFilter(type: 'action' | 'filter', name: string | Expr, contents: (writer: PHPWriter) => void, args: ActionOrFilterArgs): this;
-    if(condition: Expr): this;
-    elseIf(condition: Expr): this;
-    else(): this;
-    endIf(): this;
-    function(name: true, parameters: (string | Var)[], body: (writer: PHPWriter) => void, args?: FunctionCreationArgs): Var;
-    function(name: string | Var | false, parameters: (string | Var)[], body: (writer: PHPWriter) => void, args?: FunctionCreationArgs): this;
-    generateFunctionName(asVariable: true): Var;
-    generateFunctionName(asVariable?: false | undefined): string;
-    generateFunctionName(asVariable?: boolean): string | Var;
-    closePHP(): this;
-    openPHP(): this;
-    namespace(namespace: string): this;
-    use(...uses: string[]): this;
-    require(filePath: string | Expr, args?: RequireOrIncludeArgs): this;
-    include(filePath: string | Expr, args?: RequireOrIncludeArgs): this;
-    requireOrInclude(type: 'require' | 'include', filePath: string | Expr, args: RequireOrIncludeArgs): this;
-    /**
-     * Starts a scope that, when paired with {@link #closeScope()}, allows for automating unset calls.
-     * All scopes started MUST be paired with either an {@link #closeScope()} or {@link #popScope()} call.
-     */
-    openScope(): this;
-    /**
-     * Pops the top scope from the stack AND unsets all variables that were assigned within it
-     */
-    closeScope(): this;
-    /**
-     * Pops the top scope from the stack WITHOUT calling unset for the variables that were assigned within it.
-     * This is used to allow function bodies to be safely created without disrupting their containing scope.
-     */
-    popScope(): this;
-    withScope(code: (writer: PHPWriter) => void, opts?: {
-        actionDescription?: string;
-        usePopScopeInstead?: boolean;
-    }): this;
-    toString(args?: {
-        includeOpenPHP?: boolean;
-        includeNamespaceAndUse?: boolean;
-    }): string;
-    emitAsset(compilation: Compilation, file: string, assetInfo?: AssetInfo): void;
-}
-export {};

package/build/utils/php-writer.js

@@ -1,634 +0,0 @@
-"use strict";
-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.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"));
-const webpack_1 = require("webpack");
-class Expr {
-    static jsonToPHPConverter = json_to_php_but_with____injection_1.default.make({ shortArraySyntax: true });
-    static convertJsonToPHP = (obj) => obj instanceof Expr ? obj.toString() : Expr.jsonToPHPConverter(obj);
-    constructor() { }
-    // noinspection JSUnusedGlobalSymbols - this technically-unused method is necessary for TypeScript to differentiate subclasses of Expr from any
-    typeName() {
-        return this.constructor.name;
-    }
-    static isset(...checks) {
-        return Expr.call("isset", checks);
-    }
-    static call(name, args) {
-        return new Call(Literal.name(name), args);
-    }
-}
-exports.Expr = Expr;
-function isEnclosableExpression(a) {
-    return a instanceof Expr && 'toEnclosedForm' in a && typeof a.toEnclosedForm === 'function';
-}
-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);
-    }
-}
-exports.AbstractEnclosableExpression = AbstractEnclosableExpression;
-class ParenthesesEnclosableExpression extends AbstractEnclosableExpression {
-    toEnclosedForm() {
-        return "(" + this.toString() + ")";
-    }
-}
-exports.ParenthesesEnclosableExpression = ParenthesesEnclosableExpression;
-class EnclosedExpression extends AbstractEnclosableExpression {
-    toEnclosedForm() {
-        return this.toString();
-    }
-}
-exports.EnclosedExpression = EnclosedExpression;
-class Literal extends Expr {
-    expression;
-    constructor(expression) {
-        super();
-        this.expression = expression;
-    }
-    toString() {
-        return this.expression;
-    }
-    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 ?? AbstractEnclosableExpression.closers[enclosed] ?? enclosed);
-        }
-        if (enclosed) {
-            return new EnclosedLiteral(expression);
-        }
-        return new Literal(expression);
-    }
-    static name(expression) {
-        return new EnclosedLiteral(expression);
-    }
-}
-exports.Literal = Literal;
-class EnclosedLiteral extends Literal {
-    constructor(expression) {
-        super(expression);
-    }
-    toEnclosedForm() {
-        return this.toString();
-    }
-    not() {
-        return new Not(this);
-    }
-}
-exports.EnclosedLiteral = EnclosedLiteral;
-class EnclosableLiteral extends Literal {
-    enclosureOpen;
-    enclosureClose;
-    constructor(expression, enclosureOpen, enclosureClose) {
-        super(expression);
-        this.enclosureOpen = enclosureOpen;
-        this.enclosureClose = enclosureClose;
-    }
-    toEnclosedForm() {
-        return this.enclosureOpen + this.toString() + this.enclosureClose;
-    }
-    not() {
-        return new Not(this);
-    }
-}
-exports.EnclosableLiteral = EnclosableLiteral;
-class Var extends EnclosedExpression {
-    name;
-    potentiallyWritable = true;
-    constructor(name) {
-        super();
-        this.name = name;
-    }
-    toString() {
-        return "$" + this.name;
-    }
-}
-exports.Var = Var;
-class Op extends ParenthesesEnclosableExpression {
-    operator;
-    args;
-    constructor(operator, ...args) {
-        super();
-        this.operator = operator;
-        this.args = args;
-    }
-    toString() {
-        return this.args
-            .map(a => isEnclosableExpression(a) ? a.toEnclosedForm() : Expr.convertJsonToPHP(a))
-            .join(this.operator);
-    }
-    static binary(left, operator, right) {
-        return new Op(operator, left, right);
-    }
-    static concat(...args) {
-        return new Op(".", ...args);
-    }
-}
-exports.Op = Op;
-class Not extends ParenthesesEnclosableExpression {
-    expression;
-    constructor(expression) {
-        super();
-        this.expression = expression;
-    }
-    toString() {
-        return "!" + this.expression.toEnclosedForm();
-    }
-}
-exports.Not = Not;
-class Access extends EnclosedExpression {
-    target;
-    potentiallyWritable = true;
-    accesses;
-    constructor(target, accesses) {
-        super();
-        this.target = target;
-        this.accesses = Array.isArray(accesses) ? accesses : [accesses];
-    }
-}
-exports.Access = Access;
-class ArrayAccess extends Access {
-    toString() {
-        return this.target.toEnclosedForm() + this.accesses.map(a => `[${Expr.convertJsonToPHP(a)}]`).join("");
-    }
-    endsWithCall() {
-        return false;
-    }
-    endsWithPotentiallyWritableExpression() {
-        return true;
-    }
-}
-exports.ArrayAccess = ArrayAccess;
-class ObjectAccess extends Access {
-    static validObjectKey = /^[a-zA-Z_][a-zA-Z_0-9]*$/;
-    toString() {
-        return [this.target.toString(), ...this.accesses.map(a => {
-                if ((typeof a === 'string' && ObjectAccess.validObjectKey.test(a)) || a instanceof Var || a instanceof Call) {
-                    return a;
-                }
-                return "{" + Expr.convertJsonToPHP(a) + "}";
-            })].join("->");
-    }
-    endsWithCall() {
-        return this.accesses[this.accesses.length - 1] instanceof Call;
-    }
-    endsWithPotentiallyWritableExpression() {
-        return isPotentiallyWriteableExpression(this.accesses[this.accesses.length - 1]);
-    }
-}
-exports.ObjectAccess = ObjectAccess;
-class Call extends EnclosedExpression {
-    callee;
-    args;
-    potentiallyWritable = true;
-    constructor(callee, args) {
-        super();
-        this.callee = callee;
-        this.args = args;
-    }
-    toString() {
-        const callee = typeof this.callee === 'string' ? Expr.convertJsonToPHP(this.callee) : this.callee.toEnclosedForm();
-        return `${callee}(${this.args.map(Expr.convertJsonToPHP).join(", ")})`;
-    }
-}
-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;
-    assignees;
-    constructor(assignees, value, push = false) {
-        super();
-        this.value = value;
-        this.push = push;
-        this.assignees = Array.isArray(assignees) ? assignees : [assignees];
-        if (this.assignees.some(a => a instanceof Access && !a.endsWithPotentiallyWritableExpression())) {
-            throw new Error("Cannot assign a value to an access chain that does not end in a writable state");
-        }
-        if (!this.push && this.assignees.some(a => a instanceof Call || (a instanceof Access && a.endsWithCall()))) {
-            throw new Error("Cannot assign a value to an access chain that ends in a function call unless that 'assignment' is a push");
-        }
-    }
-    toString() {
-        if (this.push) {
-            return this.assignees[0].toEnclosedForm() + "[] = " + Expr.convertJsonToPHP(this.value);
-        }
-        return [...this.assignees.map(t => t.toEnclosedForm()), Expr.convertJsonToPHP(this.value)].join(" = ");
-    }
-}
-exports.Assignment = Assignment;
-class Constants {
-    static __FILE__ = Literal.name("__FILE__");
-    static __DIR__ = Literal.name("__DIR__");
-    static ABSPATH = Literal.name("ABSPATH");
-}
-exports.Constants = Constants;
-class PHPWriter {
-    inlineFirstLine;
-    scopeStack;
-    useList;
-    allocatedGeneratedFunctionNames;
-    isSubwriter;
-    printingInPHP;
-    buffer = [];
-    indentation;
-    fileNamespace = "";
-    myOpenedScopes = 0;
-    constructor(inlineFirstLine = false, scopeStack = [], useList = [], allocatedGeneratedFunctionNames = new Set(), isSubwriter = false, printingInPHP = true, initialIndentation = 0) {
-        this.inlineFirstLine = inlineFirstLine;
-        this.scopeStack = scopeStack;
-        this.useList = useList;
-        this.allocatedGeneratedFunctionNames = allocatedGeneratedFunctionNames;
-        this.isSubwriter = isSubwriter;
-        this.printingInPHP = printingInPHP;
-        this.indentation = "\t".repeat(initialIndentation);
-    }
-    createSubwriter() {
-        return new PHPWriter(false, this.scopeStack, this.useList, this.allocatedGeneratedFunctionNames, true, this.printingInPHP, this.indentation.length)
-            .setIndentation(this.indentation.length);
-    }
-    indent() {
-        this.indentation += "\t";
-        return this;
-    }
-    outdent() {
-        this.indentation = this.indentation.slice(0, -1);
-        return this;
-    }
-    setIndentation(level) {
-        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 = {}) {
-        let expression;
-        if (isEnclosableExpression(expr)) {
-            expression = opts.chain ? expr.toEnclosedForm() : expr.toString();
-        }
-        else if (opts.chain && expr instanceof Expr) {
-            throw new Error(`Cannot chain non-enclosable expressions`);
-        }
-        else {
-            expression = expr.toString();
-        }
-        if (opts.chain && expr instanceof Expr && !isEnclosableExpression(expr)) {
-            throw new Error(`Cannot chain non-enclosable expressions`);
-        }
-        const res = (opts.return ? "return " : "") + expression;
-        return this.append(!opts.chain ? res + ';' : res);
-    }
-    assign(assignee, expression, opts = {}) {
-        if (typeof assignee === 'string') {
-            assignee = new Var(assignee);
-        }
-        if (Array.isArray(assignee)) {
-            if (this.scopeStack.length > 0) {
-                this.scopeStack[this.scopeStack.length - 1].push(...assignee.filter(v => v instanceof Var).map(v => v.name));
-            }
-        }
-        else {
-            if (this.scopeStack.length > 0 && assignee instanceof Var) {
-                this.scopeStack[this.scopeStack.length - 1].push(assignee.name);
-            }
-        }
-        return this.appendExpr(new Assignment(assignee, expression), opts);
-    }
-    return(expression) {
-        return this.appendExpr(Expr.convertJsonToPHP(expression), { return: true });
-    }
-    static(variable, opts = {}) {
-        if (typeof variable === 'string') {
-            variable = new Var(variable);
-        }
-        const initializer = opts.initializer ? Expr.convertJsonToPHP(opts.initializer) : "null";
-        this.append(`static ${variable.toEnclosedForm()} = ${initializer};`);
-        if (opts.withTest) {
-            this.if(Op.binary(variable, "!==", new Literal(initializer)))
-                .append(`return ${Expr.convertJsonToPHP(variable)};`);
-            if (opts.withTest !== 'chainable') {
-                this.endIf();
-            }
-        }
-        return this;
-    }
-    linebreak() {
-        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.appendExpr(functionCall, opts);
-    }
-    action(name, contents, args = {}) {
-        return this.actionOrFilter('action', name, contents, args);
-    }
-    filter(name, contents, args = {}) {
-        return this.actionOrFilter('filter', name, contents, args);
-    }
-    actionOrFilter(type, name, contents, args) {
-        const { priority = 10, functionArgParameters = [], useVars = [], accountForAlreadyDoing } = args;
-        const functionWriter = this.createSubwriter();
-        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`);
-            }
-            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());
-            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}.` });
-            declarationFunction = Literal.of(functionWriter);
-        }
-        // The trailing comma inside the first item is necessary
-        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) {
-            additionArgs.push(priority);
-            if (accepted_args !== 1) {
-                additionArgs.push(accepted_args);
-            }
-        }
-        else if (accepted_args !== 1) {
-            additionArgs.push(new Parameter(accepted_args, "accepted_args"));
-        }
-        const line = Expr.call(`add_${type}`, additionArgs);
-        if (accountForAlreadyDoing) {
-            return this
-                .else()
-                .appendExpr(line)
-                .endIf()
-                .closeScope();
-        }
-        return this.openPHP().appendExpr(line);
-    }
-    if(condition) {
-        return this.openPHP().append(`if (${condition}) {`).indent();
-    }
-    elseIf(condition) {
-        return this.openPHP().outdent().append(`} else if (${condition}) {`).indent();
-    }
-    else() {
-        return this.openPHP().outdent().append(`} else {`).indent();
-    }
-    endIf() {
-        return this.openPHP().outdent().append("}");
-    }
-    function(name, parameters, body, args = {}) {
-        if (name === false) {
-            if (args.includeExistenceCheck) {
-                console.trace('Anonymous functions cannot have their existence checked for');
-            }
-            if (args.assignToName) {
-                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);
-        }
-        if (args.includeExistenceCheck) {
-            this.if(Expr.call('function_exists', [name]).not());
-        }
-        else {
-            this.openPHP();
-        }
-        if (name instanceof Var) {
-            if (this.scopeStack.length > 0) {
-                this.scopeStack[this.scopeStack.length - 1].push(name.name);
-            }
-        }
-        const declarationComponents = name === false ? [] : (name instanceof Var ? [name, '='] : ["function"]);
-        let nameAndParameters = `${!name || name instanceof Var ? 'function' : name}(${parameters.join(", ")})`;
-        if (args.useVars?.length) {
-            let useVars = `use (${args.useVars.join(", ")})`;
-            if (args.returnType) {
-                useVars += `: ${args.returnType}`;
-            }
-            declarationComponents.push(nameAndParameters, useVars);
-        }
-        else {
-            if (args.returnType) {
-                nameAndParameters += `: ${args.returnType}`;
-            }
-            declarationComponents.push(nameAndParameters);
-        }
-        declarationComponents.push("{");
-        this.append(declarationComponents.join(' '));
-        this.indent();
-        // We start a new scope here just in case this was called within an existing scope
-        // We pop the scope instead of closing it because we don't actually want to unset any variables that were created within the function
-        this.withScope(body, { actionDescription: args.scopeActionDescription ?? `closing the "${name || "anonymous"}" function`, usePopScopeInstead: true });
-        this.openPHP().outdent().append(name !== false && args.assignToName ? "};" : "}");
-        if (args.includeExistenceCheck) {
-            this.endIf();
-        }
-        return returningString ? name : this;
-    }
-    generateFunctionName(asVariable = false) {
-        let count = 0;
-        let name;
-        do {
-            name = `plaudit_webpack_extensions__generated_function__${count++}`;
-        } while (this.allocatedGeneratedFunctionNames.has(name));
-        this.allocatedGeneratedFunctionNames.add(name);
-        return asVariable ? new Var(name) : name;
-    }
-    closePHP() {
-        if (!this.printingInPHP) {
-            return this;
-        }
-        this.printingInPHP = false;
-        return this.append("?>");
-    }
-    openPHP() {
-        if (this.printingInPHP) {
-            return this;
-        }
-        this.printingInPHP = true;
-        return this.append("<?php");
-    }
-    namespace(namespace) {
-        this.fileNamespace = namespace;
-        return this;
-    }
-    use(...uses) {
-        for (const use of uses) {
-            if (!this.useList.find(u => u.toLowerCase() === use.toLowerCase())) {
-                this.useList.push(use);
-            }
-        }
-        return this;
-    }
-    require(filePath, args = {}) {
-        return this.requireOrInclude('require', filePath, args);
-    }
-    include(filePath, args = {}) {
-        return this.requireOrInclude('include', filePath, args);
-    }
-    requireOrInclude(type, filePath, args) {
-        const command = args.once ? `${type}_once` : type;
-        if (args.dirRelative && typeof filePath === 'string' && !filePath.startsWith("/")) {
-            filePath = "/" + filePath;
-        }
-        const path = args.dirRelative ? Op.concat(Constants.__DIR__, filePath) : Expr.convertJsonToPHP(filePath);
-        return this.appendExpr(`${command} ${path}`, args);
-    }
-    /**
-     * Starts a scope that, when paired with {@link #closeScope()}, allows for automating unset calls.
-     * All scopes started MUST be paired with either an {@link #closeScope()} or {@link #popScope()} call.
-     */
-    openScope() {
-        this.scopeStack.push([]);
-        this.myOpenedScopes++;
-        return this;
-    }
-    /**
-     * Pops the top scope from the stack AND unsets all variables that were assigned within it
-     */
-    closeScope() {
-        if (!this.myOpenedScopes) {
-            return this;
-        }
-        this.myOpenedScopes--;
-        const scope = this.scopeStack.pop();
-        if (!scope?.length) {
-            return this;
-        }
-        const uniquenessSet = new Set();
-        const uniqueScopeItems = scope.filter(si => !uniquenessSet.has(si) && uniquenessSet.add(si));
-        for (const scopeItem of uniqueScopeItems) {
-            this.allocatedGeneratedFunctionNames.delete(scopeItem);
-        }
-        // This is equivalent to calling this.call("unset", scope.map(v => new Var(v))), but creates fewer objects
-        return this.append(`unset(${uniqueScopeItems.map(usi => "$" + usi).join(", ")});`);
-    }
-    /**
-     * Pops the top scope from the stack WITHOUT calling unset for the variables that were assigned within it.
-     * This is used to allow function bodies to be safely created without disrupting their containing scope.
-     */
-    popScope() {
-        if (this.myOpenedScopes) {
-            this.scopeStack.pop();
-            this.myOpenedScopes--;
-        }
-        return this;
-    }
-    withScope(code, opts = {}) {
-        const expectedScopeCount = this.scopeStack.length;
-        this.openScope();
-        code(this);
-        if (opts.usePopScopeInstead) {
-            this.popScope();
-        }
-        else {
-            this.closeScope();
-        }
-        if (expectedScopeCount !== this.scopeStack.length) {
-            console.trace(`Encountered an unexpected number of scopes (saw: ${this.scopeStack.length}, expected: ${expectedScopeCount})`, `while ${opts.actionDescription ?? "ending an encapsulating scope"}.`);
-        }
-        return this;
-    }
-    toString(args = this.isSubwriter ? { includeOpenPHP: false, includeNamespaceAndUse: false } : {}) {
-        if (this.myOpenedScopes) {
-            console.trace("toString() was called on a PHPWriter that has a dangling scope");
-        }
-        const fileContents = [];
-        let canInline = true;
-        if (args.includeNamespaceAndUse !== false) {
-            if (this.fileNamespace) {
-                canInline = false;
-                fileContents.push(`namespace ${this.fileNamespace};`);
-            }
-            if (this.useList.length) {
-                canInline = false;
-                fileContents.push(...this.useList.map(use => `use ${use};`));
-            }
-        }
-        fileContents.push(...this.buffer);
-        if (args.includeOpenPHP === false) {
-            return fileContents.join("\n");
-        }
-        if (this.inlineFirstLine && canInline) {
-            return `<?php ${fileContents.join("\n")}`;
-        }
-        else if (fileContents.find(line => line.length > 0)) {
-            return "<?php\n" + fileContents.join("\n");
-        }
-        else {
-            return "<?php";
-        }
-    }
-    emitAsset(compilation, file, assetInfo) {
-        const contents = this.toString() + "\n";
-        compilation[file in compilation.assets ? 'updateAsset' : 'emitAsset'](file, new webpack_1.sources.RawSource(contents), { size: Buffer.byteLength(contents), ...assetInfo });
-    }
-}
-exports.PHPWriter = PHPWriter;