@php-wasm/fs-journal 0.5.1

package/index.js

@@ -0,0 +1,1359 @@
+var re = (r, e, t) => {
+  if (!e.has(r))
+    throw TypeError("Cannot " + t);
+};
+var a = (r, e, t) => (re(r, e, "read from private field"), t ? t.call(r) : e.get(r)), c = (r, e, t) => {
+  if (e.has(r))
+    throw TypeError("Cannot add the same private member more than once");
+  e instanceof WeakSet ? e.add(r) : e.set(r, t);
+}, d = (r, e, t, s) => (re(r, e, "write to private field"), s ? s.call(r, t) : e.set(r, t), t);
+var m = (r, e, t) => (re(r, e, "access private method"), t);
+const ie = Symbol("error"), ae = Symbol("message");
+class ne extends Event {
+  /**
+   * 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(e, t = {}) {
+    super(e), this[ie] = t.error === void 0 ? null : t.error, this[ae] = t.message === void 0 ? "" : t.message;
+  }
+  get error() {
+    return this[ie];
+  }
+  get message() {
+    return this[ae];
+  }
+}
+Object.defineProperty(ne.prototype, "error", { enumerable: !0 });
+Object.defineProperty(ne.prototype, "message", { enumerable: !0 });
+const Oe = typeof globalThis.ErrorEvent == "function" ? globalThis.ErrorEvent : ne;
+function $e(r) {
+  return r instanceof Error ? "exitCode" in r && (r == null ? void 0 : r.exitCode) === 0 || (r == null ? void 0 : r.name) === "ExitStatus" && "status" in r && r.status === 0 : !1;
+}
+class Ie extends EventTarget {
+  constructor() {
+    super(...arguments), this.listenersCount = 0;
+  }
+  addEventListener(e, t) {
+    ++this.listenersCount, super.addEventListener(e, t);
+  }
+  removeEventListener(e, t) {
+    --this.listenersCount, super.removeEventListener(e, t);
+  }
+  hasListeners() {
+    return this.listenersCount > 0;
+  }
+}
+function Ne(r) {
+  r.asm = {
+    ...r.asm
+  };
+  const e = new Ie();
+  for (const t in r.asm)
+    if (typeof r.asm[t] == "function") {
+      const s = r.asm[t];
+      r.asm[t] = function(...n) {
+        var o;
+        try {
+          return s(...n);
+        } catch (i) {
+          if (!(i instanceof Error))
+            throw i;
+          const h = Me(
+            i,
+            (o = r.lastAsyncifyStackSource) == null ? void 0 : o.stack
+          );
+          if (r.lastAsyncifyStackSource && (i.cause = r.lastAsyncifyStackSource), e.hasListeners()) {
+            e.dispatchEvent(
+              new Oe("error", {
+                error: i,
+                message: h
+              })
+            );
+            return;
+          }
+          throw $e(i) || De(h), i;
+        }
+      };
+    }
+  return e;
+}
+let se = [];
+function Le() {
+  return se;
+}
+function Me(r, e) {
+  if (r.message === "unreachable") {
+    let t = Ue;
+    e || (t += `
+
+This stack trace is lacking. For a better one initialize 
+the PHP runtime with { debug: true }, e.g. PHPNode.load('8.1', { debug: true }).
+
+`), se = je(
+      e || r.stack || ""
+    );
+    for (const s of se)
+      t += `    * ${s}
+`;
+    return t;
+  }
+  return r.message;
+}
+const Ue = `
+"unreachable" WASM instruction executed.
+
+The typical reason is a PHP function missing from the ASYNCIFY_ONLY
+list when building PHP.wasm.
+
+You will need to file a new issue in the WordPress Playground repository
+and paste this error message there:
+
+https://github.com/WordPress/wordpress-playground/issues/new
+
+If you're a core developer, the typical fix is to:
+
+* Isolate a minimal reproduction of the error
+* Add a reproduction of the error to php-asyncify.spec.ts in the WordPress Playground repository
+* Run 'npm run fix-asyncify'
+* Commit the changes, push to the repo, release updated NPM packages
+
+Below is a list of all the PHP functions found in the stack trace to
+help with the minimal reproduction. If they're all already listed in
+the Dockerfile, you'll need to trigger this error again with long stack
+traces enabled. In node.js, you can do it using the --stack-trace-limit=100
+CLI option: 
+
+`, le = "\x1B[41m", We = "\x1B[1m", ce = "\x1B[0m", he = "\x1B[K";
+let ue = !1;
+function De(r) {
+  if (!ue) {
+    ue = !0, console.log(`${le}
+${he}
+${We}  WASM ERROR${ce}${le}`);
+    for (const e of r.split(`
+`))
+      console.log(`${he}  ${e} `);
+    console.log(`${ce}`);
+  }
+}
+function je(r) {
+  try {
+    const e = r.split(`
+`).slice(1).map((t) => {
+      const s = t.trim().substring(3).split(" ");
+      return {
+        fn: s.length >= 2 ? s[0] : "<unknown>",
+        isWasm: t.includes("wasm://")
+      };
+    }).filter(
+      ({ fn: t, isWasm: s }) => s && !t.startsWith("dynCall_") && !t.startsWith("invoke_")
+    ).map(({ fn: t }) => t);
+    return Array.from(new Set(e));
+  } catch {
+    return [];
+  }
+}
+class A {
+  constructor(e, t, s, n = "", o = 0) {
+    this.httpStatusCode = e, this.headers = t, this.bytes = s, this.exitCode = o, this.errors = n;
+  }
+  static fromRawData(e) {
+    return new A(
+      e.httpStatusCode,
+      e.headers,
+      e.bytes,
+      e.errors,
+      e.exitCode
+    );
+  }
+  toRawData() {
+    return {
+      headers: this.headers,
+      bytes: this.bytes,
+      errors: this.errors,
+      exitCode: this.exitCode,
+      httpStatusCode: this.httpStatusCode
+    };
+  }
+  /**
+   * Response body as JSON.
+   */
+  get json() {
+    return JSON.parse(this.text);
+  }
+  /**
+   * Response body as text.
+   */
+  get text() {
+    return new TextDecoder().decode(this.bytes);
+  }
+}
+var k, H;
+class qe {
+  /**
+   * @param  server - The PHP server to browse.
+   * @param  config - The browser configuration.
+   */
+  constructor(e, t = {}) {
+    c(this, k, void 0);
+    c(this, H, void 0);
+    this.requestHandler = e, d(this, k, {}), d(this, H, {
+      handleRedirects: !1,
+      maxRedirects: 4,
+      ...t
+    });
+  }
+  /**
+   * Sends the request to the server.
+   *
+   * When cookies are present in the response, this method stores
+   * them and sends them with any subsequent requests.
+   *
+   * When a redirection is present in the response, this method
+   * follows it by discarding a response and sending a subsequent
+   * request.
+   *
+   * @param  request   - The request.
+   * @param  redirects - Internal. The number of redirects handled so far.
+   * @returns PHPRequestHandler response.
+   */
+  async request(e, t = 0) {
+    const s = await this.requestHandler.request({
+      ...e,
+      headers: {
+        ...e.headers,
+        cookie: this.serializeCookies()
+      }
+    });
+    if (s.headers["set-cookie"] && this.setCookies(s.headers["set-cookie"]), a(this, H).handleRedirects && s.headers.location && t < a(this, H).maxRedirects) {
+      const n = new URL(
+        s.headers.location[0],
+        this.requestHandler.absoluteUrl
+      );
+      return this.request(
+        {
+          url: n.toString(),
+          method: "GET",
+          headers: {}
+        },
+        t + 1
+      );
+    }
+    return s;
+  }
+  /** @inheritDoc */
+  pathToInternalUrl(e) {
+    return this.requestHandler.pathToInternalUrl(e);
+  }
+  /** @inheritDoc */
+  internalUrlToPath(e) {
+    return this.requestHandler.internalUrlToPath(e);
+  }
+  /** @inheritDoc */
+  get absoluteUrl() {
+    return this.requestHandler.absoluteUrl;
+  }
+  /** @inheritDoc */
+  get documentRoot() {
+    return this.requestHandler.documentRoot;
+  }
+  setCookies(e) {
+    for (const t of e)
+      try {
+        if (!t.includes("="))
+          continue;
+        const s = t.indexOf("="), n = t.substring(0, s), o = t.substring(s + 1).split(";")[0];
+        a(this, k)[n] = o;
+      } catch (s) {
+        console.error(s);
+      }
+  }
+  serializeCookies() {
+    const e = [];
+    for (const t in a(this, k))
+      e.push(`${t}=${a(this, k)[t]}`);
+    return e.join("; ");
+  }
+}
+k = new WeakMap(), H = new WeakMap();
+class oe {
+  constructor({ concurrency: e }) {
+    this._running = 0, this.concurrency = e, this.queue = [];
+  }
+  get running() {
+    return this._running;
+  }
+  async acquire() {
+    for (; ; )
+      if (this._running >= this.concurrency)
+        await new Promise((e) => this.queue.push(e));
+      else {
+        this._running++;
+        let e = !1;
+        return () => {
+          e || (e = !0, this._running--, this.queue.length > 0 && this.queue.shift()());
+        };
+      }
+  }
+  async run(e) {
+    const t = await this.acquire();
+    try {
+      return await e();
+    } finally {
+      t();
+    }
+  }
+}
+function W(...r) {
+  let e = r.join("/");
+  const t = e[0] === "/", s = e.substring(e.length - 1) === "/";
+  return e = me(e), !e && !t && (e = "."), e && s && (e += "/"), e;
+}
+function Be(r) {
+  if (r === "/")
+    return "/";
+  r = me(r);
+  const e = r.lastIndexOf("/");
+  return e === -1 ? r : r.substr(e + 1);
+}
+function me(r) {
+  const e = r[0] === "/";
+  return r = ze(
+    r.split("/").filter((t) => !!t),
+    !e
+  ).join("/"), (e ? "/" : "") + r.replace(/\/$/, "");
+}
+function ze(r, e) {
+  let t = 0;
+  for (let s = r.length - 1; s >= 0; s--) {
+    const n = r[s];
+    n === "." ? r.splice(s, 1) : n === ".." ? (r.splice(s, 1), t++) : t && (r.splice(s, 1), t--);
+  }
+  if (e)
+    for (; t; t--)
+      r.unshift("..");
+  return r;
+}
+const Ge = "http://example.com";
+function de(r) {
+  return r.toString().substring(r.origin.length);
+}
+function fe(r, e) {
+  return !e || !r.startsWith(e) ? r : r.substring(e.length);
+}
+function Je(r, e) {
+  return !e || r.startsWith(e) ? r : e + r;
+}
+var b, O, M, x, $, P, I, N, D, ye, j, ge, q, we;
+class Ye {
+  /**
+   * @param  php    - The PHP instance.
+   * @param  config - Request Handler configuration.
+   */
+  constructor(e, t = {}) {
+    /**
+     * Serves a static file from the PHP filesystem.
+     *
+     * @param  fsPath - Absolute path of the static file to serve.
+     * @returns The response.
+     */
+    c(this, D);
+    /**
+     * Runs the requested PHP file with all the request and $_SERVER
+     * superglobals populated.
+     *
+     * @param  request - The request.
+     * @returns The response.
+     */
+    c(this, j);
+    /**
+     * Resolve the requested path to the filesystem path of the requested PHP file.
+     *
+     * Fall back to index.php as if there was a url rewriting rule in place.
+     *
+     * @param  requestedPath - The requested pathname.
+     * @throws {Error} If the requested path doesn't exist.
+     * @returns The resolved filesystem path.
+     */
+    c(this, q);
+    c(this, b, void 0);
+    c(this, O, void 0);
+    c(this, M, void 0);
+    c(this, x, void 0);
+    c(this, $, void 0);
+    c(this, P, void 0);
+    c(this, I, void 0);
+    c(this, N, void 0);
+    d(this, N, new oe({ concurrency: 1 }));
+    const {
+      documentRoot: s = "/www/",
+      absoluteUrl: n = typeof location == "object" ? location == null ? void 0 : location.href : ""
+    } = t;
+    this.php = e, d(this, b, s);
+    const o = new URL(n);
+    d(this, M, o.hostname), d(this, x, o.port ? Number(o.port) : o.protocol === "https:" ? 443 : 80), d(this, O, (o.protocol || "").replace(":", ""));
+    const i = a(this, x) !== 443 && a(this, x) !== 80;
+    d(this, $, [
+      a(this, M),
+      i ? `:${a(this, x)}` : ""
+    ].join("")), d(this, P, o.pathname.replace(/\/+$/, "")), d(this, I, [
+      `${a(this, O)}://`,
+      a(this, $),
+      a(this, P)
+    ].join(""));
+  }
+  /** @inheritDoc */
+  pathToInternalUrl(e) {
+    return `${this.absoluteUrl}${e}`;
+  }
+  /** @inheritDoc */
+  internalUrlToPath(e) {
+    const t = new URL(e);
+    return t.pathname.startsWith(a(this, P)) && (t.pathname = t.pathname.slice(a(this, P).length)), de(t);
+  }
+  get isRequestRunning() {
+    return a(this, N).running > 0;
+  }
+  /** @inheritDoc */
+  get absoluteUrl() {
+    return a(this, I);
+  }
+  /** @inheritDoc */
+  get documentRoot() {
+    return a(this, b);
+  }
+  /** @inheritDoc */
+  async request(e) {
+    const t = e.url.startsWith("http://") || e.url.startsWith("https://"), s = new URL(
+      e.url,
+      t ? void 0 : Ge
+    ), n = fe(
+      s.pathname,
+      a(this, P)
+    ), o = `${a(this, b)}${n}`;
+    return Ze(o) ? await m(this, j, ge).call(this, e, s) : m(this, D, ye).call(this, o);
+  }
+}
+b = new WeakMap(), O = new WeakMap(), M = new WeakMap(), x = new WeakMap(), $ = new WeakMap(), P = new WeakMap(), I = new WeakMap(), N = new WeakMap(), D = new WeakSet(), ye = function(e) {
+  if (!this.php.fileExists(e))
+    return new A(
+      404,
+      // Let the service worker know that no static file was found
+      // and that it's okay to issue a real fetch() to the server.
+      {
+        "x-file-type": ["static"]
+      },
+      new TextEncoder().encode("404 File not found")
+    );
+  const t = this.php.readFileAsBuffer(e);
+  return new A(
+    200,
+    {
+      "content-length": [`${t.byteLength}`],
+      // @TODO: Infer the content-type from the arrayBuffer instead of the file path.
+      //        The code below won't return the correct mime-type if the extension
+      //        was tampered with.
+      "content-type": [Ke(e)],
+      "accept-ranges": ["bytes"],
+      "cache-control": ["public, max-age=0"]
+    },
+    t
+  );
+}, j = new WeakSet(), ge = async function(e, t) {
+  var n;
+  const s = await a(this, N).acquire();
+  try {
+    this.php.addServerGlobalEntry("DOCUMENT_ROOT", a(this, b)), this.php.addServerGlobalEntry(
+      "HTTPS",
+      a(this, I).startsWith("https://") ? "on" : ""
+    );
+    let o = "GET";
+    const i = {
+      host: a(this, $),
+      ...Ae(e.headers || {})
+    }, h = [];
+    if (e.files && Object.keys(e.files).length) {
+      o = "POST";
+      for (const p in e.files) {
+        const _ = e.files[p];
+        h.push({
+          key: p,
+          name: _.name,
+          type: _.type,
+          data: new Uint8Array(await _.arrayBuffer())
+        });
+      }
+      (n = i["content-type"]) != null && n.startsWith("multipart/form-data") && (e.formData = Ve(
+        e.body || ""
+      ), i["content-type"] = "application/x-www-form-urlencoded", delete e.body);
+    }
+    let u;
+    e.formData !== void 0 ? (o = "POST", i["content-type"] = i["content-type"] || "application/x-www-form-urlencoded", u = new URLSearchParams(
+      e.formData
+    ).toString()) : u = e.body;
+    let f;
+    try {
+      f = m(this, q, we).call(this, t.pathname);
+    } catch {
+      return new A(
+        404,
+        {},
+        new TextEncoder().encode("404 File not found")
+      );
+    }
+    return await this.php.run({
+      relativeUri: Je(
+        de(t),
+        a(this, P)
+      ),
+      protocol: a(this, O),
+      method: e.method || o,
+      body: u,
+      fileInfos: h,
+      scriptPath: f,
+      headers: i
+    });
+  } finally {
+    s();
+  }
+}, q = new WeakSet(), we = function(e) {
+  let t = fe(e, a(this, P));
+  t.includes(".php") ? t = t.split(".php")[0] + ".php" : (t.endsWith("/") || (t += "/"), t.endsWith("index.php") || (t += "index.php"));
+  const s = `${a(this, b)}${t}`;
+  if (this.php.fileExists(s))
+    return s;
+  if (!this.php.fileExists(`${a(this, b)}/index.php`))
+    throw new Error(`File not found: ${s}`);
+  return `${a(this, b)}/index.php`;
+};
+function Ve(r) {
+  const e = {}, t = r.match(/--(.*)\r\n/);
+  if (!t)
+    return e;
+  const s = t[1], n = r.split(`--${s}`);
+  return n.shift(), n.pop(), n.forEach((o) => {
+    const i = o.indexOf(`\r
+\r
+`), h = o.substring(0, i).trim(), u = o.substring(i + 4).trim(), f = h.match(/name="([^"]+)"/);
+    if (f) {
+      const p = f[1];
+      e[p] = u;
+    }
+  }), e;
+}
+function Ke(r) {
+  switch (r.split(".").pop()) {
+    case "css":
+      return "text/css";
+    case "js":
+      return "application/javascript";
+    case "png":
+      return "image/png";
+    case "jpg":
+    case "jpeg":
+      return "image/jpeg";
+    case "gif":
+      return "image/gif";
+    case "svg":
+      return "image/svg+xml";
+    case "woff":
+      return "font/woff";
+    case "woff2":
+      return "font/woff2";
+    case "ttf":
+      return "font/ttf";
+    case "otf":
+      return "font/otf";
+    case "eot":
+      return "font/eot";
+    case "ico":
+      return "image/x-icon";
+    case "html":
+      return "text/html";
+    case "json":
+      return "application/json";
+    case "xml":
+      return "application/xml";
+    case "txt":
+    case "md":
+      return "text/plain";
+    default:
+      return "application-octet-stream";
+  }
+}
+function Ze(r) {
+  return Qe(r) || Xe(r);
+}
+function Qe(r) {
+  return r.endsWith(".php") || r.includes(".php/");
+}
+function Xe(r) {
+  return !r.split("/").pop().includes(".");
+}
+const pe = {
+  0: "No error occurred. System call completed successfully.",
+  1: "Argument list too long.",
+  2: "Permission denied.",
+  3: "Address in use.",
+  4: "Address not available.",
+  5: "Address family not supported.",
+  6: "Resource unavailable, or operation would block.",
+  7: "Connection already in progress.",
+  8: "Bad file descriptor.",
+  9: "Bad message.",
+  10: "Device or resource busy.",
+  11: "Operation canceled.",
+  12: "No child processes.",
+  13: "Connection aborted.",
+  14: "Connection refused.",
+  15: "Connection reset.",
+  16: "Resource deadlock would occur.",
+  17: "Destination address required.",
+  18: "Mathematics argument out of domain of function.",
+  19: "Reserved.",
+  20: "File exists.",
+  21: "Bad address.",
+  22: "File too large.",
+  23: "Host is unreachable.",
+  24: "Identifier removed.",
+  25: "Illegal byte sequence.",
+  26: "Operation in progress.",
+  27: "Interrupted function.",
+  28: "Invalid argument.",
+  29: "I/O error.",
+  30: "Socket is connected.",
+  31: "There is a directory under that path.",
+  32: "Too many levels of symbolic links.",
+  33: "File descriptor value too large.",
+  34: "Too many links.",
+  35: "Message too large.",
+  36: "Reserved.",
+  37: "Filename too long.",
+  38: "Network is down.",
+  39: "Connection aborted by network.",
+  40: "Network unreachable.",
+  41: "Too many files open in system.",
+  42: "No buffer space available.",
+  43: "No such device.",
+  44: "There is no such file or directory OR the parent directory does not exist.",
+  45: "Executable file format error.",
+  46: "No locks available.",
+  47: "Reserved.",
+  48: "Not enough space.",
+  49: "No message of the desired type.",
+  50: "Protocol not available.",
+  51: "No space left on device.",
+  52: "Function not supported.",
+  53: "The socket is not connected.",
+  54: "Not a directory or a symbolic link to a directory.",
+  55: "Directory not empty.",
+  56: "State not recoverable.",
+  57: "Not a socket.",
+  58: "Not supported, or operation not supported on socket.",
+  59: "Inappropriate I/O control operation.",
+  60: "No such device or address.",
+  61: "Value too large to be stored in data type.",
+  62: "Previous owner died.",
+  63: "Operation not permitted.",
+  64: "Broken pipe.",
+  65: "Protocol error.",
+  66: "Protocol not supported.",
+  67: "Protocol wrong type for socket.",
+  68: "Result too large.",
+  69: "Read-only file system.",
+  70: "Invalid seek.",
+  71: "No such process.",
+  72: "Reserved.",
+  73: "Connection timed out.",
+  74: "Text file busy.",
+  75: "Cross-device link.",
+  76: "Extension: Capabilities insufficient."
+};
+function g(r = "") {
+  return function(t, s, n) {
+    const o = n.value;
+    n.value = function(...i) {
+      try {
+        return o.apply(this, i);
+      } catch (h) {
+        const u = typeof h == "object" ? h == null ? void 0 : h.errno : null;
+        if (u in pe) {
+          const f = pe[u], p = typeof i[0] == "string" ? i[0] : null, _ = p !== null ? r.replaceAll("{path}", p) : r;
+          throw new Error(`${_}: ${f}`, {
+            cause: h
+          });
+        }
+        throw h;
+      }
+    };
+  };
+}
+const et = /* @__PURE__ */ new Map();
+function tt(r) {
+  return et.get(r);
+}
+(function() {
+  var r;
+  return typeof process < "u" && ((r = process.release) == null ? void 0 : r.name) === "node" ? "NODE" : typeof window < "u" ? "WEB" : typeof WorkerGlobalScope < "u" && self instanceof WorkerGlobalScope ? "WORKER" : "NODE";
+})();
+var rt = Object.defineProperty, st = Object.getOwnPropertyDescriptor, w = (r, e, t, s) => {
+  for (var n = s > 1 ? void 0 : s ? st(e, t) : e, o = r.length - 1, i; o >= 0; o--)
+    (i = r[o]) && (n = (s ? i(e, t, n) : i(n)) || n);
+  return s && n && rt(e, t, n), n;
+};
+const y = "string", C = "number", l = Symbol("__private__dont__use");
+var S, v, F, R, T, L, U, B, Ee, z, be, G, Pe, J, _e, Y, Te, V, ve, K, Re, Z, ke, Q, xe, X, Se, ee, Fe, te, Ce;
+class E {
+  /**
+   * Initializes a PHP runtime.
+   *
+   * @internal
+   * @param  PHPRuntime - Optional. PHP Runtime ID as initialized by loadPHPRuntime.
+   * @param  serverOptions - Optional. Options for the PHPRequestHandler. If undefined, no request handler will be initialized.
+   */
+  constructor(e, t) {
+    c(this, B);
+    c(this, z);
+    c(this, G);
+    c(this, J);
+    c(this, Y);
+    c(this, V);
+    c(this, K);
+    c(this, Z);
+    c(this, Q);
+    /**
+     * Adds file information to $_FILES superglobal in PHP.
+     *
+     * In particular:
+     * * Creates the file data in the filesystem
+     * * Registers the file details in PHP
+     *
+     * @param  fileInfo - File details
+     */
+    c(this, X);
+    c(this, ee);
+    c(this, te);
+    c(this, S, void 0);
+    c(this, v, void 0);
+    c(this, F, void 0);
+    c(this, R, void 0);
+    c(this, T, void 0);
+    c(this, L, void 0);
+    c(this, U, void 0);
+    d(this, S, []), d(this, v, !1), d(this, F, null), d(this, R, {}), d(this, T, /* @__PURE__ */ new Map()), d(this, L, []), d(this, U, new oe({ concurrency: 1 })), e !== void 0 && this.initializeRuntime(e), t && (this.requestHandler = new qe(
+      new Ye(this, t)
+    ));
+  }
+  addEventListener(e, t) {
+    a(this, T).has(e) || a(this, T).set(e, /* @__PURE__ */ new Set()), a(this, T).get(e).add(t);
+  }
+  removeEventListener(e, t) {
+    var s;
+    (s = a(this, T).get(e)) == null || s.delete(t);
+  }
+  dispatchEvent(e) {
+    const t = a(this, T).get(e.type);
+    if (t)
+      for (const s of t)
+        s(e);
+  }
+  /** @inheritDoc */
+  async onMessage(e) {
+    a(this, L).push(e);
+  }
+  /** @inheritDoc */
+  async setSpawnHandler(e) {
+    this[l].spawnProcess = e;
+  }
+  /** @inheritDoc */
+  get absoluteUrl() {
+    return this.requestHandler.requestHandler.absoluteUrl;
+  }
+  /** @inheritDoc */
+  get documentRoot() {
+    return this.requestHandler.requestHandler.documentRoot;
+  }
+  /** @inheritDoc */
+  pathToInternalUrl(e) {
+    return this.requestHandler.requestHandler.pathToInternalUrl(e);
+  }
+  /** @inheritDoc */
+  internalUrlToPath(e) {
+    return this.requestHandler.requestHandler.internalUrlToPath(
+      e
+    );
+  }
+  initializeRuntime(e) {
+    if (this[l])
+      throw new Error("PHP runtime already initialized.");
+    const t = tt(e);
+    if (!t)
+      throw new Error("Invalid PHP runtime id.");
+    this[l] = t, t.onMessage = async (s) => {
+      for (const n of a(this, L)) {
+        const o = await n(s);
+        if (o)
+          return o;
+      }
+      return "";
+    }, d(this, F, Ne(t));
+  }
+  /** @inheritDoc */
+  setPhpIniPath(e) {
+    if (a(this, v))
+      throw new Error("Cannot set PHP ini path after calling run().");
+    this[l].ccall(
+      "wasm_set_phpini_path",
+      null,
+      ["string"],
+      [e]
+    );
+  }
+  /** @inheritDoc */
+  setPhpIniEntry(e, t) {
+    if (a(this, v))
+      throw new Error("Cannot set PHP ini entries after calling run().");
+    a(this, S).push([e, t]);
+  }
+  /** @inheritDoc */
+  chdir(e) {
+    this[l].FS.chdir(e);
+  }
+  /** @inheritDoc */
+  async request(e, t) {
+    if (!this.requestHandler)
+      throw new Error("No request handler available.");
+    return this.requestHandler.request(e, t);
+  }
+  /** @inheritDoc */
+  async run(e) {
+    const t = await a(this, U).acquire();
+    try {
+      a(this, v) || (m(this, B, Ee).call(this), d(this, v, !0)), m(this, Z, ke).call(this, e.scriptPath || ""), m(this, G, Pe).call(this, e.relativeUri || ""), m(this, Y, Te).call(this, e.method || "GET");
+      const s = Ae(e.headers || {}), n = s.host || "example.com:443";
+      if (m(this, J, _e).call(this, n, e.protocol || "http"), m(this, V, ve).call(this, s), e.body && m(this, K, Re).call(this, e.body), e.fileInfos)
+        for (const o of e.fileInfos)
+          m(this, X, Se).call(this, o);
+      return e.code && m(this, ee, Fe).call(this, " ?>" + e.code), m(this, Q, xe).call(this), await m(this, te, Ce).call(this);
+    } finally {
+      t(), this.dispatchEvent({
+        type: "request.end"
+      });
+    }
+  }
+  addServerGlobalEntry(e, t) {
+    a(this, R)[e] = t;
+  }
+  defineConstant(e, t) {
+    let s = {};
+    try {
+      s = JSON.parse(
+        this.fileExists("/tmp/consts.json") && this.readFileAsText("/tmp/consts.json") || "{}"
+      );
+    } catch {
+    }
+    this.writeFile(
+      "/tmp/consts.json",
+      JSON.stringify({
+        ...s,
+        [e]: t
+      })
+    );
+  }
+  mkdir(e) {
+    this[l].FS.mkdirTree(e);
+  }
+  mkdirTree(e) {
+    this.mkdir(e);
+  }
+  readFileAsText(e) {
+    return new TextDecoder().decode(this.readFileAsBuffer(e));
+  }
+  readFileAsBuffer(e) {
+    return this[l].FS.readFile(e);
+  }
+  writeFile(e, t) {
+    this[l].FS.writeFile(e, t);
+  }
+  unlink(e) {
+    this[l].FS.unlink(e);
+  }
+  mv(e, t) {
+    this[l].FS.rename(e, t);
+  }
+  rmdir(e, t = { recursive: !0 }) {
+    t != null && t.recursive && this.listFiles(e).forEach((s) => {
+      const n = `${e}/${s}`;
+      this.isDir(n) ? this.rmdir(n, t) : this.unlink(n);
+    }), this[l].FS.rmdir(e);
+  }
+  listFiles(e, t = { prependPath: !1 }) {
+    if (!this.fileExists(e))
+      return [];
+    try {
+      const s = this[l].FS.readdir(e).filter(
+        (n) => n !== "." && n !== ".."
+      );
+      if (t.prependPath) {
+        const n = e.replace(/\/$/, "");
+        return s.map((o) => `${n}/${o}`);
+      }
+      return s;
+    } catch (s) {
+      return console.error(s, { path: e }), [];
+    }
+  }
+  isDir(e) {
+    return this.fileExists(e) ? this[l].FS.isDir(
+      this[l].FS.lookupPath(e).node.mode
+    ) : !1;
+  }
+  fileExists(e) {
+    try {
+      return this[l].FS.lookupPath(e), !0;
+    } catch {
+      return !1;
+    }
+  }
+  exit(e = 0) {
+    return this[l]._exit(e);
+  }
+}
+S = new WeakMap(), v = new WeakMap(), F = new WeakMap(), R = new WeakMap(), T = new WeakMap(), L = new WeakMap(), U = new WeakMap(), B = new WeakSet(), Ee = function() {
+  if (this.setPhpIniEntry("auto_prepend_file", "/tmp/consts.php"), this.fileExists("/tmp/consts.php") || this.writeFile(
+    "/tmp/consts.php",
+    `<?php
+				if(file_exists('/tmp/consts.json')) {
+					$consts = json_decode(file_get_contents('/tmp/consts.json'), true);
+					foreach ($consts as $const => $value) {
+						if (!defined($const) && is_scalar($value)) {
+							define($const, $value);
+						}
+					}
+				}`
+  ), a(this, S).length > 0) {
+    const e = a(this, S).map(([t, s]) => `${t}=${s}`).join(`
+`) + `
+
+`;
+    this[l].ccall(
+      "wasm_set_phpini_entries",
+      null,
+      [y],
+      [e]
+    );
+  }
+  this[l].ccall("php_wasm_init", null, [], []);
+}, z = new WeakSet(), be = function() {
+  const e = "/tmp/headers.json";
+  if (!this.fileExists(e))
+    throw new Error(
+      "SAPI Error: Could not find response headers file."
+    );
+  const t = JSON.parse(this.readFileAsText(e)), s = {};
+  for (const n of t.headers) {
+    if (!n.includes(": "))
+      continue;
+    const o = n.indexOf(": "), i = n.substring(0, o).toLowerCase(), h = n.substring(o + 2);
+    i in s || (s[i] = []), s[i].push(h);
+  }
+  return {
+    headers: s,
+    httpStatusCode: t.status
+  };
+}, G = new WeakSet(), Pe = function(e) {
+  if (this[l].ccall(
+    "wasm_set_request_uri",
+    null,
+    [y],
+    [e]
+  ), e.includes("?")) {
+    const t = e.substring(e.indexOf("?") + 1);
+    this[l].ccall(
+      "wasm_set_query_string",
+      null,
+      [y],
+      [t]
+    );
+  }
+}, J = new WeakSet(), _e = function(e, t) {
+  this[l].ccall(
+    "wasm_set_request_host",
+    null,
+    [y],
+    [e]
+  );
+  let s;
+  try {
+    s = parseInt(new URL(e).port, 10);
+  } catch {
+  }
+  (!s || isNaN(s) || s === 80) && (s = t === "https" ? 443 : 80), this[l].ccall(
+    "wasm_set_request_port",
+    null,
+    [C],
+    [s]
+  ), (t === "https" || !t && s === 443) && this.addServerGlobalEntry("HTTPS", "on");
+}, Y = new WeakSet(), Te = function(e) {
+  this[l].ccall(
+    "wasm_set_request_method",
+    null,
+    [y],
+    [e]
+  );
+}, V = new WeakSet(), ve = function(e) {
+  e.cookie && this[l].ccall(
+    "wasm_set_cookies",
+    null,
+    [y],
+    [e.cookie]
+  ), e["content-type"] && this[l].ccall(
+    "wasm_set_content_type",
+    null,
+    [y],
+    [e["content-type"]]
+  ), e["content-length"] && this[l].ccall(
+    "wasm_set_content_length",
+    null,
+    [C],
+    [parseInt(e["content-length"], 10)]
+  );
+  for (const t in e) {
+    let s = "HTTP_";
+    ["content-type", "content-length"].includes(t.toLowerCase()) && (s = ""), this.addServerGlobalEntry(
+      `${s}${t.toUpperCase().replace(/-/g, "_")}`,
+      e[t]
+    );
+  }
+}, K = new WeakSet(), Re = function(e) {
+  this[l].ccall(
+    "wasm_set_request_body",
+    null,
+    [y],
+    [e]
+  ), this[l].ccall(
+    "wasm_set_content_length",
+    null,
+    [C],
+    [new TextEncoder().encode(e).length]
+  );
+}, Z = new WeakSet(), ke = function(e) {
+  this[l].ccall(
+    "wasm_set_path_translated",
+    null,
+    [y],
+    [e]
+  );
+}, Q = new WeakSet(), xe = function() {
+  for (const e in a(this, R))
+    this[l].ccall(
+      "wasm_add_SERVER_entry",
+      null,
+      [y, y],
+      [e, a(this, R)[e]]
+    );
+}, X = new WeakSet(), Se = function(e) {
+  const { key: t, name: s, type: n, data: o } = e, i = `/tmp/${Math.random().toFixed(20)}`;
+  this.writeFile(i, o);
+  const h = 0;
+  this[l].ccall(
+    "wasm_add_uploaded_file",
+    null,
+    [y, y, y, y, C, C],
+    [t, s, n, i, h, o.byteLength]
+  );
+}, ee = new WeakSet(), Fe = function(e) {
+  this[l].ccall(
+    "wasm_set_php_code",
+    null,
+    [y],
+    [e]
+  );
+}, te = new WeakSet(), Ce = async function() {
+  var o;
+  let e, t;
+  try {
+    e = await new Promise((i, h) => {
+      var f;
+      t = (p) => {
+        const _ = new Error("Rethrown");
+        _.cause = p.error, _.betterMessage = p.message, h(_);
+      }, (f = a(this, F)) == null || f.addEventListener(
+        "error",
+        t
+      );
+      const u = this[l].ccall(
+        "wasm_sapi_handle_request",
+        C,
+        [],
+        [],
+        { async: !0 }
+      );
+      return u instanceof Promise ? u.then(i, h) : i(u);
+    });
+  } catch (i) {
+    for (const p in this)
+      typeof this[p] == "function" && (this[p] = () => {
+        throw new Error(
+          "PHP runtime has crashed – see the earlier error for details."
+        );
+      });
+    this.functionsMaybeMissingFromAsyncify = Le();
+    const h = i, u = "betterMessage" in h ? h.betterMessage : h.message, f = new Error(u);
+    throw f.cause = h, f;
+  } finally {
+    (o = a(this, F)) == null || o.removeEventListener("error", t), d(this, R, {});
+  }
+  const { headers: s, httpStatusCode: n } = m(this, z, be).call(this);
+  return new A(
+    n,
+    s,
+    this.readFileAsBuffer("/tmp/stdout"),
+    this.readFileAsText("/tmp/stderr"),
+    e
+  );
+};
+w([
+  g('Could not create directory "{path}"')
+], E.prototype, "mkdir", 1);
+w([
+  g('Could not create directory "{path}"')
+], E.prototype, "mkdirTree", 1);
+w([
+  g('Could not read "{path}"')
+], E.prototype, "readFileAsText", 1);
+w([
+  g('Could not read "{path}"')
+], E.prototype, "readFileAsBuffer", 1);
+w([
+  g('Could not write to "{path}"')
+], E.prototype, "writeFile", 1);
+w([
+  g('Could not unlink "{path}"')
+], E.prototype, "unlink", 1);
+w([
+  g('Could not move "{path}"')
+], E.prototype, "mv", 1);
+w([
+  g('Could not remove directory "{path}"')
+], E.prototype, "rmdir", 1);
+w([
+  g('Could not list files in "{path}"')
+], E.prototype, "listFiles", 1);
+w([
+  g('Could not stat "{path}"')
+], E.prototype, "isDir", 1);
+w([
+  g('Could not stat "{path}"')
+], E.prototype, "fileExists", 1);
+function Ae(r) {
+  const e = {};
+  for (const t in r)
+    e[t.toLowerCase()] = r[t];
+  return e;
+}
+function ut(r, e, t = () => {
+}) {
+  e = ot(e);
+  const s = r[l].FS, n = nt(s, (u) => {
+    if (u.path.startsWith(e))
+      t(u);
+    else if (u.operation === "RENAME" && u.toPath.startsWith(e))
+      for (const f of He(
+        r,
+        u.path,
+        u.toPath
+      ))
+        t(f);
+  }), o = {};
+  for (const [u] of Object.entries(n))
+    o[u] = s[u];
+  function i() {
+    for (const [u, f] of Object.entries(n))
+      s[u] = function(...p) {
+        return f(...p), o[u].apply(this, p);
+      };
+  }
+  function h() {
+    for (const [u, f] of Object.entries(o))
+      r[l].FS[u] = f;
+  }
+  return r[l].journal = {
+    bind: i,
+    unbind: h
+  }, i(), h;
+}
+const nt = (r, e = () => {
+}) => ({
+  write(t) {
+    e({
+      operation: "WRITE",
+      path: t.path,
+      nodeType: "file"
+    });
+  },
+  truncate(t) {
+    let s;
+    typeof t == "string" ? s = r.lookupPath(t, {
+      follow: !0
+    }).node : s = t, e({
+      operation: "WRITE",
+      path: r.getPath(s),
+      nodeType: "file"
+    });
+  },
+  unlink(t) {
+    e({
+      operation: "DELETE",
+      path: t,
+      nodeType: "file"
+    });
+  },
+  mknod(t, s) {
+    r.isFile(s) && e({
+      operation: "CREATE",
+      path: t,
+      nodeType: "file"
+    });
+  },
+  mkdir(t) {
+    e({
+      operation: "CREATE",
+      path: t,
+      nodeType: "directory"
+    });
+  },
+  rmdir(t) {
+    e({
+      operation: "DELETE",
+      path: t,
+      nodeType: "directory"
+    });
+  },
+  rename(t, s) {
+    try {
+      const n = r.lookupPath(t, {
+        follow: !0
+      }), o = r.lookupPath(s, {
+        parent: !0
+      }).path;
+      e({
+        operation: "RENAME",
+        nodeType: r.isDir(n.node.mode) ? "directory" : "file",
+        path: n.path,
+        toPath: W(o, Be(s))
+      });
+    } catch {
+    }
+  }
+});
+function dt(r, e) {
+  r[l].journal.unbind();
+  try {
+    for (const t of e)
+      t.operation === "CREATE" ? t.nodeType === "file" ? r.writeFile(t.path, " ") : r.mkdir(t.path) : t.operation === "DELETE" ? t.nodeType === "file" ? r.unlink(t.path) : r.rmdir(t.path) : t.operation === "WRITE" ? r.writeFile(t.path, t.data) : t.operation === "RENAME" && r.mv(t.path, t.toPath);
+  } finally {
+    r[l].journal.bind();
+  }
+}
+function* He(r, e, t) {
+  if (r.isDir(e)) {
+    yield {
+      operation: "CREATE",
+      path: t,
+      nodeType: "directory"
+    };
+    for (const s of r.listFiles(e))
+      yield* He(
+        r,
+        W(e, s),
+        W(t, s)
+      );
+  } else
+    yield {
+      operation: "CREATE",
+      path: t,
+      nodeType: "file"
+    }, yield {
+      operation: "WRITE",
+      nodeType: "file",
+      path: t
+    };
+}
+function ot(r) {
+  return r.replace(/\/$/, "").replace(/\/\/+/g, "/");
+}
+function it(r) {
+  const e = {};
+  for (let t = r.length - 1; t >= 0; t--) {
+    for (let s = t - 1; s >= 0; s--) {
+      const n = at(r[t], r[s]);
+      if (n === "none")
+        continue;
+      const o = r[t], i = r[s];
+      if (o.operation === "RENAME" && i.operation === "RENAME") {
+        console.warn(
+          "[FS Journal] Normalizing a double rename is not yet supported:",
+          {
+            current: o,
+            last: i
+          }
+        );
+        continue;
+      }
+      (i.operation === "CREATE" || i.operation === "WRITE") && (o.operation === "RENAME" ? n === "same_node" ? (e[s] = [], e[t] = [
+        {
+          ...i,
+          path: o.toPath
+        },
+        ...e[t] || []
+      ]) : n === "descendant" && (e[s] = [], e[t] = [
+        {
+          ...i,
+          path: W(
+            o.toPath,
+            i.path.substring(o.path.length)
+          )
+        },
+        ...e[t] || []
+      ]) : o.operation === "WRITE" && n === "same_node" ? e[s] = [] : o.operation === "DELETE" && n === "same_node" && (e[s] = [], e[t] = []));
+    }
+    if (Object.entries(e).length > 0) {
+      const s = r.flatMap((n, o) => o in e ? e[o] : [n]);
+      return it(s);
+    }
+  }
+  return r;
+}
+function at(r, e) {
+  const t = r.path, s = r.operation !== "WRITE" && r.nodeType === "directory", n = e.operation !== "WRITE" && e.nodeType === "directory", o = e.operation === "RENAME" ? e.toPath : e.path;
+  return o === t ? "same_node" : n && t.startsWith(o + "/") ? "ancestor" : s && o.startsWith(t + "/") ? "descendant" : "none";
+}
+async function ft(r, e) {
+  const s = e.filter(
+    (n) => n.operation === "WRITE"
+  ).map((n) => ct(r, n));
+  return await Promise.all(s), e;
+}
+const lt = new oe({ concurrency: 15 });
+async function ct(r, e) {
+  const t = await lt.acquire();
+  try {
+    e.data = await r.readFileAsBuffer(e.path);
+  } catch (s) {
+    console.warn(
+      `Journal failed to hydrate a file on flush: the path ${e.path} no longer exists`
+    ), console.error(s);
+  }
+  t();
+}
+export {
+  ft as hydrateUpdateFileOps,
+  ut as journalFSEvents,
+  it as normalizeFilesystemOperations,
+  dt as replayFSJournal
+};