1681-engine 0.5.9 → 0.6.0

package/dist/dialogue/DialogueRunner.js

@@ -0,0 +1,173 @@
+import { expr as u } from "./expr.js";
+const f = 1e3;
+class d {
+  constructor(t, s = {}) {
+    this.script = t, this.options = s, this.vars = s.vars ?? {};
+    const i = s.functions ?? {};
+    this.scope = {
+      get: (e) => l(this.vars, e),
+      call: (e, n) => {
+        if (e === "visited") return this.visits.get(String(n[0])) ?? 0;
+        if (e === "chose") return this.chosen.has(`${n[0]}#${n[1]}`);
+        const o = i[e];
+        if (!o) throw new Error(`dialogue: no function '${e}'`);
+        return o(...n);
+      }
+    };
+  }
+  script;
+  options;
+  vars;
+  node = null;
+  line = 0;
+  step = { type: "end" };
+  visits = /* @__PURE__ */ new Map();
+  chosen = /* @__PURE__ */ new Set();
+  scope;
+  /** The step showing now. */
+  get current() {
+    return this.step;
+  }
+  /** The node the dialogue is in, or null once it has ended. */
+  get at() {
+    return this.node;
+  }
+  /** How many times a node was entered. */
+  visited(t) {
+    return this.visits.get(t) ?? 0;
+  }
+  /** Begins at `node` (default the script's `start`, else its first node). */
+  start(t = this.script.start ?? Object.keys(this.script.nodes)[0]) {
+    return t === void 0 ? this.finish() : this.go(t);
+  }
+  /** The line showing was read: on to the next line, the choices, or wherever the node leads. */
+  next() {
+    return this.step.type !== "line" ? this.step : (this.line++, this.show(0));
+  }
+  /** Picks a choice by its `index` (as shown). A locked or unknown index changes nothing. */
+  choose(t) {
+    if (this.step.type !== "choices" || this.node === null) return this.step;
+    if (!this.step.choices.find((n) => n.index === t)?.enabled) return this.step;
+    const i = this.node, e = this.nodeOf(i).choices[t];
+    return this.chosen.add(`${i}#${t}`), this.assign(e.set), this.run(e.do), e.goto === void 0 ? this.finish() : this.go(e.goto);
+  }
+  /** Jumps to a node from outside (the game's own event broke in). */
+  jump(t) {
+    return this.go(t);
+  }
+  /** Ends the dialogue now. */
+  stop() {
+    return this.finish();
+  }
+  /** The value of an expression over this dialogue's variables, for a game that shares the language. */
+  evaluate(t) {
+    return u(t)(this.scope);
+  }
+  save() {
+    return {
+      node: this.node,
+      line: this.line,
+      vars: structuredClone(this.vars),
+      visits: Object.fromEntries(this.visits),
+      chosen: [...this.chosen]
+    };
+  }
+  /** Puts a saved dialogue back where it was, without running the node's `set` and `do` again. */
+  restore(t) {
+    for (const s of Object.keys(this.vars)) delete this.vars[s];
+    Object.assign(this.vars, structuredClone(t.vars)), this.visits.clear();
+    for (const [s, i] of Object.entries(t.visits)) this.visits.set(s, i);
+    this.chosen.clear();
+    for (const s of t.chosen) this.chosen.add(s);
+    return t.node === null || !this.script.nodes[t.node] ? this.finish() : (this.node = t.node, this.line = t.line, this.show(0));
+  }
+  go(t) {
+    return this.enter(t, 0);
+  }
+  enter(t, s) {
+    if (s > f) throw new Error(`dialogue: '${t}' loops without showing anything`);
+    const i = this.nodeOf(t);
+    return this.node = t, this.line = 0, this.visits.set(t, (this.visits.get(t) ?? 0) + 1), this.assign(i.set), this.run(i.do), this.node !== t ? this.step : this.show(s);
+  }
+  /** The step from the current line on: the next line that holds, else the choices, else the way on. */
+  show(t) {
+    const s = this.node, i = this.nodeOf(s), e = i.lines ?? [];
+    for (; this.line < e.length; this.line++) {
+      const r = e[this.line], h = typeof r == "string" ? { text: r } : r;
+      if (!(h.if !== void 0 && !this.test(h.if)))
+        return this.step = { type: "line", node: s, speaker: h.speaker, text: this.text(h.text, h.key), tags: h.tags ?? [] };
+    }
+    const n = this.offered(s, i);
+    if (n.length > 0) return this.step = { type: "choices", node: s, choices: n };
+    const o = this.wayOn(i);
+    return o === null ? this.finish() : this.enter(o, t + 1);
+  }
+  offered(t, s) {
+    const i = [];
+    return (s.choices ?? []).forEach((e, n) => {
+      if (e.once && this.chosen.has(`${t}#${n}`)) return;
+      const o = e.if === void 0 || this.test(e.if);
+      !o && !e.showLocked || i.push({ index: n, text: this.text(e.text, e.key), enabled: o });
+    }), i.some((e) => e.enabled) ? i : [];
+  }
+  wayOn(t) {
+    if (t.next === void 0) return null;
+    if (typeof t.next == "string") return t.next;
+    for (const s of t.next) if (s.if === void 0 || this.test(s.if)) return s.goto;
+    return null;
+  }
+  finish() {
+    return this.node = null, this.step = { type: "end" };
+  }
+  nodeOf(t) {
+    const s = this.script.nodes[t];
+    if (!s) throw new Error(`dialogue: no node '${t}'`);
+    return s;
+  }
+  test(t) {
+    return !!u(t)(this.scope);
+  }
+  assign(t) {
+    if (!t) return;
+    const s = Object.entries(t).map(([i, e]) => [i, u(e)(this.scope)]);
+    for (const [i, e] of s) p(this.vars, i, e);
+  }
+  run(t) {
+    for (const s of t ?? []) {
+      const i = typeof s == "string" ? s : s.name;
+      this.options.onCommand?.(i, typeof s == "string" ? [] : s.args ?? [], this);
+    }
+  }
+  /** `text` translated, with each `{expression}` replaced by its value; `{{` and `}}` are braces. */
+  text(t, s) {
+    return (this.options.translate ? this.options.translate(t, s) : t).replace(/\{\{|\}\}|\{([^{}]+)\}/g, (e, n) => {
+      if (e === "{{") return "{";
+      if (e === "}}") return "}";
+      const o = u(n.trim())(this.scope);
+      return o == null ? "" : String(o);
+    });
+  }
+}
+function l(c, t) {
+  let s = c;
+  for (const i of t.split(".")) {
+    if (s === null || typeof s != "object" || !Object.prototype.hasOwnProperty.call(s, i)) return;
+    s = s[i];
+  }
+  return s;
+}
+function p(c, t, s) {
+  const i = t.split(".");
+  let e = c;
+  for (const o of i.slice(0, -1)) {
+    if (o === "__proto__" || o === "constructor" || o === "prototype") throw new Error(`dialogue: cannot set '${t}'`);
+    const r = e[o];
+    e = r !== null && typeof r == "object" ? r : e[o] = {};
+  }
+  const n = i[i.length - 1];
+  if (n === "__proto__" || n === "constructor" || n === "prototype") throw new Error(`dialogue: cannot set '${t}'`);
+  e[n] = s;
+}
+export {
+  d as DialogueRunner
+};

package/dist/dialogue/expr.js

@@ -0,0 +1,137 @@
+const A = ["&&", "||", "==", "!=", "<=", ">=", "<", ">", "!", "+", "-", "*", "/", "%", "(", ")", ","];
+function N(r) {
+  const i = [];
+  let o = 0;
+  for (; o < r.length; ) {
+    const l = r[o];
+    if (/\s/.test(l)) {
+      o++;
+      continue;
+    }
+    if (/[0-9.]/.test(l)) {
+      const c = /^(?:\d+\.?\d*|\.\d+)/.exec(r.slice(o));
+      if (!c) throw new Error(`bad number at ${o}`);
+      i.push({ k: "num", v: Number(c[0]) }), o += c[0].length;
+      continue;
+    }
+    if (l === '"' || l === "'") {
+      let c = o + 1, p = "";
+      for (; c < r.length && r[c] !== l; )
+        r[c] === "\\" && c + 1 < r.length && c++, p += r[c], c++;
+      if (c >= r.length) throw new Error(`unclosed string at ${o}`);
+      i.push({ k: "str", v: p }), o = c + 1;
+      continue;
+    }
+    if (/[A-Za-z_$]/.test(l)) {
+      const c = /^[A-Za-z_$][\w$]*(?:\.[A-Za-z_$][\w$]*)*/.exec(r.slice(o));
+      i.push({ k: "id", v: c[0] }), o += c[0].length;
+      continue;
+    }
+    const f = A.find((c) => r.startsWith(c, o));
+    if (!f) throw new Error(`unexpected '${l}' at ${o}`);
+    i.push({ k: "op", v: f }), o += f.length;
+  }
+  return i;
+}
+const m = (r) => !!r, k = (r, i) => r === i || r == null && i == null, s = (r) => typeof r == "number" ? r : typeof r == "boolean" ? Number(r) : r == null ? 0 : Number(r);
+function Z(r) {
+  let i;
+  try {
+    i = N(r);
+  } catch (n) {
+    throw new Error(`expression '${r}': ${n.message}`);
+  }
+  let o = 0;
+  const l = () => i[o], f = (n) => l()?.k === "op" && l().v === n, c = (n) => {
+    const e = l();
+    return e?.k === "op" && n.includes(e.v);
+  }, p = (n) => {
+    throw new Error(`expression '${r}': ${n}`);
+  }, y = (n) => f(n) ? o++ : p(`expected '${n}'`), h = (n, e, u) => () => {
+    let t = n();
+    for (; c(e); ) {
+      const a = i[o++].v;
+      t = u(a, t, n());
+    }
+    return t;
+  }, x = () => {
+    const n = i[o++];
+    if (!n) return p("ended early");
+    if (n.k === "num" || n.k === "str") {
+      const e = n.v;
+      return () => e;
+    }
+    if (n.k === "id") {
+      const e = n.v;
+      if (e === "true") return () => !0;
+      if (e === "false") return () => !1;
+      if (e === "null") return () => null;
+      if (f("(")) {
+        o++;
+        const u = [];
+        for (; !f(")") && (u.push($()), !!f(",")); )
+          o++;
+        return y(")"), (t) => t.call(e, u.map((a) => a(t)));
+      }
+      return (u) => {
+        const t = u.get(e);
+        return typeof t == "number" || typeof t == "string" || typeof t == "boolean" || t == null ? t : String(t);
+      };
+    }
+    if (n.v === "(") {
+      const e = $();
+      return y(")"), e;
+    }
+    return p(`unexpected '${n.v}'`);
+  }, w = () => {
+    if (f("!")) {
+      o++;
+      const n = w();
+      return (e) => !m(n(e));
+    }
+    if (f("-")) {
+      o++;
+      const n = w();
+      return (e) => -s(n(e));
+    }
+    return x();
+  }, v = h(
+    w,
+    ["*", "/", "%"],
+    (n, e, u) => n === "*" ? (t) => s(e(t)) * s(u(t)) : n === "/" ? (t) => s(e(t)) / s(u(t)) : (t) => s(e(t)) % s(u(t))
+  ), E = h(
+    v,
+    ["+", "-"],
+    (n, e, u) => n === "+" ? (t) => {
+      const a = e(t), d = u(t);
+      return typeof a == "string" || typeof d == "string" ? `${a ?? ""}${d ?? ""}` : s(a) + s(d);
+    } : (t) => s(e(t)) - s(u(t))
+  ), _ = h(E, ["<", ">", "<=", ">=", "==", "!="], (n, e, u) => {
+    switch (n) {
+      case "==":
+        return (t) => k(e(t), u(t));
+      case "!=":
+        return (t) => !k(e(t), u(t));
+      case "<":
+        return (t) => s(e(t)) < s(u(t));
+      case ">":
+        return (t) => s(e(t)) > s(u(t));
+      case "<=":
+        return (t) => s(e(t)) <= s(u(t));
+      default:
+        return (t) => s(e(t)) >= s(u(t));
+    }
+  }), z = h(_, ["&&"], (n, e, u) => (t) => m(e(t)) && m(u(t))), $ = h(z, ["||"], (n, e, u) => (t) => m(e(t)) || m(u(t)));
+  i.length === 0 && p("empty");
+  const b = $();
+  return o < i.length && p(`unexpected '${i[o].v}'`), b;
+}
+const g = /* @__PURE__ */ new Map();
+function O(r) {
+  let i = g.get(r);
+  return i || (i = Z(r), g.size > 2e3 && g.clear(), g.set(r, i)), i;
+}
+export {
+  Z as compileExpr,
+  O as expr
+};

package/dist/dialogue/validateDialogue.js

@@ -0,0 +1,52 @@
+import { compileExpr as A } from "./expr.js";
+function S(r, d = {}) {
+  const $ = [], s = (e, n) => $.push({ path: e, message: n, level: "error" }), g = Object.keys(r.nodes ?? {});
+  if (g.length === 0)
+    return s("nodes", "the script has no nodes"), $;
+  const m = r.start ?? g[0];
+  r.nodes[m] || s("start", `no node '${m}'`);
+  const p = d.functions ? /* @__PURE__ */ new Set(["visited", "chose", ...d.functions]) : null, a = (e, n) => {
+    if (typeof n != "string") return s(e, "must be an expression in a string");
+    try {
+      A(n);
+    } catch (o) {
+      return s(e, o.message);
+    }
+    if (p)
+      for (const o of n.matchAll(/([A-Za-z_$][\w$]*)\s*\(/g)) p.has(o[1]) || s(e, `no function '${o[1]}'`);
+  }, h = (e, n) => {
+    if (typeof n != "string") return s(e, "must be text");
+    for (const o of n.replace(/\{\{|\}\}/g, "").matchAll(/\{([^{}]*)\}/g)) a(e, o[1].trim());
+  }, u = (e, n) => {
+    (typeof n != "string" || !r.nodes[n]) && s(e, `no node '${String(n)}'`);
+  }, y = (e, n) => {
+    for (const [o, i] of Object.entries(n ?? {})) a(`${e}.${o}`, i);
+  }, v = (e, n) => {
+    (n ?? []).forEach((o, i) => {
+      const t = typeof o == "string" ? o : o?.name;
+      typeof t != "string" ? s(`${e}[${i}]`, "a command needs a name") : d.commands && !d.commands.includes(t) && s(`${e}[${i}]`, `no command '${t}'`);
+    });
+  }, w = /* @__PURE__ */ new Map();
+  for (const e of g) {
+    const n = r.nodes[e], o = `nodes.${e}`, i = [];
+    y(`${o}.set`, n.set), v(`${o}.do`, n.do), (n.lines ?? []).forEach((t, f) => {
+      if (typeof t == "string") return h(`${o}.lines[${f}]`, t);
+      h(`${o}.lines[${f}].text`, t.text), t.if !== void 0 && a(`${o}.lines[${f}].if`, t.if);
+    }), (n.choices ?? []).forEach((t, f) => {
+      const c = `${o}.choices[${f}]`;
+      h(`${c}.text`, t.text), t.if !== void 0 && a(`${c}.if`, t.if), y(`${c}.set`, t.set), v(`${c}.do`, t.do), t.goto !== void 0 && (u(`${c}.goto`, t.goto), i.push(t.goto));
+    }), typeof n.next == "string" ? (u(`${o}.next`, n.next), i.push(n.next)) : Array.isArray(n.next) && n.next.forEach((t, f) => {
+      t.if !== void 0 && a(`${o}.next[${f}].if`, t.if), u(`${o}.next[${f}].goto`, t.goto), i.push(t.goto);
+    }), w.set(e, i);
+  }
+  const l = /* @__PURE__ */ new Set(), x = r.nodes[m] ? [m] : [];
+  for (; x.length; ) {
+    const e = x.pop();
+    l.has(e) || !r.nodes[e] || (l.add(e), x.push(...w.get(e) ?? []));
+  }
+  for (const e of g) l.has(e) || $.push({ path: `nodes.${e}`, message: "nothing leads here from the start", level: "warning" });
+  return $;
+}
+export {
+  S as validateDialogue
+};

package/dist/ecs/prefab.js

@@ -0,0 +1,94 @@
+function P(r, t) {
+  return [r, t];
+}
+function y(r, t, e = {}) {
+  const o = e.extends ?? null, n = new Map(o?.parts ?? []);
+  for (const [s, i] of t)
+    i === null ? n.delete(s) : n.set(s, l(n.get(s), i));
+  return { name: r, parts: n, base: o };
+}
+function w(r, t, e = {}) {
+  const o = e.with?.length ? y(t.name, e.with, { extends: t }).parts : t.parts, n = r.create(), s = { entity: n, args: e.args };
+  for (const [i, f] of o)
+    e.without?.includes(i) || r.add(n, i, g(f, s));
+  return n;
+}
+function x(r, t) {
+  for (let e = r; e; e = e.base) if (e === t) return !0;
+  return !1;
+}
+function g(r, t) {
+  return typeof r == "function" ? r(t) : r !== null && typeof r == "object" ? structuredClone(r) : r;
+}
+const h = (r) => r !== null && typeof r == "object" && !Array.isArray(r) && Object.getPrototypeOf(r) === Object.prototype;
+function l(r, t) {
+  if (!h(r) || !h(t)) return t;
+  const e = { ...r };
+  for (const [o, n] of Object.entries(t)) e[o] = l(r[o], n);
+  return e;
+}
+class O {
+  types = /* @__PURE__ */ new Map();
+  factories = /* @__PURE__ */ new Map();
+  prefabs = /* @__PURE__ */ new Map();
+  /** Lets data name a component type. */
+  component(t, e) {
+    return this.types.set(t, e), this;
+  }
+  /** A value made in code for a prefab loaded from data (and its variants): the data cannot hold a function. */
+  factory(t, e, o) {
+    let n = this.factories.get(t);
+    return n || this.factories.set(t, n = /* @__PURE__ */ new Map()), n.set(e, o), this;
+  }
+  /** Adds a prefab made in code. */
+  add(t) {
+    return this.prefabs.set(t.name, t), this;
+  }
+  /**
+   * Builds the prefabs of `data`, bases before their variants (in any order in the data), and adds them. Throws,
+   * naming the prefab, on an unknown component or base, or a prefab that extends itself.
+   */
+  load(t) {
+    const e = /* @__PURE__ */ new Map(), o = /* @__PURE__ */ new Set(), n = (s) => {
+      const i = e.get(s);
+      if (i) return i;
+      const f = t[s];
+      if (!f) return this.get(s);
+      if (o.has(s)) throw new Error(`PrefabLibrary: '${s}' extends itself`);
+      o.add(s);
+      const d = f.extends === void 0 ? void 0 : n(f.extends), u = Object.entries(f.components ?? {}).map(([c, a]) => {
+        const b = this.types.get(c);
+        if (!b) throw new Error(`PrefabLibrary: '${s}' names an unknown component '${c}'`);
+        return [b, a];
+      });
+      for (const [c, a] of this.factories.get(s) ?? []) u.push([c, a]);
+      const p = y(s, u, { extends: d });
+      return o.delete(s), e.set(s, p), p;
+    };
+    for (const s of Object.keys(t)) n(s);
+    for (const [s, i] of e) this.prefabs.set(s, i);
+    return this;
+  }
+  get(t) {
+    const e = this.prefabs.get(t);
+    if (!e) throw new Error(`PrefabLibrary: no prefab '${t}'`);
+    return e;
+  }
+  has(t) {
+    return this.prefabs.has(t);
+  }
+  names() {
+    return [...this.prefabs.keys()];
+  }
+  /** `spawnPrefab` by name. */
+  spawn(t, e, o = {}) {
+    return w(t, this.get(e), o);
+  }
+}
+export {
+  O as PrefabLibrary,
+  y as definePrefab,
+  x as isPrefabOf,
+  P as prefabPart,
+  w as spawnPrefab
+};

package/dist/electron/lockdown.js

@@ -0,0 +1,31 @@
+import { isAllowedNavigation as a, isDevToolsKey as d, debuggerRequested as f, isAllowedExternal as u } from "./lockdownRules.js";
+function g(r, n) {
+  const i = n.log ?? ((...e) => console.log(...e)), t = r.webContents, s = (e, o) => {
+    u(e, n.external) ? n.shell.openExternal(e).catch((c) => i("could not open", e, c)) : i(`refused ${o}:`, e);
+  };
+  t.setWindowOpenHandler(({ url: e }) => (s(e, "external link"), { action: "deny" })), t.on("will-navigate", (e, o) => {
+    a(o, n.devServerUrl) || (e.preventDefault(), s(o, "navigation"));
+  }), t.on("will-redirect", (e, o) => {
+    a(o, n.devServerUrl) || e.preventDefault();
+  });
+  const l = n.devToolsKey === void 0 ? "F12" : n.devToolsKey;
+  t.on("before-input-event", (e, o) => {
+    if (n.packaged) {
+      d(o) && e.preventDefault();
+      return;
+    }
+    l && o.type === "keyDown" && o.key === l && (t.toggleDevTools(), e.preventDefault());
+  });
+}
+function w(r, n = []) {
+  const i = new Set(n);
+  r.setPermissionRequestHandler((t, s, l) => l(i.has(s))), r.setPermissionCheckHandler((t, s) => i.has(s));
+}
+function p(r, n = process.argv, i = (t) => process.exit(t)) {
+  return !r.isPackaged || !f(n, (t) => r.commandLine.hasSwitch(t)) ? !1 : (console.error("[main] refusing to run with a debugger attached"), i(1), !0);
+}
+export {
+  w as denyPermissions,
+  g as lockDownWindow,
+  p as refuseDebugLaunch
+};

package/dist/electron/lockdownRules.js

@@ -0,0 +1,42 @@
+function i(e) {
+  try {
+    return new URL(e);
+  } catch {
+    return null;
+  }
+}
+function g(e, r) {
+  const t = i(e);
+  if (!t || t.protocol !== "https:" || t.username || t.password) return !1;
+  const o = t.hostname.toLowerCase(), s = (r.paths ?? []).filter((n) => n.host.toLowerCase() === o);
+  return s.length ? s.some((n) => t.pathname.toLowerCase().startsWith(n.prefix.toLowerCase())) : r.hosts.some((n) => {
+    const a = n.toLowerCase();
+    return o === a || o.endsWith(`.${a}`);
+  });
+}
+function f(e, r) {
+  const t = i(e);
+  if (!t) return !1;
+  if (r) {
+    const o = i(r);
+    return !!o && t.origin === o.origin;
+  }
+  return t.protocol === "file:";
+}
+function l(e) {
+  if (e.type !== "keyDown") return !1;
+  if (e.key === "F12") return !0;
+  const r = e.key.toLowerCase();
+  return (e.control || e.meta) && (e.shift || e.alt) && (r === "i" || r === "j" || r === "c");
+}
+const c = ["--inspect", "--remote-debugging-port", "--remote-debugging-pipe", "--remote-debugging-address"], u = ["remote-debugging-port", "remote-debugging-pipe", "inspect", "inspect-brk"];
+function d(e, r = () => !1) {
+  return e.some((o) => c.some((s) => o === s || o.startsWith(`${s}=`) || o.startsWith(`${s}-`))) || u.some((o) => r(o));
+}
+export {
+  c as DEBUG_SWITCHES,
+  d as debuggerRequested,
+  g as isAllowedExternal,
+  f as isAllowedNavigation,
+  l as isDevToolsKey
+};

package/dist/electron/sessionStore.js

@@ -0,0 +1,48 @@
+import { promises as r } from "node:fs";
+import { join as n } from "node:path";
+class l {
+  constructor(t) {
+    this.o = t, this.file = n(t.dir, t.fileName ?? "session.bin"), this.maxLength = t.maxLength ?? 4096, this.platform = t.platform ?? process.platform;
+  }
+  o;
+  file;
+  maxLength;
+  platform;
+  /** Whether the OS can encrypt for real here. */
+  canEncrypt() {
+    const t = this.o.safeStorage;
+    return t.isEncryptionAvailable() ? this.platform !== "linux" || t.getSelectedStorageBackend?.() !== "basic_text" : !1;
+  }
+  /** The saved value, or null when there is none, it cannot be decrypted (another OS user, a reinstall) or nothing may be. */
+  async get() {
+    if (!this.canEncrypt()) return null;
+    try {
+      return this.o.safeStorage.decryptString(await r.readFile(this.file));
+    } catch {
+      return null;
+    }
+  }
+  /** Saves `value`; false when it is not a string, too long, or the OS cannot encrypt it. */
+  async set(t) {
+    if (typeof t != "string" || t.length > this.maxLength || !this.canEncrypt()) return !1;
+    const e = `${this.file}.${process.pid}.${Date.now()}.tmp`;
+    try {
+      await r.mkdir(this.o.dir, { recursive: !0 }), await r.writeFile(e, this.o.safeStorage.encryptString(t)), await r.rename(e, this.file);
+    } catch (a) {
+      throw await r.rm(e, { force: !0 }), a;
+    }
+    return !0;
+  }
+  async clear() {
+    await r.rm(this.file, { force: !0 });
+  }
+}
+function h(s, t, e = "session") {
+  return s.handle(`${e}:get`, () => t.get()), s.handle(`${e}:set`, (a, i) => t.set(i)), s.handle(`${e}:clear`, () => t.clear()), () => {
+    for (const a of ["get", "set", "clear"]) s.removeHandler?.(`${e}:${a}`);
+  };
+}
+export {
+  l as SessionStore,
+  h as registerSessionStore
+};

package/dist/electron/shellId.js

@@ -0,0 +1,18 @@
+import { createHash as a } from "node:crypto";
+import { readdirSync as f, readFileSync as d } from "node:fs";
+import { join as i } from "node:path";
+function p(n, r) {
+  const o = typeof r == "string" ? { dirs: [r] } : r, s = o.match ?? ((t) => t.endsWith(".cjs")), e = a("sha256");
+  e.update(`electron ${n}
+`);
+  for (const t of o.dirs)
+    for (const c of f(t).filter(s).sort())
+      e.update(`${c}
+`), e.update(d(i(t, c)));
+  for (const t of o.extra ?? []) e.update(`extra ${t}
+`);
+  return e.digest("hex").slice(0, o.length ?? 16);
+}
+export {
+  p as shellId
+};

package/dist/electron/webFiles.js

@@ -0,0 +1,36 @@
+import { createHash as s } from "node:crypto";
+import { readFile as c, mkdir as l, writeFile as u, readdir as f } from "node:fs/promises";
+import { join as r, dirname as h } from "node:path";
+const m = (t) => s("sha256").update(t).digest("hex");
+async function n(t, e = "") {
+  const i = [];
+  for (const a of await f(r(t, e), { withFileTypes: !0 })) {
+    const o = e ? `${e}/${a.name}` : a.name;
+    a.isDirectory() ? i.push(...await n(t, o)) : i.push(o);
+  }
+  return i;
+}
+async function d(t) {
+  const e = /* @__PURE__ */ new Map();
+  for (const i of await n(t)) e.set(i, m(await c(r(t, ...i.split("/")))));
+  return e;
+}
+async function F(t, e, i) {
+  const a = r(t, ...e.split("/"));
+  await l(h(a), { recursive: !0 }), await u(a, i);
+}
+async function T(t, e, i) {
+  const a = new AbortController(), o = setTimeout(() => a.abort(), i);
+  try {
+    return await t(e, { signal: a.signal, cache: "no-store" });
+  } finally {
+    clearTimeout(o);
+  }
+}
+export {
+  T as fetchWithTimeout,
+  d as hashWeb,
+  n as listFiles,
+  F as putFile,
+  m as sha256
+};