@wp-playground/blueprints 0.1.40 → 0.1.43

package/index.js

@@ -0,0 +1,2106 @@
+function b(r) {
+  return new DOMParser().parseFromString(r.text, "text/html");
+}
+function E(r) {
+  const e = r.split(".").shift().replace("-", " ");
+  return e.charAt(0).toUpperCase() + e.slice(1).toLowerCase();
+}
+async function g(r, e, t) {
+  let s = "";
+  await r.fileExists(e) && (s = await r.readFileAsText(e)), await r.writeFile(e, t(s));
+}
+async function oe(r) {
+  return new Uint8Array(await r.arrayBuffer());
+}
+const O = "/vfs-blueprints", A = "/vfs-blueprints/wp-config-consts.php", ae = async (r, { plugin: e }, t) => {
+  t?.tracker.setCaption(`Activating ${e}`);
+  const i = b(
+    await r.request({
+      url: "/wp-admin/plugins.php"
+    })
+  ).querySelector(
+    `tr[data-slug="${e}"] a`
+  ).attributes.getNamedItem("href").value;
+  await r.request({
+    url: "/wp-admin/" + i
+  });
+}, ce = async (r, e) => {
+  const t = new le(
+    r,
+    e.siteUrl,
+    e.wordpressPath || "/wordpress"
+  );
+  e.patchSqlitePlugin !== !1 && await t.patchSqlitePlugin(), e.addPhpInfo !== !1 && await t.addPhpInfo(), e.patchSiteUrl !== !1 && await t.patchSiteUrl(), e.disableSiteHealth !== !1 && await t.disableSiteHealth(), e.disableWpNewBlogNotification !== !1 && await t.disableWpNewBlogNotification();
+};
+class le {
+  constructor(e, t, s) {
+    this.php = e, this.scopedSiteUrl = t, this.wordpressPath = s;
+  }
+  async patchSqlitePlugin() {
+    await g(
+      this.php,
+      `${this.wordpressPath}/wp-content/plugins/sqlite-database-integration/wp-includes/sqlite/class-wp-sqlite-translator.php`,
+      (e) => e.replace(
+        "if ( false === strtotime( $value ) )",
+        'if ( $value === "0000-00-00 00:00:00" || false === strtotime( $value ) )'
+      )
+    );
+  }
+  async addPhpInfo() {
+    await this.php.writeFile(
+      `${this.wordpressPath}/phpinfo.php`,
+      "<?php phpinfo(); "
+    );
+  }
+  async patchSiteUrl() {
+    await g(
+      this.php,
+      `${this.wordpressPath}/wp-config.php`,
+      (e) => `<?php
+				if(!defined('WP_HOME')) {
+					define('WP_HOME', "${this.scopedSiteUrl}");
+					define('WP_SITEURL', "${this.scopedSiteUrl}");
+				}
+				?>${e}`
+    );
+  }
+  async disableSiteHealth() {
+    await g(
+      this.php,
+      `${this.wordpressPath}/wp-includes/default-filters.php`,
+      (e) => e.replace(
+        /add_filter[^;]+wp_maybe_grant_site_health_caps[^;]+;/i,
+        ""
+      )
+    );
+  }
+  async disableWpNewBlogNotification() {
+    await g(
+      this.php,
+      `${this.wordpressPath}/wp-config.php`,
+      // The original version of this function crashes WASM PHP, let's define an empty one instead.
+      (e) => `${e} function wp_new_blog_notification(...$args){} `
+    );
+  }
+}
+const ue = async (r, { code: e }) => await r.run({ code: e }), he = async (r, { options: e }) => await r.run(e), pe = async (r, { key: e, value: t }) => {
+  await r.setPhpIniEntry(e, t);
+}, de = async (r, { request: e }) => await r.request(e), fe = async (r, { fromPath: e, toPath: t }) => {
+  await r.writeFile(
+    t,
+    await r.readFileAsBuffer(e)
+  );
+}, me = async (r, { fromPath: e, toPath: t }) => {
+  await r.mv(e, t);
+}, we = async (r, { path: e }) => {
+  await r.mkdir(e);
+}, ge = async (r, { path: e }) => {
+  await r.unlink(e);
+}, ye = async (r, { path: e }) => {
+  await r.rmdir(e);
+}, Pe = async (r, { path: e, data: t }) => {
+  t instanceof File && (t = await oe(t)), await r.writeFile(e, t);
+}, K = async (r, { consts: e }) => {
+  const t = await r.documentRoot;
+  await g(
+    r,
+    `${t}/playground-consts.json`,
+    (s) => JSON.stringify({
+      ...JSON.parse(s || "{}"),
+      ...e
+    })
+  ), await g(
+    r,
+    `${t}/wp-config.php`,
+    (s) => s.includes("playground-consts.json") ? s : `<?php
+	$consts = json_decode(file_get_contents('./playground-consts.json'), true);
+	foreach ($consts as $const => $value) {
+		if (!defined($const)) {
+			define($const, $value);
+		}
+	}
+?>${s}`
+  );
+}, _e = async (r, { siteUrl: e }) => await K(r, {
+  consts: {
+    WP_HOME: e,
+    WP_SITEURL: e
+  }
+});
+class Y {
+  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()();
+        };
+  }
+  async run(e) {
+    const t = await this.acquire();
+    try {
+      return await e();
+    } finally {
+      t();
+    }
+  }
+}
+const be = Symbol("literal");
+function _(r) {
+  if (typeof r == "string")
+    return r.startsWith("$") ? r : JSON.stringify(r);
+  if (typeof r == "number")
+    return r.toString();
+  if (Array.isArray(r))
+    return `array(${r.map(_).join(", ")})`;
+  if (r === null)
+    return "null";
+  if (typeof r == "object")
+    return be in r ? r.toString() : `array(${Object.entries(r).map(([t, s]) => `${JSON.stringify(t)} => ${_(s)}`).join(", ")})`;
+  if (typeof r == "function")
+    return r();
+  throw new Error(`Unsupported value: ${r}`);
+}
+function x(r) {
+  const e = {};
+  for (const t in r)
+    e[t] = _(r[t]);
+  return e;
+}
+const I = `<?php
+
+function zipDir($dir, $output, $additionalFiles = array())
+{
+    $zip = new ZipArchive;
+    $res = $zip->open($output, ZipArchive::CREATE);
+    if ($res === TRUE) {
+        foreach ($additionalFiles as $file) {
+            $zip->addFile($file);
+        }
+        $directories = array(
+            rtrim($dir, '/') . '/'
+        );
+        while (sizeof($directories)) {
+            $dir = array_pop($directories);
+
+            if ($handle = opendir($dir)) {
+                while (false !== ($entry = readdir($handle))) {
+                    if ($entry == '.' || $entry == '..') {
+                        continue;
+                    }
+
+                    $entry = $dir . $entry;
+
+                    if (is_dir($entry)) {
+                        $directory_path = $entry . '/';
+                        array_push($directories, $directory_path);
+                    } else if (is_file($entry)) {
+                        $zip->addFile($entry);
+                    }
+                }
+                closedir($handle);
+            }
+        }
+        $zip->close();
+        chmod($output, 0777);
+    }
+}
+
+function unzip($zipPath, $extractTo, $overwrite = true)
+{
+    if(!is_dir($extractTo)) {
+        mkdir($extractTo, 0777, true);
+    }
+    $zip = new ZipArchive;
+    $res = $zip->open($zipPath);
+    if ($res === TRUE) {
+        $zip->extractTo($extractTo);
+        $zip->close();
+        chmod($extractTo, 0777);
+    }
+}
+
+
+function delTree($dir)
+{
+    $files = array_diff(scandir($dir), array('.', '..'));
+    foreach ($files as $file) {
+        (is_dir("$dir/$file")) ? delTree("$dir/$file") : unlink("$dir/$file");
+    }
+    return rmdir($dir);
+}
+`;
+async function $e(r) {
+  const e = "wordpress-playground.zip", t = `/${e}`, s = x({
+    zipPath: t,
+    documentRoot: await r.documentRoot
+  });
+  await Q(
+    r,
+    `zipDir(${s.documentRoot}, ${s.zipPath});`
+  );
+  const n = await r.readFileAsBuffer(t);
+  return r.unlink(t), new File([n], e);
+}
+const ve = async (r, { fullSiteZip: e }) => {
+  const t = "/import.zip";
+  await r.writeFile(
+    t,
+    new Uint8Array(await e.arrayBuffer())
+  );
+  const s = await r.absoluteUrl, n = await r.documentRoot;
+  await r.rmdir(n), await Z(r, { zipPath: t, extractToPath: "/" });
+  const i = x({ absoluteUrl: s });
+  await Re(
+    r,
+    `${n}/wp-config.php`,
+    (o) => `<?php
+			if(!defined('WP_HOME')) {
+				define('WP_HOME', ${i.absoluteUrl});
+				define('WP_SITEURL', ${i.absoluteUrl});
+			}
+			?>${o}`
+  );
+}, Z = async (r, { zipPath: e, extractToPath: t }) => {
+  const s = x({
+    zipPath: e,
+    extractToPath: t
+  });
+  await Q(
+    r,
+    `unzip(${s.zipPath}, ${s.extractToPath});`
+  );
+}, Se = async (r, { file: e }) => {
+  const t = await r.request({
+    url: "/wp-admin/admin.php?import=wordpress"
+  }), s = L(t).getElementById("import-upload-form")?.getAttribute("action"), n = await r.request({
+    url: `/wp-admin/${s}`,
+    method: "POST",
+    files: { import: e }
+  }), i = L(n).querySelector(
+    "#wpbody-content form"
+  );
+  if (!i)
+    throw console.log(n.text), new Error(
+      "Could not find an importer form in response. See the response text above for details."
+    );
+  const o = Ee(i);
+  o.fetch_attachments = "1";
+  for (const a in o)
+    if (a.startsWith("user_map[")) {
+      const c = "user_new[" + a.slice(9, -1) + "]";
+      o[c] = "1";
+    }
+  await r.request({
+    url: i.action,
+    method: "POST",
+    formData: o
+  });
+};
+function L(r) {
+  return new DOMParser().parseFromString(r.text, "text/html");
+}
+function Ee(r) {
+  return Object.fromEntries(new FormData(r).entries());
+}
+async function Re(r, e, t) {
+  await r.writeFile(
+    e,
+    t(await r.readFileAsText(e))
+  );
+}
+async function Q(r, e) {
+  const t = await r.run({
+    code: I + e
+  });
+  if (t.exitCode !== 0)
+    throw console.log(I + e), console.log(e + ""), console.log(t.errors), t.errors;
+  return t;
+}
+const Te = async (r, { pluginZipFile: e, options: t = {} }, s) => {
+  s?.tracker.setCaption(
+    `Installing the ${E(e?.name)} plugin`
+  );
+  try {
+    const n = "activate" in t ? t.activate : !0, i = await r.request({
+      url: "/wp-admin/plugin-install.php?tab=upload"
+    }), o = b(i), a = new FormData(
+      o.querySelector(".wp-upload-form")
+    ), { pluginzip: c, ...u } = Object.fromEntries(
+      a.entries()
+    ), h = await r.request({
+      url: "/wp-admin/update.php?action=upload-plugin",
+      method: "POST",
+      formData: u,
+      files: { pluginzip: e }
+    });
+    if (n) {
+      const v = b(h).querySelector("#wpbody-content .button.button-primary").attributes.getNamedItem("href").value, S = new URL(
+        v,
+        await r.pathToInternalUrl("/wp-admin/")
+      ).toString();
+      await r.request({
+        url: S
+      });
+    }
+    await r.isDir(
+      "/wordpress/wp-content/plugins/gutenberg"
+    ) && !await r.fileExists("/wordpress/.gutenberg-patched") && (await r.writeFile("/wordpress/.gutenberg-patched", "1"), await H(
+      r,
+      "/wordpress/wp-content/plugins/gutenberg/build/block-editor/index.js",
+      (d) => d.replace(
+        /srcDoc:("[^"]+"|[^,]+)/g,
+        'src:"/wp-includes/empty.html"'
+      )
+    ), await H(
+      r,
+      "/wordpress/wp-content/plugins/gutenberg/build/block-editor/index.min.js",
+      (d) => d.replace(
+        /srcDoc:("[^"]+"|[^,]+)/g,
+        'src:"/wp-includes/empty.html"'
+      )
+    ));
+  } catch (n) {
+    console.error(
+      `Proceeding without the ${e.name} theme. Could not install it in wp-admin. The original error was: ${n}`
+    ), console.error(n);
+  }
+};
+async function H(r, e, t) {
+  return await r.writeFile(
+    e,
+    t(await r.readFileAsText(e))
+  );
+}
+const xe = async (r, { themeZipFile: e, options: t = {} }, s) => {
+  s?.tracker.setCaption(
+    `Installing the ${E(e.name)} theme`
+  );
+  try {
+    const n = "activate" in t ? t.activate : !0, i = await r.request({
+      url: "/wp-admin/theme-install.php"
+    }), o = b(i), a = new FormData(
+      o.querySelector(".wp-upload-form")
+    ), { themezip: c, ...u } = Object.fromEntries(
+      a.entries()
+    ), h = await r.request({
+      url: "/wp-admin/update.php?action=upload-theme",
+      method: "POST",
+      formData: u,
+      files: { themezip: e }
+    });
+    if (n) {
+      const d = b(h), v = d.querySelector(
+        "#wpbody-content > .wrap"
+      );
+      if (v?.textContent?.includes(
+        "Theme installation failed."
+      )) {
+        console.error(v?.textContent);
+        return;
+      }
+      const S = d.querySelector(
+        "#wpbody-content .activatelink, .update-from-upload-actions .button.button-primary"
+      );
+      if (!S) {
+        console.error('The "activate" button was not found.');
+        return;
+      }
+      const ne = S.attributes.getNamedItem("href").value, ie = new URL(
+        ne,
+        await r.pathToInternalUrl("/wp-admin/")
+      ).toString();
+      await r.request({
+        url: ie
+      });
+    }
+  } catch (n) {
+    console.error(
+      `Proceeding without the ${e.name} theme. Could not install it in wp-admin. The original error was: ${n}`
+    ), console.error(n);
+  }
+}, Fe = async (r, { username: e = "admin", password: t = "password" } = {}, s) => {
+  s?.tracker.setCaption(s?.initialCaption || "Logging in"), await r.request({
+    url: "/wp-login.php"
+  }), await r.request({
+    url: "/wp-login.php",
+    method: "POST",
+    formData: {
+      log: e,
+      pwd: t,
+      rememberme: "forever"
+    }
+  });
+}, ke = async (r, { options: e }) => {
+  await r.request({
+    url: "/wp-admin/install.php?step=2",
+    method: "POST",
+    formData: {
+      language: "en",
+      prefix: "wp_",
+      weblog_title: "My WordPress Website",
+      user_name: e.adminPassword || "admin",
+      admin_password: e.adminPassword || "password",
+      // The installation wizard demands typing the same password twice
+      admin_password2: e.adminPassword || "password",
+      Submit: "Install WordPress",
+      pw_weak: "1",
+      admin_email: "admin@localhost.com"
+    }
+  });
+}, Ce = async (r, { options: e }) => {
+  const t = `<?php
+	include 'wordpress/wp-load.php';
+	$site_options = ${_(e)};
+	foreach($site_options as $name => $value) {
+		update_option($name, $value);
+	}
+	echo "Success";
+	`, s = await r.run({
+    code: t
+  });
+  return X(s), { code: t, result: s };
+}, Ue = async (r, { meta: e, userId: t }) => {
+  const s = `<?php
+	include 'wordpress/wp-load.php';
+	$meta = ${_(e)};
+	foreach($meta as $name => $value) {
+		update_user_meta(${_(t)}, $name, $value);
+	}
+	echo "Success";
+	`, n = await r.run({
+    code: s
+  });
+  return X(n), { code: s, result: n };
+};
+async function X(r) {
+  if (r.text !== "Success")
+    throw console.log(r), new Error(`Failed to run code: ${r.text} ${r.errors}`);
+}
+const Oe = async (r, { consts: e }) => {
+  r.mkdir(O);
+  const t = `${O}/playground-consts.json`;
+  return await g(
+    r,
+    t,
+    (s) => JSON.stringify({
+      ...JSON.parse(s || "{}"),
+      ...e
+    })
+  ), await g(r, A, (s) => s.includes("playground-consts.json") ? s : `<?php
+	$consts = json_decode(file_get_contents('${t}'), true);
+	foreach ($consts as $const => $value) {
+		if (!defined($const)) {
+			define($const, $value);
+		}
+	}
+?>${s}`), A;
+}, Ae = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  activatePlugin: ae,
+  applyWordPressPatches: ce,
+  cp: fe,
+  defineSiteUrl: _e,
+  defineVirtualWpConfigConsts: Oe,
+  defineWpConfigConsts: K,
+  importFile: Se,
+  installPlugin: Te,
+  installTheme: xe,
+  login: Fe,
+  mkdir: we,
+  mv: me,
+  replaceSite: ve,
+  request: de,
+  rm: ge,
+  rmdir: ye,
+  runPHP: ue,
+  runPHPWithOptions: he,
+  runWpInstallationWizard: ke,
+  setPhpIniEntry: pe,
+  setSiteOptions: Ce,
+  unzip: Z,
+  updateUserMeta: Ue,
+  writeFile: Pe,
+  zipEntireSite: $e
+}, Symbol.toStringTag, { value: "Module" })), Ie = 5 * 1024 * 1024;
+function Le(r, e) {
+  const t = r.headers.get("content-length") || "", s = parseInt(t, 10) || Ie;
+  function n(i, o) {
+    e(
+      new CustomEvent("progress", {
+        detail: {
+          loaded: i,
+          total: o
+        }
+      })
+    );
+  }
+  return new Response(
+    new ReadableStream({
+      async start(i) {
+        if (!r.body) {
+          i.close();
+          return;
+        }
+        const o = r.body.getReader();
+        let a = 0;
+        for (; ; )
+          try {
+            const { done: c, value: u } = await o.read();
+            if (u && (a += u.byteLength), c) {
+              n(a, a), i.close();
+              break;
+            } else
+              n(a, s), i.enqueue(u);
+          } catch (c) {
+            console.error({ e: c }), i.error(c);
+            break;
+          }
+      }
+    }),
+    {
+      status: r.status,
+      statusText: r.statusText,
+      headers: r.headers
+    }
+  );
+}
+const R = 1e-5;
+class F extends EventTarget {
+  constructor({
+    weight: e = 1,
+    caption: t = "",
+    fillTime: s = 4
+  } = {}) {
+    super(), this._selfWeight = 1, this._selfDone = !1, this._selfProgress = 0, this._selfCaption = "", this._isFilling = !1, this._subTrackers = [], this._weight = e, this._selfCaption = t, this._fillTime = s;
+  }
+  /**
+   * Creates a new sub-tracker with a specific weight.
+   *
+   * The weight determines what percentage of the overall progress
+   * the sub-tracker represents. For example, if the main tracker is
+   * monitoring a process that has two stages, and the first stage
+   * is expected to take twice as long as the second stage, you could
+   * create the first sub-tracker with a weight of 0.67 and the second
+   * sub-tracker with a weight of 0.33.
+   *
+   * The caption is an optional string that describes the current stage
+   * of the operation. If provided, it will be used as the progress caption
+   * for the sub-tracker. If not provided, the main tracker will look for
+   * the next sub-tracker with a non-empty caption and use that as the progress
+   * caption instead.
+   *
+   * Returns the newly-created sub-tracker.
+   *
+   * @throws {Error} If the weight of the new stage would cause the total weight of all stages to exceed 1.
+   *
+   * @param weight The weight of the new stage, as a decimal value between 0 and 1.
+   * @param caption The caption for the new stage, which will be used as the progress caption for the sub-tracker.
+   *
+   * @example
+   * ```ts
+   * const tracker = new ProgressTracker();
+   * const subTracker1 = tracker.stage(0.67, 'Slow stage');
+   * const subTracker2 = tracker.stage(0.33, 'Fast stage');
+   *
+   * subTracker2.set(50);
+   * subTracker1.set(75);
+   * subTracker2.set(100);
+   * subTracker1.set(100);
+   * ```
+   */
+  stage(e, t = "") {
+    if (e || (e = this._selfWeight), this._selfWeight - e < -R)
+      throw new Error(
+        `Cannot add a stage with weight ${e} as the total weight of registered stages would exceed 1.`
+      );
+    this._selfWeight -= e;
+    const s = new F({
+      caption: t,
+      weight: e,
+      fillTime: this._fillTime
+    });
+    return this._subTrackers.push(s), s.addEventListener("progress", () => this.notifyProgress()), s.addEventListener("done", () => {
+      this.done && this.notifyDone();
+    }), s;
+  }
+  /**
+   * Fills the progress bar slowly over time, simulating progress.
+   *
+   * The progress bar is filled in a 100 steps, and each step, the progress
+   * is increased by 1. If `stopBeforeFinishing` is true, the progress bar
+   * will stop filling when it reaches 99% so that you can call `finish()`
+   * explicitly.
+   *
+   * If the progress bar is filling or already filled, this method does nothing.
+   *
+   * @example
+   * ```ts
+   * const progress = new ProgressTracker({ caption: 'Processing...' });
+   * progress.fillSlowly();
+   * ```
+   *
+   * @param options Optional options.
+   */
+  fillSlowly({ stopBeforeFinishing: e = !0 } = {}) {
+    if (this._isFilling)
+      return;
+    this._isFilling = !0;
+    const t = 100, s = this._fillTime / t;
+    this._fillInterval = setInterval(() => {
+      this.set(this._selfProgress + 1), e && this._selfProgress >= 99 && clearInterval(this._fillInterval);
+    }, s);
+  }
+  set(e) {
+    this._selfProgress = Math.min(e, 100), this.notifyProgress(), this._selfProgress + R >= 100 && this.finish();
+  }
+  finish() {
+    this._fillInterval && clearInterval(this._fillInterval), this._selfDone = !0, this._selfProgress = 100, this._isFilling = !1, this._fillInterval = void 0, this.notifyProgress(), this.notifyDone();
+  }
+  get caption() {
+    for (let e = this._subTrackers.length - 1; e >= 0; e--)
+      if (!this._subTrackers[e].done) {
+        const t = this._subTrackers[e].caption;
+        if (t)
+          return t;
+      }
+    return this._selfCaption;
+  }
+  setCaption(e) {
+    this._selfCaption = e, this.notifyProgress();
+  }
+  get done() {
+    return this.progress + R >= 100;
+  }
+  get progress() {
+    if (this._selfDone)
+      return 100;
+    const e = this._subTrackers.reduce(
+      (t, s) => t + s.progress * s.weight,
+      this._selfProgress * this._selfWeight
+    );
+    return Math.round(e * 1e4) / 1e4;
+  }
+  get weight() {
+    return this._weight;
+  }
+  get observer() {
+    return this._progressObserver || (this._progressObserver = (e) => {
+      this.set(e);
+    }), this._progressObserver;
+  }
+  get loadingListener() {
+    return this._loadingListener || (this._loadingListener = (e) => {
+      this.set(e.detail.loaded / e.detail.total * 100);
+    }), this._loadingListener;
+  }
+  pipe(e) {
+    e.setProgress({
+      progress: this.progress,
+      caption: this.caption
+    }), this.addEventListener("progress", (t) => {
+      e.setProgress({
+        progress: t.detail.progress,
+        caption: t.detail.caption
+      });
+    }), this.addEventListener("done", () => {
+      e.setLoaded();
+    });
+  }
+  addEventListener(e, t) {
+    super.addEventListener(e, t);
+  }
+  removeEventListener(e, t) {
+    super.removeEventListener(e, t);
+  }
+  notifyProgress() {
+    const e = this;
+    this.dispatchEvent(
+      new CustomEvent("progress", {
+        detail: {
+          get progress() {
+            return e.progress;
+          },
+          get caption() {
+            return e.caption;
+          }
+        }
+      })
+    );
+  }
+  notifyDone() {
+    this.dispatchEvent(new CustomEvent("done"));
+  }
+}
+const N = Symbol("error"), q = Symbol("message");
+class k 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[N] = t.error === void 0 ? null : t.error, this[q] = t.message === void 0 ? "" : t.message;
+  }
+  get error() {
+    return this[N];
+  }
+  get message() {
+    return this[q];
+  }
+}
+Object.defineProperty(k.prototype, "error", { enumerable: !0 });
+Object.defineProperty(k.prototype, "message", { enumerable: !0 });
+const He = typeof globalThis.ErrorEvent == "function" ? globalThis.ErrorEvent : k;
+class Ne 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 qe(r) {
+  r.asm = {
+    ...r.asm
+  };
+  const e = new Ne();
+  for (const t in r.asm)
+    if (typeof r.asm[t] == "function") {
+      const s = r.asm[t];
+      r.asm[t] = function(...n) {
+        try {
+          return s(...n);
+        } catch (i) {
+          if (!(i instanceof Error))
+            throw i;
+          if ("exitCode" in i && i?.exitCode === 0)
+            return;
+          const o = We(
+            i,
+            r.lastAsyncifyStackSource?.stack
+          );
+          if (r.lastAsyncifyStackSource && (i.cause = r.lastAsyncifyStackSource), !e.hasListeners())
+            throw ze(o), i;
+          e.dispatchEvent(
+            new He("error", {
+              error: i,
+              message: o
+            })
+          );
+        }
+      };
+    }
+  return e;
+}
+let T = [];
+function De() {
+  return T;
+}
+function We(r, e) {
+  if (r.message === "unreachable") {
+    let t = Me;
+    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 }).
+
+`), T = Be(
+      e || r.stack || ""
+    );
+    for (const s of T)
+      t += `    * ${s}
+`;
+    return t;
+  }
+  return r.message;
+}
+const Me = `
+"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: 
+
+`, D = "\x1B[41m", je = "\x1B[1m", W = "\x1B[0m", M = "\x1B[K";
+let j = !1;
+function ze(r) {
+  if (!j) {
+    j = !0, console.log(`${D}
+${M}
+${je}  WASM ERROR${W}${D}`);
+    for (const e of r.split(`
+`))
+      console.log(`${M}  ${e} `);
+    console.log(`${W}`);
+  }
+}
+function Be(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 $ {
+  constructor(e, t, s, n = "", i = 0) {
+    this.httpStatusCode = e, this.headers = t, this.bytes = s, this.exitCode = i, this.errors = n;
+  }
+  static fromRawData(e) {
+    return new $(
+      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);
+  }
+}
+const ee = [
+  "8.2",
+  "8.1",
+  "8.0",
+  "7.4",
+  "7.3",
+  "7.2",
+  "7.1",
+  "7.0",
+  "5.6"
+], Ge = ee[0];
+class Ve {
+  #e;
+  #t;
+  /**
+   * @param  server - The PHP server to browse.
+   * @param  config - The browser configuration.
+   */
+  constructor(e, t = {}) {
+    this.requestHandler = e, this.#e = {}, this.#t = {
+      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.#r()
+      }
+    });
+    if (s.headers["set-cookie"] && this.#s(s.headers["set-cookie"]), this.#t.handleRedirects && s.headers.location && t < this.#t.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;
+  }
+  #s(e) {
+    for (const t of e)
+      try {
+        if (!t.includes("="))
+          continue;
+        const s = t.indexOf("="), n = t.substring(0, s), i = t.substring(s + 1).split(";")[0];
+        this.#e[n] = i;
+      } catch (s) {
+        console.error(s);
+      }
+  }
+  #r() {
+    const e = [];
+    for (const t in this.#e)
+      e.push(`${t}=${this.#e[t]}`);
+    return e.join("; ");
+  }
+}
+const Je = "http://example.com";
+function z(r) {
+  return r.toString().substring(r.origin.length);
+}
+function B(r, e) {
+  return !e || !r.startsWith(e) ? r : r.substring(e.length);
+}
+function Ke(r, e) {
+  return !e || r.startsWith(e) ? r : e + r;
+}
+class Ye {
+  #e;
+  #t;
+  #s;
+  #r;
+  #i;
+  #n;
+  #o;
+  #a;
+  #c;
+  /**
+   * @param  php    - The PHP instance.
+   * @param  config - Request Handler configuration.
+   */
+  constructor(e, t = {}) {
+    this.#a = new Y({ concurrency: 1 });
+    const {
+      documentRoot: s = "/www/",
+      absoluteUrl: n = typeof location == "object" ? location?.href : "",
+      isStaticFilePath: i = () => !1
+    } = t;
+    this.php = e, this.#e = s, this.#c = i;
+    const o = new URL(n);
+    this.#s = o.hostname, this.#r = o.port ? Number(o.port) : o.protocol === "https:" ? 443 : 80, this.#t = (o.protocol || "").replace(":", "");
+    const a = this.#r !== 443 && this.#r !== 80;
+    this.#i = [
+      this.#s,
+      a ? `:${this.#r}` : ""
+    ].join(""), this.#n = o.pathname.replace(/\/+$/, ""), this.#o = [
+      `${this.#t}://`,
+      this.#i,
+      this.#n
+    ].join("");
+  }
+  /** @inheritDoc */
+  pathToInternalUrl(e) {
+    return `${this.absoluteUrl}${e}`;
+  }
+  /** @inheritDoc */
+  internalUrlToPath(e) {
+    const t = new URL(e);
+    return t.pathname.startsWith(this.#n) && (t.pathname = t.pathname.slice(this.#n.length)), z(t);
+  }
+  get isRequestRunning() {
+    return this.#a.running > 0;
+  }
+  /** @inheritDoc */
+  get absoluteUrl() {
+    return this.#o;
+  }
+  /** @inheritDoc */
+  get documentRoot() {
+    return this.#e;
+  }
+  /** @inheritDoc */
+  async request(e) {
+    const t = e.url.startsWith("http://") || e.url.startsWith("https://"), s = new URL(
+      e.url,
+      t ? void 0 : Je
+    ), n = B(
+      s.pathname,
+      this.#n
+    );
+    return this.#c(n) ? this.#l(n) : await this.#u(e, s);
+  }
+  /**
+   * Serves a static file from the PHP filesystem.
+   *
+   * @param  path - The requested static file path.
+   * @returns The response.
+   */
+  #l(e) {
+    const t = `${this.#e}${e}`;
+    if (!this.php.fileExists(t))
+      return new $(
+        404,
+        {},
+        new TextEncoder().encode("404 File not found")
+      );
+    const s = this.php.readFileAsBuffer(t);
+    return new $(
+      200,
+      {
+        "content-length": [`${s.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": [Qe(t)],
+        "accept-ranges": ["bytes"],
+        "cache-control": ["public, max-age=0"]
+      },
+      s
+    );
+  }
+  /**
+   * Runs the requested PHP file with all the request and $_SERVER
+   * superglobals populated.
+   *
+   * @param  request - The request.
+   * @returns The response.
+   */
+  async #u(e, t) {
+    const s = await this.#a.acquire();
+    try {
+      this.php.addServerGlobalEntry("DOCUMENT_ROOT", this.#e), this.php.addServerGlobalEntry(
+        "HTTPS",
+        this.#o.startsWith("https://") ? "on" : ""
+      );
+      let n = "GET";
+      const i = {
+        host: this.#i,
+        ...te(e.headers || {})
+      }, o = [];
+      if (e.files && Object.keys(e.files).length) {
+        n = "POST";
+        for (const c in e.files) {
+          const u = e.files[c];
+          o.push({
+            key: c,
+            name: u.name,
+            type: u.type,
+            data: new Uint8Array(await u.arrayBuffer())
+          });
+        }
+        i["content-type"]?.startsWith("multipart/form-data") && (e.formData = Ze(
+          e.body || ""
+        ), i["content-type"] = "application/x-www-form-urlencoded", delete e.body);
+      }
+      let a;
+      return e.formData !== void 0 ? (n = "POST", i["content-type"] = i["content-type"] || "application/x-www-form-urlencoded", a = new URLSearchParams(
+        e.formData
+      ).toString()) : a = e.body, await this.php.run({
+        relativeUri: Ke(
+          z(t),
+          this.#n
+        ),
+        protocol: this.#t,
+        method: e.method || n,
+        body: a,
+        fileInfos: o,
+        scriptPath: this.#h(t.pathname),
+        headers: i
+      });
+    } finally {
+      s();
+    }
+  }
+  /**
+   * 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 t = B(e, this.#n);
+    t.includes(".php") ? t = t.split(".php")[0] + ".php" : (t.endsWith("/") || (t += "/"), t.endsWith("index.php") || (t += "index.php"));
+    const s = `${this.#e}${t}`;
+    return this.php.fileExists(s) ? s : `${this.#e}/index.php`;
+  }
+}
+function Ze(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((i) => {
+    const o = i.indexOf(`\r
+\r
+`), a = i.substring(0, o).trim(), c = i.substring(o + 4).trim(), u = a.match(/name="([^"]+)"/);
+    if (u) {
+      const h = u[1];
+      e[h] = c;
+    }
+  }), e;
+}
+function Qe(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";
+  }
+}
+const G = {
+  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 f(r = "") {
+  return function(t, s, n) {
+    const i = n.value;
+    n.value = function(...o) {
+      try {
+        return i.apply(this, o);
+      } catch (a) {
+        const c = typeof a == "object" ? a?.errno : null;
+        if (c in G) {
+          const u = G[c], h = typeof o[0] == "string" ? o[0] : null, d = h !== null ? r.replaceAll("{path}", h) : r;
+          throw new Error(`${d}: ${u}`, {
+            cause: a
+          });
+        }
+        throw a;
+      }
+    };
+  };
+}
+const Xe = [];
+function et(r) {
+  return Xe[r];
+}
+(function() {
+  return typeof process < "u" && process.release?.name === "node" ? "NODE" : typeof window < "u" ? "WEB" : typeof WorkerGlobalScope < "u" && self instanceof WorkerGlobalScope ? "WORKER" : "NODE";
+})();
+var tt = Object.defineProperty, rt = Object.getOwnPropertyDescriptor, m = (r, e, t, s) => {
+  for (var n = s > 1 ? void 0 : s ? rt(e, t) : e, i = r.length - 1, o; i >= 0; i--)
+    (o = r[i]) && (n = (s ? o(e, t, n) : o(n)) || n);
+  return s && n && tt(e, t, n), n;
+};
+const p = "string", P = "number", l = Symbol("__private__dont__use");
+class w {
+  /**
+   * 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) {
+    this.#e = [], this.#t = !1, this.#s = null, this.#r = {}, e !== void 0 && this.initializeRuntime(e), t && (this.requestHandler = new Ve(
+      new Ye(this, t)
+    ));
+  }
+  #e;
+  #t;
+  #s;
+  #r;
+  /** @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 = et(e);
+    if (!t)
+      throw new Error("Invalid PHP runtime id.");
+    this[l] = t, this.#s = qe(t);
+  }
+  /** @inheritDoc */
+  setPhpIniPath(e) {
+    if (this.#t)
+      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 (this.#t)
+      throw new Error("Cannot set PHP ini entries after calling run().");
+    this.#e.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) {
+    this.#t || (this.#i(), this.#t = !0), this.#h(e.scriptPath || ""), this.#o(e.relativeUri || ""), this.#c(e.method || "GET");
+    const { host: t, ...s } = {
+      host: "example.com:443",
+      ...te(e.headers || {})
+    };
+    if (this.#a(t, e.protocol || "http"), this.#l(s), e.body && this.#u(e.body), e.fileInfos)
+      for (const n of e.fileInfos)
+        this.#d(n);
+    return e.code && this.#f(" ?>" + e.code), this.#p(), await this.#m();
+  }
+  #i() {
+    if (this.#e.length > 0) {
+      const e = this.#e.map(([t, s]) => `${t}=${s}`).join(`
+`) + `
+
+`;
+      this[l].ccall(
+        "wasm_set_phpini_entries",
+        null,
+        [p],
+        [e]
+      );
+    }
+    this[l].ccall("php_wasm_init", null, [], []);
+  }
+  #n() {
+    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 i = n.indexOf(": "), o = n.substring(0, i).toLowerCase(), a = n.substring(i + 2);
+      o in s || (s[o] = []), s[o].push(a);
+    }
+    return {
+      headers: s,
+      httpStatusCode: t.status
+    };
+  }
+  #o(e) {
+    if (this[l].ccall(
+      "wasm_set_request_uri",
+      null,
+      [p],
+      [e]
+    ), e.includes("?")) {
+      const t = e.substring(e.indexOf("?") + 1);
+      this[l].ccall(
+        "wasm_set_query_string",
+        null,
+        [p],
+        [t]
+      );
+    }
+  }
+  #a(e, t) {
+    this[l].ccall(
+      "wasm_set_request_host",
+      null,
+      [p],
+      [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,
+      [P],
+      [s]
+    ), (t === "https" || !t && s === 443) && this.addServerGlobalEntry("HTTPS", "on");
+  }
+  #c(e) {
+    this[l].ccall(
+      "wasm_set_request_method",
+      null,
+      [p],
+      [e]
+    );
+  }
+  #l(e) {
+    e.cookie && this[l].ccall(
+      "wasm_set_cookies",
+      null,
+      [p],
+      [e.cookie]
+    ), e["content-type"] && this[l].ccall(
+      "wasm_set_content_type",
+      null,
+      [p],
+      [e["content-type"]]
+    ), e["content-length"] && this[l].ccall(
+      "wasm_set_content_length",
+      null,
+      [P],
+      [parseInt(e["content-length"], 10)]
+    );
+    for (const t in e)
+      this.addServerGlobalEntry(
+        `HTTP_${t.toUpperCase().replace(/-/g, "_")}`,
+        e[t]
+      );
+  }
+  #u(e) {
+    this[l].ccall(
+      "wasm_set_request_body",
+      null,
+      [p],
+      [e]
+    ), this[l].ccall(
+      "wasm_set_content_length",
+      null,
+      [P],
+      [new TextEncoder().encode(e).length]
+    );
+  }
+  #h(e) {
+    this[l].ccall(
+      "wasm_set_path_translated",
+      null,
+      [p],
+      [e]
+    );
+  }
+  addServerGlobalEntry(e, t) {
+    this.#r[e] = t;
+  }
+  #p() {
+    for (const e in this.#r)
+      this[l].ccall(
+        "wasm_add_SERVER_entry",
+        null,
+        [p, p],
+        [e, this.#r[e]]
+      );
+  }
+  /**
+   * 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
+   */
+  #d(e) {
+    const { key: t, name: s, type: n, data: i } = e, o = `/tmp/${Math.random().toFixed(20)}`;
+    this.writeFile(o, i);
+    const a = 0;
+    this[l].ccall(
+      "wasm_add_uploaded_file",
+      null,
+      [p, p, p, p, P, P],
+      [t, s, n, o, a, i.byteLength]
+    );
+  }
+  #f(e) {
+    this[l].ccall(
+      "wasm_set_php_code",
+      null,
+      [p],
+      [e]
+    );
+  }
+  async #m() {
+    let e, t;
+    try {
+      e = await new Promise(async (i, o) => {
+        t = (a) => {
+          const c = new Error("Rethrown");
+          c.cause = a.error, c.betterMessage = a.message, o(c);
+        }, this.#s?.addEventListener(
+          "error",
+          t
+        );
+        try {
+          i(
+            /**
+             * This is awkward, but Asyncify makes wasm_sapi_handle_request return
+             * Promise<Promise<number>>.
+             *
+             * @TODO: Determine whether this is a bug in emscripten or in our code.
+             */
+            await await this[l].ccall(
+              "wasm_sapi_handle_request",
+              P,
+              [],
+              []
+            )
+          );
+        } catch (a) {
+          o(a);
+        }
+      });
+    } catch (i) {
+      for (const u in this)
+        typeof this[u] == "function" && (this[u] = () => {
+          throw new Error(
+            "PHP runtime has crashed – see the earlier error for details."
+          );
+        });
+      this.functionsMaybeMissingFromAsyncify = De();
+      const o = i, a = "betterMessage" in o ? o.betterMessage : o.message, c = new Error(a);
+      throw c.cause = o, c;
+    } finally {
+      this.#s?.removeEventListener("error", t), this.#r = {};
+    }
+    const { headers: s, httpStatusCode: n } = this.#n();
+    return new $(
+      n,
+      s,
+      this.readFileAsBuffer("/tmp/stdout"),
+      this.readFileAsText("/tmp/stderr"),
+      e
+    );
+  }
+  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.mv(e, t);
+  }
+  rmdir(e, t = { recursive: !0 }) {
+    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) {
+    if (!this.fileExists(e))
+      return [];
+    try {
+      return this[l].FS.readdir(e).filter(
+        (t) => t !== "." && t !== ".."
+      );
+    } catch (t) {
+      return console.error(t, { 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;
+    }
+  }
+}
+m([
+  f('Could not create directory "{path}"')
+], w.prototype, "mkdir", 1);
+m([
+  f('Could not create directory "{path}"')
+], w.prototype, "mkdirTree", 1);
+m([
+  f('Could not read "{path}"')
+], w.prototype, "readFileAsText", 1);
+m([
+  f('Could not read "{path}"')
+], w.prototype, "readFileAsBuffer", 1);
+m([
+  f('Could not write to "{path}"')
+], w.prototype, "writeFile", 1);
+m([
+  f('Could not unlink "{path}"')
+], w.prototype, "unlink", 1);
+m([
+  f('Could not move "{path}"')
+], w.prototype, "mv", 1);
+m([
+  f('Could not remove directory "{path}"')
+], w.prototype, "rmdir", 1);
+m([
+  f('Could not list files in "{path}"')
+], w.prototype, "listFiles", 1);
+m([
+  f('Could not stat "{path}"')
+], w.prototype, "isDir", 1);
+m([
+  f('Could not stat "{path}"')
+], w.prototype, "fileExists", 1);
+function te(r) {
+  const e = {};
+  for (const t in r)
+    e[t.toLowerCase()] = r[t];
+  return e;
+}
+const st = [
+  "vfs",
+  "literal",
+  "wordpress.org/themes",
+  "wordpress.org/plugins",
+  "url"
+];
+function nt(r) {
+  return r && typeof r == "object" && typeof r.resource == "string" && st.includes(r.resource);
+}
+class y {
+  /**
+   * Creates a new Resource based on the given file reference
+   *
+   * @param ref The file reference to create the Resource for
+   * @param options Additional options for the Resource
+   * @returns A new Resource instance
+   */
+  static create(e, { semaphore: t, progress: s }) {
+    let n;
+    switch (e.resource) {
+      case "vfs":
+        n = new it(e, s);
+        break;
+      case "literal":
+        n = new ot(e, s);
+        break;
+      case "wordpress.org/themes":
+        n = new lt(e, s);
+        break;
+      case "wordpress.org/plugins":
+        n = new ut(e, s);
+        break;
+      case "url":
+        n = new ct(e, s);
+        break;
+      default:
+        throw new Error(`Invalid resource: ${e}`);
+    }
+    return n = new ht(n), t && (n = new pt(n, t)), n;
+  }
+  setPlayground(e) {
+    this.playground = e;
+  }
+  /** Whether this Resource is loaded asynchronously */
+  get isAsync() {
+    return !1;
+  }
+}
+class it extends y {
+  /**
+   * Creates a new instance of `VFSResource`.
+   * @param playground The playground client.
+   * @param resource The VFS reference.
+   * @param progress The progress tracker.
+   */
+  constructor(e, t) {
+    super(), this.resource = e, this.progress = t;
+  }
+  /** @inheritDoc */
+  async resolve() {
+    const e = await this.playground.readFileAsBuffer(
+      this.resource.path
+    );
+    return this.progress?.set(100), new File([e], this.name);
+  }
+  /** @inheritDoc */
+  get name() {
+    return this.resource.path;
+  }
+}
+class ot extends y {
+  /**
+   * Creates a new instance of `LiteralResource`.
+   * @param resource The literal reference.
+   * @param progress The progress tracker.
+   */
+  constructor(e, t) {
+    super(), this.resource = e, this.progress = t;
+  }
+  /** @inheritDoc */
+  async resolve() {
+    return this.progress?.set(100), new File([this.resource.contents], this.resource.name);
+  }
+  /** @inheritDoc */
+  get name() {
+    return this.resource.name;
+  }
+}
+class C extends y {
+  /**
+   * Creates a new instance of `FetchResource`.
+   * @param progress The progress tracker.
+   */
+  constructor(e) {
+    super(), this.progress = e;
+  }
+  /** @inheritDoc */
+  async resolve() {
+    this.progress?.setCaption(this.caption);
+    const e = this.getURL();
+    let t = await fetch(e);
+    if (t = await Le(
+      t,
+      this.progress?.loadingListener ?? at
+    ), t.status !== 200)
+      throw new Error(`Could not download "${e}"`);
+    return new File([await t.blob()], this.name);
+  }
+  /**
+   * Gets the caption for the progress tracker.
+   * @returns The caption.
+   */
+  get caption() {
+    return `Downloading ${this.name}`;
+  }
+  /** @inheritDoc */
+  get name() {
+    try {
+      return new URL(this.getURL(), "http://example.com").pathname.split("/").pop();
+    } catch {
+      return this.getURL();
+    }
+  }
+  /** @inheritDoc */
+  get isAsync() {
+    return !0;
+  }
+}
+const at = () => {
+};
+class ct extends C {
+  /**
+   * Creates a new instance of `UrlResource`.
+   * @param resource The URL reference.
+   * @param progress The progress tracker.
+   */
+  constructor(e, t) {
+    super(t), this.resource = e;
+  }
+  /** @inheritDoc */
+  getURL() {
+    return this.resource.url;
+  }
+  /** @inheritDoc */
+  get caption() {
+    return this.resource.caption ?? super.caption;
+  }
+}
+let U = "https://playground.wordpress.net/plugin-proxy";
+function gt(r) {
+  U = r;
+}
+class lt extends C {
+  constructor(e, t) {
+    super(t), this.resource = e;
+  }
+  get name() {
+    return E(this.resource.slug);
+  }
+  getURL() {
+    const e = re(this.resource.slug);
+    return `${U}?theme=` + e;
+  }
+}
+class ut extends C {
+  constructor(e, t) {
+    super(t), this.resource = e;
+  }
+  /** @inheritDoc */
+  get name() {
+    return E(this.resource.slug);
+  }
+  /** @inheritDoc */
+  getURL() {
+    const e = re(this.resource.slug);
+    return `${U}?plugin=` + e;
+  }
+}
+function re(r) {
+  return !r || r.endsWith(".zip") ? r : r + ".latest-stable.zip";
+}
+class se extends y {
+  constructor(e) {
+    super(), this.resource = e;
+  }
+  /** @inheritDoc */
+  async resolve() {
+    return this.resource.resolve();
+  }
+  /** @inheritDoc */
+  async setPlayground(e) {
+    return this.resource.setPlayground(e);
+  }
+  /** @inheritDoc */
+  get progress() {
+    return this.resource.progress;
+  }
+  /** @inheritDoc */
+  set progress(e) {
+    this.resource.progress = e;
+  }
+  /** @inheritDoc */
+  get name() {
+    return this.resource.name;
+  }
+  /** @inheritDoc */
+  get isAsync() {
+    return this.resource.isAsync;
+  }
+}
+class ht extends se {
+  /** @inheritDoc */
+  async resolve() {
+    return this.promise || (this.promise = super.resolve()), this.promise;
+  }
+}
+class pt extends se {
+  constructor(e, t) {
+    super(e), this.semaphore = t;
+  }
+  /** @inheritDoc */
+  async resolve() {
+    return this.isAsync ? this.semaphore.run(() => super.resolve()) : super.resolve();
+  }
+}
+const dt = ["6.2", "6.1", "6.0", "5.9"];
+function yt(r, {
+  progress: e = new F(),
+  semaphore: t = new Y({ concurrency: 3 }),
+  onStepCompleted: s = () => {
+  }
+} = {}) {
+  const n = (r.steps || []).filter(ft), i = n.reduce(
+    (a, c) => a + (c.progress?.weight || 1),
+    0
+  ), o = n.map(
+    (a) => mt(a, {
+      semaphore: t,
+      rootProgressTracker: e,
+      totalProgressWeight: i
+    })
+  );
+  return {
+    versions: {
+      php: V(
+        r.preferredVersions?.php,
+        ee,
+        Ge
+      ),
+      wp: V(
+        r.preferredVersions?.wp,
+        dt,
+        "6.2"
+      )
+    },
+    run: async (a) => {
+      try {
+        for (const { resources: c } of o)
+          for (const u of c)
+            u.setPlayground(a), u.isAsync && u.resolve();
+        for (const { run: c, step: u } of o) {
+          const h = await c(a);
+          s(h, u);
+        }
+        try {
+          await a.goTo(
+            r.landingPage || "/"
+          );
+        } catch {
+        }
+      } finally {
+        e.finish();
+      }
+    }
+  };
+}
+function V(r, e, t) {
+  return r && e.includes(r) ? r : t;
+}
+function ft(r) {
+  return !!(typeof r == "object" && r);
+}
+function mt(r, {
+  semaphore: e,
+  rootProgressTracker: t,
+  totalProgressWeight: s
+}) {
+  const n = t.stage(
+    (r.progress?.weight || 1) / s
+  ), i = {};
+  for (const h of Object.keys(r)) {
+    let d = r[h];
+    nt(d) && (d = y.create(d, {
+      semaphore: e
+    })), i[h] = d;
+  }
+  const o = async (h) => {
+    try {
+      return n.fillSlowly(), await Ae[r.step](
+        h,
+        await wt(i),
+        {
+          tracker: n,
+          initialCaption: r.progress?.caption
+        }
+      );
+    } finally {
+      n.finish();
+    }
+  }, a = J(i), c = J(i).filter(
+    (h) => h.isAsync
+  ), u = 1 / (c.length + 1);
+  for (const h of c)
+    h.progress = n.stage(u);
+  return { run: o, step: r, resources: a };
+}
+function J(r) {
+  const e = [];
+  for (const t in r) {
+    const s = r[t];
+    s instanceof y && e.push(s);
+  }
+  return e;
+}
+async function wt(r) {
+  const e = {};
+  for (const t in r) {
+    const s = r[t];
+    s instanceof y ? e[t] = await s.resolve() : e[t] = s;
+  }
+  return e;
+}
+async function Pt(r, e) {
+  await r.run(e);
+}
+export {
+  ae as activatePlugin,
+  ce as applyWordPressPatches,
+  yt as compileBlueprint,
+  fe as cp,
+  _e as defineSiteUrl,
+  Oe as defineVirtualWpConfigConsts,
+  K as defineWpConfigConsts,
+  Se as importFile,
+  Te as installPlugin,
+  xe as installTheme,
+  Fe as login,
+  we as mkdir,
+  me as mv,
+  ve as replaceSite,
+  de as request,
+  ge as rm,
+  ye as rmdir,
+  Pt as runBlueprintSteps,
+  ue as runPHP,
+  he as runPHPWithOptions,
+  ke as runWpInstallationWizard,
+  pe as setPhpIniEntry,
+  gt as setPluginProxyURL,
+  Ce as setSiteOptions,
+  Z as unzip,
+  Ue as updateUserMeta,
+  Pe as writeFile,
+  $e as zipEntireSite
+};