@x-python/core - npm Package Compare versions

Comparing version 0.0.3 to 0.0.4

dist/x-python.js

@@ -1,20 +0,149 @@
-import d from "immer";
-import S from "state-local";
-const a = {
-  pyodideSource: "https://cdn.jsdelivr.net/pyodide/v0.21.3/full/"
+import m from "immer";
+function w(I, g, C) {
+  return g in I ? Object.defineProperty(I, g, {
+    value: C,
+    enumerable: !0,
+    configurable: !0,
+    writable: !0
+  }) : I[g] = C, I;
+}
+function X(I, g) {
+  var C = Object.keys(I);
+  if (Object.getOwnPropertySymbols) {
+    var A = Object.getOwnPropertySymbols(I);
+    g && (A = A.filter(function(i) {
+      return Object.getOwnPropertyDescriptor(I, i).enumerable;
+    })), C.push.apply(C, A);
+  }
+  return C;
+}
+function W(I) {
+  for (var g = 1; g < arguments.length; g++) {
+    var C = arguments[g] != null ? arguments[g] : {};
+    g % 2 ? X(Object(C), !0).forEach(function(A) {
+      w(I, A, C[A]);
+    }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(I, Object.getOwnPropertyDescriptors(C)) : X(Object(C)).forEach(function(A) {
+      Object.defineProperty(I, A, Object.getOwnPropertyDescriptor(C, A));
+    });
+  }
+  return I;
+}
+function Y() {
+  for (var I = arguments.length, g = new Array(I), C = 0; C < I; C++)
+    g[C] = arguments[C];
+  return function(A) {
+    return g.reduceRight(function(i, l) {
+      return l(i);
+    }, A);
+  };
+}
+function s(I) {
+  return function g() {
+    for (var C = this, A = arguments.length, i = new Array(A), l = 0; l < A; l++)
+      i[l] = arguments[l];
+    return i.length >= I.length ? I.apply(this, i) : function() {
+      for (var c = arguments.length, B = new Array(c), G = 0; G < c; G++)
+        B[G] = arguments[G];
+      return g.apply(C, [].concat(i, B));
+    };
+  };
+}
+function e(I) {
+  return {}.toString.call(I).includes("Object");
+}
+function H(I) {
+  return !Object.keys(I).length;
+}
+function K(I) {
+  return typeof I == "function";
+}
+function V(I, g) {
+  return Object.prototype.hasOwnProperty.call(I, g);
+}
+function k(I, g) {
+  return e(g) || n("changeType"), Object.keys(g).some(function(C) {
+    return !V(I, C);
+  }) && n("changeField"), g;
+}
+function r(I) {
+  K(I) || n("selectorType");
+}
+function L(I) {
+  K(I) || e(I) || n("handlerType"), e(I) && Object.values(I).some(function(g) {
+    return !K(g);
+  }) && n("handlersType");
+}
+function R(I) {
+  I || n("initialIsRequired"), e(I) || n("initialType"), H(I) && n("initialContent");
+}
+function J(I, g) {
+  throw new Error(I[g] || I.default);
+}
+var v = {
+  initialIsRequired: "initial state is required",
+  initialType: "initial state should be an object",
+  initialContent: "initial state shouldn't be an empty object",
+  handlerType: "handler should be an object or a function",
+  handlersType: "all handlers should be a functions",
+  selectorType: "selector should be a function",
+  changeType: "provided value of changes should be an object",
+  changeField: 'it seams you want to change a field in the state which is not specified in the "initial" state',
+  default: "an unknown error accured in `state-local` package"
+}, n = s(J)(v), a = {
+  changes: k,
+  selector: r,
+  handler: L,
+  initial: R
 };
-var p = /* @__PURE__ */ ((I) => (I[I.READY = 0] = "READY", I))(p || {}), c = /* @__PURE__ */ ((I) => (I[I.EXEC = 0] = "EXEC", I[I.COMPLETE = 1] = "COMPLETE", I[I.INSTALL = 2] = "INSTALL", I[I.FORMAT = 3] = "FORMAT", I))(c || {});
-function u(I) {
-  let A;
-  return () => (A || (A = I()), A);
+function F(I) {
+  var g = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {};
+  a.initial(I), a.handler(g);
+  var C = {
+    current: I
+  }, A = s(z)(C, g), i = s(N)(C), l = s(a.changes)(I), c = s(U)(C);
+  function B() {
+    var b = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : function(y) {
+      return y;
+    };
+    return a.selector(b), b(C.current);
+  }
+  function G(b) {
+    Y(A, i, l, c)(b);
+  }
+  return [B, G];
 }
-function s(I, A) {
-  if (!A)
+function U(I, g) {
+  return K(g) ? g(I.current) : g;
+}
+function N(I, g) {
+  return I.current = W(W({}, I.current), g), g;
+}
+function z(I, g, C) {
+  return K(g) ? g(I.current) : Object.keys(C).forEach(function(A) {
+    var i;
+    return (i = g[A]) === null || i === void 0 ? void 0 : i.call(g, I.current[A]);
+  }), C;
+}
+var Q = {
+  create: F
+};
+const T = {
+  loadPyodideOptions: {
+    indexURL: "https://cdn.jsdelivr.net/pyodide/v0.21.3/full/"
+  }
+};
+var t = /* @__PURE__ */ ((I) => (I[I.READY = 0] = "READY", I))(t || {}), d = /* @__PURE__ */ ((I) => (I[I.EXEC = 0] = "EXEC", I[I.COMPLETE = 1] = "COMPLETE", I[I.INSTALL = 2] = "INSTALL", I[I.FORMAT = 3] = "FORMAT", I))(d || {});
+function O(I) {
+  let g;
+  return () => (g || (g = I()), g);
+}
+function p(I, g) {
+  if (!g)
     throw new Error(`a wrong id is provided from worker - callback with ${I} id doesn't exist`);
 }
-const W = "var y, P, x, T, C = { exports: {} };
C.exports = function() {
  function e(s) {
    return !isNaN(parseFloat(s)) && isFinite(s);
  }
  function t(s) {
    return s.charAt(0).toUpperCase() + s.substring(1);
  }
  function r(s) {
    return function() {
      return this[s];
    };
  }
  var n = ["isConstructor", "isEval", "isNative", "isToplevel"], i = ["columnNumber", "lineNumber"], o = ["fileName", "functionName", "source"], a = ["args"], d = ["evalOrigin"], m = n.concat(i, o, a, d);
  function l(s) {
    if (s)
      for (var p = 0; p < m.length; p++)
        s[m[p]] !== void 0 && this["set" + t(m[p])](s[m[p]]);
  }
  l.prototype = { getArgs: function() {
    return this.args;
  }, setArgs: function(s) {
    if (Object.prototype.toString.call(s) !== "[object Array]")
      throw new TypeError("Args must be an Array");
    this.args = s;
  }, getEvalOrigin: function() {
    return this.evalOrigin;
  }, setEvalOrigin: function(s) {
    if (s instanceof l)
      this.evalOrigin = s;
    else {
      if (!(s instanceof Object))
        throw new TypeError("Eval Origin must be an Object or StackFrame");
      this.evalOrigin = new l(s);
    }
  }, toString: function() {
    var s = this.getFileName() || "", p = this.getLineNumber() || "", h = this.getColumnNumber() || "", v = this.getFunctionName() || "";
    return this.getIsEval() ? s ? "[eval] (" + s + ":" + p + ":" + h + ")" : "[eval]:" + p + ":" + h : v ? v + " (" + s + ":" + p + ":" + h + ")" : s + ":" + p + ":" + h;
  } }, l.fromString = function(s) {
    var p = s.indexOf("("), h = s.lastIndexOf(")"), v = s.substring(0, p), W = s.substring(p + 1, h).split(","), R = s.substring(h + 1);
    if (R.indexOf("@") === 0)
      var E = /@(.+?)(?::(\d+))?(?::(\d+))?$/.exec(R, ""), X = E[1], B = E[2], V = E[3];
    return new l({ functionName: v, args: W || void 0, fileName: X, lineNumber: B || void 0, columnNumber: V || void 0 });
  };
  for (var f = 0; f < n.length; f++)
    l.prototype["get" + t(n[f])] = r(n[f]), l.prototype["set" + t(n[f])] = function(s) {
      return function(p) {
        this[s] = Boolean(p);
      };
    }(n[f]);
  for (var c = 0; c < i.length; c++)
    l.prototype["get" + t(i[c])] = r(i[c]), l.prototype["set" + t(i[c])] = function(s) {
      return function(p) {
        if (!e(p))
          throw new TypeError(s + " must be a Number");
        this[s] = Number(p);
      };
    }(i[c]);
  for (var u = 0; u < o.length; u++)
    l.prototype["get" + t(o[u])] = r(o[u]), l.prototype["set" + t(o[u])] = function(s) {
      return function(p) {
        this[s] = String(p);
      };
    }(o[u]);
  return l;
}();
var q = (y = C.exports, P = /(^|@)\S+:\d+/, x = /^\s*at .*(\S+:\d+|\(native\))/m, T = /^(eval@)?(\[native code])?$/, { parse: function(e) {
  if (e.stacktrace !== void 0 || e["opera#sourceloc"] !== void 0)
    return this.parseOpera(e);
  if (e.stack && e.stack.match(x))
    return this.parseV8OrIE(e);
  if (e.stack)
    return this.parseFFOrSafari(e);
  throw new Error("Cannot parse given Error object");
}, extractLocation: function(e) {
  if (e.indexOf(":") === -1)
    return [e];
  var t = /(.+?)(?::(\d+))?(?::(\d+))?$/.exec(e.replace(/[()]/g, ""));
  return [t[1], t[2] || void 0, t[3] || void 0];
}, parseV8OrIE: function(e) {
  return e.stack.split(`
`).filter(function(t) {
    return !!t.match(x);
  }, this).map(function(t) {
    t.indexOf("(eval ") > -1 && (t = t.replace(/eval code/g, "eval").replace(/(\(eval at [^()]*)|(,.*$)/g, ""));
    var r = t.replace(/^\s+/, "").replace(/\(eval code/g, "(").replace(/^.*?\s+/, ""), n = r.match(/ (\(.+\)$)/);
    r = n ? r.replace(n[0], "") : r;
    var i = this.extractLocation(n ? n[1] : r), o = n && r || void 0, a = ["eval", "<anonymous>"].indexOf(i[0]) > -1 ? void 0 : i[0];
    return new y({ functionName: o, fileName: a, lineNumber: i[1], columnNumber: i[2], source: t });
  }, this);
}, parseFFOrSafari: function(e) {
  return e.stack.split(`
`).filter(function(t) {
    return !t.match(T);
  }, this).map(function(t) {
    if (t.indexOf(" > eval") > -1 && (t = t.replace(/ line (\d+)(?: > eval line \d+)* > eval:\d+:\d+/g, ":$1")), t.indexOf("@") === -1 && t.indexOf(":") === -1)
      return new y({ functionName: t });
    var r = /((.*".+"[^@]*)?[^@]*)(?:@)/, n = t.match(r), i = n && n[1] ? n[1] : void 0, o = this.extractLocation(t.replace(r, ""));
    return new y({ functionName: i, fileName: o[0], lineNumber: o[1], columnNumber: o[2], source: t });
  }, this);
}, parseOpera: function(e) {
  return !e.stacktrace || e.message.indexOf(`
`) > -1 && e.message.split(`
`).length > e.stacktrace.split(`
`).length ? this.parseOpera9(e) : e.stack ? this.parseOpera11(e) : this.parseOpera10(e);
}, parseOpera9: function(e) {
  for (var t = /Line (\d+).*script (?:in )?(\S+)/i, r = e.message.split(`
`), n = [], i = 2, o = r.length; i < o; i += 2) {
    var a = t.exec(r[i]);
    a && n.push(new y({ fileName: a[2], lineNumber: a[1], source: r[i] }));
  }
  return n;
}, parseOpera10: function(e) {
  for (var t = /Line (\d+).*script (?:in )?(\S+)(?:: In function (\S+))?$/i, r = e.stacktrace.split(`
`), n = [], i = 0, o = r.length; i < o; i += 2) {
    var a = t.exec(r[i]);
    a && n.push(new y({ functionName: a[3] || void 0, fileName: a[2], lineNumber: a[1], source: r[i] }));
  }
  return n;
}, parseOpera11: function(e) {
  return e.stack.split(`
`).filter(function(t) {
    return !!t.match(P) && !t.match(/^Error created at/);
  }, this).map(function(t) {
    var r, n = t.split("@"), i = this.extractLocation(n.pop()), o = n.shift() || "", a = o.replace(/<anonymous function(: (\w+))?>/, "$2").replace(/\([^)]*\)/g, "") || void 0;
    o.match(/\(([^)]*)\)/) && (r = o.replace(/^[^(]+\(([^)]*)\)$/, "$1"));
    var d = r === void 0 || r === "[arguments not available]" ? void 0 : r.split(",");
    return new y({ functionName: a, args: d, fileName: i[0], lineNumber: i[1], columnNumber: i[2], source: t });
  }, this);
} });
const w = typeof process < "u" && process.release && process.release.name === "node" && process.browser === void 0;
let I, F, L, U, $, j, k, M, b;
if (j = w ? function(e, t) {
  return L.resolve(t || ".", e);
} : function(e, t) {
  return t === void 0 && (t = location), new URL(e, t).toString();
}, w || (k = "/"), M = w ? async function(e, t) {
  if (e.startsWith("file://") && (e = e.slice(7)), e.includes("://")) {
    let r = await F(e);
    if (!r.ok)
      throw new Error(`Failed to load '${e}': request failed.`);
    return new Uint8Array(await r.arrayBuffer());
  }
  {
    const r = await $.readFile(e);
    return new Uint8Array(r.buffer, r.byteOffset, r.byteLength);
  }
} : async function(e, t) {
  const r = new URL(e, location);
  let n = t ? { integrity: t } : {}, i = await fetch(r, n);
  if (!i.ok)
    throw new Error(`Failed to load '${r}': request failed.`);
  return new Uint8Array(await i.arrayBuffer());
}, globalThis.document)
  b = async (e) => await import(e);
else if (globalThis.importScripts)
  b = async (e) => {
    try {
      globalThis.importScripts(e);
    } catch (t) {
      if (!(t instanceof TypeError))
        throw t;
      await import(e);
    }
  };
else {
  if (!w)
    throw new Error("Cannot determine runtime environment");
  b = async function(e) {
    e.startsWith("file://") && (e = e.slice(7)), e.includes("://") ? U.runInThisContext(await (await F(e)).text()) : await import(I.pathToFileURL(e).href);
  };
}
function z(e, t, r, n) {
  r && (e.print = r), n && (e.printErr = n), t && e.preRun.push(function() {
    e.FS.init(function(i) {
      const o = new TextEncoder();
      let a = new Uint8Array(0), d = -1;
      function m() {
        try {
          if (d === -1) {
            let l = i();
            if (l == null)
              return null;
            if (typeof l != "string")
              throw new TypeError(`Expected stdin to return string, null, or undefined, got type ${typeof l}.`);
            l.endsWith(`
`) || (l += `
`), a = o.encode(l), d = 0;
          }
          if (d < a.length) {
            let l = a[d];
            return d++, l;
          }
          return d = -1, null;
        } catch (l) {
          throw console.error("Error thrown in stdin:"), console.error(l), l;
        }
      }
      return m;
    }(t), null, null);
  });
}
function G(e, t) {
  e.runPythonInternal_dict = e._pyodide._base.eval_code("{}"), e.importlib = e.runPythonInternal("import importlib; importlib");
  let r = e.importlib.import_module;
  e.sys = r("sys"), e.sys.path.insert(0, t.homedir);
  let n = e.runPythonInternal("import __main__; __main__.__dict__"), i = e.runPythonInternal("import builtins; builtins.__dict__");
  var o;
  e.globals = (o = i, new Proxy(n, { get: (m, l) => l === "get" ? (f) => {
    let c = m.get(f);
    return c === void 0 && (c = o.get(f)), c;
  } : l === "has" ? (f) => m.has(f) || o.has(f) : Reflect.get(m, l) }));
  let a = e._pyodide._importhook;
  a.register_js_finder(), a.register_js_module("js", t.jsglobals), a.register_unvendored_stdlib_finder();
  let d = e.makePublicAPI();
  return a.register_js_module("pyodide_js", d), e.pyodide_py = r("pyodide"), e.pyodide_code = r("pyodide.code"), e.pyodide_ffi = r("pyodide.ffi"), e.package_loader = r("pyodide._package_loader"), d.pyodide_py = e.pyodide_py, d.globals = e.globals, d;
}
async function J(e = {}) {
  await async function() {
    if (!w || (I = (await import("./__vite-browser-external-5003d29c.js")).default, $ = await import("./__vite-browser-external-5003d29c.js"), F = globalThis.fetch ? fetch : (await import("./index-8385436f.js")).default, U = (await import("./__vite-browser-external-5003d29c.js")).default, L = await import("./__vite-browser-external-5003d29c.js"), k = L.sep, typeof require < "u"))
      return;
    const c = { fs: await import("./__vite-browser-external-5003d29c.js"), crypto: await import("./__vite-browser-external-5003d29c.js"), ws: await import("./__vite-browser-external-5003d29c.js"), child_process: await import("./__vite-browser-external-5003d29c.js") };
    globalThis.require = function(u) {
      return c[u];
    };
  }();
  let t = e.indexURL || function() {
    if (typeof __dirname == "string")
      return __dirname;
    let c;
    try {
      throw new Error();
    } catch (p) {
      c = p;
    }
    let u = q.parse(c)[0].fileName;
    const s = u.lastIndexOf(k);
    if (s === -1)
      throw new Error("Could not extract indexURL path from pyodide module location");
    return u.slice(0, s);
  }();
  t = j(t), t.endsWith("/") || (t += "/"), e.indexURL = t;
  const r = { fullStdLib: !0, jsglobals: globalThis, stdin: globalThis.prompt ? globalThis.prompt : void 0, homedir: "/home/pyodide", lockFileURL: t + "repodata.json" }, n = Object.assign(r, e), i = M(n.indexURL + "pyodide_py.tar"), o = { noImageDecoding: !0, noAudioDecoding: !0, noWasmDecoding: !1, preloadedWasm: {}, preRun: [] }, a = { config: n };
  o.API = a, z(o, n.stdin, n.stdout, n.stderr), function(c, u) {
    c.preRun.push(function() {
      try {
        c.FS.mkdirTree(u);
      } catch (s) {
        console.error(`Error occurred while making a home directory '${u}':`), console.error(s), console.error("Using '/' for a home directory instead"), u = "/";
      }
      c.ENV.HOME = u, c.FS.chdir(u);
    });
  }(o, n.homedir);
  const d = new Promise((c) => o.postRun = c);
  o.locateFile = (c) => n.indexURL + c;
  const m = `${n.indexURL}pyodide.asm.js`;
  if (await b(m), await _createPyodideModule(o), await d, a.version !== "0.21.3")
    throw new Error(`Pyodide version does not match: '0.21.3' <==> '${a.version}'. If you updated the Pyodide version, make sure you also updated the 'indexURL' parameter passed to loadPyodide.`);
  o.locateFile = (c) => {
    throw new Error("Didn't expect to load any more file_packager files!");
  };
  const l = await i;
  (function(c, u) {
    let s = c.FS.open("/pyodide_py.tar", "w");
    c.FS.write(s, u, 0, u.byteLength, void 0, !0), c.FS.close(s);
    const p = c.stringToNewUTF8(`
from sys import version_info
pyversion = f"python{version_info.major}.{version_info.minor}"
import shutil
shutil.unpack_archive("/pyodide_py.tar", f"/lib/{pyversion}/site-packages/")
del shutil
import importlib
importlib.invalidate_caches()
del importlib
    `);
    if (c._PyRun_SimpleString(p))
      throw new Error("OOPS!");
    c._free(p), c.FS.unlink("/pyodide_py.tar");
  })(o, l), o._pyodide_init();
  const f = G(a, n);
  if (f.version.includes("dev") || a.setCdnUrl(`https://cdn.jsdelivr.net/pyodide/v${f.version}/full/`), await a.packageIndexReady, a.repodata_info.version !== "0.21.3")
    throw new Error("Lock file version doesn't match Pyodide version");
  return n.fullStdLib && await f.loadPackage(["distutils"]), f.runPython("print('Python initialization complete')"), f;
}
const Y = {
  pyodideSource: "https://cdn.jsdelivr.net/pyodide/v0.21.3/full/"
};
var K = `# pyright: reportMissingImports=false
# type: ignore

# black
import sys
import micropip
import asyncio
sys.modules["_multiprocessing"] = object

await micropip.install("jedi")
await micropip.install("black")

import jedi
from black import format_str, FileMode


def get_autocompletion(code, line, column):
    result = jedi.Interpreter(code, [globals(), locals()])

    completions = result.complete(line, column)

    matches = []
    for comp in completions:
        matches.append(dict(
            name=comp.name,
            type=comp.type,
            description=comp.description,
            full_name=comp.full_name
        ))

    return {
        "matches": matches
    }


async def install_pacakge(package):
    try:
        await micropip.install(package, keep_going=True)
        return {
            "success": True
        }
    except Exception as e:
        return {
            "success": False,
            "error": str(e)
        }


def format_code(code):
    return format_str(code, mode=FileMode())
`, A = /* @__PURE__ */ ((e) => (e[e.READY = 0] = "READY", e))(A || {}), g = /* @__PURE__ */ ((e) => (e[e.EXEC = 0] = "EXEC", e[e.COMPLETE = 1] = "COMPLETE", e[e.INSTALL = 2] = "INSTALL", e[e.FORMAT = 3] = "FORMAT", e))(g || {});
const D = "wrapper";
function _(e, t) {
  var i;
  const r = ((i = e == null ? void 0 : e.toJs) == null ? void 0 : i.call(e, {
    dict_converter: Object.fromEntries,
    create_pyproxies: !1
  })) || e, n = t.isPyProxy(r) ? r.toString() : r;
  if (ArrayBuffer.isView(n)) {
    const o = new TextDecoder().decode(n);
    return e.getBuffer().release(), o;
  }
  return n;
}
const N = /File "<exec>", line (\d+)($|, in <module>)$/m, O = new RegExp(
  `File "<exec>", line (\\d+), in ${D}`,
  "m"
), H = /line (\d+)/g;
function S(e) {
  return e.replace(H, (t, r) => `line ${+r - 1}`);
}
function Q(e) {
  const t = N.test(e), r = O.test(e);
  if (!(t || r))
    return e;
  const n = e.split(`
`), i = n.findIndex(
    (a) => t ? N.test(a) : O.test(a)
  );
  let o = !1;
  return n.slice(i).reduce((a, d) => {
    if (o)
      a.push(S(d));
    else {
      if (t && !r && N.test(d))
        return o = !0, a.push(S(d).replace(", in <module>", "")), a;
      if (r && O.test(d))
        return o = !0, a.push(S(d).replace(`, in ${D}`, "")), a;
    }
    return a;
  }, []).join(`
`);
}
async function Z() {
  const e = await J({
    indexURL: Y.pyodideSource
  });
  await e.loadPackage("micropip"), await e.runPythonAsync(K), postMessage(A.READY);
  const t = {
    [g.EXEC]: async ({ code: r, context: n = {} }) => {
      Object.entries(n).forEach(([i, o]) => {
        e.globals.set(i, e.toPy(o));
      });
      try {
        await e.loadPackagesFromImports(r), e.runPython("import sys, io; sys.stdout = io.StringIO(); sys.stderr = io.StringIO()");
        const i = await e.runPythonAsync(r), o = e.runPython("import sys; sys.stdout.getvalue()").trim(), a = e.runPython("import sys; sys.stderr.getvalue()").trim();
        return {
          result: _(i, e),
          stdout: _(o, e),
          stderr: a,
          error: null
        };
      } catch (i) {
        return {
          result: null,
          stdout: null,
          stderr: null,
          error: Q(i.message)
        };
      } finally {
        Object.entries(n).forEach(([i]) => {
          var o;
          e.globals.set(i, (o = e.toPy(null)) == null ? void 0 : o.toString());
        });
      }
    },
    [g.COMPLETE]: async ({
      code: r,
      line: n,
      column: i
    }) => {
      await e.loadPackagesFromImports(r);
      const o = e.globals.get("get_autocompletion")(r, n, i);
      return { result: _(o, e), error: null };
    },
    [g.INSTALL]: async ({ packages: r }) => {
      const n = await e.globals.get("install_pacakge")(r[0]);
      return console.log(_(n, e)), _(n, e);
    },
    [g.FORMAT]: async ({ code: r }) => {
      const n = e.globals.get("format_code")(r);
      return { result: _(n, e), error: null };
    }
  };
  onmessage = async function(n) {
    const { id: i, action: o = g.EXEC } = n.data;
    switch (o) {
      case g.EXEC:
        const a = await t[g.EXEC](n.data.payload);
        postMessage({
          ...a,
          id: i,
          action: o
        });
        break;
      case g.COMPLETE:
        const d = await t[g.COMPLETE](
          n.data.payload
        );
        postMessage({
          ...d,
          id: i,
          action: o
        });
        break;
      case g.INSTALL:
        const m = await t[g.INSTALL](n.data.payload);
        postMessage({
          ...m,
          id: i,
          action: o
        });
        break;
      case g.FORMAT:
        const l = await t[g.FORMAT](n.data.payload);
        postMessage({
          ...l,
          id: i,
          action: o
        });
        break;
    }
  };
}
Z();
", X = typeof window < "u" && window.Blob && new Blob([atob(W)], { type: "text/javascript;charset=utf-8" });
-function n() {
-  const I = X && (window.URL || window.webkitURL).createObjectURL(X);
+const h = "var y, P, x, T, C = { exports: {} };
C.exports = function() {
  function e(s) {
    return !isNaN(parseFloat(s)) && isFinite(s);
  }
  function t(s) {
    return s.charAt(0).toUpperCase() + s.substring(1);
  }
  function n(s) {
    return function() {
      return this[s];
    };
  }
  var r = ["isConstructor", "isEval", "isNative", "isToplevel"], i = ["columnNumber", "lineNumber"], o = ["fileName", "functionName", "source"], a = ["args"], d = ["evalOrigin"], m = r.concat(i, o, a, d);
  function l(s) {
    if (s)
      for (var p = 0; p < m.length; p++)
        s[m[p]] !== void 0 && this["set" + t(m[p])](s[m[p]]);
  }
  l.prototype = { getArgs: function() {
    return this.args;
  }, setArgs: function(s) {
    if (Object.prototype.toString.call(s) !== "[object Array]")
      throw new TypeError("Args must be an Array");
    this.args = s;
  }, getEvalOrigin: function() {
    return this.evalOrigin;
  }, setEvalOrigin: function(s) {
    if (s instanceof l)
      this.evalOrigin = s;
    else {
      if (!(s instanceof Object))
        throw new TypeError("Eval Origin must be an Object or StackFrame");
      this.evalOrigin = new l(s);
    }
  }, toString: function() {
    var s = this.getFileName() || "", p = this.getLineNumber() || "", h = this.getColumnNumber() || "", v = this.getFunctionName() || "";
    return this.getIsEval() ? s ? "[eval] (" + s + ":" + p + ":" + h + ")" : "[eval]:" + p + ":" + h : v ? v + " (" + s + ":" + p + ":" + h + ")" : s + ":" + p + ":" + h;
  } }, l.fromString = function(s) {
    var p = s.indexOf("("), h = s.lastIndexOf(")"), v = s.substring(0, p), W = s.substring(p + 1, h).split(","), R = s.substring(h + 1);
    if (R.indexOf("@") === 0)
      var E = /@(.+?)(?::(\d+))?(?::(\d+))?$/.exec(R, ""), X = E[1], B = E[2], V = E[3];
    return new l({ functionName: v, args: W || void 0, fileName: X, lineNumber: B || void 0, columnNumber: V || void 0 });
  };
  for (var f = 0; f < r.length; f++)
    l.prototype["get" + t(r[f])] = n(r[f]), l.prototype["set" + t(r[f])] = function(s) {
      return function(p) {
        this[s] = Boolean(p);
      };
    }(r[f]);
  for (var c = 0; c < i.length; c++)
    l.prototype["get" + t(i[c])] = n(i[c]), l.prototype["set" + t(i[c])] = function(s) {
      return function(p) {
        if (!e(p))
          throw new TypeError(s + " must be a Number");
        this[s] = Number(p);
      };
    }(i[c]);
  for (var u = 0; u < o.length; u++)
    l.prototype["get" + t(o[u])] = n(o[u]), l.prototype["set" + t(o[u])] = function(s) {
      return function(p) {
        this[s] = String(p);
      };
    }(o[u]);
  return l;
}();
var q = (y = C.exports, P = /(^|@)\S+:\d+/, x = /^\s*at .*(\S+:\d+|\(native\))/m, T = /^(eval@)?(\[native code])?$/, { parse: function(e) {
  if (e.stacktrace !== void 0 || e["opera#sourceloc"] !== void 0)
    return this.parseOpera(e);
  if (e.stack && e.stack.match(x))
    return this.parseV8OrIE(e);
  if (e.stack)
    return this.parseFFOrSafari(e);
  throw new Error("Cannot parse given Error object");
}, extractLocation: function(e) {
  if (e.indexOf(":") === -1)
    return [e];
  var t = /(.+?)(?::(\d+))?(?::(\d+))?$/.exec(e.replace(/[()]/g, ""));
  return [t[1], t[2] || void 0, t[3] || void 0];
}, parseV8OrIE: function(e) {
  return e.stack.split(`
`).filter(function(t) {
    return !!t.match(x);
  }, this).map(function(t) {
    t.indexOf("(eval ") > -1 && (t = t.replace(/eval code/g, "eval").replace(/(\(eval at [^()]*)|(,.*$)/g, ""));
    var n = t.replace(/^\s+/, "").replace(/\(eval code/g, "(").replace(/^.*?\s+/, ""), r = n.match(/ (\(.+\)$)/);
    n = r ? n.replace(r[0], "") : n;
    var i = this.extractLocation(r ? r[1] : n), o = r && n || void 0, a = ["eval", "<anonymous>"].indexOf(i[0]) > -1 ? void 0 : i[0];
    return new y({ functionName: o, fileName: a, lineNumber: i[1], columnNumber: i[2], source: t });
  }, this);
}, parseFFOrSafari: function(e) {
  return e.stack.split(`
`).filter(function(t) {
    return !t.match(T);
  }, this).map(function(t) {
    if (t.indexOf(" > eval") > -1 && (t = t.replace(/ line (\d+)(?: > eval line \d+)* > eval:\d+:\d+/g, ":$1")), t.indexOf("@") === -1 && t.indexOf(":") === -1)
      return new y({ functionName: t });
    var n = /((.*".+"[^@]*)?[^@]*)(?:@)/, r = t.match(n), i = r && r[1] ? r[1] : void 0, o = this.extractLocation(t.replace(n, ""));
    return new y({ functionName: i, fileName: o[0], lineNumber: o[1], columnNumber: o[2], source: t });
  }, this);
}, parseOpera: function(e) {
  return !e.stacktrace || e.message.indexOf(`
`) > -1 && e.message.split(`
`).length > e.stacktrace.split(`
`).length ? this.parseOpera9(e) : e.stack ? this.parseOpera11(e) : this.parseOpera10(e);
}, parseOpera9: function(e) {
  for (var t = /Line (\d+).*script (?:in )?(\S+)/i, n = e.message.split(`
`), r = [], i = 2, o = n.length; i < o; i += 2) {
    var a = t.exec(n[i]);
    a && r.push(new y({ fileName: a[2], lineNumber: a[1], source: n[i] }));
  }
  return r;
}, parseOpera10: function(e) {
  for (var t = /Line (\d+).*script (?:in )?(\S+)(?:: In function (\S+))?$/i, n = e.stacktrace.split(`
`), r = [], i = 0, o = n.length; i < o; i += 2) {
    var a = t.exec(n[i]);
    a && r.push(new y({ functionName: a[3] || void 0, fileName: a[2], lineNumber: a[1], source: n[i] }));
  }
  return r;
}, parseOpera11: function(e) {
  return e.stack.split(`
`).filter(function(t) {
    return !!t.match(P) && !t.match(/^Error created at/);
  }, this).map(function(t) {
    var n, r = t.split("@"), i = this.extractLocation(r.pop()), o = r.shift() || "", a = o.replace(/<anonymous function(: (\w+))?>/, "$2").replace(/\([^)]*\)/g, "") || void 0;
    o.match(/\(([^)]*)\)/) && (n = o.replace(/^[^(]+\(([^)]*)\)$/, "$1"));
    var d = n === void 0 || n === "[arguments not available]" ? void 0 : n.split(",");
    return new y({ functionName: a, args: d, fileName: i[0], lineNumber: i[1], columnNumber: i[2], source: t });
  }, this);
} });
const w = typeof process < "u" && process.release && process.release.name === "node" && process.browser === void 0;
let I, F, L, U, $, j, k, M, b;
if (j = w ? function(e, t) {
  return L.resolve(t || ".", e);
} : function(e, t) {
  return t === void 0 && (t = location), new URL(e, t).toString();
}, w || (k = "/"), M = w ? async function(e, t) {
  if (e.startsWith("file://") && (e = e.slice(7)), e.includes("://")) {
    let n = await F(e);
    if (!n.ok)
      throw new Error(`Failed to load '${e}': request failed.`);
    return new Uint8Array(await n.arrayBuffer());
  }
  {
    const n = await $.readFile(e);
    return new Uint8Array(n.buffer, n.byteOffset, n.byteLength);
  }
} : async function(e, t) {
  const n = new URL(e, location);
  let r = t ? { integrity: t } : {}, i = await fetch(n, r);
  if (!i.ok)
    throw new Error(`Failed to load '${n}': request failed.`);
  return new Uint8Array(await i.arrayBuffer());
}, globalThis.document)
  b = async (e) => await import(e);
else if (globalThis.importScripts)
  b = async (e) => {
    try {
      globalThis.importScripts(e);
    } catch (t) {
      if (!(t instanceof TypeError))
        throw t;
      await import(e);
    }
  };
else {
  if (!w)
    throw new Error("Cannot determine runtime environment");
  b = async function(e) {
    e.startsWith("file://") && (e = e.slice(7)), e.includes("://") ? U.runInThisContext(await (await F(e)).text()) : await import(I.pathToFileURL(e).href);
  };
}
function z(e, t, n, r) {
  n && (e.print = n), r && (e.printErr = r), t && e.preRun.push(function() {
    e.FS.init(function(i) {
      const o = new TextEncoder();
      let a = new Uint8Array(0), d = -1;
      function m() {
        try {
          if (d === -1) {
            let l = i();
            if (l == null)
              return null;
            if (typeof l != "string")
              throw new TypeError(`Expected stdin to return string, null, or undefined, got type ${typeof l}.`);
            l.endsWith(`
`) || (l += `
`), a = o.encode(l), d = 0;
          }
          if (d < a.length) {
            let l = a[d];
            return d++, l;
          }
          return d = -1, null;
        } catch (l) {
          throw console.error("Error thrown in stdin:"), console.error(l), l;
        }
      }
      return m;
    }(t), null, null);
  });
}
function G(e, t) {
  e.runPythonInternal_dict = e._pyodide._base.eval_code("{}"), e.importlib = e.runPythonInternal("import importlib; importlib");
  let n = e.importlib.import_module;
  e.sys = n("sys"), e.sys.path.insert(0, t.homedir);
  let r = e.runPythonInternal("import __main__; __main__.__dict__"), i = e.runPythonInternal("import builtins; builtins.__dict__");
  var o;
  e.globals = (o = i, new Proxy(r, { get: (m, l) => l === "get" ? (f) => {
    let c = m.get(f);
    return c === void 0 && (c = o.get(f)), c;
  } : l === "has" ? (f) => m.has(f) || o.has(f) : Reflect.get(m, l) }));
  let a = e._pyodide._importhook;
  a.register_js_finder(), a.register_js_module("js", t.jsglobals), a.register_unvendored_stdlib_finder();
  let d = e.makePublicAPI();
  return a.register_js_module("pyodide_js", d), e.pyodide_py = n("pyodide"), e.pyodide_code = n("pyodide.code"), e.pyodide_ffi = n("pyodide.ffi"), e.package_loader = n("pyodide._package_loader"), d.pyodide_py = e.pyodide_py, d.globals = e.globals, d;
}
async function J(e = {}) {
  await async function() {
    if (!w || (I = (await import("./__vite-browser-external-5003d29c.js")).default, $ = await import("./__vite-browser-external-5003d29c.js"), F = globalThis.fetch ? fetch : (await import("./index-8385436f.js")).default, U = (await import("./__vite-browser-external-5003d29c.js")).default, L = await import("./__vite-browser-external-5003d29c.js"), k = L.sep, typeof require < "u"))
      return;
    const c = { fs: await import("./__vite-browser-external-5003d29c.js"), crypto: await import("./__vite-browser-external-5003d29c.js"), ws: await import("./__vite-browser-external-5003d29c.js"), child_process: await import("./__vite-browser-external-5003d29c.js") };
    globalThis.require = function(u) {
      return c[u];
    };
  }();
  let t = e.indexURL || function() {
    if (typeof __dirname == "string")
      return __dirname;
    let c;
    try {
      throw new Error();
    } catch (p) {
      c = p;
    }
    let u = q.parse(c)[0].fileName;
    const s = u.lastIndexOf(k);
    if (s === -1)
      throw new Error("Could not extract indexURL path from pyodide module location");
    return u.slice(0, s);
  }();
  t = j(t), t.endsWith("/") || (t += "/"), e.indexURL = t;
  const n = { fullStdLib: !0, jsglobals: globalThis, stdin: globalThis.prompt ? globalThis.prompt : void 0, homedir: "/home/pyodide", lockFileURL: t + "repodata.json" }, r = Object.assign(n, e), i = M(r.indexURL + "pyodide_py.tar"), o = { noImageDecoding: !0, noAudioDecoding: !0, noWasmDecoding: !1, preloadedWasm: {}, preRun: [] }, a = { config: r };
  o.API = a, z(o, r.stdin, r.stdout, r.stderr), function(c, u) {
    c.preRun.push(function() {
      try {
        c.FS.mkdirTree(u);
      } catch (s) {
        console.error(`Error occurred while making a home directory '${u}':`), console.error(s), console.error("Using '/' for a home directory instead"), u = "/";
      }
      c.ENV.HOME = u, c.FS.chdir(u);
    });
  }(o, r.homedir);
  const d = new Promise((c) => o.postRun = c);
  o.locateFile = (c) => r.indexURL + c;
  const m = `${r.indexURL}pyodide.asm.js`;
  if (await b(m), await _createPyodideModule(o), await d, a.version !== "0.21.3")
    throw new Error(`Pyodide version does not match: '0.21.3' <==> '${a.version}'. If you updated the Pyodide version, make sure you also updated the 'indexURL' parameter passed to loadPyodide.`);
  o.locateFile = (c) => {
    throw new Error("Didn't expect to load any more file_packager files!");
  };
  const l = await i;
  (function(c, u) {
    let s = c.FS.open("/pyodide_py.tar", "w");
    c.FS.write(s, u, 0, u.byteLength, void 0, !0), c.FS.close(s);
    const p = c.stringToNewUTF8(`
from sys import version_info
pyversion = f"python{version_info.major}.{version_info.minor}"
import shutil
shutil.unpack_archive("/pyodide_py.tar", f"/lib/{pyversion}/site-packages/")
del shutil
import importlib
importlib.invalidate_caches()
del importlib
    `);
    if (c._PyRun_SimpleString(p))
      throw new Error("OOPS!");
    c._free(p), c.FS.unlink("/pyodide_py.tar");
  })(o, l), o._pyodide_init();
  const f = G(a, r);
  if (f.version.includes("dev") || a.setCdnUrl(`https://cdn.jsdelivr.net/pyodide/v${f.version}/full/`), await a.packageIndexReady, a.repodata_info.version !== "0.21.3")
    throw new Error("Lock file version doesn't match Pyodide version");
  return r.fullStdLib && await f.loadPackage(["distutils"]), f.runPython("print('Python initialization complete')"), f;
}
const Y = {
  loadPyodideOptions: {
    indexURL: "https://cdn.jsdelivr.net/pyodide/v0.21.3/full/"
  }
};
var K = `# pyright: reportMissingImports=false
# type: ignore

# black
import sys
import micropip
import asyncio
sys.modules["_multiprocessing"] = object

await micropip.install("jedi")
await micropip.install("black")

import jedi
from black import format_str, FileMode


def get_autocompletion(code, line, column):
    result = jedi.Interpreter(code, [globals(), locals()])

    completions = result.complete(line, column)

    matches = []
    for comp in completions:
        matches.append(dict(
            name=comp.name,
            type=comp.type,
            description=comp.description,
            full_name=comp.full_name
        ))

    return {
        "matches": matches
    }


async def install_pacakge(package):
    try:
        await micropip.install(package, keep_going=True)
        return {
            "success": True
        }
    except Exception as e:
        return {
            "success": False,
            "error": str(e)
        }


def format_code(code):
    return format_str(code, mode=FileMode())
`, A = /* @__PURE__ */ ((e) => (e[e.READY = 0] = "READY", e))(A || {}), g = /* @__PURE__ */ ((e) => (e[e.EXEC = 0] = "EXEC", e[e.COMPLETE = 1] = "COMPLETE", e[e.INSTALL = 2] = "INSTALL", e[e.FORMAT = 3] = "FORMAT", e))(g || {});
const D = "wrapper";
function _(e, t) {
  var i;
  const n = ((i = e == null ? void 0 : e.toJs) == null ? void 0 : i.call(e, {
    dict_converter: Object.fromEntries,
    create_pyproxies: !1
  })) || e, r = t.isPyProxy(n) ? n.toString() : n;
  if (ArrayBuffer.isView(r)) {
    const o = new TextDecoder().decode(r);
    return e.getBuffer().release(), o;
  }
  return r;
}
const N = /File "<exec>", line (\d+)($|, in <module>)$/m, O = new RegExp(
  `File "<exec>", line (\\d+), in ${D}`,
  "m"
), H = /line (\d+)/g;
function S(e) {
  return e.replace(H, (t, n) => `line ${+n - 1}`);
}
function Q(e) {
  const t = N.test(e), n = O.test(e);
  if (!(t || n))
    return e;
  const r = e.split(`
`), i = r.findIndex(
    (a) => t ? N.test(a) : O.test(a)
  );
  let o = !1;
  return r.slice(i).reduce((a, d) => {
    if (o)
      a.push(S(d));
    else {
      if (t && !n && N.test(d))
        return o = !0, a.push(S(d).replace(", in <module>", "")), a;
      if (n && O.test(d))
        return o = !0, a.push(S(d).replace(`, in ${D}`, "")), a;
    }
    return a;
  }, []).join(`
`);
}
async function Z() {
  const e = await J(Y.loadPyodideOptions);
  await e.loadPackage("micropip"), await e.runPythonAsync(K), postMessage(A.READY);
  const t = {
    [g.EXEC]: async ({ code: n, context: r = {} }) => {
      Object.entries(r).forEach(([i, o]) => {
        e.globals.set(i, e.toPy(o));
      });
      try {
        await e.loadPackagesFromImports(n), e.runPython("import sys, io; sys.stdout = io.StringIO(); sys.stderr = io.StringIO()");
        const i = await e.runPythonAsync(n), o = e.runPython("import sys; sys.stdout.getvalue()").trim(), a = e.runPython("import sys; sys.stderr.getvalue()").trim();
        return {
          result: _(i, e),
          stdout: _(o, e),
          stderr: a,
          error: null
        };
      } catch (i) {
        return {
          result: null,
          stdout: null,
          stderr: null,
          error: Q(i.message)
        };
      } finally {
        Object.entries(r).forEach(([i]) => {
          var o;
          e.globals.set(i, (o = e.toPy(null)) == null ? void 0 : o.toString());
        });
      }
    },
    [g.COMPLETE]: async ({
      code: n,
      line: r,
      column: i
    }) => {
      await e.loadPackagesFromImports(n);
      const o = e.globals.get("get_autocompletion")(n, r, i);
      return { result: _(o, e), error: null };
    },
    [g.INSTALL]: async ({ packages: n }) => {
      const r = await e.globals.get("install_pacakge")(n[0]);
      return console.log(_(r, e)), _(r, e);
    },
    [g.FORMAT]: async ({ code: n }) => {
      const r = e.globals.get("format_code")(n);
      return { result: _(r, e), error: null };
    }
  };
  onmessage = async function(r) {
    const { id: i, action: o = g.EXEC } = r.data;
    switch (o) {
      case g.EXEC:
        const a = await t[g.EXEC](r.data.payload);
        postMessage({
          ...a,
          id: i,
          action: o
        });
        break;
      case g.COMPLETE:
        const d = await t[g.COMPLETE](
          r.data.payload
        );
        postMessage({
          ...d,
          id: i,
          action: o
        });
        break;
      case g.INSTALL:
        const m = await t[g.INSTALL](r.data.payload);
        postMessage({
          ...m,
          id: i,
          action: o
        });
        break;
      case g.FORMAT:
        const l = await t[g.FORMAT](r.data.payload);
        postMessage({
          ...l,
          id: i,
          action: o
        });
        break;
    }
  };
}
Z();
", S = typeof window < "u" && window.Blob && new Blob([atob(h)], { type: "text/javascript;charset=utf-8" });
+function f() {
+  const I = S && (window.URL || window.webkitURL).createObjectURL(S);
   try {
-    return I ? new Worker(I) : new Worker("data:application/javascript;base64," + W, { type: "module" });
+    return I ? new Worker(I) : new Worker("data:application/javascript;base64," + h, { type: "module" });
   } finally {
@@ -24,4 +153,4 @@ I && (window.URL || window.webkitURL).revokeObjectURL(I);
 }
-const H = Boolean(globalThis.Worker), [G, B] = S.create({
-  config: a,
+const M = Boolean(globalThis.Worker), [Z, o] = Q.create({
+  config: T,
   pyodideWorker: null,
@@ -33,95 +162,95 @@ execCallbacks: {},
   commandUniqueId: 0
-}), m = {
+}), u = {
   async ensureWorkerIsSetup() {
-    const { pyodideWorker: I } = G();
-    I || await h();
+    const { pyodideWorker: I } = Z();
+    I || await E();
   },
-  async command(I, A) {
-    await m.ensureWorkerIsSetup();
-    const { commandUniqueId: g, pyodideWorker: C } = G();
-    B({ commandUniqueId: g + 1 }), C == null || C.postMessage({ payload: I, id: g, action: A });
+  async command(I, g) {
+    await u.ensureWorkerIsSetup();
+    const { commandUniqueId: C, pyodideWorker: A } = Z();
+    o({ commandUniqueId: C + 1 }), A == null || A.postMessage({ payload: I, id: C, action: g });
   }
 };
-function w({ result: I, error: A, id: g, stderr: C, stdout: b }) {
-  const { execCallbacks: l } = G();
-  s(g, Boolean(l[g]));
-  const { resolve: Z } = l[g];
-  B({
-    execCallbacks: d(l, (o) => {
-      delete o[g];
+function j({ result: I, error: g, id: C, stderr: A, stdout: i }) {
+  const { execCallbacks: l } = Z();
+  p(C, Boolean(l[C]));
+  const { resolve: c } = l[C];
+  o({
+    execCallbacks: m(l, (B) => {
+      delete B[C];
     })
-  }), Z({ result: I, error: A, stderr: C, stdout: b });
+  }), c({ result: I, error: g, stderr: A, stdout: i });
 }
-function Y({ result: I, error: A, id: g }) {
-  const { completeCallbacks: C } = G();
-  s(g, Boolean(C[g]));
-  const { resolve: b, reject: l } = C[g];
-  if (B({
-    completeCallbacks: d(C, (Z) => {
-      delete Z[g];
+function P({ result: I, error: g, id: C }) {
+  const { completeCallbacks: A } = Z();
+  p(C, Boolean(A[C]));
+  const { resolve: i, reject: l } = A[C];
+  if (o({
+    completeCallbacks: m(A, (c) => {
+      delete c[C];
     })
-  }), A) {
-    l == null || l(A);
+  }), g) {
+    l == null || l(g);
     return;
   }
-  b(I);
+  i(I);
 }
-function V({ success: I, error: A, id: g }) {
-  const { installCallbacks: C } = G();
-  s(g, Boolean(C[g]));
-  const { resolve: b, reject: l } = C[g];
-  if (B({
-    installCallbacks: d(C, (Z) => {
-      delete Z[g];
+function x({ success: I, error: g, id: C }) {
+  const { installCallbacks: A } = Z();
+  p(C, Boolean(A[C]));
+  const { resolve: i, reject: l } = A[C];
+  if (o({
+    installCallbacks: m(A, (c) => {
+      delete c[C];
     })
-  }), A) {
-    l == null || l(A);
+  }), g) {
+    l == null || l(g);
     return;
   }
-  b({ success: I, error: A });
+  i({ success: I, error: g });
 }
-function k({ result: I, error: A, id: g }) {
-  const { formatCallbacks: C } = G();
-  s(g, Boolean(C[g]));
-  const { resolve: b } = C[g];
-  B({
-    formatCallbacks: d(C, (l) => {
-      delete l[g];
+function D({ result: I, error: g, id: C }) {
+  const { formatCallbacks: A } = Z();
+  p(C, Boolean(A[C]));
+  const { resolve: i } = A[C];
+  o({
+    formatCallbacks: m(A, (l) => {
+      delete l[C];
     })
-  }), b({ result: I, error: A });
+  }), i({ result: I, error: g });
 }
-const h = u(function() {
-  return new Promise((A, g) => {
-    H || g(new Error(`your browser does
+const E = O(function() {
+  return new Promise((g, C) => {
+    M || C(new Error(`your browser does
 t support web workers!`));
-    const C = new n();
-    C.onmessage = function(l) {
-      l.data === p.READY ? (B({ pyodideWorker: C }), C.onmessage = function(o) {
-        const { action: K, ...i } = o.data;
-        switch (K) {
-          case c.EXEC:
-            w(i);
+    const A = new f();
+    A.onmessage = function(l) {
+      l.data === t.READY ? (o({ pyodideWorker: A }), A.onmessage = function(B) {
+        const { action: G, ...b } = B.data;
+        switch (G) {
+          case d.EXEC:
+            j(b);
             break;
-          case c.COMPLETE:
-            Y(i);
+          case d.COMPLETE:
+            P(b);
             break;
-          case c.INSTALL:
-            V(i);
+          case d.INSTALL:
+            x(b);
             break;
-          case c.FORMAT:
-            k(i);
+          case d.FORMAT:
+            D(b);
             break;
         }
-      }, A(C)) : g(new Error("unexpected error in setup process"));
-    }, C.onerror = function(l) {
-      g(l.message);
+      }, g(A)) : C(new Error("unexpected error in setup process"));
+    }, A.onerror = function(l) {
+      C(l.message);
     };
   });
 });
-async function e(I) {
-  return new Promise((A) => {
-    const { execCallbacks: g, commandUniqueId: C } = G();
-    m.command(I, c.EXEC), B({
-      execCallbacks: d(g, (b) => {
-        b[C] = { resolve: A };
+async function $(I) {
+  return new Promise((g) => {
+    const { execCallbacks: C, commandUniqueId: A } = Z();
+    u.command(I, d.EXEC), o({
+      execCallbacks: m(C, (i) => {
+        i[A] = { resolve: g };
       })
@@ -131,12 +260,12 @@ });
 }
-const J = {
+const _ = {
   async repl(I) {
-    return new Promise((A, g) => {
-      const { commandUniqueId: C, completeCallbacks: b } = G(), { code: l, line: Z, column: o } = I;
-      let K = Z, i = o;
-      Z || (K = l.split(`
-`).length), i || (i = l.split(`
-`)[K - 1].length), m.command({ code: l, line: K, column: i }, c.COMPLETE), B({
-        completeCallbacks: d(b, (y) => {
-          y[C] = { resolve: A, reject: g };
+    return new Promise((g, C) => {
+      const { commandUniqueId: A, completeCallbacks: i } = Z(), { code: l, line: c, column: B } = I;
+      let G = c, b = B;
+      c || (G = l.split(`
+`).length), b || (b = l.split(`
+`)[G - 1].length), u.command({ code: l, line: G, column: b }, d.COMPLETE), o({
+        completeCallbacks: m(i, (y) => {
+          y[A] = { resolve: g, reject: C };
         })
@@ -147,8 +276,8 @@ });
 };
-async function F(I) {
-  return new Promise((A, g) => {
-    const { installCallbacks: C, commandUniqueId: b } = G();
-    m.command({ packages: I }, c.INSTALL), B({
-      installCallbacks: d(C, (l) => {
-        l[b] = { resolve: A, reject: g };
+async function II(I) {
+  return new Promise((g, C) => {
+    const { installCallbacks: A, commandUniqueId: i } = Z();
+    u.command({ packages: I }, d.INSTALL), o({
+      installCallbacks: m(A, (l) => {
+        l[i] = { resolve: g, reject: C };
       })
@@ -158,8 +287,8 @@ });
 }
-async function v(I) {
-  return new Promise((A, g) => {
-    const { formatCallbacks: C, commandUniqueId: b } = G();
-    m.command(I, c.FORMAT), B({
-      formatCallbacks: d(C, (l) => {
-        l[b] = { resolve: A, reject: g };
+async function gI(I) {
+  return new Promise((g, C) => {
+    const { formatCallbacks: A, commandUniqueId: i } = Z();
+    u.command(I, d.FORMAT), o({
+      formatCallbacks: m(A, (l) => {
+        l[i] = { resolve: g, reject: C };
       })
@@ -170,7 +299,7 @@ });
 export {
-  J as complete,
-  e as exec,
-  v as format,
-  h as init,
-  F as install
+  _ as complete,
+  $ as exec,
+  gI as format,
+  E as init,
+  II as install
 };

package.json

 {
   "name": "@x-python/core",
-  "version": "0.0.3",
+  "version": "0.0.4",
   "type": "module",
@@ -20,3 +20,3 @@ "license": "MIT",
   ],
-  "main": "./dist/x-python.cjs",
+  "main": "./dist/x-python.umd.cjs",
   "module": "./dist/x-python.js",
@@ -51,3 +51,3 @@ "unpkg": "./dist/x-python.umd.cjs",
       "import": "./dist/x-python.js",
-      "require": "./dist/x-python.cjs"
+      "require": "./dist/x-python.umd.cjs"
     }
@@ -54,0 +54,0 @@ },

New alerts

License Policy Violation

License

This package is not allowed per your license policy. Review the package's license to ensure compliance.

Found 1 instance in 1 package

Major refactor

Supply chain risk

Package has recently undergone a major refactor. It may be unstable or indicate significant internal changes. Use caution when updating to versions that include significant changes.

Found 1 instance in 1 package

Long strings

Supply chain risk

Contains long string literals, which may be a sign of obfuscated or packed code.

Found 1 instance in 1 package

Fixed alerts

License Policy Violation

License

This package is not allowed per your license policy. Review the package's license to ensure compliance.

Found 1 instance in 1 package

Long strings

Supply chain risk

Contains long string literals, which may be a sign of obfuscated or packed code.

Found 1 instance in 1 package

Minified code

Quality

This package contains minified code. This may be harmless in some cases where minified code is included in packaged libraries, however packages on npm should not minify code.

Found 1 instance in 1 package

Improved metrics

Lines of code

562

increased by6.04%

Number of low quality alerts

2

decreased by-33.33%

Number of low supply chain risk alerts

2

decreased by-33.33%

Worsened metrics

Total package byte prevSize

77675

decreased by-20.77%

Number of package files

7

decreased by-12.5%

Number of medium supply chain risk alerts

1

increased byInfinity%

No dependency changes