@php-wasm/web 0.0.1

package/index-9258d089.js

@@ -0,0 +1,1054 @@
+const u = "string", m = "number", b = [];
+async function le(t, e = {}, n = []) {
+  let r, s;
+  const l = new Promise((o) => {
+    s = o;
+  }), i = new Promise((o) => {
+    r = o;
+  }), a = t.default(D, {
+    onAbort(o) {
+      console.error("WASM aborted: "), console.error(o);
+    },
+    ENV: {},
+    // Emscripten sometimes prepends a '/' to the path, which
+    // breaks vite dev mode. An identity `locateFile` function
+    // fixes it.
+    locateFile: (o) => o,
+    ...e,
+    noInitialRun: !0,
+    onRuntimeInitialized() {
+      e.onRuntimeInitialized && e.onRuntimeInitialized(), r();
+    },
+    monitorRunDependencies(o) {
+      o === 0 && (delete a.monitorRunDependencies, s());
+    }
+  });
+  for (const { default: o } of n)
+    o(a);
+  return n.length || s(), await l, await i, b.push(a), b.length - 1;
+}
+const D = function() {
+  return typeof window < "u" && !{}.TEST ? "WEB" : typeof WorkerGlobalScope < "u" && self instanceof WorkerGlobalScope ? "WORKER" : "NODE";
+}();
+class ce {
+  #e;
+  #t = [];
+  #n = !1;
+  /**
+   * Initializes a PHP runtime.
+   *
+   * @internal
+   * @param  PHPRuntime - Optional. PHP Runtime ID as initialized by loadPHPRuntime.
+   */
+  constructor(e) {
+    e !== void 0 && this.initializeRuntime(e);
+  }
+  initializeRuntime(e) {
+    if (this.#e)
+      throw new Error("PHP runtime already initialized.");
+    if (!b[e])
+      throw new Error("Invalid PHP runtime id.");
+    this.#e = b[e];
+  }
+  /** @inheritDoc */
+  setPhpIniPath(e) {
+    if (this.#n)
+      throw new Error("Cannot set PHP ini path after calling run().");
+    this.#e.ccall("wasm_set_phpini_path", null, ["string"], [e]);
+  }
+  /** @inheritDoc */
+  setPhpIniEntry(e, n) {
+    if (this.#n)
+      throw new Error("Cannot set PHP ini entries after calling run().");
+    this.#t.push([e, n]);
+  }
+  /** @inheritDoc */
+  run(e = {}) {
+    this.#n || (this.#s(), this.#n = !0), this.#u(e.scriptPath || ""), this.#r(e.relativeUri || ""), this.#o(e.method || "GET");
+    const { host: n, ...r } = {
+      host: "example.com:443",
+      ...j(e.headers || {})
+    };
+    if (this.#a(n, e.protocol || "http"), this.#l(r), e.body && this.#c(e.body), e.fileInfos)
+      for (const s of e.fileInfos)
+        this.#h(s);
+    return e.code && this.#f(" ?>" + e.code), this.#d();
+  }
+  #s() {
+    if (this.#t.length > 0) {
+      const e = this.#t.map(([n, r]) => `${n}=${r}`).join(`
+`);
+      this.#e.ccall(
+        "wasm_set_phpini_entries",
+        null,
+        [u],
+        [e]
+      );
+    }
+    this.#e.ccall("php_wasm_init", null, [], []);
+  }
+  cli(e) {
+    for (const n of e)
+      this.#e.ccall("wasm_add_cli_arg", null, [u], [n]);
+    return this.#e.ccall("run_cli", null, [], [], { async: !0 });
+  }
+  #i() {
+    const e = "/tmp/headers.json";
+    if (!this.fileExists(e))
+      throw new Error(
+        "SAPI Error: Could not find response headers file."
+      );
+    const n = JSON.parse(this.readFileAsText(e)), r = {};
+    for (const s of n.headers) {
+      if (!s.includes(": "))
+        continue;
+      const l = s.indexOf(": "), i = s.substring(0, l).toLowerCase(), a = s.substring(l + 2);
+      i in r || (r[i] = []), r[i].push(a);
+    }
+    return {
+      headers: r,
+      httpStatusCode: n.status
+    };
+  }
+  #r(e) {
+    if (this.#e.ccall("wasm_set_request_uri", null, [u], [e]), e.includes("?")) {
+      const n = e.substring(e.indexOf("?") + 1);
+      this.#e.ccall(
+        "wasm_set_query_string",
+        null,
+        [u],
+        [n]
+      );
+    }
+  }
+  #a(e, n) {
+    this.#e.ccall("wasm_set_request_host", null, [u], [e]);
+    let r;
+    try {
+      r = parseInt(new URL(e).port, 10);
+    } catch {
+    }
+    (!r || isNaN(r) || r === 80) && (r = n === "https" ? 443 : 80), this.#e.ccall("wasm_set_request_port", null, [m], [r]), (n === "https" || !n && r === 443) && this.addServerGlobalEntry("HTTPS", "on");
+  }
+  #o(e) {
+    this.#e.ccall("wasm_set_request_method", null, [u], [e]);
+  }
+  setSkipShebang(e) {
+    this.#e.ccall(
+      "wasm_set_skip_shebang",
+      null,
+      [m],
+      [e ? 1 : 0]
+    );
+  }
+  #l(e) {
+    e.cookie && this.#e.ccall(
+      "wasm_set_cookies",
+      null,
+      [u],
+      [e.cookie]
+    ), e["content-type"] && this.#e.ccall(
+      "wasm_set_content_type",
+      null,
+      [u],
+      [e["content-type"]]
+    ), e["content-length"] && this.#e.ccall(
+      "wasm_set_content_length",
+      null,
+      [m],
+      [parseInt(e["content-length"], 10)]
+    );
+    for (const n in e)
+      this.addServerGlobalEntry(
+        `HTTP_${n.toUpperCase().replace(/-/g, "_")}`,
+        e[n]
+      );
+  }
+  #c(e) {
+    this.#e.ccall("wasm_set_request_body", null, [u], [e]), this.#e.ccall(
+      "wasm_set_content_length",
+      null,
+      [m],
+      [e.length]
+    );
+  }
+  #u(e) {
+    this.#e.ccall("wasm_set_path_translated", null, [u], [e]);
+  }
+  addServerGlobalEntry(e, n) {
+    this.#e.ccall(
+      "wasm_add_SERVER_entry",
+      null,
+      [u, u],
+      [e, n]
+    );
+  }
+  /**
+   * 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
+   */
+  #h(e) {
+    const { key: n, name: r, type: s, data: l } = e, i = `/tmp/${Math.random().toFixed(20)}`;
+    this.writeFile(i, l);
+    const a = 0;
+    this.#e.ccall(
+      "wasm_add_uploaded_file",
+      null,
+      [u, u, u, u, m, m],
+      [n, r, s, i, a, l.byteLength]
+    );
+  }
+  #f(e) {
+    this.#e.ccall("wasm_set_php_code", null, [u], [e]);
+  }
+  #d() {
+    return {
+      exitCode: this.#e.ccall(
+        "wasm_sapi_handle_request",
+        m,
+        [],
+        []
+      ),
+      body: this.readFileAsBuffer("/tmp/stdout"),
+      errors: this.readFileAsText("/tmp/stderr"),
+      ...this.#i()
+    };
+  }
+  mkdirTree(e) {
+    this.#e.FS.mkdirTree(e);
+  }
+  readFileAsText(e) {
+    return new TextDecoder().decode(this.readFileAsBuffer(e));
+  }
+  /** @inheritDoc */
+  readFileAsBuffer(e) {
+    return this.#e.FS.readFile(e);
+  }
+  /** @inheritDoc */
+  writeFile(e, n) {
+    this.#e.FS.writeFile(e, n);
+  }
+  /** @inheritDoc */
+  unlink(e) {
+    this.#e.FS.unlink(e);
+  }
+  /** @inheritDoc */
+  listFiles(e) {
+    if (!this.fileExists(e))
+      return [];
+    try {
+      return this.#e.FS.readdir(e).filter(
+        (n) => n !== "." && n !== ".."
+      );
+    } catch (n) {
+      return console.error(n, { path: e }), [];
+    }
+  }
+  isDir(e) {
+    return this.fileExists(e) ? this.#e.FS.isDir(
+      this.#e.FS.lookupPath(e).node.mode
+    ) : !1;
+  }
+  fileExists(e) {
+    try {
+      return this.#e.FS.lookupPath(e), !0;
+    } catch {
+      return !1;
+    }
+  }
+  mount(e, n) {
+    this.#e.FS.mount(
+      this.#e.FS.filesystems.NODEFS,
+      e,
+      n
+    );
+  }
+}
+function j(t) {
+  const e = {};
+  for (const n in t)
+    e[n.toLowerCase()] = t[n];
+  return e;
+}
+const B = "http://example.com";
+function U(t) {
+  return t.toString().substring(t.origin.length);
+}
+function O(t, e) {
+  return !e || !t.startsWith(e) ? t : t.substring(e.length);
+}
+function G(t, e) {
+  return !e || t.startsWith(e) ? t : e + t;
+}
+class ue {
+  #e;
+  #t;
+  #n;
+  #s;
+  #i;
+  #r;
+  #a;
+  #o;
+  /**
+   * @param  php    - The PHP instance.
+   * @param  config - Server configuration.
+   */
+  constructor(e, n = {}) {
+    const {
+      documentRoot: r = "/www/",
+      absoluteUrl: s = location.origin,
+      isStaticFilePath: l = () => !1
+    } = n;
+    this.php = e, this.#e = r, this.#o = l;
+    const i = new URL(s);
+    this.#n = i.hostname, this.#s = i.port ? Number(i.port) : i.protocol === "https:" ? 443 : 80, this.#t = (i.protocol || "").replace(":", "");
+    const a = this.#s !== 443 && this.#s !== 80;
+    this.#i = [
+      this.#n,
+      a ? `:${this.#s}` : ""
+    ].join(""), this.#r = i.pathname.replace(/\/+$/, ""), this.#a = [
+      `${this.#t}://`,
+      this.#i,
+      this.#r
+    ].join("");
+  }
+  /**
+   * Converts a path to an absolute URL based at the PHPServer
+   * root.
+   *
+   * @param  path The server path to convert to an absolute URL.
+   * @returns The absolute URL.
+   */
+  pathToInternalUrl(e) {
+    return `${this.absoluteUrl}${e}`;
+  }
+  /**
+   * Converts an absolute URL based at the PHPServer to a relative path
+   * without the server pathname and scope.
+   *
+   * @param  internalUrl An absolute URL based at the PHPServer root.
+   * @returns The relative path.
+   */
+  internalUrlToPath(e) {
+    const n = new URL(e);
+    return n.pathname.startsWith(this.#r) && (n.pathname = n.pathname.slice(this.#r.length)), U(n);
+  }
+  /**
+   * The absolute URL of this PHPServer instance.
+   */
+  get absoluteUrl() {
+    return this.#a;
+  }
+  /**
+   * The absolute URL of this PHPServer instance.
+   */
+  get documentRoot() {
+    return this.#e;
+  }
+  /**
+   * Serves the request – either by serving a static file, or by
+   * dispatching it to the PHP runtime.
+   *
+   * @param  request - The request.
+   * @returns The response.
+   */
+  async request(e) {
+    let n;
+    e.relativeUrl !== void 0 ? n = new URL(e.relativeUrl, B) : n = new URL(e.absoluteUrl);
+    const r = O(
+      n.pathname,
+      this.#r
+    );
+    return this.#o(r) ? this.#l(r) : await this.#c(e, n);
+  }
+  /**
+   * Serves a static file from the PHP filesystem.
+   *
+   * @param  path - The requested static file path.
+   * @returns The response.
+   */
+  #l(e) {
+    const n = `${this.#e}${e}`;
+    if (!this.php.fileExists(n))
+      return {
+        body: new TextEncoder().encode("404 File not found"),
+        headers: {},
+        httpStatusCode: 404,
+        exitCode: 0,
+        errors: ""
+      };
+    const r = this.php.readFileAsBuffer(n);
+    return {
+      body: r,
+      headers: {
+        "content-length": [`${r.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": [V(n)],
+        "accept-ranges": ["bytes"],
+        "cache-control": ["public, max-age=0"]
+      },
+      httpStatusCode: 200,
+      exitCode: 0,
+      errors: ""
+    };
+  }
+  /**
+   * Runs the requested PHP file with all the request and $_SERVER
+   * superglobals populated.
+   *
+   * @param  request - The request.
+   * @returns The response.
+   */
+  async #c(e, n) {
+    this.php.addServerGlobalEntry("DOCUMENT_ROOT", this.#e), this.php.addServerGlobalEntry(
+      "HTTPS",
+      this.#a.startsWith("https://") ? "on" : ""
+    );
+    let r = "GET";
+    const s = [];
+    if (e.files) {
+      r = "POST";
+      for (const a in e.files) {
+        const o = e.files[a];
+        s.push({
+          key: a,
+          name: o.name,
+          type: o.type,
+          data: new Uint8Array(await o.arrayBuffer())
+        });
+      }
+    }
+    const l = {
+      host: this.#i
+    };
+    let i;
+    return e.formData !== void 0 ? (r = "POST", l["content-type"] = "application/x-www-form-urlencoded", i = new URLSearchParams(
+      e.formData
+    ).toString()) : i = e.body, this.php.run({
+      relativeUri: G(
+        U(n),
+        this.#r
+      ),
+      protocol: this.#t,
+      method: e.method || r,
+      body: i,
+      fileInfos: s,
+      scriptPath: this.#u(n.pathname),
+      headers: {
+        ...l,
+        ...e.headers || {}
+      }
+    });
+  }
+  /**
+   * 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.
+   * @returns The resolved filesystem path.
+   */
+  #u(e) {
+    let n = O(e, this.#r);
+    n.includes(".php") ? n = n.split(".php")[0] + ".php" : (n.endsWith("/") || (n += "/"), n.endsWith("index.php") || (n += "index.php"));
+    const r = `${this.#e}${n}`;
+    return this.php.fileExists(r) ? r : `${this.#e}/index.php`;
+  }
+}
+function V(t) {
+  switch (t.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";
+  }
+}
+class he {
+  #e;
+  #t;
+  /**
+   * @param  server - The PHP server to browse.
+   * @param  config - The browser configuration.
+   */
+  constructor(e, n = {}) {
+    this.server = e, this.#e = {}, this.#t = {
+      handleRedirects: !1,
+      maxRedirects: 4,
+      ...n
+    };
+  }
+  async request(e, n = 0) {
+    const r = await this.server.request({
+      ...e,
+      headers: {
+        ...e.headers,
+        cookie: this.#s()
+      }
+    });
+    if (r.headers["set-cookie"] && this.#n(r.headers["set-cookie"]), this.#t.handleRedirects && r.headers.location && n < this.#t.maxRedirects) {
+      const s = new URL(
+        r.headers.location[0],
+        this.server.absoluteUrl
+      );
+      return this.request(
+        {
+          absoluteUrl: s.toString(),
+          method: "GET",
+          headers: {}
+        },
+        n + 1
+      );
+    }
+    return r;
+  }
+  #n(e) {
+    for (const n of e)
+      try {
+        if (!n.includes("="))
+          continue;
+        const r = n.indexOf("="), s = n.substring(0, r), l = n.substring(r + 1).split(";")[0];
+        this.#e[s] = l;
+      } catch (r) {
+        console.error(r);
+      }
+  }
+  #s() {
+    const e = [];
+    for (const n in this.#e)
+      e.push(`${n}=${this.#e[n]}`);
+    return e.join("; ");
+  }
+}
+/**
+ * @license
+ * Copyright 2019 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+const A = Symbol("Comlink.proxy"), q = Symbol("Comlink.endpoint"), J = Symbol("Comlink.releaseProxy"), k = Symbol("Comlink.finalizer"), E = Symbol("Comlink.thrown"), L = (t) => typeof t == "object" && t !== null || typeof t == "function", Y = {
+  canHandle: (t) => L(t) && t[A],
+  serialize(t) {
+    const { port1: e, port2: n } = new MessageChannel();
+    return T(t, e), [n, [n]];
+  },
+  deserialize(t) {
+    return t.start(), F(t);
+  }
+}, K = {
+  canHandle: (t) => L(t) && E in t,
+  serialize({ value: t }) {
+    let e;
+    return t instanceof Error ? e = {
+      isError: !0,
+      value: {
+        message: t.message,
+        name: t.name,
+        stack: t.stack
+      }
+    } : e = { isError: !1, value: t }, [e, []];
+  },
+  deserialize(t) {
+    throw t.isError ? Object.assign(new Error(t.value.message), t.value) : t.value;
+  }
+}, S = /* @__PURE__ */ new Map([
+  ["proxy", Y],
+  ["throw", K]
+]);
+function Q(t, e) {
+  for (const n of t)
+    if (e === n || n === "*" || n instanceof RegExp && n.test(e))
+      return !0;
+  return !1;
+}
+function T(t, e = globalThis, n = ["*"]) {
+  e.addEventListener("message", function r(s) {
+    if (!s || !s.data)
+      return;
+    if (!Q(n, s.origin)) {
+      console.warn(`Invalid origin '${s.origin}' for comlink proxy`);
+      return;
+    }
+    const { id: l, type: i, path: a } = Object.assign({ path: [] }, s.data), o = (s.data.argumentList || []).map(g);
+    let c;
+    try {
+      const h = a.slice(0, -1).reduce((d, y) => d[y], t), p = a.reduce((d, y) => d[y], t);
+      switch (i) {
+        case "GET":
+          c = p;
+          break;
+        case "SET":
+          h[a.slice(-1)[0]] = g(s.data.value), c = !0;
+          break;
+        case "APPLY":
+          c = p.apply(h, o);
+          break;
+        case "CONSTRUCT":
+          {
+            const d = new p(...o);
+            c = M(d);
+          }
+          break;
+        case "ENDPOINT":
+          {
+            const { port1: d, port2: y } = new MessageChannel();
+            T(t, y), c = ne(d, [d]);
+          }
+          break;
+        case "RELEASE":
+          c = void 0;
+          break;
+        default:
+          return;
+      }
+    } catch (h) {
+      c = { value: h, [E]: 0 };
+    }
+    Promise.resolve(c).catch((h) => ({ value: h, [E]: 0 })).then((h) => {
+      const [p, d] = x(h);
+      e.postMessage(Object.assign(Object.assign({}, p), { id: l }), d), i === "RELEASE" && (e.removeEventListener("message", r), H(e), k in t && typeof t[k] == "function" && t[k]());
+    }).catch((h) => {
+      const [p, d] = x({
+        value: new TypeError("Unserializable return value"),
+        [E]: 0
+      });
+      e.postMessage(Object.assign(Object.assign({}, p), { id: l }), d);
+    });
+  }), e.start && e.start();
+}
+function X(t) {
+  return t.constructor.name === "MessagePort";
+}
+function H(t) {
+  X(t) && t.close();
+}
+function F(t, e) {
+  return v(t, [], e);
+}
+function P(t) {
+  if (t)
+    throw new Error("Proxy has been released and is not useable");
+}
+function I(t) {
+  return w(t, {
+    type: "RELEASE"
+  }).then(() => {
+    H(t);
+  });
+}
+const R = /* @__PURE__ */ new WeakMap(), _ = "FinalizationRegistry" in globalThis && new FinalizationRegistry((t) => {
+  const e = (R.get(t) || 0) - 1;
+  R.set(t, e), e === 0 && I(t);
+});
+function Z(t, e) {
+  const n = (R.get(e) || 0) + 1;
+  R.set(e, n), _ && _.register(t, e, t);
+}
+function ee(t) {
+  _ && _.unregister(t);
+}
+function v(t, e = [], n = function() {
+}) {
+  let r = !1;
+  const s = new Proxy(n, {
+    get(l, i) {
+      if (P(r), i === J)
+        return () => {
+          ee(s), I(t), r = !0;
+        };
+      if (i === "then") {
+        if (e.length === 0)
+          return { then: () => s };
+        const a = w(t, {
+          type: "GET",
+          path: e.map((o) => o.toString())
+        }).then(g);
+        return a.then.bind(a);
+      }
+      return v(t, [...e, i]);
+    },
+    set(l, i, a) {
+      P(r);
+      const [o, c] = x(a);
+      return w(t, {
+        type: "SET",
+        path: [...e, i].map((h) => h.toString()),
+        value: o
+      }, c).then(g);
+    },
+    apply(l, i, a) {
+      P(r);
+      const o = e[e.length - 1];
+      if (o === q)
+        return w(t, {
+          type: "ENDPOINT"
+        }).then(g);
+      if (o === "bind")
+        return v(t, e.slice(0, -1));
+      const [c, h] = C(a);
+      return w(t, {
+        type: "APPLY",
+        path: e.map((p) => p.toString()),
+        argumentList: c
+      }, h).then(g);
+    },
+    construct(l, i) {
+      P(r);
+      const [a, o] = C(i);
+      return w(t, {
+        type: "CONSTRUCT",
+        path: e.map((c) => c.toString()),
+        argumentList: a
+      }, o).then(g);
+    }
+  });
+  return Z(s, t), s;
+}
+function te(t) {
+  return Array.prototype.concat.apply([], t);
+}
+function C(t) {
+  const e = t.map(x);
+  return [e.map((n) => n[0]), te(e.map((n) => n[1]))];
+}
+const W = /* @__PURE__ */ new WeakMap();
+function ne(t, e) {
+  return W.set(t, e), t;
+}
+function M(t) {
+  return Object.assign(t, { [A]: !0 });
+}
+function N(t, e = globalThis, n = "*") {
+  return {
+    postMessage: (r, s) => t.postMessage(r, n, s),
+    addEventListener: e.addEventListener.bind(e),
+    removeEventListener: e.removeEventListener.bind(e)
+  };
+}
+function x(t) {
+  for (const [e, n] of S)
+    if (n.canHandle(t)) {
+      const [r, s] = n.serialize(t);
+      return [
+        {
+          type: "HANDLER",
+          name: e,
+          value: r
+        },
+        s
+      ];
+    }
+  return [
+    {
+      type: "RAW",
+      value: t
+    },
+    W.get(t) || []
+  ];
+}
+function g(t) {
+  switch (t.type) {
+    case "HANDLER":
+      return S.get(t.name).deserialize(t.value);
+    case "RAW":
+      return t.value;
+  }
+}
+function w(t, e, n) {
+  return new Promise((r) => {
+    const s = re();
+    t.addEventListener("message", function l(i) {
+      !i.data || !i.data.id || i.data.id !== s || (t.removeEventListener("message", l), r(i.data));
+    }), t.start && t.start(), t.postMessage(Object.assign({ id: s }, e), n);
+  });
+}
+function re() {
+  return new Array(4).fill(0).map(() => Math.floor(Math.random() * Number.MAX_SAFE_INTEGER).toString(16)).join("-");
+}
+function fe(t) {
+  z();
+  const e = t instanceof Worker ? t : N(t);
+  return F(e);
+}
+function de(t, e) {
+  z();
+  let n;
+  const r = new Promise((i) => {
+    n = i;
+  }), s = $(t), l = new Proxy(s, {
+    get: (i, a) => a === "isReady" ? () => r : a in i ? i[a] : e?.[a]
+  });
+  return T(
+    l,
+    typeof window < "u" ? N(self.parent) : void 0
+  ), [n, l];
+}
+function z() {
+  S.set("EVENT", {
+    canHandle: (t) => t instanceof CustomEvent,
+    serialize: (t) => [
+      {
+        detail: t.detail
+      },
+      []
+    ],
+    deserialize: (t) => t
+  }), S.set("FUNCTION", {
+    canHandle: (t) => typeof t == "function",
+    serialize(t) {
+      console.debug("[Comlink][Performance] Proxying a function");
+      const { port1: e, port2: n } = new MessageChannel();
+      return T(t, e), [n, [n]];
+    },
+    deserialize(t) {
+      return t.start(), F(t);
+    }
+  });
+}
+function $(t) {
+  return new Proxy(t, {
+    get(e, n) {
+      switch (typeof e[n]) {
+        case "function":
+          return (...r) => e[n](...r);
+        case "object":
+          return e[n] === null ? e[n] : $(e[n]);
+        case "undefined":
+        case "number":
+        case "string":
+          return e[n];
+        default:
+          return M(e[n]);
+      }
+    }
+  });
+}
+const f = /* @__PURE__ */ new WeakMap();
+class pe {
+  /** @inheritDoc */
+  constructor(e, n) {
+    f.set(this, {
+      php: e.server.php,
+      phpServer: e.server,
+      phpBrowser: e,
+      monitor: n
+    }), this.absoluteUrl = Promise.resolve(e.server.absoluteUrl), this.documentRoot = Promise.resolve(e.server.documentRoot);
+  }
+  /** @inheritDoc @php-wasm/web!PHPServer.pathToInternalUrl */
+  async pathToInternalUrl(e) {
+    return f.get(this).phpServer.pathToInternalUrl(e);
+  }
+  /** @inheritDoc @php-wasm/web!PHPServer.internalUrlToPath */
+  async internalUrlToPath(e) {
+    return f.get(this).phpServer.internalUrlToPath(e);
+  }
+  async onDownloadProgress(e) {
+    f.get(this).monitor?.addEventListener("progress", e);
+  }
+  /** @inheritDoc @php-wasm/web!PHPServer.request */
+  request(e, n) {
+    return f.get(this).phpBrowser.request(e, n);
+  }
+  /** @inheritDoc @php-wasm/web!PHP.run */
+  async run(e) {
+    return f.get(this).php.run(e);
+  }
+  /** @inheritDoc @php-wasm/web!PHP.setPhpIniPath */
+  setPhpIniPath(e) {
+    return f.get(this).php.setPhpIniPath(e);
+  }
+  /** @inheritDoc @php-wasm/web!PHP.setPhpIniEntry */
+  setPhpIniEntry(e, n) {
+    f.get(this).php.setPhpIniEntry(e, n);
+  }
+  /** @inheritDoc @php-wasm/web!PHP.mkdirTree */
+  mkdirTree(e) {
+    f.get(this).php.mkdirTree(e);
+  }
+  /** @inheritDoc @php-wasm/web!PHP.readFileAsText */
+  async readFileAsText(e) {
+    return f.get(this).php.readFileAsText(e);
+  }
+  /** @inheritDoc @php-wasm/web!PHP.readFileAsBuffer */
+  async readFileAsBuffer(e) {
+    return f.get(this).php.readFileAsBuffer(e);
+  }
+  /** @inheritDoc @php-wasm/web!PHP.writeFile */
+  writeFile(e, n) {
+    f.get(this).php.writeFile(e, n);
+  }
+  /** @inheritDoc @php-wasm/web!PHP.unlink */
+  unlink(e) {
+    f.get(this).php.unlink(e);
+  }
+  /** @inheritDoc @php-wasm/web!PHP.listFiles */
+  async listFiles(e) {
+    return f.get(this).php.listFiles(e);
+  }
+  /** @inheritDoc @php-wasm/web!PHP.isDir */
+  async isDir(e) {
+    return f.get(this).php.isDir(e);
+  }
+  /** @inheritDoc @php-wasm/web!PHP.fileExists */
+  async fileExists(e) {
+    return f.get(this).php.fileExists(e);
+  }
+}
+const me = {};
+async function ge(t = "8.2") {
+  switch (t) {
+    case "8.2":
+      return await import("php_8_2.js");
+    case "8.1":
+      return await import("php_8_1.js");
+    case "8.0":
+      return await import("php_8_0.js");
+    case "7.4":
+      return await import("php_7_4.js");
+    case "7.3":
+      return await import("php_7_3.js");
+    case "7.2":
+      return await import("php_7_2.js");
+    case "7.1":
+      return await import("php_7_1.js");
+    case "7.0":
+      return await import("php_7_0.js");
+    case "5.6":
+      return await import("php_5_6.js");
+  }
+  throw new Error(`Unsupported PHP version ${t}`);
+}
+function we() {
+  const t = {};
+  return typeof self?.location?.href < "u" && new URL(self.location.href).searchParams.forEach((n, r) => {
+    t[r] = n;
+  }), t;
+}
+const ye = function() {
+  return navigator.userAgent.toLowerCase().indexOf("firefox") > -1 ? "iframe" : "webworker";
+}();
+async function Pe(t, e = "webworker", n = {}) {
+  if (t = se(t, n), e === "webworker")
+    return new Worker(t, { type: "module" });
+  if (e === "iframe")
+    return (await ie(t)).contentWindow;
+  throw new Error(`Unknown backendName: ${e}`);
+}
+function se(t, e) {
+  if (!Object.entries(e).length)
+    return t + "";
+  const n = new URL(t);
+  for (const [r, s] of Object.entries(e))
+    n.searchParams.set(r, s);
+  return n.toString();
+}
+async function ie(t) {
+  const e = document.createElement("iframe"), n = "/" + t.split("/").slice(-1)[0];
+  return e.src = n, e.style.display = "none", document.body.appendChild(e), await new Promise((r) => {
+    e.addEventListener("load", r);
+  }), e;
+}
+function ae(t, e) {
+  return {
+    type: "response",
+    requestId: t,
+    response: e
+  };
+}
+async function Ee(t, e, n, r) {
+  const s = navigator.serviceWorker;
+  if (!s)
+    throw new Error("Service workers are not supported in this browser.");
+  const l = await s.getRegistrations();
+  if (l.length > 0) {
+    const i = await oe();
+    if (r !== i) {
+      console.debug(
+        `[window] Reloading the currently registered Service Worker (expected version: ${r}, registered version: ${i})`
+      );
+      for (const a of l) {
+        let o = !1;
+        try {
+          await a.update();
+        } catch {
+          o = !0;
+        }
+        const c = a.waiting || a.installing;
+        c && !o && (i !== null ? c.postMessage("skip-waiting") : o = !0), o && (await a.unregister(), window.location.reload());
+      }
+    }
+  } else
+    console.debug(
+      `[window] Creating a Service Worker registration (version: ${r})`
+    ), await s.register(n, {
+      type: "module"
+    });
+  navigator.serviceWorker.addEventListener(
+    "message",
+    async function(a) {
+      if (console.debug("Message from ServiceWorker", a), e && a.data.scope !== e)
+        return;
+      const o = a.data.args || [], c = a.data.method, h = await t[c](...o);
+      a.source.postMessage(ae(a.data.requestId, h));
+    }
+  ), s.startMessages();
+}
+async function oe() {
+  try {
+    return (await (await fetch("/version")).json()).version;
+  } catch {
+    return null;
+  }
+}
+export {
+  ce as PHP,
+  he as PHPBrowser,
+  pe as PHPClient,
+  ue as PHPServer,
+  fe as consumeAPI,
+  de as exposeAPI,
+  ge as getPHPLoaderModule,
+  me as isAssignableToRemoteClient,
+  le as loadPHPRuntime,
+  we as parseWorkerStartupOptions,
+  ye as recommendedWorkerBackend,
+  Ee as registerServiceWorker,
+  Pe as spawnPHPWorkerThread
+};