@php-wasm/web 0.1.10 → 0.1.19

package/index-e5292333.js

@@ -0,0 +1,1342 @@
+const W = [
+  "8.2",
+  "8.1",
+  "8.0",
+  "7.4",
+  "7.3",
+  "7.2",
+  "7.1",
+  "7.0",
+  "5.6"
+], Y = W[0], Se = W;
+class K {
+  #e;
+  #t;
+  /**
+   * @param  server - The PHP server to browse.
+   * @param  config - The browser configuration.
+   */
+  constructor(e, r = {}) {
+    this.server = e, this.#e = {}, this.#t = {
+      handleRedirects: !1,
+      maxRedirects: 4,
+      ...r
+    };
+  }
+  /**
+   * 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, r = 0) {
+    const n = await this.server.request({
+      ...e,
+      headers: {
+        ...e.headers,
+        cookie: this.#s()
+      }
+    });
+    if (n.headers["set-cookie"] && this.#r(n.headers["set-cookie"]), this.#t.handleRedirects && n.headers.location && r < this.#t.maxRedirects) {
+      const s = new URL(
+        n.headers.location[0],
+        this.server.absoluteUrl
+      );
+      return this.request(
+        {
+          url: s.toString(),
+          method: "GET",
+          headers: {}
+        },
+        r + 1
+      );
+    }
+    return n;
+  }
+  #r(e) {
+    for (const r of e)
+      try {
+        if (!r.includes("="))
+          continue;
+        const n = r.indexOf("="), s = r.substring(0, n), a = r.substring(n + 1).split(";")[0];
+        this.#e[s] = a;
+      } catch (n) {
+        console.error(n);
+      }
+  }
+  #s() {
+    const e = [];
+    for (const r in this.#e)
+      e.push(`${r}=${this.#e[r]}`);
+    return e.join("; ");
+  }
+}
+const Q = "http://example.com";
+function N(t) {
+  return t.toString().substring(t.origin.length);
+}
+function M(t, e) {
+  return !e || !t.startsWith(e) ? t : t.substring(e.length);
+}
+function X(t, e) {
+  return !e || t.startsWith(e) ? t : e + t;
+}
+class Z {
+  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
+        return this._running++, () => {
+          this._running--, this.queue.length > 0 && this.queue.shift()();
+        };
+  }
+}
+class E {
+  constructor(e, r, n, s = "", a = 0) {
+    this.httpStatusCode = e, this.headers = r, this.bytes = n, this.exitCode = a, this.errors = s;
+  }
+  static fromRawData(e) {
+    return new E(
+      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);
+  }
+}
+class ee {
+  #e;
+  #t;
+  #r;
+  #s;
+  #i;
+  #n;
+  #o;
+  #a;
+  #l;
+  /**
+   * @param  php    - The PHP instance.
+   * @param  config - Request Handler configuration.
+   */
+  constructor(e, r = {}) {
+    this.#a = new Z({ concurrency: 1 });
+    const {
+      documentRoot: n = "/www/",
+      absoluteUrl: s = location.origin,
+      isStaticFilePath: a = () => !1
+    } = r;
+    this.php = e, this.#e = n, this.#l = a;
+    const i = new URL(s);
+    this.#r = i.hostname, this.#s = i.port ? Number(i.port) : i.protocol === "https:" ? 443 : 80, this.#t = (i.protocol || "").replace(":", "");
+    const o = this.#s !== 443 && this.#s !== 80;
+    this.#i = [
+      this.#r,
+      o ? `:${this.#s}` : ""
+    ].join(""), this.#n = i.pathname.replace(/\/+$/, ""), this.#o = [
+      `${this.#t}://`,
+      this.#i,
+      this.#n
+    ].join("");
+  }
+  /**
+   * Converts a path to an absolute URL based at the PHPRequestHandler
+   * 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 PHPRequestHandler to a relative path
+   * without the server pathname and scope.
+   *
+   * @param  internalUrl An absolute URL based at the PHPRequestHandler root.
+   * @returns The relative path.
+   */
+  internalUrlToPath(e) {
+    const r = new URL(e);
+    return r.pathname.startsWith(this.#n) && (r.pathname = r.pathname.slice(this.#n.length)), N(r);
+  }
+  get isRequestRunning() {
+    return this.#a.running > 0;
+  }
+  /**
+   * The absolute URL of this PHPRequestHandler instance.
+   */
+  get absoluteUrl() {
+    return this.#o;
+  }
+  /**
+   * The absolute URL of this PHPRequestHandler 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) {
+    const r = e.url.startsWith("http://") || e.url.startsWith("https://"), n = new URL(
+      e.url,
+      r ? void 0 : Q
+    ), s = M(
+      n.pathname,
+      this.#n
+    );
+    return this.#l(s) ? this.#c(s) : await this.#u(e, n);
+  }
+  /**
+   * Serves a static file from the PHP filesystem.
+   *
+   * @param  path - The requested static file path.
+   * @returns The response.
+   */
+  #c(e) {
+    const r = `${this.#e}${e}`;
+    if (!this.php.fileExists(r))
+      return new E(
+        404,
+        {},
+        new TextEncoder().encode("404 File not found")
+      );
+    const n = this.php.readFileAsBuffer(r);
+    return new E(
+      200,
+      {
+        "content-length": [`${n.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": [te(r)],
+        "accept-ranges": ["bytes"],
+        "cache-control": ["public, max-age=0"]
+      },
+      n
+    );
+  }
+  /**
+   * Runs the requested PHP file with all the request and $_SERVER
+   * superglobals populated.
+   *
+   * @param  request - The request.
+   * @returns The response.
+   */
+  async #u(e, r) {
+    const n = await this.#a.acquire();
+    try {
+      this.php.addServerGlobalEntry("DOCUMENT_ROOT", this.#e), this.php.addServerGlobalEntry(
+        "HTTPS",
+        this.#o.startsWith("https://") ? "on" : ""
+      );
+      let s = "GET";
+      const a = [];
+      if (e.files) {
+        s = "POST";
+        for (const l in e.files) {
+          const c = e.files[l];
+          a.push({
+            key: l,
+            name: c.name,
+            type: c.type,
+            data: new Uint8Array(await c.arrayBuffer())
+          });
+        }
+      }
+      const i = {
+        host: this.#i
+      };
+      let o;
+      return e.formData !== void 0 ? (s = "POST", i["content-type"] = "application/x-www-form-urlencoded", o = new URLSearchParams(
+        e.formData
+      ).toString()) : o = e.body, await this.php.run({
+        relativeUri: X(
+          N(r),
+          this.#n
+        ),
+        protocol: this.#t,
+        method: e.method || s,
+        body: o,
+        fileInfos: a,
+        scriptPath: this.#h(r.pathname),
+        headers: {
+          ...i,
+          ...e.headers || {}
+        }
+      });
+    } finally {
+      n();
+    }
+  }
+  /**
+   * 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.
+   */
+  #h(e) {
+    let r = M(e, this.#n);
+    r.includes(".php") ? r = r.split(".php")[0] + ".php" : (r.endsWith("/") || (r += "/"), r.endsWith("index.php") || (r += "index.php"));
+    const n = `${this.#e}${r}`;
+    return this.php.fileExists(n) ? n : `${this.#e}/index.php`;
+  }
+}
+function te(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";
+  }
+}
+const I = {
+  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(t = "") {
+  return function(r, n, s) {
+    const a = s.value;
+    s.value = function(...i) {
+      try {
+        return a.apply(this, i);
+      } catch (o) {
+        const l = typeof o == "object" ? o?.errno : null;
+        if (l in I) {
+          const c = I[l], u = typeof i[0] == "string" ? i[0] : null, p = u !== null ? t.replaceAll("{path}", u) : t;
+          throw new Error(`${p}: ${c}`, {
+            cause: o
+          });
+        }
+        throw o;
+      }
+    };
+  };
+}
+var re = Object.defineProperty, ne = Object.getOwnPropertyDescriptor, w = (t, e, r, n) => {
+  for (var s = n > 1 ? void 0 : n ? ne(e, r) : e, a = t.length - 1, i; a >= 0; a--)
+    (i = t[a]) && (s = (n ? i(e, r, s) : i(s)) || s);
+  return n && s && re(e, r, s), s;
+};
+const h = "string", y = "number", _ = [], se = function() {
+  return typeof window < "u" && !{}.TEST ? "WEB" : typeof WorkerGlobalScope < "u" && self instanceof WorkerGlobalScope ? "WORKER" : "NODE";
+}();
+class m {
+  /**
+   * 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, r) {
+    this.#t = [], this.#r = !1, e !== void 0 && this.initializeRuntime(e), r && (this.requestHandler = new K(
+      new ee(this, r)
+    ));
+  }
+  #e;
+  #t;
+  #r;
+  initializeRuntime(e) {
+    if (this.#e)
+      throw new Error("PHP runtime already initialized.");
+    if (!_[e])
+      throw new Error("Invalid PHP runtime id.");
+    this.#e = _[e];
+  }
+  /** @inheritDoc */
+  setPhpIniPath(e) {
+    if (this.#r)
+      throw new Error("Cannot set PHP ini path after calling run().");
+    this.#e.ccall("wasm_set_phpini_path", null, ["string"], [e]);
+  }
+  /** @inheritDoc */
+  setPhpIniEntry(e, r) {
+    if (this.#r)
+      throw new Error("Cannot set PHP ini entries after calling run().");
+    this.#t.push([e, r]);
+  }
+  /** @inheritDoc */
+  chdir(e) {
+    this.#e.FS.chdir(e);
+  }
+  /** @inheritDoc */
+  async request(e, r) {
+    if (!this.requestHandler)
+      throw new Error("No request handler available.");
+    return this.requestHandler.request(e, r);
+  }
+  /** @inheritDoc */
+  async run(e = {}) {
+    this.#r || (this.#s(), this.#r = !0), this.#u(e.scriptPath || ""), this.#n(e.relativeUri || ""), this.#a(e.method || "GET");
+    const { host: r, ...n } = {
+      host: "example.com:443",
+      ...ie(e.headers || {})
+    };
+    if (this.#o(r, e.protocol || "http"), this.#l(n), e.body && this.#c(e.body), e.fileInfos)
+      for (const s of e.fileInfos)
+        this.#h(s);
+    return e.code && this.#d(" ?>" + e.code), await this.#f();
+  }
+  #s() {
+    if (this.#t.length > 0) {
+      const e = this.#t.map(([r, n]) => `${r}=${n}`).join(`
+`) + `
+
+`;
+      this.#e.ccall(
+        "wasm_set_phpini_entries",
+        null,
+        [h],
+        [e]
+      );
+    }
+    this.#e.ccall("php_wasm_init", null, [], []);
+  }
+  cli(e) {
+    for (const r of e)
+      this.#e.ccall("wasm_add_cli_arg", null, [h], [r]);
+    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 r = JSON.parse(this.readFileAsText(e)), n = {};
+    for (const s of r.headers) {
+      if (!s.includes(": "))
+        continue;
+      const a = s.indexOf(": "), i = s.substring(0, a).toLowerCase(), o = s.substring(a + 2);
+      i in n || (n[i] = []), n[i].push(o);
+    }
+    return {
+      headers: n,
+      httpStatusCode: r.status
+    };
+  }
+  #n(e) {
+    if (this.#e.ccall("wasm_set_request_uri", null, [h], [e]), e.includes("?")) {
+      const r = e.substring(e.indexOf("?") + 1);
+      this.#e.ccall(
+        "wasm_set_query_string",
+        null,
+        [h],
+        [r]
+      );
+    }
+  }
+  #o(e, r) {
+    this.#e.ccall("wasm_set_request_host", null, [h], [e]);
+    let n;
+    try {
+      n = parseInt(new URL(e).port, 10);
+    } catch {
+    }
+    (!n || isNaN(n) || n === 80) && (n = r === "https" ? 443 : 80), this.#e.ccall("wasm_set_request_port", null, [y], [n]), (r === "https" || !r && n === 443) && this.addServerGlobalEntry("HTTPS", "on");
+  }
+  #a(e) {
+    this.#e.ccall("wasm_set_request_method", null, [h], [e]);
+  }
+  setSkipShebang(e) {
+    this.#e.ccall(
+      "wasm_set_skip_shebang",
+      null,
+      [y],
+      [e ? 1 : 0]
+    );
+  }
+  #l(e) {
+    e.cookie && this.#e.ccall(
+      "wasm_set_cookies",
+      null,
+      [h],
+      [e.cookie]
+    ), e["content-type"] && this.#e.ccall(
+      "wasm_set_content_type",
+      null,
+      [h],
+      [e["content-type"]]
+    ), e["content-length"] && this.#e.ccall(
+      "wasm_set_content_length",
+      null,
+      [y],
+      [parseInt(e["content-length"], 10)]
+    );
+    for (const r in e)
+      this.addServerGlobalEntry(
+        `HTTP_${r.toUpperCase().replace(/-/g, "_")}`,
+        e[r]
+      );
+  }
+  #c(e) {
+    this.#e.ccall("wasm_set_request_body", null, [h], [e]), this.#e.ccall(
+      "wasm_set_content_length",
+      null,
+      [y],
+      [e.length]
+    );
+  }
+  #u(e) {
+    this.#e.ccall("wasm_set_path_translated", null, [h], [e]);
+  }
+  addServerGlobalEntry(e, r) {
+    this.#e.ccall(
+      "wasm_add_SERVER_entry",
+      null,
+      [h, h],
+      [e, r]
+    );
+  }
+  /**
+   * 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: r, name: n, type: s, data: a } = e, i = `/tmp/${Math.random().toFixed(20)}`;
+    this.writeFile(i, a);
+    const o = 0;
+    this.#e.ccall(
+      "wasm_add_uploaded_file",
+      null,
+      [h, h, h, h, y, y],
+      [r, n, s, i, o, a.byteLength]
+    );
+  }
+  #d(e) {
+    this.#e.ccall("wasm_set_php_code", null, [h], [e]);
+  }
+  async #f() {
+    const e = await await this.#e.ccall(
+      "wasm_sapi_handle_request",
+      y,
+      [],
+      []
+    ), { headers: r, httpStatusCode: n } = this.#i();
+    return new E(
+      n,
+      r,
+      this.readFileAsBuffer("/tmp/stdout"),
+      this.readFileAsText("/tmp/stderr"),
+      e
+    );
+  }
+  mkdirTree(e) {
+    this.#e.FS.mkdirTree(e);
+  }
+  readFileAsText(e) {
+    return new TextDecoder().decode(this.readFileAsBuffer(e));
+  }
+  readFileAsBuffer(e) {
+    return this.#e.FS.readFile(e);
+  }
+  writeFile(e, r) {
+    this.#e.FS.writeFile(e, r);
+  }
+  unlink(e) {
+    this.#e.FS.unlink(e);
+  }
+  listFiles(e) {
+    if (!this.fileExists(e))
+      return [];
+    try {
+      return this.#e.FS.readdir(e).filter(
+        (r) => r !== "." && r !== ".."
+      );
+    } catch (r) {
+      return console.error(r, { 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, r) {
+    this.#e.FS.mount(
+      this.#e.FS.filesystems.NODEFS,
+      e,
+      r
+    );
+  }
+}
+w([
+  g('Could not create directory "{path}"')
+], m.prototype, "mkdirTree", 1);
+w([
+  g('Could not read "{path}"')
+], m.prototype, "readFileAsText", 1);
+w([
+  g('Could not read "{path}"')
+], m.prototype, "readFileAsBuffer", 1);
+w([
+  g('Could not write to "{path}"')
+], m.prototype, "writeFile", 1);
+w([
+  g('Could not unlink "{path}"')
+], m.prototype, "unlink", 1);
+w([
+  g('Could not list files in "{path}"')
+], m.prototype, "listFiles", 1);
+w([
+  g('Could not stat "{path}"')
+], m.prototype, "isDir", 1);
+w([
+  g('Could not stat "{path}"')
+], m.prototype, "fileExists", 1);
+w([
+  g("Could not mount a directory")
+], m.prototype, "mount", 1);
+function ie(t) {
+  const e = {};
+  for (const r in t)
+    e[r.toLowerCase()] = t[r];
+  return e;
+}
+async function oe(t, e = {}, r = []) {
+  let n, s;
+  const a = new Promise((l) => {
+    s = l;
+  }), i = new Promise((l) => {
+    n = l;
+  }), o = t.init(se, {
+    onAbort(l) {
+      console.error("WASM aborted: "), console.error(l);
+    },
+    ENV: {},
+    // Emscripten sometimes prepends a '/' to the path, which
+    // breaks vite dev mode. An identity `locateFile` function
+    // fixes it.
+    locateFile: (l) => l,
+    ...e,
+    noInitialRun: !0,
+    onRuntimeInitialized() {
+      e.onRuntimeInitialized && e.onRuntimeInitialized(), n();
+    },
+    monitorRunDependencies(l) {
+      l === 0 && (delete o.monitorRunDependencies, s());
+    }
+  });
+  for (const { default: l } of r)
+    l(o);
+  return r.length || s(), await a, await i, _.push(o), _.length - 1;
+}
+/**
+ * @license
+ * Copyright 2019 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+const D = Symbol("Comlink.proxy"), ae = Symbol("Comlink.endpoint"), le = Symbol("Comlink.releaseProxy"), O = Symbol("Comlink.finalizer"), x = Symbol("Comlink.thrown"), z = (t) => typeof t == "object" && t !== null || typeof t == "function", ce = {
+  canHandle: (t) => z(t) && t[D],
+  serialize(t) {
+    const { port1: e, port2: r } = new MessageChannel();
+    return F(t, e), [r, [r]];
+  },
+  deserialize(t) {
+    return t.start(), L(t);
+  }
+}, ue = {
+  canHandle: (t) => z(t) && x 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", ce],
+  ["throw", ue]
+]);
+function he(t, e) {
+  for (const r of t)
+    if (e === r || r === "*" || r instanceof RegExp && r.test(e))
+      return !0;
+  return !1;
+}
+function F(t, e = globalThis, r = ["*"]) {
+  e.addEventListener("message", function n(s) {
+    if (!s || !s.data)
+      return;
+    if (!he(r, s.origin)) {
+      console.warn(`Invalid origin '${s.origin}' for comlink proxy`);
+      return;
+    }
+    const { id: a, type: i, path: o } = Object.assign({ path: [] }, s.data), l = (s.data.argumentList || []).map(P);
+    let c;
+    try {
+      const u = o.slice(0, -1).reduce((f, R) => f[R], t), p = o.reduce((f, R) => f[R], t);
+      switch (i) {
+        case "GET":
+          c = p;
+          break;
+        case "SET":
+          u[o.slice(-1)[0]] = P(s.data.value), c = !0;
+          break;
+        case "APPLY":
+          c = p.apply(u, l);
+          break;
+        case "CONSTRUCT":
+          {
+            const f = new p(...l);
+            c = B(f);
+          }
+          break;
+        case "ENDPOINT":
+          {
+            const { port1: f, port2: R } = new MessageChannel();
+            F(t, R), c = ge(f, [f]);
+          }
+          break;
+        case "RELEASE":
+          c = void 0;
+          break;
+        default:
+          return;
+      }
+    } catch (u) {
+      c = { value: u, [x]: 0 };
+    }
+    Promise.resolve(c).catch((u) => ({ value: u, [x]: 0 })).then((u) => {
+      const [p, f] = C(u);
+      e.postMessage(Object.assign(Object.assign({}, p), { id: a }), f), i === "RELEASE" && (e.removeEventListener("message", n), $(e), O in t && typeof t[O] == "function" && t[O]());
+    }).catch((u) => {
+      const [p, f] = C({
+        value: new TypeError("Unserializable return value"),
+        [x]: 0
+      });
+      e.postMessage(Object.assign(Object.assign({}, p), { id: a }), f);
+    });
+  }), e.start && e.start();
+}
+function de(t) {
+  return t.constructor.name === "MessagePort";
+}
+function $(t) {
+  de(t) && t.close();
+}
+function L(t, e) {
+  return H(t, [], e);
+}
+function v(t) {
+  if (t)
+    throw new Error("Proxy has been released and is not useable");
+}
+function q(t) {
+  return b(t, {
+    type: "RELEASE"
+  }).then(() => {
+    $(t);
+  });
+}
+const k = /* @__PURE__ */ new WeakMap(), T = "FinalizationRegistry" in globalThis && new FinalizationRegistry((t) => {
+  const e = (k.get(t) || 0) - 1;
+  k.set(t, e), e === 0 && q(t);
+});
+function fe(t, e) {
+  const r = (k.get(e) || 0) + 1;
+  k.set(e, r), T && T.register(t, e, t);
+}
+function pe(t) {
+  T && T.unregister(t);
+}
+function H(t, e = [], r = function() {
+}) {
+  let n = !1;
+  const s = new Proxy(r, {
+    get(a, i) {
+      if (v(n), i === le)
+        return () => {
+          pe(s), q(t), n = !0;
+        };
+      if (i === "then") {
+        if (e.length === 0)
+          return { then: () => s };
+        const o = b(t, {
+          type: "GET",
+          path: e.map((l) => l.toString())
+        }).then(P);
+        return o.then.bind(o);
+      }
+      return H(t, [...e, i]);
+    },
+    set(a, i, o) {
+      v(n);
+      const [l, c] = C(o);
+      return b(t, {
+        type: "SET",
+        path: [...e, i].map((u) => u.toString()),
+        value: l
+      }, c).then(P);
+    },
+    apply(a, i, o) {
+      v(n);
+      const l = e[e.length - 1];
+      if (l === ae)
+        return b(t, {
+          type: "ENDPOINT"
+        }).then(P);
+      if (l === "bind")
+        return H(t, e.slice(0, -1));
+      const [c, u] = U(o);
+      return b(t, {
+        type: "APPLY",
+        path: e.map((p) => p.toString()),
+        argumentList: c
+      }, u).then(P);
+    },
+    construct(a, i) {
+      v(n);
+      const [o, l] = U(i);
+      return b(t, {
+        type: "CONSTRUCT",
+        path: e.map((c) => c.toString()),
+        argumentList: o
+      }, l).then(P);
+    }
+  });
+  return fe(s, t), s;
+}
+function me(t) {
+  return Array.prototype.concat.apply([], t);
+}
+function U(t) {
+  const e = t.map(C);
+  return [e.map((r) => r[0]), me(e.map((r) => r[1]))];
+}
+const j = /* @__PURE__ */ new WeakMap();
+function ge(t, e) {
+  return j.set(t, e), t;
+}
+function B(t) {
+  return Object.assign(t, { [D]: !0 });
+}
+function V(t, e = globalThis, r = "*") {
+  return {
+    postMessage: (n, s) => t.postMessage(n, r, s),
+    addEventListener: e.addEventListener.bind(e),
+    removeEventListener: e.removeEventListener.bind(e)
+  };
+}
+function C(t) {
+  for (const [e, r] of S)
+    if (r.canHandle(t)) {
+      const [n, s] = r.serialize(t);
+      return [
+        {
+          type: "HANDLER",
+          name: e,
+          value: n
+        },
+        s
+      ];
+    }
+  return [
+    {
+      type: "RAW",
+      value: t
+    },
+    j.get(t) || []
+  ];
+}
+function P(t) {
+  switch (t.type) {
+    case "HANDLER":
+      return S.get(t.name).deserialize(t.value);
+    case "RAW":
+      return t.value;
+  }
+}
+function b(t, e, r) {
+  return new Promise((n) => {
+    const s = we();
+    t.addEventListener("message", function a(i) {
+      !i.data || !i.data.id || i.data.id !== s || (t.removeEventListener("message", a), n(i.data));
+    }), t.start && t.start(), t.postMessage(Object.assign({ id: s }, e), r);
+  });
+}
+function we() {
+  return new Array(4).fill(0).map(() => Math.floor(Math.random() * Number.MAX_SAFE_INTEGER).toString(16)).join("-");
+}
+function ve(t) {
+  G();
+  const e = t instanceof Worker ? t : V(t);
+  return L(e);
+}
+function xe(t, e) {
+  G();
+  let r;
+  const n = new Promise((i) => {
+    r = i;
+  }), s = J(t), a = new Proxy(s, {
+    get: (i, o) => o === "isReady" ? () => n : o in i ? i[o] : e?.[o]
+  });
+  return F(
+    a,
+    typeof window < "u" ? V(self.parent) : void 0
+  ), [r, a];
+}
+function G() {
+  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: r } = new MessageChannel();
+      return F(t, e), [r, [r]];
+    },
+    deserialize(t) {
+      return t.start(), L(t);
+    }
+  }), S.set("PHPResponse", {
+    canHandle: (t) => typeof t == "object" && t !== null && "headers" in t && "bytes" in t && "errors" in t && "exitCode" in t && "httpStatusCode" in t,
+    serialize(t) {
+      return [t.toRawData(), []];
+    },
+    deserialize(t) {
+      return E.fromRawData(t);
+    }
+  });
+}
+function J(t) {
+  return new Proxy(t, {
+    get(e, r) {
+      switch (typeof e[r]) {
+        case "function":
+          return (...n) => e[r](...n);
+        case "object":
+          return e[r] === null ? e[r] : J(e[r]);
+        case "undefined":
+        case "number":
+        case "string":
+          return e[r];
+        default:
+          return B(e[r]);
+      }
+    }
+  });
+}
+async function ye(t = Y) {
+  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}`);
+}
+class A extends m {
+  /**
+   * Creates a new PHP instance.
+   *
+   * Dynamically imports the PHP module, initializes the runtime,
+   * and sets up networking. It's a shorthand for the lower-level
+   * functions like `getPHPLoaderModule`, `loadPHPRuntime`, and
+   * `PHP.initializeRuntime`
+   *
+   * @param phpVersion The PHP Version to load
+   * @param options The options to use when loading PHP
+   * @returns A new PHP instance
+   */
+  static async load(e, r = {}) {
+    return await A.loadSync(e, r).phpReady;
+  }
+  /**
+   * Does what load() does, but synchronously returns
+   * an object with the PHP instance and a promise that
+   * resolves when the PHP instance is ready.
+   *
+   * @see load
+   */
+  static loadSync(e, r = {}) {
+    const n = new A(void 0, r.requestHandler), a = (async () => {
+      const i = await Promise.all([
+        ye(e),
+        ...r.dataModules || []
+      ]), [o, ...l] = i;
+      r.downloadMonitor?.setModules(i);
+      const c = await oe(
+        o,
+        {
+          ...r.emscriptenOptions || {},
+          ...r.downloadMonitor?.getEmscriptenOptions() || {}
+        },
+        l
+      );
+      return n.initializeRuntime(c), { dataModules: l };
+    })();
+    return {
+      php: n,
+      phpReady: a.then(() => n),
+      dataModules: a.then((i) => i.dataModules)
+    };
+  }
+}
+const d = /* @__PURE__ */ new WeakMap();
+class _e {
+  /** @inheritDoc */
+  constructor(e, r) {
+    d.set(this, {
+      php: e,
+      monitor: r
+    }), this.absoluteUrl = Promise.resolve(
+      e.requestHandler.server.absoluteUrl
+    ), this.documentRoot = Promise.resolve(
+      e.requestHandler.server.documentRoot
+    );
+  }
+  /** @inheritDoc @php-wasm/web!PHPRequestHandler.pathToInternalUrl */
+  async pathToInternalUrl(e) {
+    return d.get(this).php.requestHandler.server.pathToInternalUrl(e);
+  }
+  /** @inheritDoc @php-wasm/web!PHPRequestHandler.internalUrlToPath */
+  async internalUrlToPath(e) {
+    return d.get(this).php.requestHandler.server.internalUrlToPath(e);
+  }
+  async onDownloadProgress(e) {
+    d.get(this).monitor?.addEventListener("progress", e);
+  }
+  /** @inheritDoc @php-wasm/web!PHPRequestHandler.request */
+  request(e, r) {
+    return d.get(this).php.request(e, r);
+  }
+  /** @inheritDoc @php-wasm/web!PHP.run */
+  async run(e) {
+    return d.get(this).php.run(e);
+  }
+  /** @inheritDoc @php-wasm/web!PHP.chdir */
+  chdir(e) {
+    return d.get(this).php.chdir(e);
+  }
+  /** @inheritDoc @php-wasm/web!PHP.setPhpIniPath */
+  setPhpIniPath(e) {
+    return d.get(this).php.setPhpIniPath(e);
+  }
+  /** @inheritDoc @php-wasm/web!PHP.setPhpIniEntry */
+  setPhpIniEntry(e, r) {
+    d.get(this).php.setPhpIniEntry(e, r);
+  }
+  /** @inheritDoc @php-wasm/web!PHP.mkdirTree */
+  mkdirTree(e) {
+    d.get(this).php.mkdirTree(e);
+  }
+  /** @inheritDoc @php-wasm/web!PHP.readFileAsText */
+  async readFileAsText(e) {
+    return d.get(this).php.readFileAsText(e);
+  }
+  /** @inheritDoc @php-wasm/web!PHP.readFileAsBuffer */
+  async readFileAsBuffer(e) {
+    return d.get(this).php.readFileAsBuffer(e);
+  }
+  /** @inheritDoc @php-wasm/web!PHP.writeFile */
+  writeFile(e, r) {
+    d.get(this).php.writeFile(e, r);
+  }
+  /** @inheritDoc @php-wasm/web!PHP.unlink */
+  unlink(e) {
+    d.get(this).php.unlink(e);
+  }
+  /** @inheritDoc @php-wasm/web!PHP.listFiles */
+  async listFiles(e) {
+    return d.get(this).php.listFiles(e);
+  }
+  /** @inheritDoc @php-wasm/web!PHP.isDir */
+  async isDir(e) {
+    return d.get(this).php.isDir(e);
+  }
+  /** @inheritDoc @php-wasm/web!PHP.fileExists */
+  async fileExists(e) {
+    return d.get(this).php.fileExists(e);
+  }
+}
+function Pe(t, e) {
+  return {
+    type: "response",
+    requestId: t,
+    response: e
+  };
+}
+async function ke(t, e, r, n) {
+  const s = navigator.serviceWorker;
+  if (!s)
+    throw new Error("Service workers are not supported in this browser.");
+  const a = await s.getRegistrations();
+  if (a.length > 0) {
+    const i = await be();
+    if (n !== i) {
+      console.debug(
+        `[window] Reloading the currently registered Service Worker (expected version: ${n}, registered version: ${i})`
+      );
+      for (const o of a) {
+        let l = !1;
+        try {
+          await o.update();
+        } catch {
+          l = !0;
+        }
+        const c = o.waiting || o.installing;
+        c && !l && (i !== null ? c.postMessage("skip-waiting") : l = !0), l && (await o.unregister(), window.location.reload());
+      }
+    }
+  } else
+    console.debug(
+      `[window] Creating a Service Worker registration (version: ${n})`
+    ), await s.register(r, {
+      type: "module"
+    });
+  navigator.serviceWorker.addEventListener(
+    "message",
+    async function(o) {
+      if (console.debug("Message from ServiceWorker", o), e && o.data.scope !== e)
+        return;
+      const l = o.data.args || [], c = o.data.method, u = await t[c](...l);
+      o.source.postMessage(Pe(o.data.requestId, u));
+    }
+  ), s.startMessages();
+}
+async function be() {
+  try {
+    return (await (await fetch("/version")).json()).version;
+  } catch {
+    return null;
+  }
+}
+function Te() {
+  const t = {};
+  return typeof self?.location?.href < "u" && new URL(self.location.href).searchParams.forEach((r, n) => {
+    t[n] = r;
+  }), t;
+}
+const Ce = function() {
+  return navigator.userAgent.toLowerCase().indexOf("firefox") > -1 ? "iframe" : "webworker";
+}();
+async function Fe(t, e = "webworker", r = {}) {
+  if (t = Ee(t, r), e === "webworker")
+    return new Worker(t, { type: "module" });
+  if (e === "iframe")
+    return (await Re(t)).contentWindow;
+  throw new Error(`Unknown backendName: ${e}`);
+}
+function Ee(t, e) {
+  if (!Object.entries(e).length)
+    return t + "";
+  const r = new URL(t);
+  for (const [n, s] of Object.entries(e))
+    r.searchParams.set(n, s);
+  return r.toString();
+}
+async function Re(t) {
+  const e = document.createElement("iframe"), r = "/" + t.split("/").slice(-1)[0];
+  return e.src = r, e.style.display = "none", document.body.appendChild(e), await new Promise((n) => {
+    e.addEventListener("load", n);
+  }), e;
+}
+export {
+  Y as LatestSupportedPHPVersion,
+  A as PHP,
+  K as PHPBrowser,
+  _e as PHPClient,
+  ee as PHPRequestHandler,
+  W as SupportedPHPVersions,
+  Se as SupportedPHPVersionsList,
+  ve as consumeAPI,
+  xe as exposeAPI,
+  ye as getPHPLoaderModule,
+  oe as loadPHPRuntime,
+  Te as parseWorkerStartupOptions,
+  Ce as recommendedWorkerBackend,
+  ke as registerServiceWorker,
+  Fe as spawnPHPWorkerThread
+};