@php-wasm/universal 0.9.19 → 0.9.20

package/lib/emscripten-types.d.ts

@@ -0,0 +1,265 @@
+/** Other WebAssembly declarations, for compatibility with older versions of Typescript */
+export declare namespace Emscripten {
+    export interface RootFS extends Emscripten.FileSystemInstance {
+        filesystems: Record<string, Emscripten.FileSystemType>;
+    }
+    export interface FileSystemType {
+        mount(mount: FS.Mount): FS.FSNode;
+        syncfs(mount: FS.Mount, populate: () => unknown, done: (err?: number | null) => unknown): void;
+    }
+    export type EnvironmentType = 'WEB' | 'NODE' | 'SHELL' | 'WORKER';
+    export type JSType = 'number' | 'string' | 'array' | 'boolean';
+    export type TypeCompatibleWithC = number | string | any[] | boolean;
+    export type CIntType = 'i8' | 'i16' | 'i32' | 'i64';
+    export type CFloatType = 'float' | 'double';
+    export type CPointerType = 'i8*' | 'i16*' | 'i32*' | 'i64*' | 'float*' | 'double*' | '*';
+    export type CType = CIntType | CFloatType | CPointerType;
+    export interface CCallOpts {
+        async?: boolean | undefined;
+    }
+    type NamespaceToInstance<T> = {
+        [K in keyof T]: T[K] extends (...args: any[]) => any ? T[K] : never;
+    };
+    export type FileSystemInstance = NamespaceToInstance<typeof FS> & {
+        mkdirTree(path: string): void;
+        lookupPath(path: string, opts?: any): FS.Lookup;
+    };
+    export interface EmscriptenModule {
+        print(str: string): void;
+        printErr(str: string): void;
+        arguments: string[];
+        environment: Emscripten.EnvironmentType;
+        preInit: Array<{
+            (): void;
+        }>;
+        preRun: Array<{
+            (): void;
+        }>;
+        postRun: Array<{
+            (): void;
+        }>;
+        onAbort: {
+            (what: any): void;
+        };
+        onRuntimeInitialized: {
+            (): void;
+        };
+        preinitializedWebGLContext: WebGLRenderingContext;
+        noInitialRun: boolean;
+        noExitRuntime: boolean;
+        logReadFiles: boolean;
+        filePackagePrefixURL: string;
+        wasmBinary: ArrayBuffer;
+        destroy(object: object): void;
+        getPreloadedPackage(remotePackageName: string, remotePackageSize: number): ArrayBuffer;
+        instantiateWasm(imports: WebAssembly.Imports, successCallback: (module: WebAssembly.Instance) => void): WebAssembly.Exports | undefined;
+        locateFile(url: string, scriptDirectory: string): string;
+        onCustomMessage(event: MessageEvent): void;
+        HEAP: Int32Array;
+        IHEAP: Int32Array;
+        FHEAP: Float64Array;
+        HEAP8: Int8Array;
+        HEAP16: Int16Array;
+        HEAP32: Int32Array;
+        HEAPU8: Uint8Array;
+        HEAPU16: Uint16Array;
+        HEAPU32: Uint32Array;
+        HEAPF32: Float32Array;
+        HEAPF64: Float64Array;
+        HEAP64: BigInt64Array;
+        HEAPU64: BigUint64Array;
+        TOTAL_STACK: number;
+        TOTAL_MEMORY: number;
+        FAST_MEMORY: number;
+        addOnPreRun(cb: () => any): void;
+        addOnInit(cb: () => any): void;
+        addOnPreMain(cb: () => any): void;
+        addOnExit(cb: () => any): void;
+        addOnPostRun(cb: () => any): void;
+        preloadedImages: any;
+        preloadedAudios: any;
+        _malloc(size: number): number;
+        _free(ptr: number): void;
+    }
+    /**
+     * A factory function is generated when setting the `MODULARIZE` build option
+     * to `1` in your Emscripten build. It return a Promise that resolves to an
+     * initialized, ready-to-call `EmscriptenModule` instance.
+     *
+     * By default, the factory function will be named `Module`. It's recommended to
+     * use the `EXPORT_ES6` option, in which the factory function will be the
+     * default export. If used without `EXPORT_ES6`, the factory function will be a
+     * global variable. You can rename the variable using the `EXPORT_NAME` build
+     * option. It's left to you to export any global variables as needed in your
+     * application's types.
+     * @param moduleOverrides Default properties for the initialized module.
+     */
+    export type EmscriptenModuleFactory<T extends EmscriptenModule = EmscriptenModule> = (moduleOverrides?: Partial<T>) => Promise<T>;
+    export namespace FS {
+        interface Lookup {
+            path: string;
+            node: FSNode;
+        }
+        interface Analyze {
+            isRoot: boolean;
+            exists: boolean;
+            error: Error;
+            name: string;
+            path: Lookup['path'];
+            object: Lookup['node'];
+            parentExists: boolean;
+            parentPath: Lookup['path'];
+            parentObject: Lookup['node'];
+        }
+        interface Mount {
+            type: Emscripten.FileSystemType;
+            opts: object;
+            mountpoint: string;
+            mounts: Mount[];
+            root: FSNode;
+        }
+        class FSStream {
+            constructor();
+            object: FSNode;
+            readonly isRead: boolean;
+            readonly isWrite: boolean;
+            readonly isAppend: boolean;
+            flags: number;
+            position: number;
+        }
+        class FSNode {
+            parent: FSNode;
+            mount: Mount;
+            mounted?: Mount;
+            id: number;
+            name: string;
+            mode: number;
+            rdev: number;
+            readMode: number;
+            writeMode: number;
+            constructor(parent: FSNode, name: string, mode: number, rdev: number);
+            read: boolean;
+            write: boolean;
+            readonly isFolder: boolean;
+            readonly isDevice: boolean;
+        }
+        interface ErrnoError extends Error {
+            name: 'ErronoError';
+            errno: number;
+            code: string;
+        }
+        function lookupPath(path: string, opts: any): Lookup;
+        function getPath(node: FSNode): string;
+        function analyzePath(path: string, dontResolveLastLink?: boolean): Analyze;
+        function isFile(mode: number): boolean;
+        function isDir(mode: number): boolean;
+        function isLink(mode: number): boolean;
+        function isChrdev(mode: number): boolean;
+        function isBlkdev(mode: number): boolean;
+        function isFIFO(mode: number): boolean;
+        function isSocket(mode: number): boolean;
+        function major(dev: number): number;
+        function minor(dev: number): number;
+        function makedev(ma: number, mi: number): number;
+        function registerDevice(dev: number, ops: any): void;
+        function syncfs(populate: boolean, callback: (e: any) => any): void;
+        function syncfs(callback: (e: any) => any, populate?: boolean): void;
+        function mount(type: Emscripten.FileSystemType, opts: any, mountpoint: string): any;
+        function unmount(mountpoint: string): void;
+        function mkdir(path: string, mode?: number): any;
+        function mkdev(path: string, mode?: number, dev?: number): any;
+        function symlink(oldpath: string, newpath: string): any;
+        function rename(old_path: string, new_path: string): void;
+        function rmdir(path: string): void;
+        function readdir(path: string): any;
+        function unlink(path: string): void;
+        function readlink(path: string): string;
+        function stat(path: string, dontFollow?: boolean): any;
+        function lstat(path: string): any;
+        function chmod(path: string, mode: number, dontFollow?: boolean): void;
+        function lchmod(path: string, mode: number): void;
+        function fchmod(fd: number, mode: number): void;
+        function chown(path: string, uid: number, gid: number, dontFollow?: boolean): void;
+        function lchown(path: string, uid: number, gid: number): void;
+        function fchown(fd: number, uid: number, gid: number): void;
+        function truncate(path: string, len: number): void;
+        function ftruncate(fd: number, len: number): void;
+        function utime(path: string, atime: number, mtime: number): void;
+        function open(path: string, flags: string, mode?: number, fd_start?: number, fd_end?: number): FSStream;
+        function close(stream: FSStream): void;
+        function llseek(stream: FSStream, offset: number, whence: number): any;
+        function read(stream: FSStream, buffer: ArrayBufferView, offset: number, length: number, position?: number): number;
+        function write(stream: FSStream, buffer: ArrayBufferView, offset: number, length: number, position?: number, canOwn?: boolean): number;
+        function allocate(stream: FSStream, offset: number, length: number): void;
+        function mmap(stream: FSStream, buffer: ArrayBufferView, offset: number, length: number, position: number, prot: number, flags: number): any;
+        function ioctl(stream: FSStream, cmd: any, arg: any): any;
+        function readFile(path: string, opts: {
+            encoding: 'binary';
+            flags?: string | undefined;
+        }): Uint8Array;
+        function readFile(path: string, opts: {
+            encoding: 'utf8';
+            flags?: string | undefined;
+        }): string;
+        function readFile(path: string, opts?: {
+            flags?: string | undefined;
+        }): Uint8Array;
+        function writeFile(path: string, data: string | ArrayBufferView, opts?: {
+            flags?: string | undefined;
+        }): void;
+        function cwd(): string;
+        function chdir(path: string): void;
+        function init(input: null | (() => number | null), output: null | ((c: number) => any), error: null | ((c: number) => any)): void;
+        function createLazyFile(parent: string | FSNode, name: string, url: string, canRead: boolean, canWrite: boolean): FSNode;
+        function createPreloadedFile(parent: string | FSNode, name: string, url: string, canRead: boolean, canWrite: boolean, onload?: () => void, onerror?: () => void, dontCreateFile?: boolean, canOwn?: boolean): void;
+        function createDataFile(parent: string | FSNode, name: string, data: ArrayBufferView, canRead: boolean, canWrite: boolean, canOwn: boolean): FSNode;
+    }
+    export const MEMFS: Emscripten.FileSystemType;
+    export const NODEFS: Emscripten.FileSystemType;
+    export const IDBFS: Emscripten.FileSystemType;
+    type StringToType<R> = R extends Emscripten.JSType ? {
+        number: number;
+        string: string;
+        array: number[] | string[] | boolean[] | Uint8Array | Int8Array;
+        boolean: boolean;
+        null: null;
+    }[R] : never;
+    type ArgsToType<T extends Array<Emscripten.JSType | null>> = Extract<{
+        [P in keyof T]: StringToType<T[P]>;
+    }, any[]>;
+    type ReturnToType<R extends Emscripten.JSType | null> = R extends null ? null : StringToType<Exclude<R, null>>;
+    export function cwrap<I extends Array<Emscripten.JSType | null> | [], R extends Emscripten.JSType | null>(ident: string, returnType: R, argTypes: I, opts?: Emscripten.CCallOpts): (...arg: ArgsToType<I>) => ReturnToType<R>;
+    export function ccall<I extends Array<Emscripten.JSType | null> | [], R extends Emscripten.JSType | null>(ident: string, returnType: R, argTypes: I, args: ArgsToType<I>, opts?: Emscripten.CCallOpts): ReturnToType<R>;
+    export function setValue(ptr: number, value: any, type: Emscripten.CType, noSafe?: boolean): void;
+    export function getValue(ptr: number, type: Emscripten.CType, noSafe?: boolean): number;
+    export function allocate(slab: number[] | ArrayBufferView | number, types: Emscripten.CType | Emscripten.CType[], allocator: number, ptr?: number): number;
+    export function stackAlloc(size: number): number;
+    export function stackSave(): number;
+    export function stackRestore(ptr: number): void;
+    export function UTF8ToString(ptr: number, maxBytesToRead?: number): string;
+    export function stringToUTF8(str: string, outPtr: number, maxBytesToRead?: number): void;
+    export function lengthBytesUTF8(str: string): number;
+    export function allocateUTF8(str: string): number;
+    export function allocateUTF8OnStack(str: string): number;
+    export function UTF16ToString(ptr: number): string;
+    export function stringToUTF16(str: string, outPtr: number, maxBytesToRead?: number): void;
+    export function lengthBytesUTF16(str: string): number;
+    export function UTF32ToString(ptr: number): string;
+    export function stringToUTF32(str: string, outPtr: number, maxBytesToRead?: number): void;
+    export function lengthBytesUTF32(str: string): number;
+    export function intArrayFromString(stringy: string, dontAddNull?: boolean, length?: number): number[];
+    export function intArrayToString(array: number[]): string;
+    export function writeStringToMemory(str: string, buffer: number, dontAddNull: boolean): void;
+    export function writeArrayToMemory(array: number[], buffer: number): void;
+    export function writeAsciiToMemory(str: string, buffer: number, dontAddNull: boolean): void;
+    export function addRunDependency(id: any): void;
+    export function removeRunDependency(id: any): void;
+    export function addFunction(func: (...args: any[]) => any, signature?: string): number;
+    export function removeFunction(funcPtr: number): void;
+    export const ALLOC_NORMAL: number;
+    export const ALLOC_STACK: number;
+    export const ALLOC_STATIC: number;
+    export const ALLOC_DYNAMIC: number;
+    export const ALLOC_NONE: number;
+    export {};
+}

package/lib/encode-as-multipart.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Encodes a multipart/form-data request body.
+ *
+ * @param   data - The form data to encode.
+ * @returns The encoded body and a correctly formatted content type header.
+ */
+export declare function encodeAsMultipart(data: Record<string, string | Uint8Array | File>): Promise<{
+    bytes: Uint8Array;
+    contentType: string;
+}>;

package/lib/error-event-polyfill.d.ts

@@ -0,0 +1,30 @@
+declare const kError: unique symbol;
+declare const kMessage: unique symbol;
+interface ErrorEventOptions {
+    error?: Error;
+    message?: string;
+}
+/**
+ * Class representing an error event.
+ *
+ * @extends Event
+ */
+declare class ErrorEvent2 extends Event {
+    [kError]: any;
+    [kMessage]: any;
+    /**
+     * Create a new `ErrorEvent`.
+     *
+     * @param type The name of the event
+     * @param options A dictionary object that allows for setting
+     *                  attributes via object members of the same name.
+     */
+    constructor(type: 'error', options?: ErrorEventOptions);
+    get error(): any;
+    get message(): any;
+}
+export declare const ErrorEvent: typeof ErrorEvent2 | {
+    new (type: string, eventInitDict?: ErrorEventInit | undefined): ErrorEvent;
+    prototype: ErrorEvent;
+};
+export {};

package/lib/fs-helpers.d.ts

@@ -0,0 +1,94 @@
+import { Emscripten } from './emscripten-types';
+export interface RmDirOptions {
+    /**
+     * If true, recursively removes the directory and all its contents.
+     * Default: true.
+     */
+    recursive?: boolean;
+}
+export interface ListFilesOptions {
+    /**
+     * If true, prepend given folder path to all file names.
+     * Default: false.
+     */
+    prependPath: boolean;
+}
+export declare class FSHelpers {
+    /**
+     * Reads a file from the PHP filesystem and returns it as a string.
+     *
+     * @throws {@link @php-wasm/universal:ErrnoError} – If the file doesn't exist.
+     * @param  path - The file path to read.
+     * @returns The file contents.
+     */
+    static readFileAsText(FS: Emscripten.RootFS, path: string): string;
+    /**
+     * Reads a file from the PHP filesystem and returns it as an array buffer.
+     *
+     * @throws {@link @php-wasm/universal:ErrnoError} – If the file doesn't exist.
+     * @param  path - The file path to read.
+     * @returns The file contents.
+     */
+    static readFileAsBuffer(FS: Emscripten.RootFS, path: string): Uint8Array;
+    /**
+     * Overwrites data in a file in the PHP filesystem.
+     * Creates a new file if one doesn't exist yet.
+     *
+     * @param  path - The file path to write to.
+     * @param  data - The data to write to the file.
+     */
+    static writeFile(FS: Emscripten.RootFS, path: string, data: string | Uint8Array): void;
+    /**
+     * Removes a file from the PHP filesystem.
+     *
+     * @throws {@link @php-wasm/universal:ErrnoError} – If the file doesn't exist.
+     * @param  path - The file path to remove.
+     */
+    static unlink(FS: Emscripten.RootFS, path: string): void;
+    /**
+     * Moves a file or directory in the PHP filesystem to a
+     * new location.
+     *
+     * @param oldPath The path to rename.
+     * @param newPath The new path.
+     */
+    static mv(FS: Emscripten.RootFS, fromPath: string, toPath: string): void;
+    /**
+     * Removes a directory from the PHP filesystem.
+     *
+     * @param path The directory path to remove.
+     * @param options Options for the removal.
+     */
+    static rmdir(FS: Emscripten.RootFS, path: string, options?: RmDirOptions): void;
+    /**
+     * Lists the files and directories in the given directory.
+     *
+     * @param  path - The directory path to list.
+     * @param  options - Options for the listing.
+     * @returns The list of files and directories in the given directory.
+     */
+    static listFiles(FS: Emscripten.RootFS, path: string, options?: ListFilesOptions): string[];
+    /**
+     * Checks if a directory exists in the PHP filesystem.
+     *
+     * @param  path – The path to check.
+     * @returns True if the path is a directory, false otherwise.
+     */
+    static isDir(FS: Emscripten.RootFS, path: string): boolean;
+    /**
+     * Checks if a file (or a directory) exists in the PHP filesystem.
+     *
+     * @param  path - The file path to check.
+     * @returns True if the file exists, false otherwise.
+     */
+    static fileExists(FS: Emscripten.RootFS, path: string): boolean;
+    /**
+     * Recursively creates a directory with the given path in the PHP filesystem.
+     * For example, if the path is `/root/php/data`, and `/root` already exists,
+     * it will create the directories `/root/php` and `/root/php/data`.
+     *
+     * @param  path - The directory path to create.
+     */
+    static mkdir(FS: Emscripten.RootFS, path: string): void;
+    static copyRecursive(FS: Emscripten.FileSystemInstance, fromPath: string, toPath: string): void;
+}

package/lib/http-cookie-store.d.ts

@@ -0,0 +1,8 @@
+/**
+ * @public
+ */
+export declare class HttpCookieStore {
+    cookies: Record<string, string>;
+    rememberCookiesFromResponseHeaders(headers: Record<string, string[]>): void;
+    getCookieRequestHeader(): string;
+}

package/lib/index.d.ts

@@ -0,0 +1,32 @@
+export type { MessageListener, PHPOutput, PHPRunOptions, UniversalPHP, PHPEvent, PHPEventListener, HTTPMethod, PHPRequest, PHPRequestHeaders, SpawnHandler, } from './universal-php';
+export { FSHelpers } from './fs-helpers';
+export type { ListFilesOptions, RmDirOptions } from './fs-helpers';
+export { PHPWorker } from './php-worker';
+export { getPhpIniEntries, setPhpIniEntries, withPHPIniValues } from './ini';
+export { UnhandledRejectionsTarget } from './wasm-error-reporting';
+export { HttpCookieStore } from './http-cookie-store';
+export type { IteratePhpFilesOptions as IterateFilesOptions } from './iterate-files';
+export { iteratePhpFiles as iterateFiles } from './iterate-files';
+export { writeFilesStreamToPhp } from './write-files-stream-to-php';
+export { PHPProcessManager } from './php-process-manager';
+export type { MaxPhpInstancesError, PHPFactory, PHPFactoryOptions, ProcessManagerOptions, SpawnedPHP, } from './php-process-manager';
+export { PHPResponse } from './php-response';
+export type { PHPResponseData } from './php-response';
+export type { ErrnoError } from './rethrow-file-system-error';
+export { LatestSupportedPHPVersion, SupportedPHPVersions, SupportedPHPVersionsList, } from './supported-php-versions';
+export type { SupportedPHPVersion } from './supported-php-versions';
+export { SupportedPHPExtensionsList, SupportedPHPExtensionBundles, } from './supported-php-extensions';
+export type { SupportedPHPExtension, SupportedPHPExtensionBundle, } from './supported-php-extensions';
+export { PHP, __private__dont__use } from './php';
+export type { MountHandler, UnmountFunction } from './php';
+export { loadPHPRuntime } from './load-php-runtime';
+export type * from './emscripten-types';
+export type { DataModule, EmscriptenOptions, PHPLoaderModule, PHPRuntime, PHPRuntimeId, RuntimeType, } from './load-php-runtime';
+export type { PHPRequestHandlerConfiguration, RewriteRule, } from './php-request-handler';
+export { PHPRequestHandler, applyRewriteRules } from './php-request-handler';
+export { rotatePHPRuntime } from './rotate-php-runtime';
+export { writeFiles } from './write-files';
+export type { FileTree } from './write-files';
+export { DEFAULT_BASE_URL, ensurePathPrefix, removePathPrefix, toRelativeUrl, } from './urls';
+export { isExitCodeZero } from './is-exit-code-zero';
+export { proxyFileSystem } from './proxy-file-system';

package/lib/ini.d.ts

@@ -0,0 +1,45 @@
+import { UniversalPHP } from './universal-php';
+/**
+ * Reads the php.ini file and returns its entries.
+ *
+ * @param php The PHP instance.
+ * @param entries Optional. If provided, only the specified entries will be returned.
+ * @returns The php.ini entries.
+ */
+export declare function getPhpIniEntries(php: UniversalPHP, entries?: string[]): Promise<{
+    [key: string]: any;
+}>;
+/**
+ * Rewrites the php.ini file with the given entries.
+ *
+ * @param php The PHP instance.
+ * @param entries The entries to write to the php.ini file.
+ */
+export declare function setPhpIniEntries(php: UniversalPHP, entries: Record<string, unknown>): Promise<void>;
+/**
+ * Sets php.ini values to the given values, executes a callback,
+ * and restores the original php.ini values. This is useful for
+ * running code with temporary php.ini values, such as when
+ * disabling network-related PHP functions just to run WordPress
+ * installer.
+ *
+ * @example
+ * ```ts
+ *	await withPHPIniValues(
+ *		php,
+ *		{
+ *			disable_functions: 'fsockopen',
+ *			allow_url_fopen: '0',
+ *		},
+ *		async () => await runWpInstallationWizard(php, {
+ *			options: {},
+ *		})
+ *	);
+ *	```
+ *
+ * @param php The PHP instance.
+ * @param phpIniValues The php.ini values to set.
+ * @param callback The callback to execute.
+ * @returns The result of the callback.
+ */
+export declare function withPHPIniValues(php: UniversalPHP, phpIniValues: Record<string, string>, callback: () => Promise<any>): Promise<any>;

package/lib/is-exit-code-zero.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Check if the Emscripten-thrown error is an exit code 0 error.
+ *
+ * @param e The error to check
+ * @returns True if the error is an exit code 0 error
+ */
+export declare function isExitCodeZero(e: any): boolean;

package/lib/iterate-files.d.ts

@@ -0,0 +1,26 @@
+import { UniversalPHP } from './universal-php';
+export type IteratePhpFilesOptions = {
+    /**
+     * Should yield paths relative to the root directory?
+     * If false, all paths will be absolute.
+     */
+    relativePaths?: boolean;
+    /**
+     * A prefix to add to all paths.
+     * Only used if `relativePaths` is true.
+     */
+    pathPrefix?: string;
+    /**
+     * A list of paths to exclude from the results.
+     */
+    exceptPaths?: string[];
+};
+/**
+ * Iterates over all files in a php directory and its subdirectories.
+ *
+ * @param php - The PHP instance.
+ * @param root - The root directory to start iterating from.
+ * @param options - Optional configuration.
+ * @returns All files found in the tree.
+ */
+export declare function iteratePhpFiles(php: UniversalPHP, root: string, { relativePaths, pathPrefix, exceptPaths, }?: IteratePhpFilesOptions): AsyncGenerator<File>;

package/lib/load-php-runtime.d.ts

@@ -0,0 +1,150 @@
+/**
+ * Loads the PHP runtime with the given arguments and data dependencies.
+ *
+ * This function handles the entire PHP initialization pipeline. In particular, it:
+ *
+ * * Instantiates the Emscripten PHP module
+ * * Wires it together with the data dependencies and loads them
+ * * Ensures is all happens in a correct order
+ * * Waits until the entire loading sequence is finished
+ *
+ * Basic usage:
+ *
+ * ```js
+ *  const phpLoaderModule = await getPHPLoaderModule("7.4");
+ *  const php = await loadPHPRuntime( phpLoaderModule );
+ *  console.log(php.run(`<?php echo "Hello, world!"; `));
+ *  // { stdout: ArrayBuffer containing the string "Hello, world!", stderr: [''], exitCode: 0 }
+ * ```
+ *
+ * **The PHP loader module:**
+ *
+ * In the basic usage example, `phpLoaderModule` is **not** a vanilla Emscripten module. Instead,
+ * it's an ESM module that wraps the regular Emscripten output and adds some
+ * extra functionality. It's generated by the Dockerfile shipped with this repo.
+ * Here's the API it provides:
+ *
+ * ```js
+ * // php.wasm size in bytes:
+ * export const dependenciesTotalSize = 5644199;
+ *
+ * // php.wasm filename:
+ * export const dependencyFilename = 'php.wasm';
+ *
+ * // Run Emscripten's generated module:
+ * export default function(jsEnv, emscriptenModuleArgs) {}
+ * ```
+ *
+ * **PHP Filesystem:**
+ *
+ * Once initialized, the PHP has its own filesystem separate from the project
+ * files. It's provided by [Emscripten and uses its FS library](https://emscripten.org/docs/api_reference/Filesystem-API.html).
+ *
+ * The API exposed to you via the PHP class is succinct and abstracts
+ * certain unintuitive parts of low-level filesystem interactions.
+ *
+ * Here's how to use it:
+ *
+ * ```js
+ * // Recursively create a /var/www directory
+ * php.mkdirTree('/var/www');
+ *
+ * console.log(php.fileExists('/var/www/file.txt'));
+ * // false
+ *
+ * php.writeFile('/var/www/file.txt', 'Hello from the filesystem!');
+ *
+ * console.log(php.fileExists('/var/www/file.txt'));
+ * // true
+ *
+ * console.log(php.readFile('/var/www/file.txt'));
+ * // "Hello from the filesystem!
+ *
+ * // Delete the file:
+ * php.unlink('/var/www/file.txt');
+ * ```
+ *
+ * For more details consult the PHP class directly.
+ *
+ * **Data dependencies:**
+ *
+ * Using existing PHP packages by manually recreating them file-by-file would
+ * be quite inconvenient. Fortunately, Emscripten provides a "data dependencies"
+ * feature.
+ *
+ * Data dependencies consist of a `dependency.data` file and a `dependency.js` loader and
+ * can be packaged with the [file_packager.py tool]( https://emscripten.org/docs/porting/files/packaging_files.html#packaging-using-the-file-packager-tool).
+ * This project requires wrapping the Emscripten-generated `dependency.js` file in an ES
+ * module as follows:
+ *
+ * 1. Prepend `export default function(emscriptenPHPModule) {'; `
+ * 2. Prepend `export const dependencyFilename = '<DATA FILE NAME>'; `
+ * 3. Prepend `export const dependenciesTotalSize = <DATA FILE SIZE>;`
+ * 4. Append `}`
+ *
+ * Be sure to use the `--export-name="emscriptenPHPModule"` file_packager.py option.
+ *
+ * You want the final output to look as follows:
+ *
+ * ```js
+ * export const dependenciesTotalSize = 5644199;
+ * export const dependencyFilename = 'dependency.data';
+ * export default function(emscriptenPHPModule) {
+ *    // Emscripten-generated code:
+ *    var Module = typeof emscriptenPHPModule !== 'undefined' ? emscriptenPHPModule : {};
+ *    // ... the rest of it ...
+ * }
+ * ```
+ *
+ * Such a constructions enables loading the `dependency.js` as an ES Module using
+ * `import("/dependency.js")`.
+ *
+ * Once it's ready, you can load PHP and your data dependencies as follows:
+ *
+ * ```js
+ *  const [phpLoaderModule, wordPressLoaderModule] = await Promise.all([
+ *    getPHPLoaderModule("7.4"),
+ *    import("/wp.js")
+ *  ]);
+ *  const php = await loadPHPRuntime(phpLoaderModule, {}, [wordPressLoaderModule]);
+ * ```
+ *
+ * @public
+ * @param  phpLoaderModule         - The ESM-wrapped Emscripten module. Consult the Dockerfile for the build process.
+ * @param  phpModuleArgs           - The Emscripten module arguments, see https://emscripten.org/docs/api_reference/module.html#affecting-execution.
+ * @returns Loaded runtime id.
+ */
+export declare function loadPHPRuntime(phpLoaderModule: PHPLoaderModule, phpModuleArgs?: EmscriptenOptions): Promise<number>;
+export type RuntimeType = 'NODE' | 'WEB' | 'WORKER';
+export type PHPRuntimeId = number;
+export declare function getLoadedRuntime(id: PHPRuntimeId): PHPRuntime;
+export declare const currentJsRuntime: string;
+export type PHPRuntime = any;
+export type PHPLoaderModule = {
+    dependencyFilename: string;
+    dependenciesTotalSize: number;
+    init: (jsRuntime: string, options: EmscriptenOptions) => PHPRuntime;
+};
+export type DataModule = {
+    dependencyFilename: string;
+    dependenciesTotalSize: number;
+    default: (phpRuntime: PHPRuntime) => void;
+};
+export type EmscriptenOptions = {
+    onAbort?: (message: string) => void;
+    /**
+     * Set to true for debugging tricky WebAssembly errors.
+     */
+    debug?: boolean;
+    ENV?: Record<string, string>;
+    locateFile?: (path: string) => string;
+    noInitialRun?: boolean;
+    print?: (message: string) => void;
+    printErr?: (message: string) => void;
+    quit?: (status: number, toThrow: any) => void;
+    onRuntimeInitialized?: () => void;
+    monitorRunDependencies?: (left: number) => void;
+    onMessage?: (listener: EmscriptenMessageListener) => void;
+    instantiateWasm?: (info: WebAssembly.Imports, receiveInstance: (instance: WebAssembly.Instance, module: WebAssembly.Module) => void) => void;
+} & Record<string, any>;
+export type EmscriptenMessageListener = (type: string, data: string) => void;