ss-component-new 1.3.736 → 1.3.737

package/dist/pyodide-Dc1Mu-0d.js

@@ -0,0 +1,489 @@
+var Ee = Object.defineProperty, s = (e, t) => Ee(e, "name", { value: t, configurable: !0 }), W = ((e) => typeof require < "u" ? require : typeof Proxy < "u" ? new Proxy(e, { get: (t, r) => (typeof require < "u" ? require : t)[r] }) : e)(function(e) {
+  if (typeof require < "u") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + e + '" is not supported');
+}), be = (() => {
+  for (var e = new Uint8Array(128), t = 0; t < 64; t++) e[t < 26 ? t + 65 : t < 52 ? t + 71 : t < 62 ? t - 4 : t * 4 - 205] = t;
+  return (r) => {
+    for (var a = r.length, i = new Uint8Array((a - (r[a - 1] == "=") - (r[a - 2] == "=")) * 3 / 4 | 0), n = 0, o = 0; n < a; ) {
+      var l = e[r.charCodeAt(n++)], c = e[r.charCodeAt(n++)], u = e[r.charCodeAt(n++)], d = e[r.charCodeAt(n++)];
+      i[o++] = l << 2 | c >> 4, i[o++] = c << 4 | u >> 2, i[o++] = u << 6 | d;
+    }
+    return i;
+  };
+})();
+function M(e) {
+  return !isNaN(parseFloat(e)) && isFinite(e);
+}
+s(M, "_isNumber");
+function g(e) {
+  return e.charAt(0).toUpperCase() + e.substring(1);
+}
+s(g, "_capitalize");
+function F(e) {
+  return function() {
+    return this[e];
+  };
+}
+s(F, "_getter");
+var N = ["isConstructor", "isEval", "isNative", "isToplevel"], _ = ["columnNumber", "lineNumber"], S = ["fileName", "functionName", "source"], Ne = ["args"], _e = ["evalOrigin"], k = N.concat(_, S, Ne, _e);
+function p(e) {
+  if (e) for (var t = 0; t < k.length; t++) e[k[t]] !== void 0 && this["set" + g(k[t])](e[k[t]]);
+}
+s(p, "StackFrame");
+p.prototype = { getArgs: s(function() {
+  return this.args;
+}, "getArgs"), setArgs: s(function(e) {
+  if (Object.prototype.toString.call(e) !== "[object Array]") throw new TypeError("Args must be an Array");
+  this.args = e;
+}, "setArgs"), getEvalOrigin: s(function() {
+  return this.evalOrigin;
+}, "getEvalOrigin"), setEvalOrigin: s(function(e) {
+  if (e instanceof p) this.evalOrigin = e;
+  else if (e instanceof Object) this.evalOrigin = new p(e);
+  else throw new TypeError("Eval Origin must be an Object or StackFrame");
+}, "setEvalOrigin"), toString: s(function() {
+  var e = this.getFileName() || "", t = this.getLineNumber() || "", r = this.getColumnNumber() || "", a = this.getFunctionName() || "";
+  return this.getIsEval() ? e ? "[eval] (" + e + ":" + t + ":" + r + ")" : "[eval]:" + t + ":" + r : a ? a + " (" + e + ":" + t + ":" + r + ")" : e + ":" + t + ":" + r;
+}, "toString") };
+p.fromString = s(function(e) {
+  var t = e.indexOf("("), r = e.lastIndexOf(")"), a = e.substring(0, t), i = e.substring(t + 1, r).split(","), n = e.substring(r + 1);
+  if (n.indexOf("@") === 0) var o = /@(.+?)(?::(\d+))?(?::(\d+))?$/.exec(n, ""), l = o[1], c = o[2], u = o[3];
+  return new p({ functionName: a, args: i || void 0, fileName: l, lineNumber: c || void 0, columnNumber: u || void 0 });
+}, "StackFrame$$fromString");
+for (w = 0; w < N.length; w++) p.prototype["get" + g(N[w])] = F(N[w]), p.prototype["set" + g(N[w])] = /* @__PURE__ */ function(e) {
+  return function(t) {
+    this[e] = !!t;
+  };
+}(N[w]);
+var w;
+for (v = 0; v < _.length; v++) p.prototype["get" + g(_[v])] = F(_[v]), p.prototype["set" + g(_[v])] = /* @__PURE__ */ function(e) {
+  return function(t) {
+    if (!M(t)) throw new TypeError(e + " must be a Number");
+    this[e] = Number(t);
+  };
+}(_[v]);
+var v;
+for (E = 0; E < S.length; E++) p.prototype["get" + g(S[E])] = F(S[E]), p.prototype["set" + g(S[E])] = /* @__PURE__ */ function(e) {
+  return function(t) {
+    this[e] = String(t);
+  };
+}(S[E]);
+var E, R = p;
+function B() {
+  var e = /^\s*at .*(\S+:\d+|\(native\))/m, t = /^(eval@)?(\[native code])?$/;
+  return { parse: s(function(r) {
+    if (r.stack && r.stack.match(e)) return this.parseV8OrIE(r);
+    if (r.stack) return this.parseFFOrSafari(r);
+    throw new Error("Cannot parse given Error object");
+  }, "ErrorStackParser$$parse"), extractLocation: s(function(r) {
+    if (r.indexOf(":") === -1) return [r];
+    var a = /(.+?)(?::(\d+))?(?::(\d+))?$/, i = a.exec(r.replace(/[()]/g, ""));
+    return [i[1], i[2] || void 0, i[3] || void 0];
+  }, "ErrorStackParser$$extractLocation"), parseV8OrIE: s(function(r) {
+    var a = r.stack.split(`
+`).filter(function(i) {
+      return !!i.match(e);
+    }, this);
+    return a.map(function(i) {
+      i.indexOf("(eval ") > -1 && (i = i.replace(/eval code/g, "eval").replace(/(\(eval at [^()]*)|(,.*$)/g, ""));
+      var n = i.replace(/^\s+/, "").replace(/\(eval code/g, "(").replace(/^.*?\s+/, ""), o = n.match(/ (\(.+\)$)/);
+      n = o ? n.replace(o[0], "") : n;
+      var l = this.extractLocation(o ? o[1] : n), c = o && n || void 0, u = ["eval", "<anonymous>"].indexOf(l[0]) > -1 ? void 0 : l[0];
+      return new R({ functionName: c, fileName: u, lineNumber: l[1], columnNumber: l[2], source: i });
+    }, this);
+  }, "ErrorStackParser$$parseV8OrIE"), parseFFOrSafari: s(function(r) {
+    var a = r.stack.split(`
+`).filter(function(i) {
+      return !i.match(t);
+    }, this);
+    return a.map(function(i) {
+      if (i.indexOf(" > eval") > -1 && (i = i.replace(/ line (\d+)(?: > eval line \d+)* > eval:\d+:\d+/g, ":$1")), i.indexOf("@") === -1 && i.indexOf(":") === -1) return new R({ functionName: i });
+      var n = /((.*".+"[^@]*)?[^@]*)(?:@)/, o = i.match(n), l = o && o[1] ? o[1] : void 0, c = this.extractLocation(i.replace(n, ""));
+      return new R({ functionName: l, fileName: c[0], lineNumber: c[1], columnNumber: c[2], source: i });
+    }, this);
+  }, "ErrorStackParser$$parseFFOrSafari") };
+}
+s(B, "ErrorStackParser");
+var Se = new B(), Ie = Se;
+function $() {
+  var o;
+  if (typeof API < "u" && API !== globalThis.API) return API.runtimeEnv;
+  let e = typeof Bun < "u", t = typeof Deno < "u", r = typeof process == "object" && typeof process.versions == "object" && typeof process.versions.node == "string" && !process.browser, a = typeof navigator == "object" && typeof navigator.userAgent == "string" && navigator.userAgent.indexOf("Chrome") === -1 && navigator.userAgent.indexOf("Safari") > -1, i = typeof read == "function" && typeof load == "function", n = typeof navigator == "object" && ((o = navigator.userAgent) == null ? void 0 : o.includes("Cloudflare-Workers"));
+  return j({ IN_BUN: e, IN_DENO: t, IN_NODE: r, IN_SAFARI: a, IN_SHELL: i, IN_WORKERD: n });
+}
+s($, "getGlobalRuntimeEnv");
+var m = $();
+function j(e) {
+  let t = e.IN_NODE && typeof module < "u" && module.exports && typeof W == "function" && typeof __dirname == "string", r = e.IN_NODE && !t, a = !e.IN_NODE && !e.IN_DENO && !e.IN_BUN, i = a && typeof window < "u" && typeof window.document < "u" && typeof document.createElement == "function" && "sessionStorage" in window && typeof globalThis.importScripts != "function", n = a && typeof globalThis.WorkerGlobalScope < "u" && typeof globalThis.self < "u" && globalThis.self instanceof globalThis.WorkerGlobalScope;
+  if (n && H()) throw new Error("Classic web workers are not supported");
+  let o = { ...e, IN_BROWSER: a, IN_BROWSER_MAIN_THREAD: i, IN_BROWSER_WEB_WORKER: n, IN_NODE_COMMONJS: t, IN_NODE_ESM: r };
+  if (!(o.IN_BROWSER_MAIN_THREAD || o.IN_BROWSER_WEB_WORKER || o.IN_NODE || o.IN_SHELL || o.IN_WORKERD)) throw new Error(`Cannot determine runtime environment: ${JSON.stringify(o)}`);
+  return o;
+}
+s(j, "calculateDerivedFlags");
+function H() {
+  try {
+    return globalThis.importScripts("data:text/javascript,"), !0;
+  } catch {
+    return !1;
+  }
+}
+s(H, "isClassicWorker");
+var J, D, U, x;
+async function C() {
+  if (!m.IN_NODE || (J = (await import("./__vite-browser-external-DYxpcVy9.js")).default, U = await import("./__vite-browser-external-DYxpcVy9.js"), x = await import("./__vite-browser-external-DYxpcVy9.js"), (await import("./__vite-browser-external-DYxpcVy9.js")).default, D = await import("./__vite-browser-external-DYxpcVy9.js"), T = D.sep, typeof W < "u")) return;
+  let e = U, t = await import("./__vite-browser-external-DYxpcVy9.js"), r = await import("./__vite-browser-external-DYxpcVy9.js"), a = await import("./__vite-browser-external-DYxpcVy9.js"), i = { fs: e, crypto: t, ws: r, child_process: a };
+  globalThis.require = function(n) {
+    return i[n];
+  };
+}
+s(C, "initNodeModules");
+function z(e, t) {
+  return D.resolve(t || ".", e);
+}
+s(z, "node_resolvePath");
+function V(e, t) {
+  return t === void 0 && (t = location), new URL(e, t).toString();
+}
+s(V, "browser_resolvePath");
+var O;
+m.IN_NODE ? O = z : m.IN_SHELL ? O = s((e) => e, "resolvePath") : O = V;
+var T;
+m.IN_NODE || (T = "/");
+function G(e, t) {
+  return e.startsWith("file://") && (e = e.slice(7)), e.includes("://") ? { response: fetch(e) } : { binary: x.readFile(e).then((r) => new Uint8Array(r.buffer, r.byteOffset, r.byteLength)) };
+}
+s(G, "node_getBinaryResponse");
+function q(e, t) {
+  if (e.startsWith("file://") && (e = e.slice(7)), e.includes("://")) throw new Error("Shell cannot fetch urls");
+  return { binary: Promise.resolve(new Uint8Array(readbuffer(e))) };
+}
+s(q, "shell_getBinaryResponse");
+function K(e, t) {
+  let r = new URL(e, location);
+  return { response: fetch(r, t ? { integrity: t } : {}) };
+}
+s(K, "browser_getBinaryResponse");
+var A;
+m.IN_NODE ? A = G : m.IN_SHELL ? A = q : A = K;
+async function Q(e, t) {
+  let { response: r, binary: a } = A(e, t);
+  if (a) return a;
+  let i = await r;
+  if (!i.ok) throw new Error(`Failed to load '${e}': request failed.`);
+  return new Uint8Array(await i.arrayBuffer());
+}
+s(Q, "loadBinaryFile");
+var P;
+m.IN_NODE ? P = Y : P = s(async (e) => await import(e), "loadScript");
+async function Y(e) {
+  return e.startsWith("file://") && (e = e.slice(7)), e.includes("://") ? await import(e) : await import(J.pathToFileURL(e).href);
+}
+s(Y, "nodeLoadScript");
+async function X(e) {
+  if (m.IN_NODE) {
+    await C();
+    let t = await x.readFile(e, { encoding: "utf8" });
+    return JSON.parse(t);
+  } else if (m.IN_SHELL) {
+    let t = read(e);
+    return JSON.parse(t);
+  } else return await (await fetch(e)).json();
+}
+s(X, "loadLockFile");
+async function Z() {
+  if (m.IN_NODE_COMMONJS) return __dirname;
+  let e;
+  try {
+    throw new Error();
+  } catch (a) {
+    e = a;
+  }
+  let t = Ie.parse(e)[0].fileName;
+  if (m.IN_NODE && !t.startsWith("file://") && (t = `file://${t}`), m.IN_NODE_ESM) {
+    let a = await import("./__vite-browser-external-DYxpcVy9.js");
+    return (await import("./__vite-browser-external-DYxpcVy9.js")).fileURLToPath(a.dirname(t));
+  }
+  let r = t.lastIndexOf(T);
+  if (r === -1) throw new Error("Could not extract indexURL path from pyodide module location. Please pass the indexURL explicitly to loadPyodide.");
+  return t.slice(0, r);
+}
+s(Z, "calculateDirname");
+function ee(e) {
+  var t;
+  return e.substring(0, e.lastIndexOf("/") + 1) || ((t = globalThis.location) == null ? void 0 : t.toString()) || ".";
+}
+s(ee, "calculateInstallBaseUrl");
+function te(e) {
+  let t = e.FS, r = e.FS.filesystems.MEMFS, a = e.PATH, i = { DIR_MODE: 16895, FILE_MODE: 33279, mount: s(function(n) {
+    if (!n.opts.fileSystemHandle) throw new Error("opts.fileSystemHandle is required");
+    return r.mount.apply(null, arguments);
+  }, "mount"), syncfs: s(async (n, o, l) => {
+    try {
+      let c = i.getLocalSet(n), u = await i.getRemoteSet(n), d = o ? u : c, y = o ? c : u;
+      await i.reconcile(n, d, y), l(null);
+    } catch (c) {
+      l(c);
+    }
+  }, "syncfs"), getLocalSet: s((n) => {
+    let o = /* @__PURE__ */ Object.create(null);
+    function l(d) {
+      return d !== "." && d !== "..";
+    }
+    s(l, "isRealDir");
+    function c(d) {
+      return (y) => a.join2(d, y);
+    }
+    s(c, "toAbsolute");
+    let u = t.readdir(n.mountpoint).filter(l).map(c(n.mountpoint));
+    for (; u.length; ) {
+      let d = u.pop(), y = t.stat(d);
+      t.isDir(y.mode) && u.push.apply(u, t.readdir(d).filter(l).map(c(d))), o[d] = { timestamp: y.mtime, mode: y.mode };
+    }
+    return { type: "local", entries: o };
+  }, "getLocalSet"), getRemoteSet: s(async (n) => {
+    let o = /* @__PURE__ */ Object.create(null), l = await Oe(n.opts.fileSystemHandle);
+    for (let [c, u] of l) c !== "." && (o[a.join2(n.mountpoint, c)] = { timestamp: u.kind === "file" ? new Date((await u.getFile()).lastModified) : /* @__PURE__ */ new Date(), mode: u.kind === "file" ? i.FILE_MODE : i.DIR_MODE });
+    return { type: "remote", entries: o, handles: l };
+  }, "getRemoteSet"), loadLocalEntry: s((n) => {
+    let o = t.lookupPath(n, {}).node, l = t.stat(n);
+    if (t.isDir(l.mode)) return { timestamp: l.mtime, mode: l.mode };
+    if (t.isFile(l.mode)) return o.contents = r.getFileDataAsTypedArray(o), { timestamp: l.mtime, mode: l.mode, contents: o.contents };
+    throw new Error("node type not supported");
+  }, "loadLocalEntry"), storeLocalEntry: s((n, o) => {
+    if (t.isDir(o.mode)) t.mkdirTree(n, o.mode);
+    else if (t.isFile(o.mode)) t.writeFile(n, o.contents, { canOwn: !0 });
+    else throw new Error("node type not supported");
+    t.chmod(n, o.mode), t.utime(n, o.timestamp, o.timestamp);
+  }, "storeLocalEntry"), removeLocalEntry: s((n) => {
+    var o = t.stat(n);
+    t.isDir(o.mode) ? t.rmdir(n) : t.isFile(o.mode) && t.unlink(n);
+  }, "removeLocalEntry"), loadRemoteEntry: s(async (n) => {
+    if (n.kind === "file") {
+      let o = await n.getFile();
+      return { contents: new Uint8Array(await o.arrayBuffer()), mode: i.FILE_MODE, timestamp: new Date(o.lastModified) };
+    } else {
+      if (n.kind === "directory") return { mode: i.DIR_MODE, timestamp: /* @__PURE__ */ new Date() };
+      throw new Error("unknown kind: " + n.kind);
+    }
+  }, "loadRemoteEntry"), storeRemoteEntry: s(async (n, o, l) => {
+    let c = n.get(a.dirname(o)), u = t.isFile(l.mode) ? await c.getFileHandle(a.basename(o), { create: !0 }) : await c.getDirectoryHandle(a.basename(o), { create: !0 });
+    if (u.kind === "file") {
+      let d = await u.createWritable();
+      await d.write(l.contents), await d.close();
+    }
+    n.set(o, u);
+  }, "storeRemoteEntry"), removeRemoteEntry: s(async (n, o) => {
+    await n.get(a.dirname(o)).removeEntry(a.basename(o)), n.delete(o);
+  }, "removeRemoteEntry"), reconcile: s(async (n, o, l) => {
+    let c = 0, u = [];
+    Object.keys(o.entries).forEach(function(f) {
+      let h = o.entries[f], b = l.entries[f];
+      (!b || t.isFile(h.mode) && h.timestamp.getTime() > b.timestamp.getTime()) && (u.push(f), c++);
+    }), u.sort();
+    let d = [];
+    if (Object.keys(l.entries).forEach(function(f) {
+      o.entries[f] || (d.push(f), c++);
+    }), d.sort().reverse(), !c) return;
+    let y = o.type === "remote" ? o.handles : l.handles;
+    for (let f of u) {
+      let h = a.normalize(f.replace(n.mountpoint, "/")).substring(1);
+      if (l.type === "local") {
+        let b = y.get(h), ve = await i.loadRemoteEntry(b);
+        i.storeLocalEntry(f, ve);
+      } else {
+        let b = i.loadLocalEntry(f);
+        await i.storeRemoteEntry(y, h, b);
+      }
+    }
+    for (let f of d) if (l.type === "local") i.removeLocalEntry(f);
+    else {
+      let h = a.normalize(f.replace(n.mountpoint, "/")).substring(1);
+      await i.removeRemoteEntry(y, h);
+    }
+  }, "reconcile") };
+  e.FS.filesystems.NATIVEFS_ASYNC = i;
+}
+s(te, "initializeNativeFS");
+var Oe = s(async (e) => {
+  let t = [];
+  async function r(i) {
+    for await (let n of i.values()) t.push(n), n.kind === "directory" && await r(n);
+  }
+  s(r, "collect"), await r(e);
+  let a = /* @__PURE__ */ new Map();
+  a.set(".", e);
+  for (let i of t) {
+    let n = (await e.resolve(i)).join("/");
+    a.set(n, i);
+  }
+  return a;
+}, "getFsHandles"), Ae = be("AGFzbQEAAAABDANfAGAAAW9gAW8BfwMDAgECBygCE0pzdl9HZXRFcnJvcl9pbXBvcnQAAA5Kc3ZFcnJvcl9DaGVjawABChMCBwD7AQD7GwsJACAA+xr7FAAL"), ke = async function() {
+  if (!(globalThis.navigator && (/iPad|iPhone|iPod/.test(navigator.userAgent) || navigator.platform === "MacIntel" && typeof navigator.maxTouchPoints < "u" && navigator.maxTouchPoints > 1))) try {
+    let e = await WebAssembly.compile(Ae);
+    return await WebAssembly.instantiate(e);
+  } catch (e) {
+    if (e instanceof WebAssembly.CompileError) return;
+    throw e;
+  }
+}();
+async function re() {
+  let e = await ke;
+  if (e) return e.exports;
+  let t = Symbol("error marker");
+  return { Jsv_GetError_import: s(() => t, "Jsv_GetError_import"), JsvError_Check: s((r) => r === t, "JsvError_Check") };
+}
+s(re, "getJsvErrorImport");
+function ne(e) {
+  let t = { config: e, runtimeEnv: m }, r = { noImageDecoding: !0, noAudioDecoding: !0, noWasmDecoding: !1, preRun: ce(e), print: e.stdout, printErr: e.stderr, onExit(a) {
+    r.exitCode = a;
+  }, thisProgram: e._sysExecutable, arguments: e.args, API: t, locateFile: s((a) => e.indexURL + a, "locateFile"), instantiateWasm: ue(e.indexURL) };
+  return r;
+}
+s(ne, "createSettings");
+function ie(e) {
+  return function(t) {
+    let r = "/";
+    try {
+      t.FS.mkdirTree(e);
+    } catch (a) {
+      console.error(`Error occurred while making a home directory '${e}':`), console.error(a), console.error(`Using '${r}' for a home directory instead`), e = r;
+    }
+    t.FS.chdir(e);
+  };
+}
+s(ie, "createHomeDirectory");
+function oe(e) {
+  return function(t) {
+    Object.assign(t.ENV, e);
+  };
+}
+s(oe, "setEnvironment");
+function ae(e) {
+  return e ? [async (t) => {
+    t.addRunDependency("fsInitHook");
+    try {
+      await e(t.FS, { sitePackages: t.API.sitePackages });
+    } finally {
+      t.removeRunDependency("fsInitHook");
+    }
+  }] : [];
+}
+s(ae, "callFsInitHook");
+function se(e) {
+  let t = e.HEAPU32[e._Py_Version >>> 2], r = t >>> 24 & 255, a = t >>> 16 & 255, i = t >>> 8 & 255;
+  return [r, a, i];
+}
+s(se, "computeVersionTuple");
+function le(e) {
+  let t = Q(e);
+  return async (r) => {
+    r.API.pyVersionTuple = se(r);
+    let [a, i] = r.API.pyVersionTuple;
+    r.FS.mkdirTree("/lib"), r.API.sitePackages = `/lib/python${a}.${i}/site-packages`, r.FS.mkdirTree(r.API.sitePackages), r.addRunDependency("install-stdlib");
+    try {
+      let n = await t;
+      r.FS.writeFile(`/lib/python${a}${i}.zip`, n);
+    } catch (n) {
+      console.error("Error occurred while installing the standard library:"), console.error(n);
+    } finally {
+      r.removeRunDependency("install-stdlib");
+    }
+  };
+}
+s(le, "installStdlib");
+function ce(e) {
+  let t;
+  return e.stdLibURL != null ? t = e.stdLibURL : t = e.indexURL + "python_stdlib.zip", [le(t), ie(e.env.HOME), oe(e.env), te, ...ae(e.fsInit)];
+}
+s(ce, "getFileSystemInitializationFuncs");
+function ue(e) {
+  if (typeof WasmOffsetConverter < "u") return;
+  let { binary: t, response: r } = A(e + "pyodide.asm.wasm"), a = re();
+  return function(i, n) {
+    return async function() {
+      let { Jsv_GetError_import: o, JsvError_Check: l } = await a;
+      i.env.Jsv_GetError_import = o, i.env.JsvError_Check = l;
+      try {
+        let c;
+        r ? c = await WebAssembly.instantiateStreaming(r, i) : c = await WebAssembly.instantiate(await t, i);
+        let { instance: u, module: d } = c;
+        n(u, d);
+      } catch (c) {
+        console.warn("wasm instantiation failed!"), console.warn(c);
+      }
+    }(), {};
+  };
+}
+s(ue, "getInstantiateWasmFunc");
+var Fe = "314.0.2";
+function I(e) {
+  return e === void 0 || e.endsWith("/") ? e : e + "/";
+}
+s(I, "withTrailingSlash");
+var L = Fe;
+async function de(e = {}) {
+  var i, n;
+  if (await C(), e.lockFileContents && e.lockFileURL) throw new Error("Can't pass both lockFileContents and lockFileURL");
+  let t = e.indexURL || await Z();
+  if (t = I(O(t)), e.packageBaseUrl = I(e.packageBaseUrl), e.cdnUrl = I(e.packageBaseUrl ?? `https://cdn.jsdelivr.net/pyodide/v${L}/full/`), !e.lockFileContents) {
+    let o = e.lockFileURL ?? t + "pyodide-lock.json";
+    e.lockFileContents = X(o), e.packageBaseUrl ?? (e.packageBaseUrl = ee(o));
+  }
+  e.indexURL = t, e.packageCacheDir && (e.packageCacheDir = I(O(e.packageCacheDir)));
+  let r = { jsglobals: globalThis, stdin: globalThis.prompt ? () => globalThis.prompt() : void 0, args: [], env: {}, packages: [], packageCacheDir: e.packageBaseUrl, enableRunUntilComplete: !0, checkAPIVersion: !0, BUILD_ID: "a4189f0fe3d610ecd603639c08596362b70a34b106c58c9a93486c22df4c89a5" }, a = Object.assign(r, e);
+  return (i = a.env).HOME ?? (i.HOME = "/home/pyodide"), (n = a.env).PYTHONINSPECT ?? (n.PYTHONINSPECT = "1"), a;
+}
+s(de, "initializeConfiguration");
+function fe(e) {
+  let t = ne(e), r = t.API;
+  return r.lockFilePromise = Promise.resolve(e.lockFileContents), t;
+}
+s(fe, "createEmscriptenSettings");
+async function pe(e) {
+  if (e.createPyodideModule) return e.createPyodideModule;
+  let t = `${e.indexURL}pyodide.asm.mjs`;
+  return (await P(t)).default;
+}
+s(pe, "loadWasmScript");
+async function me(e, t) {
+  if (!e._loadSnapshot) return;
+  let r = await e._loadSnapshot, a = ArrayBuffer.isView(r) ? r : new Uint8Array(r);
+  return t.noInitialRun = !0, t.INITIAL_MEMORY = a.length, a;
+}
+s(me, "prepareSnapshot");
+async function ye(e, t) {
+  let r = await e(t);
+  if (t.exitCode !== void 0) throw new r.ExitStatus(t.exitCode);
+  return r;
+}
+s(ye, "instantiatePyodideModule");
+function ge(e, t) {
+  let r = e.API;
+  if (t.pyproxyToStringRepr && r.setPyProxyToStringMethod(!0), t.convertNullToNone && r.setCompatNullToNone(!0), t.toJsLiteralMap && r.setCompatToJsLiteralMap(!0), r.version !== L && t.checkAPIVersion) throw new Error(`Pyodide version does not match: '${L}' <==> '${r.version}'. If you updated the Pyodide version, make sure you also updated the 'indexURL' parameter passed to loadPyodide.`);
+  e.locateFile = (a) => {
+    throw a.endsWith(".so") ? new Error(`Failed to find dynamic library "${a}"`) : new Error(`Unexpected call to locateFile("${a}")`);
+  };
+}
+s(ge, "configureAPI");
+function he(e, t, r) {
+  let a = e.API, i;
+  return t && (i = a.restoreSnapshot(t)), a.finalizeBootstrap(i, r._snapshotDeserializer);
+}
+s(he, "bootstrapPyodide");
+async function we(e, t) {
+  let r = e._api;
+  return r.sys.path.insert(0, ""), r._pyodide.set_excepthook(), await r.packageIndexReady, r.initializeStreams(t.stdin, t.stdout, t.stderr), e;
+}
+s(we, "finalizeSetup");
+async function Re(e = {}) {
+  let t = await de(e), r = fe(t), a = await pe(t), i = await me(t, r), n = await ye(a, r);
+  ge(n, t);
+  let o = he(n, i, t);
+  return await we(o, t);
+}
+s(Re, "loadPyodide");
+export {
+  Re as loadPyodide,
+  L as version
+};