@stlite/desktop 0.98.1 → 0.99.1

package/build/assets/worker-DSGzx9v2-CeEZF0Hz.js

@@ -0,0 +1,773 @@
+function te(o) {
+  return o && o.__esModule && Object.prototype.hasOwnProperty.call(o, "default") ? o.default : o;
+}
+var O, $;
+function re() {
+  if ($) return O;
+  $ = 1;
+  function o(i) {
+    if (typeof i != "string")
+      throw new TypeError("Path must be a string. Received " + JSON.stringify(i));
+  }
+  function c(i, e) {
+    for (var t = "", s = 0, a = -1, d = 0, r, l = 0; l <= i.length; ++l) {
+      if (l < i.length)
+        r = i.charCodeAt(l);
+      else {
+        if (r === 47)
+          break;
+        r = 47;
+      }
+      if (r === 47) {
+        if (!(a === l - 1 || d === 1)) if (a !== l - 1 && d === 2) {
+          if (t.length < 2 || s !== 2 || t.charCodeAt(t.length - 1) !== 46 || t.charCodeAt(t.length - 2) !== 46) {
+            if (t.length > 2) {
+              var u = t.lastIndexOf("/");
+              if (u !== t.length - 1) {
+                u === -1 ? (t = "", s = 0) : (t = t.slice(0, u), s = t.length - 1 - t.lastIndexOf("/")), a = l, d = 0;
+                continue;
+              }
+            } else if (t.length === 2 || t.length === 1) {
+              t = "", s = 0, a = l, d = 0;
+              continue;
+            }
+          }
+          e && (t.length > 0 ? t += "/.." : t = "..", s = 2);
+        } else
+          t.length > 0 ? t += "/" + i.slice(a + 1, l) : t = i.slice(a + 1, l), s = l - a - 1;
+        a = l, d = 0;
+      } else r === 46 && d !== -1 ? ++d : d = -1;
+    }
+    return t;
+  }
+  function m(i, e) {
+    var t = e.dir || e.root, s = e.base || (e.name || "") + (e.ext || "");
+    return t ? t === e.root ? t + s : t + i + s : s;
+  }
+  var g = {
+    // path.resolve([from ...], to)
+    resolve: function() {
+      for (var e = "", t = !1, s, a = arguments.length - 1; a >= -1 && !t; a--) {
+        var d;
+        a >= 0 ? d = arguments[a] : (s === void 0 && (s = process.cwd()), d = s), o(d), d.length !== 0 && (e = d + "/" + e, t = d.charCodeAt(0) === 47);
+      }
+      return e = c(e, !t), t ? e.length > 0 ? "/" + e : "/" : e.length > 0 ? e : ".";
+    },
+    normalize: function(e) {
+      if (o(e), e.length === 0) return ".";
+      var t = e.charCodeAt(0) === 47, s = e.charCodeAt(e.length - 1) === 47;
+      return e = c(e, !t), e.length === 0 && !t && (e = "."), e.length > 0 && s && (e += "/"), t ? "/" + e : e;
+    },
+    isAbsolute: function(e) {
+      return o(e), e.length > 0 && e.charCodeAt(0) === 47;
+    },
+    join: function() {
+      if (arguments.length === 0)
+        return ".";
+      for (var e, t = 0; t < arguments.length; ++t) {
+        var s = arguments[t];
+        o(s), s.length > 0 && (e === void 0 ? e = s : e += "/" + s);
+      }
+      return e === void 0 ? "." : g.normalize(e);
+    },
+    relative: function(e, t) {
+      if (o(e), o(t), e === t || (e = g.resolve(e), t = g.resolve(t), e === t)) return "";
+      for (var s = 1; s < e.length && e.charCodeAt(s) === 47; ++s)
+        ;
+      for (var a = e.length, d = a - s, r = 1; r < t.length && t.charCodeAt(r) === 47; ++r)
+        ;
+      for (var l = t.length, u = l - r, k = d < u ? d : u, w = -1, y = 0; y <= k; ++y) {
+        if (y === k) {
+          if (u > k) {
+            if (t.charCodeAt(r + y) === 47)
+              return t.slice(r + y + 1);
+            if (y === 0)
+              return t.slice(r + y);
+          } else d > k && (e.charCodeAt(s + y) === 47 ? w = y : y === 0 && (w = 0));
+          break;
+        }
+        var P = e.charCodeAt(s + y), R = t.charCodeAt(r + y);
+        if (P !== R)
+          break;
+        P === 47 && (w = y);
+      }
+      var b = "";
+      for (y = s + w + 1; y <= a; ++y)
+        (y === a || e.charCodeAt(y) === 47) && (b.length === 0 ? b += ".." : b += "/..");
+      return b.length > 0 ? b + t.slice(r + w) : (r += w, t.charCodeAt(r) === 47 && ++r, t.slice(r));
+    },
+    _makeLong: function(e) {
+      return e;
+    },
+    dirname: function(e) {
+      if (o(e), e.length === 0) return ".";
+      for (var t = e.charCodeAt(0), s = t === 47, a = -1, d = !0, r = e.length - 1; r >= 1; --r)
+        if (t = e.charCodeAt(r), t === 47) {
+          if (!d) {
+            a = r;
+            break;
+          }
+        } else
+          d = !1;
+      return a === -1 ? s ? "/" : "." : s && a === 1 ? "//" : e.slice(0, a);
+    },
+    basename: function(e, t) {
+      if (t !== void 0 && typeof t != "string") throw new TypeError('"ext" argument must be a string');
+      o(e);
+      var s = 0, a = -1, d = !0, r;
+      if (t !== void 0 && t.length > 0 && t.length <= e.length) {
+        if (t.length === e.length && t === e) return "";
+        var l = t.length - 1, u = -1;
+        for (r = e.length - 1; r >= 0; --r) {
+          var k = e.charCodeAt(r);
+          if (k === 47) {
+            if (!d) {
+              s = r + 1;
+              break;
+            }
+          } else
+            u === -1 && (d = !1, u = r + 1), l >= 0 && (k === t.charCodeAt(l) ? --l === -1 && (a = r) : (l = -1, a = u));
+        }
+        return s === a ? a = u : a === -1 && (a = e.length), e.slice(s, a);
+      } else {
+        for (r = e.length - 1; r >= 0; --r)
+          if (e.charCodeAt(r) === 47) {
+            if (!d) {
+              s = r + 1;
+              break;
+            }
+          } else a === -1 && (d = !1, a = r + 1);
+        return a === -1 ? "" : e.slice(s, a);
+      }
+    },
+    extname: function(e) {
+      o(e);
+      for (var t = -1, s = 0, a = -1, d = !0, r = 0, l = e.length - 1; l >= 0; --l) {
+        var u = e.charCodeAt(l);
+        if (u === 47) {
+          if (!d) {
+            s = l + 1;
+            break;
+          }
+          continue;
+        }
+        a === -1 && (d = !1, a = l + 1), u === 46 ? t === -1 ? t = l : r !== 1 && (r = 1) : t !== -1 && (r = -1);
+      }
+      return t === -1 || a === -1 || // We saw a non-dot character immediately before the dot
+      r === 0 || // The (right-most) trimmed path component is exactly '..'
+      r === 1 && t === a - 1 && t === s + 1 ? "" : e.slice(t, a);
+    },
+    format: function(e) {
+      if (e === null || typeof e != "object")
+        throw new TypeError('The "pathObject" argument must be of type Object. Received type ' + typeof e);
+      return m("/", e);
+    },
+    parse: function(e) {
+      o(e);
+      var t = { root: "", dir: "", base: "", ext: "", name: "" };
+      if (e.length === 0) return t;
+      var s = e.charCodeAt(0), a = s === 47, d;
+      a ? (t.root = "/", d = 1) : d = 0;
+      for (var r = -1, l = 0, u = -1, k = !0, w = e.length - 1, y = 0; w >= d; --w) {
+        if (s = e.charCodeAt(w), s === 47) {
+          if (!k) {
+            l = w + 1;
+            break;
+          }
+          continue;
+        }
+        u === -1 && (k = !1, u = w + 1), s === 46 ? r === -1 ? r = w : y !== 1 && (y = 1) : r !== -1 && (y = -1);
+      }
+      return r === -1 || u === -1 || // We saw a non-dot character immediately before the dot
+      y === 0 || // The (right-most) trimmed path component is exactly '..'
+      y === 1 && r === u - 1 && r === l + 1 ? u !== -1 && (l === 0 && a ? t.base = t.name = e.slice(1, u) : t.base = t.name = e.slice(l, u)) : (l === 0 && a ? (t.name = e.slice(1, r), t.base = e.slice(1, u)) : (t.name = e.slice(l, r), t.base = e.slice(l, u)), t.ext = e.slice(r, u)), l > 0 ? t.dir = e.slice(0, l - 1) : a && (t.dir = "/"), t;
+    },
+    sep: "/",
+    delimiter: ":",
+    win32: null,
+    posix: null
+  };
+  return g.posix = g, O = g, O;
+}
+var oe = re(), M = /* @__PURE__ */ te(oe);
+const N = "/home/pyodide", W = (o) => `${N}/${o}`, C = (o, c) => o == null ? M.resolve(N, c) : M.resolve(W(o), c);
+function z(o, c) {
+  const m = M.normalize(c), i = M.dirname(m).split(/(?=\/)/);
+  let e = "";
+  for (const t of i) {
+    e += t;
+    const s = o.FS.analyzePath(e);
+    if (s.exists && s.object) {
+      if (!o.FS.isDir(s.object.mode))
+        throw new Error(`"${e}" already exists and is not a directory.`);
+      continue;
+    }
+    try {
+      o.FS.mkdir(e);
+    } catch (a) {
+      throw console.error(`Failed to create a directory "${e}"`), a;
+    }
+  }
+}
+function x(o, c, m, g) {
+  z(o, c), o.FS.writeFile(c, m, g);
+}
+function ne(o, c, m) {
+  z(o, m), o.FS.rename(c, m);
+}
+const se = "[", ae = "(<=>!~", ie = ";", le = "@", ce = new RegExp(`[${se + ae + ie + le}]`);
+function de(o) {
+  return o.split(ce)[0].trim();
+}
+function q(o) {
+  return o.forEach((m) => {
+    let g;
+    try {
+      g = new URL(m);
+    } catch {
+      return;
+    }
+    if (g.protocol === "emfs:" || g.protocol === "file:")
+      throw new Error(`"emfs:" and "file:" protocols are not allowed for the requirement (${m})`);
+  }), o.filter((m) => de(m) === "streamlit" ? (console.warn(`Streamlit is specified in the requirements ("${m}"), but it will be ignored. A built-in version of Streamlit will be used.`), !1) : !0);
+}
+async function ue(o) {
+  const c = typeof process < "u" && process.versions?.node;
+  let m;
+  c ? m = (await import(
+    /* webpackIgnore: true */
+    "./__vite-browser-external-CPvbk0mb.js"
+  )).sep : m = "/";
+  const g = o.slice(0, o.lastIndexOf(m) + 1);
+  if (o.endsWith(".mjs")) {
+    if (c) {
+      const i = await import(
+        /* webpackIgnore: true */
+        "./__vite-browser-external-CPvbk0mb.js"
+      ), e = await import(
+        /* webpackIgnore: true */
+        "./__vite-browser-external-CPvbk0mb.js"
+      );
+      !o.includes("://") && i.isAbsolute(o) && (o = e.pathToFileURL(o).href);
+    }
+    return {
+      scriptURL: o,
+      pyodideIndexURL: g,
+      isESModule: !0
+    };
+  } else
+    return {
+      scriptURL: o,
+      pyodideIndexURL: g,
+      isESModule: !1
+    };
+}
+async function ge(o, c) {
+  const { scriptURL: m, pyodideIndexURL: g, isESModule: i } = await ue(o);
+  let e;
+  return i ? e = (await import(
+    /* webpackIgnore: true */
+    /* @vite-ignore */
+    m
+  )).loadPyodide : (importScripts(m), e = self.loadPyodide), e({ ...c, indexURL: g });
+}
+function fe(o) {
+  o.runPython(`
+import micropip
+micropip.add_mock_package(
+    "pyarrow", "0.0.1",
+    modules={
+        "pyarrow": """
+__version__ = '0.0.1'  # TODO: Update when releasing
+
+
+class Table:
+    @classmethod
+    def from_pandas(*args, **kwargs):
+        raise NotImplementedError("stlite is not supporting this method.")
+
+
+class Array:
+    def __init__(self, *args, **kwargs):
+        raise NotImplementedError("stlite is not supporting PyArrow.Array")
+
+
+class ChunkedArray:
+    def __init__(self, *args, **kwargs):
+        raise NotImplementedError("stlite is not supporting PyArrow.ChunkedArray")
+"""
+    }
+)
+`);
+}
+function me(o, c, m) {
+  const g = o.pyimport("pyodide"), i = (r) => g.code.find_imports(r).toJs(), e = m.map((r) => i(r)), a = Array.from(new Set(e.flat())).filter((r) => !o.runPython(`__import__('importlib').util.find_spec('${r}')`)).map((r) => o._api._import_name_to_package_name.get(r)).filter((r) => r);
+  if (a.length === 0)
+    return Promise.resolve();
+  const d = o.loadPackage(a);
+  return c(a, d), d.then();
+}
+function K(o, c, m) {
+  const g = me(o, c, m);
+  o.runPython(`
+def __set_module_auto_load_promise__(promise):
+    from streamlit.runtime.scriptrunner import script_runner
+    script_runner.moduleAutoLoadPromise = promise
+
+__set_module_auto_load_promise__`)(g);
+}
+async function pe(o, c, m) {
+  const { line: g, column: i } = m, e = o.Script(c);
+  if (g > e._code_lines.length)
+    return [];
+  const t = e.complete.callKwargs({
+    line: g,
+    column: i,
+    fuzzy: !1
+  }), s = [];
+  for (const a of t.toJs())
+    s.push({
+      name: a.name,
+      type: a.$type,
+      // PyProxy.type is overridden in Pyodide. We need to access it this way. Ref: https://github.com/pyodide/pyodide/issues/4032
+      docstring: a.docstring.callKwargs({ raw: !0 }),
+      complete: a.complete
+    }), a.destroy();
+  return s;
+}
+let D = null, J = Promise.resolve(), j = !1;
+async function he(o, c, m, g, i) {
+  const { files: e, archives: t, requirements: s, prebuiltPackageNames: a, wheels: d, installs: r, pyodideUrl: l = o, streamlitConfig: u, idbfsMountpoints: k, nodefsMountpoints: w, moduleAutoLoad: y, env: P, languageServer: R } = m, b = q(s);
+  D ? (i("Pyodide is already loaded."), console.debug("Pyodide is already loaded.")) : (i("Loading Pyodide."), console.debug("Loading Pyodide."), D = ge(l, {
+    stdout: console.log,
+    stderr: console.error
+  }), console.debug("Loaded Pyodide"));
+  const n = (
+    // XXX: `{ FS: any }` is a temporary workaround to fix the type error.
+    await D
+  );
+  if (P) {
+    console.debug("Setting environment variables", P);
+    const f = n.pyimport("os");
+    f.environ.update(n.toPy(P)), console.debug("Set environment variables", f.environ);
+  }
+  let p = !1;
+  k && (p = !0, k.forEach((f) => {
+    n.FS.mkdir(f), n.FS.mount(n.FS.filesystems.IDBFS, {}, f);
+  }), await new Promise((f, _) => {
+    n.FS.syncfs(!0, (S) => {
+      S ? _(S) : f();
+    });
+  })), w && Object.entries(w).forEach(([f, _]) => {
+    n.FS.mkdir(f), n.FS.mount(n.FS.filesystems.NODEFS, { root: _ }, f);
+  }), i("Mounting files.");
+  const h = [];
+  await Promise.all(Object.keys(e).map(async (f) => {
+    const _ = e[f];
+    f = C(c, f);
+    let S;
+    "url" in _ ? (console.debug(`Fetch a file from ${_.url}`), S = await fetch(_.url).then((F) => F.arrayBuffer()).then((F) => new Uint8Array(F))) : S = _.data, console.debug(`Write a file "${f}"`), x(n, f, S, e.opts), f.endsWith(".py") && h.push(f);
+  })), i("Unpacking archives."), await Promise.all(t.map(async (f) => {
+    let _;
+    "url" in f ? (console.debug(`Fetch an archive from ${f.url}`), _ = await fetch(f.url).then((ee) => ee.arrayBuffer())) : _ = f.buffer;
+    const { format: S, options: F } = f;
+    console.debug("Unpack an archive", { format: S, options: F }), n.unpackArchive(_, S, F);
+  })), await n.loadPackage("micropip");
+  const v = n.pyimport("micropip");
+  i("Mocking some packages."), console.debug("Mock pyarrow"), fe(n), console.debug("Mocked pyarrow"), i("Installing packages."), console.debug("Installing the prebuilt packages:", a), await n.loadPackage(a), console.debug("Installed the prebuilt packages");
+  const L = async () => {
+    console.debug("Installing the packages:", {
+      requirements: b,
+      systemPackagesInstalled: j
+    });
+    const f = [];
+    j || (console.debug("System packages will be installed"), d && (f.push(d.streamlit), f.push(d.stliteLib)), R && f.push("jedi"));
+    const _ = [...f, ...b];
+    console.debug("Installing the packages:", _), await v.install.callKwargs(_, { keep_going: !0 }), f.length > 0 && (console.debug("Installed the system packages"), j = !0), console.debug("Installed the packages");
+  }, A = J.then(() => L());
+  if (J = A.catch((f) => {
+    console.error("Package installation failed:", f);
+  }), await A, r && (console.debug("Installing the additional requirements"), await Promise.all(r.map(({ requirements: f, options: _ }) => {
+    const S = q(f);
+    return console.debug("Installing the requirements:", S), v.install.callKwargs(S, _ ?? {});
+  }))), y) {
+    const f = h.map((_) => n.FS.readFile(_, { encoding: "utf8" }));
+    K(n, g, f);
+  }
+  await n.runPythonAsync(`
+import importlib
+importlib.invalidate_caches()
+`), i("Loading streamlit package."), console.debug("Loading the Streamlit package"), await n.runPythonAsync(`
+import streamlit.runtime
+  `), console.debug("Loaded the Streamlit package"), i("Setting up the loggers."), console.debug("Setting the loggers"), await n.runPythonAsync(`
+import logging
+import streamlit.logger
+
+streamlit.logger.get_logger = logging.getLogger
+streamlit.logger.setup_formatter = None
+streamlit.logger.update_formatter = lambda *a, **k: None
+streamlit.logger.set_log_level = lambda *a, **k: None
+
+for name in streamlit.logger._loggers.keys():
+    if name == "root":
+        name = "streamlit"
+    logger = logging.getLogger(name)
+    logger.propagate = True
+    logger.handlers.clear()
+    logger.setLevel(logging.NOTSET)
+
+streamlit.logger._loggers = {}
+`);
+  const E = (f, _) => {
+    f >= 40 ? console.error(_) : f >= 30 ? console.warn(_) : f >= 20 ? console.info(_) : console.debug(_);
+  }, I = n.runPython(`
+def __setup_loggers__(streamlit_level, streamlit_message_format, callback):
+    class JsHandler(logging.Handler):
+        def emit(self, record):
+            msg = self.format(record)
+            callback(record.levelno, msg)
+
+
+    root_message_format = "%(levelname)s:%(name)s:%(message)s"
+
+    root_logger = logging.getLogger()
+    root_logger.handlers.clear()
+    root_formatter = logging.Formatter(root_message_format)
+    root_handler = JsHandler()
+    root_handler.setFormatter(root_formatter)
+    root_logger.addHandler(root_handler)
+    root_logger.setLevel(logging.DEBUG)
+
+    streamlit_logger = logging.getLogger("streamlit")
+    streamlit_logger.propagate = False
+    streamlit_logger.handlers.clear()
+    streamlit_formatter = logging.Formatter(streamlit_message_format)
+    streamlit_handler = JsHandler()
+    streamlit_handler.setFormatter(streamlit_formatter)
+    streamlit_logger.addHandler(streamlit_handler)
+    streamlit_logger.setLevel(streamlit_level.upper())
+
+__setup_loggers__`), X = (u?.["logger.level"] ?? "INFO").toString(), Q = u?.["logger.messageFormat"] ?? "%(asctime)s %(message)s";
+  if (I(X, Q, E), console.debug("Set the loggers"), i("Mocking some Streamlit functions for the browser environment."), console.debug("Mocking some Streamlit functions"), await n.runPythonAsync(`
+import streamlit
+
+def is_cacheable_msg(msg):
+  return False
+
+streamlit.runtime.runtime.is_cacheable_msg = is_cacheable_msg
+`), console.debug("Mocked some Streamlit functions"), p) {
+    i("Setting up the IndexedDB filesystem synchronizer."), console.debug("Setting up the IndexedDB filesystem synchronizer");
+    let f = !1;
+    const _ = () => {
+      console.debug("The script has finished. Syncing the filesystem."), f || (f = !0, n.FS.syncfs(!1, (F) => {
+        f = !1, F && console.error(F);
+      }));
+    };
+    (await n.runPython(`
+def __setup_script_finished_callback__(callback):
+    from streamlit.runtime.app_session import AppSession
+    from streamlit.runtime.scriptrunner import ScriptRunnerEvent
+
+    def wrap_app_session_on_scriptrunner_event(original_method):
+        def wrapped(self, *args, **kwargs):
+            if "event" in kwargs:
+                event = kwargs["event"]
+                if event == ScriptRunnerEvent.SCRIPT_STOPPED_WITH_SUCCESS or event == ScriptRunnerEvent.SCRIPT_STOPPED_FOR_RERUN or event == ScriptRunnerEvent.SHUTDOWN:
+                    callback()
+            return original_method(self, *args, **kwargs)
+        return wrapped
+
+    AppSession._on_scriptrunner_event = wrap_app_session_on_scriptrunner_event(AppSession._on_scriptrunner_event)
+
+__setup_script_finished_callback__`))(_), console.debug("Set up the IndexedDB filesystem synchronizer");
+  }
+  console.debug("Setting up the Streamlit configuration");
+  const { load_config_options: V } = n.pyimport("stlite_lib.bootstrap"), Y = {
+    // gatherUsageStats is disabled as default, but can be enabled explicitly by setting it to true.
+    "browser.gatherUsageStats": !1,
+    ...u,
+    "runner.fastReruns": !1
+    // Fast reruns do not work well with the async script runner of stlite. See https://github.com/whitphx/stlite/pull/550#issuecomment-1505485865.
+  }, Z = c != null;
+  V(n.toPy(Y), Z), console.debug("Set up the Streamlit configuration");
+  let T;
+  if (R) {
+    i("Loading auto-completion engine."), console.debug("Loading Jedi");
+    try {
+      T = await n.pyimport("jedi"), console.debug("Loaded Jedi");
+    } catch (f) {
+      console.error("Failed to load Jedi:", f), T = void 0;
+    }
+  }
+  return {
+    pyodide: n,
+    micropip: v,
+    jedi: T,
+    initData: m
+  };
+}
+async function U(o, c, m) {
+  const g = C(c, m);
+  console.debug("Preparing the Streamlit environment");
+  const { prepare: i } = o.pyimport("stlite_lib.bootstrap");
+  i(g, []), console.debug("Prepared the Streamlit environment"), console.debug("Booting up the Streamlit server");
+  const t = o.pyimport("stlite_lib.server.Server")(g, c ? W(c) : void 0);
+  return await t.start(), console.debug("Booted up the Streamlit server"), t;
+}
+function B(o, c, m, g) {
+  function i(d) {
+    c({
+      type: "event:loadProgress",
+      data: {
+        message: d
+      }
+    });
+  }
+  const e = (d, r) => {
+    const l = new MessageChannel();
+    c({
+      type: "event:moduleAutoLoad",
+      data: {
+        packagesToLoad: d
+      }
+    }, [l.port2]), r.then((u) => {
+      l.port1.postMessage({
+        type: "moduleAutoLoad:success",
+        data: {
+          loadedPackages: u
+        }
+      }), l.port1.close();
+    }).catch((u) => {
+      throw l.port1.postMessage({
+        type: "moduleAutoLoad:error",
+        error: u
+      }), l.port1.close(), u;
+    });
+  };
+  let t = null, s = null;
+  const a = async (d) => {
+    const r = d.data;
+    if (r.type === "initData") {
+      const n = r.data, p = {
+        ...m,
+        ...n
+      };
+      console.debug("Initial data", p), t = he(o, g, p, e, i), t.then(({ pyodide: h }) => (i("Booting up the Streamlit server."), s = U(h, g, p.entrypoint), s)).then(() => {
+        c({
+          type: "event:loadFinished"
+        });
+      }).catch((h) => {
+        console.error(h), c({
+          type: "event:loadError",
+          data: {
+            error: h
+          }
+        });
+      });
+      return;
+    }
+    if (!t)
+      throw new Error("Pyodide initialization has not been started yet.");
+    if (!s)
+      throw new Error("Streamlit server has not been started yet.");
+    const l = await t, u = l.pyodide, k = l.micropip, w = l.jedi, { moduleAutoLoad: y } = l.initData, P = await s, R = d.ports[0];
+    function b(n) {
+      R.postMessage(n);
+    }
+    try {
+      switch (r.type) {
+        case "reboot": {
+          console.debug("Reboot the Streamlit server", r.data);
+          const { entrypoint: n } = r.data;
+          P.stop(), console.debug("Booting up the Streamlit server"), s = U(u, g, n), await s, console.debug("Booted up the Streamlit server"), b({
+            type: "reply"
+          });
+          break;
+        }
+        case "websocket:connect": {
+          console.debug("websocket:connect", r.data);
+          const { path: n } = r.data;
+          P.start_websocket(n, (p, h) => {
+            if (h) {
+              const v = p;
+              try {
+                const L = v.toJs(), A = L.buffer.slice(L.byteOffset, L.byteOffset + L.byteLength);
+                c({
+                  type: "websocket:message",
+                  data: {
+                    payload: A
+                  }
+                }, [A]);
+              } finally {
+                v.destroy();
+              }
+            } else
+              c({
+                type: "websocket:message",
+                data: {
+                  payload: p
+                }
+              });
+          }), b({
+            type: "reply"
+          });
+          break;
+        }
+        case "websocket:send": {
+          console.debug("websocket:send", r.data);
+          const { payload: n } = r.data;
+          P.receive_websocket_from_js(n);
+          break;
+        }
+        case "http:request": {
+          console.debug("http:request", r.data);
+          const { request: n } = r.data, p = (h, v, L) => {
+            const A = v.toJs(), E = A instanceof Map ? new Map(A) : new Map(Object.entries(A)), I = L.toJs();
+            console.debug({ statusCode: h, headers: E, body: I }), b({
+              type: "http:response",
+              data: {
+                response: {
+                  statusCode: h,
+                  headers: E,
+                  body: I
+                }
+              }
+            });
+          };
+          P.receive_http_from_js(n.method, decodeURIComponent(n.path), n.headers, n.body, p);
+          break;
+        }
+        case "file:write": {
+          const { path: n, data: p, opts: h } = r.data, v = C(g, n);
+          y && typeof p == "string" && v.endsWith(".py") && (console.debug(`Auto install the requirements in ${v}`), K(u, e, [p])), console.debug(`Write a file "${v}"`), x(u, v, p, h), b({
+            type: "reply"
+          });
+          break;
+        }
+        case "file:rename": {
+          const { oldPath: n, newPath: p } = r.data, h = C(g, n), v = C(g, p);
+          console.debug(`Rename "${h}" to ${v}`), ne(u, h, v), b({
+            type: "reply"
+          });
+          break;
+        }
+        case "file:unlink": {
+          const { path: n } = r.data, p = C(g, n);
+          console.debug(`Remove "${p}`), u.FS.unlink(p), b({
+            type: "reply"
+          });
+          break;
+        }
+        case "file:read": {
+          const { path: n, opts: p } = r.data;
+          console.debug(`Read "${n}"`);
+          const h = u.FS.readFile(n, p);
+          b({
+            type: "reply:file:read",
+            data: {
+              content: h
+            }
+          });
+          break;
+        }
+        case "install": {
+          const { requirements: n, options: p } = r.data, h = q(n);
+          console.debug("Install the requirements:", h), await k.install.callKwargs(h, p ?? {}).then(() => {
+            console.debug("Successfully installed"), b({
+              type: "reply"
+            });
+          });
+          break;
+        }
+        case "setEnv": {
+          const { env: n } = r.data;
+          u.pyimport("os").environ.update(u.toPy(n)), console.debug("Successfully set the environment variables", n), b({
+            type: "reply"
+          });
+          break;
+        }
+        case "code_completion": {
+          if (!w)
+            throw new Error("Jedi is not installed");
+          const { code: n, line: p, column: h } = r.data, v = await pe(w, n, {
+            line: p,
+            column: h
+          });
+          b({
+            type: "reply:code_completion",
+            data: {
+              codeCompletions: v
+            }
+          });
+          break;
+        }
+        case "run_python": {
+          const { code: n } = r.data;
+          console.debug("Run python code", n);
+          const p = await u.runPythonAsync(n);
+          let h;
+          p instanceof u.ffi.PyProxy ? (console.debug("The result is a PyProxy object"), h = p.toJs(), p.destroy(), console.debug("Converted the result to a JS object", h)) : (h = p, console.debug("The result is a JS primitive", h)), b({
+            type: "reply:run_python",
+            data: {
+              result: h
+            }
+          });
+          break;
+        }
+        case "add_mock_package": {
+          const { name: n, version: p, modules: h, persistent: v } = r.data;
+          console.debug("Add a mock package:", {
+            name: n,
+            version: p,
+            modules: h,
+            persistent: v
+          }), k.add_mock_package.callKwargs({
+            name: n,
+            version: p,
+            modules: u.toPy(h),
+            persistent: v
+          }), b({
+            type: "reply"
+          });
+          break;
+        }
+      }
+    } catch (n) {
+      if (console.error(n), !(n instanceof Error))
+        throw n;
+      const p = new Error(n.message);
+      p.name = n.name, p.stack = n.stack, b({
+        type: "reply",
+        error: p
+      });
+    }
+  };
+  return c({
+    type: "event:envSetup"
+  }), a;
+}
+const G = "abcdefghijklmnopqrstuvwxyz", ye = G.length;
+function _e(o) {
+  let c = "";
+  for (let m = 0; m < o; m++) {
+    const g = Math.floor(Math.random() * ye);
+    c += G[g];
+  }
+  return c;
+}
+const H = "https://cdn.jsdelivr.net/pyodide/v0.29.3/full/pyodide.mjs";
+if ("postMessage" in self)
+  self.onmessage = B(H, (o, c) => c ? self.postMessage(o, c) : self.postMessage(o));
+else {
+  const o = [];
+  self.onconnect = (c) => {
+    let m;
+    do
+      m = _e(4);
+    while (o.includes(m));
+    o.push(m), console.debug("SharedWorker mode.", { appId: m });
+    const g = c.ports[0];
+    g.onmessage = B(H, (i, e) => e ? g.postMessage(i, e) : g.postMessage(i), void 0, m), g.start();
+  };
+}
+//# sourceMappingURL=worker-DSGzx9v2.js.map