semantic-golfer 0.0.0 → 1.0.0

package/dist-electron/index.js

@@ -0,0 +1,2072 @@
+import { fileURLToPath as Hr } from "node:url";
+import M from "node:path";
+import { app as P, shell as It, dialog as Wr, ipcMain as xt, Menu as Se, BrowserWindow as kr, nativeTheme as pe } from "electron";
+import re, { readFile as Qr } from "node:fs/promises";
+import { createHash as Yr, randomUUID as Kr } from "node:crypto";
+import { State as Jr, withLock as se, AsyncDisposeAggregator as Zr, LongTimeout as kt, isLockActive as Dr } from "lifecycle-utils";
+import { getLlama as en, LlamaLogLevel as tn, createModelDownloader as rn } from "node-llama-cpp";
+import { execFile as nn } from "node:child_process";
+import { promisify as sn } from "node:util";
+import on from "electron-updater";
+const de = [
+  {
+    id: "gemma-q8",
+    name: "Gemma 4",
+    parameters: "5B E2B",
+    quant: "Q8_0",
+    size: "5.0 GB",
+    uri: "hf:giladgd/gemma-4-E2B-it-GGUF:Q8_0"
+  },
+  {
+    id: "gemma-q6",
+    name: "Gemma 4",
+    parameters: "5B E2B",
+    quant: "Q6_K",
+    size: "3.9 GB",
+    uri: "hf:giladgd/gemma-4-E2B-it-GGUF:Q6_K"
+  },
+  {
+    id: "qwen-2b",
+    name: "Qwen 3.5",
+    parameters: "2B",
+    quant: "Q4_K_M",
+    size: "1.3 GB",
+    uri: "hf:unsloth/Qwen3.5-2B-GGUF:Q4_K_M"
+  },
+  {
+    id: "qwen-0.8b",
+    name: "Qwen 3.5",
+    parameters: "0.8B",
+    quant: "Q8_0",
+    size: "0.8 GB",
+    uri: "hf:unsloth/Qwen3.5-0.8B-GGUF:Q8_0"
+  }
+];
+function Re(e) {
+  const r = de.find((i) => i.id === e);
+  if (r == null)
+    throw new Error("Unknown model");
+  return r;
+}
+const an = ["noul", "choice", "score"], Dt = { noul: 2, choice: 50, score: 10 };
+function ln(e) {
+  const r = vt(e?.input);
+  if (r != null)
+    return r;
+  if (e.additionalInputs != null) {
+    if (!Array.isArray(e.additionalInputs) || e.additionalInputs.length > 6)
+      return "Use at most seven questions per document.";
+    for (const i of e.additionalInputs) {
+      const t = vt(i);
+      if (t != null)
+        return t;
+      if (i.document !== e.input.document)
+        return "All questions must use the same document.";
+    }
+  }
+}
+function cn(e, r) {
+  return typeof e == "string" && e.length <= 1e3 && (r === "noul" || e.trim().length > 0);
+}
+function Pr({ type: e, criteria: r }) {
+  if (e === "noul")
+    return r;
+  let i = r.length;
+  for (; i > 0; ) {
+    const t = r[i - 1];
+    if (typeof t != "string" || t.length > 1e3 || t.trim())
+      break;
+    i--;
+  }
+  return i === r.length ? r : r.slice(0, i);
+}
+function vt(e) {
+  if (e == null || !an.includes(e.type))
+    return "Choose a decision type.";
+  if (typeof e.document != "string" || e.document.length > 32e3)
+    return "Keep the document under 32,000 characters.";
+  if (typeof e.instruction != "string" || !e.instruction.trim() || e.instruction.length > 1e3)
+    return "Enter a question (up to 1,000 characters).";
+  if (!Array.isArray(e.criteria) || e.criteria.length < 2 || e.criteria.length > Dt[e.type])
+    return e.type === "noul" ? "Use exactly two criteria." : `Use between 2 and ${Dt[e.type]} criteria.`;
+  const r = Pr(e);
+  if (r.length < 2)
+    return "Enter at least two nonempty criteria.";
+  if (r.some((i) => !cn(i, e.type)))
+    return e.type === "noul" ? "Use text of up to 1,000 characters for each criterion." : "Fill in each criterion (up to 1,000 characters).";
+}
+function un(e) {
+  const r = vt(e);
+  if (r != null)
+    throw new Error(r);
+  const { type: i, instruction: t } = e, s = Pr(e);
+  return i === "noul" ? { type: i, instruction: t, criteria: { true: s[0], false: s[1] } } : i === "choice" ? { type: i, instruction: t, criteria: Object.fromEntries(s.map((l, a) => [String(a), l])) } : { type: i, instruction: t, criteria: s };
+}
+const dn = { models: {}, localModels: [], scores: [] }, v = new Jr(dn);
+let Pt, ve, ce, ge;
+const we = /* @__PURE__ */ new Map(), Cr = /* @__PURE__ */ new Map(), $t = [v, "inference"];
+function Et() {
+  return M.join(P.getPath("userData"), "models");
+}
+function oe(e) {
+  const r = Cr.get(e);
+  return r ?? (Re(e), M.join(Et(), `${e}.gguf`));
+}
+function Y(e, r) {
+  v.state = {
+    ...v.state,
+    models: { ...v.state.models, [e]: { downloaded: !1, ...v.state.models[e], ...r } }
+  };
+}
+async function hn() {
+  await Promise.all(de.map(async ({ id: e }) => {
+    const r = await re.stat(oe(e)).catch(() => {
+    });
+    Y(e, { downloaded: r != null && r.isFile() && r.size > 0 });
+  }));
+}
+function fn(e) {
+  const r = Re(e);
+  if (we.has(e) || v.state.models[e]?.downloaded || v.state.models[e]?.deleting)
+    return;
+  const i = new AbortController();
+  we.set(e, i), Y(e, { error: void 0, download: { status: "downloading", downloadedSize: 0, totalSize: 0 } }), (async () => {
+    let t;
+    try {
+      let s = 0;
+      t = await rn({
+        modelUri: r.uri,
+        dirPath: M.dirname(oe(e)),
+        fileName: M.basename(oe(e)),
+        onProgress({ downloadedSize: l, totalSize: a, estimatedTimeLeft: u, averageSpeed: o }) {
+          i.signal.aborted || Date.now() - s < 100 && l < a || (s = Date.now(), Y(e, { download: {
+            status: "downloading",
+            downloadedSize: l,
+            totalSize: a,
+            speed: Number.isFinite(o) && o >= 0 ? o : void 0,
+            eta: o > 0 && Number.isFinite(u) ? u : void 0
+          } }));
+        }
+      }), i.signal.throwIfAborted(), await t.download({ signal: i.signal }), i.signal.throwIfAborted(), Y(e, { downloaded: !0, download: void 0 }), v.state.loadedModelId == null && v.state.loading == null && _r(e);
+    } catch (s) {
+      await t?.cancel().catch(console.error), Y(e, { download: void 0, error: i.signal.aborted ? void 0 : String(s) });
+    } finally {
+      we.delete(e);
+    }
+  })();
+}
+function pn(e) {
+  Re(e);
+  const r = v.state.models[e]?.download;
+  r != null && (Y(e, { download: { ...r, status: "canceling" } }), we.get(e)?.abort());
+}
+function _r(e) {
+  const r = oe(e);
+  if (!v.state.models[e]?.downloaded)
+    throw new Error("Download the model first.");
+  if (!(v.state.models[e]?.deleting || v.state.loading != null || v.state.loadedModelId === e))
+    return v.state = { ...v.state, loadedModelId: void 0, loading: { modelId: e, progress: 0, stage: "model" }, error: void 0 }, se($t, async () => {
+      try {
+        await yt(), Pt ??= await en({ logLevel: tn.error }), ve = await Pt.loadModel({
+          modelPath: r,
+          onLoadProgress(i) {
+            v.state = { ...v.state, loading: { modelId: e, progress: i, stage: "model" } };
+          }
+        }), v.state = { ...v.state, loading: { modelId: e, progress: 1, stage: "context" } }, ce = await ve.createDecisionContext({ contextSize: { max: 4096 }, parallelQuestions: 3 }), v.state = { ...v.state, loading: { modelId: e, progress: 1, stage: "warmup" } }, await ce.warmup(), v.state = { ...v.state, loadedModelId: e, loading: void 0 };
+      } catch (i) {
+        await yt().catch((t) => {
+          i = t;
+        }), v.state = { ...v.state, loading: void 0, error: String(i) };
+      }
+    });
+}
+async function yt() {
+  v.state = { ...v.state, loadedModelId: void 0 }, ge ??= new Zr().add(async () => {
+    await ce?.dispose();
+  }).add(async () => {
+    await ve?.dispose();
+  }).dispose().catch((e) => {
+    throw new Error(`Could not fully unload the model. Restart the app before loading another model. ${String(e)}`);
+  }), await ge, ce = void 0, ve = void 0, ge = void 0;
+}
+async function mn(e) {
+  oe(e?.modelId);
+  const r = ln(e);
+  if (r != null)
+    throw new Error(r);
+  const i = [e.input, ...e.additionalInputs ?? []], t = Object.fromEntries(i.map((s, l) => [String(l), un(s)]));
+  return await se($t, async () => {
+    if (ce == null || v.state.loadedModelId !== e.modelId)
+      throw new Error("The selected model is no longer loaded.");
+    const s = performance.now(), l = await ce.decide(e.input.document, t);
+    return {
+      answer: l[0],
+      additionalAnswers: e.additionalInputs == null ? void 0 : i.slice(1).map((a, u) => l[String(u + 1)]),
+      duration: performance.now() - s
+    };
+  });
+}
+async function gn(e) {
+  const { canceled: r, filePaths: i } = await Wr.showOpenDialog(e, {
+    title: "Select a model",
+    filters: [{ name: "GGUF models", extensions: ["gguf"] }],
+    properties: ["openFile"]
+  });
+  if (r || i[0] == null)
+    return;
+  const t = await re.realpath(i[0]), s = await re.stat(t);
+  if (!s.isFile() || s.size === 0 || M.extname(t).toLowerCase() !== ".gguf")
+    throw new Error("Select a nonempty GGUF model file.");
+  const l = de.find(({ id: u }) => oe(u) === t);
+  if (l != null)
+    return Y(l.id, { downloaded: !0 }), l.id;
+  const a = `local:${Yr("sha256").update(`${t}\0${s.size}\0${s.mtimeMs}`).digest("hex")}`;
+  return Cr.set(a, t), v.state.localModels.some((u) => u.id === a) || (v.state = { ...v.state, localModels: [...v.state.localModels, { id: a, name: M.basename(t) }] }), Y(a, { downloaded: !0 }), a;
+}
+async function wn() {
+  await re.mkdir(Et(), { recursive: !0 });
+  const e = await It.openPath(Et());
+  if (e)
+    throw new Error(e);
+}
+async function vn(e) {
+  if (Re(e), v.state.models[e]?.deleting || !v.state.models[e]?.downloaded || v.state.loading != null)
+    return;
+  const r = v.state.loadedModelId === e;
+  Y(e, { deleting: !0, error: void 0 });
+  try {
+    await se($t, async () => {
+      (r || ge != null) && await yt(), await re.rm(oe(e), { force: !0 }), Y(e, { downloaded: !1 });
+    });
+  } catch (i) {
+    throw Y(e, { error: String(i) }), i;
+  } finally {
+    Y(e, { deleting: !1 });
+  }
+}
+function En() {
+  let e, r;
+  return {
+    promise: new Promise((i, t) => {
+      e = i, r = t;
+    }),
+    resolve: e,
+    reject: r
+  };
+}
+const yn = Math.random.bind(Math), Rn = "useandom-26T198340PX75pxJACKVERYMINDBUSHWOLF_GQZbfghjklqvwyzrict";
+function Tn(e = 21) {
+  let r = "", i = e;
+  for (; i--; ) r += Rn[yn() * 64 | 0];
+  return r;
+}
+const In = 6e4, Gr = (e) => e, $n = Gr, { clearTimeout: Ct, setTimeout: An } = globalThis;
+function Sn(e, r) {
+  const { post: i, on: t, off: s = () => {
+  }, eventNames: l = [], serialize: a = Gr, deserialize: u = $n, resolver: o, bind: g = "rpc", timeout: n = In, proxify: c = !0 } = r;
+  let d = !1;
+  const p = /* @__PURE__ */ new Map();
+  let A, h;
+  async function q(E, S, L, w) {
+    if (d) throw new Error(`[birpc] rpc is closed, cannot call "${E}"`);
+    const C = {
+      m: E,
+      a: S,
+      t: "q"
+    };
+    w && (C.o = !0);
+    const K = async (m) => i(a(m));
+    if (L) {
+      await K(C);
+      return;
+    }
+    if (A) try {
+      await A;
+    } finally {
+      A = void 0;
+    }
+    let { promise: B, resolve: X, reject: ee } = En();
+    const F = Tn();
+    C.i = F;
+    let te;
+    async function le(m = C) {
+      return n >= 0 && (te = An(() => {
+        try {
+          if (r.onTimeoutError?.call(h, E, S) !== !0) throw new Error(`[birpc] timeout on calling "${E}"`);
+        } catch (f) {
+          ee(f);
+        }
+        p.delete(F);
+      }, n), typeof te == "object" && (te = te.unref?.())), p.set(F, {
+        resolve: X,
+        reject: ee,
+        timeoutId: te,
+        method: E
+      }), await K(m), B;
+    }
+    try {
+      r.onRequest ? await r.onRequest.call(h, C, le, X) : await le();
+    } catch (m) {
+      if (r.onGeneralError?.call(h, m) !== !0) throw m;
+      return;
+    } finally {
+      Ct(te), p.delete(F);
+    }
+    return B;
+  }
+  const x = {
+    $call: (E, ...S) => q(E, S, !1),
+    $callOptional: (E, ...S) => q(E, S, !1, !0),
+    $callEvent: (E, ...S) => q(E, S, !0),
+    $callRaw: (E) => q(E.method, E.args, E.event, E.optional),
+    $rejectPendingCalls: U,
+    get $closed() {
+      return d;
+    },
+    get $meta() {
+      return r.meta;
+    },
+    $close: _,
+    $functions: e
+  };
+  c ? h = new Proxy({}, { get(E, S) {
+    if (Object.hasOwn(x, S)) return x[S];
+    if (S === "then" && !l.includes("then") && !("then" in e)) return;
+    const L = (...C) => q(S, C, !0);
+    if (l.includes(S))
+      return L.asEvent = L, L;
+    const w = (...C) => q(S, C, !1);
+    return w.asEvent = L, w;
+  } }) : h = x;
+  function _(E) {
+    d = !0, p.forEach(({ reject: S, method: L }) => {
+      const w = /* @__PURE__ */ new Error(`[birpc] rpc is closed, cannot call "${L}"`);
+      if (E)
+        return E.cause ??= w, S(E);
+      S(w);
+    }), p.clear(), s(j);
+  }
+  function U(E) {
+    const S = Array.from(p.values()).map(({ method: L, reject: w }) => E ? E({
+      method: L,
+      reject: w
+    }) : w(/* @__PURE__ */ new Error(`[birpc]: rejected pending call "${L}".`)));
+    return p.clear(), S;
+  }
+  async function j(E, ...S) {
+    let L;
+    try {
+      L = u(E);
+    } catch (w) {
+      if (r.onGeneralError?.call(h, w) !== !0) throw w;
+      return;
+    }
+    if (L.t === "q") {
+      const { m: w, a: C, o: K } = L;
+      let B, X, ee = await (o ? o.call(h, w, e[w]) : e[w]);
+      if (K && (ee ||= () => {
+      }), !ee) X = /* @__PURE__ */ new Error(`[birpc] function "${w}" not found`);
+      else try {
+        B = await ee.apply(g === "rpc" ? h : e, C);
+      } catch (F) {
+        X = F;
+      }
+      if (L.i) {
+        if (X && r.onFunctionError && r.onFunctionError.call(h, X, w, C) === !0)
+          return;
+        if (!X) try {
+          await i(a({
+            t: "s",
+            i: L.i,
+            r: B
+          }), ...S);
+          return;
+        } catch (F) {
+          if (X = F, r.onGeneralError?.call(h, F, w, C) !== !0) throw F;
+        }
+        try {
+          await i(a({
+            t: "s",
+            i: L.i,
+            e: X
+          }), ...S);
+        } catch (F) {
+          if (r.onGeneralError?.call(h, F, w, C) !== !0) throw F;
+        }
+      }
+    } else {
+      const { i: w, r: C, e: K } = L, B = p.get(w);
+      B && (Ct(B.timeoutId), K ? B.reject(K) : B.resolve(C)), p.delete(w);
+    }
+  }
+  return A = t(j), h;
+}
+function bn(e, r, i, t) {
+  let s;
+  return Sn(t, {
+    post: (l) => i.webContents.send(e, l),
+    on: (l) => {
+      s = (a, u) => {
+        a.sender === i.webContents && l(u);
+      }, xt.on(r, s);
+    },
+    off: () => {
+      s != null && xt.off(r, s);
+    },
+    serialize: (l) => JSON.stringify(l, (a, u) => u instanceof Error ? String(u) : u),
+    deserialize: (l) => JSON.parse(l)
+  });
+}
+const _t = {
+  animal: ["Names an animal", "Does the text contain an actual animal name? A category label is not an animal name.", "An animal name like cat, dog, or fox appears in the text.", "No animal name appears in the text."],
+  help: ["Asks for help", "Does the writer ask someone for help?", "The writer requests assistance or asks someone to help."],
+  urgent: ["Needs action now", "Does the text explicitly call for immediate action?", "The message requests action now, immediately, or describes an emergency."],
+  apology: ["Apologizes", "Does the writer apologize?", "The writer expresses regret for something and says sorry or apologizes."],
+  weather: ["Names bad weather", "Does the text name a bad-weather condition?", "A concrete condition is named, such as rain, snow, or a storm. The generic phrase bad weather alone does not count. Do not infer unfinished words."],
+  alternative: ["Proposes another plan", "Does the writer propose a replacement plan?", "The writer suggests doing something else instead of the original plan."],
+  food: ["Names a food", "Does the text name a food?", "The text names a food such as pizza, bread, soup, or rice. The generic word food alone does not count. Do not infer unfinished words."],
+  question: ["Asks a question", "Does the quoted Text contain an interrogative sentence? Judge only the quoted Text. Unfinished words do not count; do not guess what comes next.", "The text contains a question.", "The text contains no questions."],
+  excited: ["Shows excitement", "Does the writer express excitement?", "The writer expresses enthusiasm, delight, or eagerness about something."],
+  thanks: ["Expresses thanks", "Does the writer thank someone?", "The text includes thanks, thank you, or another expression of gratitude."],
+  time: ["Gives a time", "Does the text mention a time or day?", "A specific time or day is mentioned, such as noon, six, Friday, or tomorrow."],
+  place: ["Names a location", "Does the text mention a place or location?", "A concrete place is named, such as a house, river, bridge, park, kitchen, or office."],
+  invite: ["Invites someone", "Does the writer invite someone to take part?", "The writer invites the reader to join an activity or come somewhere."],
+  warning: ["Warns of a risk", "Does the message warn someone about a danger or problem?", "The writer warns of a specific risk or harmful possibility."],
+  reason: ["Explains why", "Does the message give a reason for a situation, action, or request?", "A reason is given for a situation, request, or action, for example using because or so."],
+  condition: ["Sets a condition", "Does the message make an action depend on a condition?", "An action or outcome depends on an explicit condition, for example if or unless something happens."],
+  offer: ["Offers assistance", "Does the writer offer to help someone?", "The writer offers their own help or assistance."],
+  promise: ["Makes a commitment", "Does the writer commit to a future action?", "The writer states something they will do or promises to do it."],
+  contrast: ["Contrasts two facts", "Does the text contrast two facts or qualities?", "The text presents contrasting preferences or facts, often joined by but, although, or despite."],
+  refuse: ["Declines a request", "Does the writer decline or refuse something?", "The writer clearly says they cannot or will not accept, attend, or do something."],
+  repair: ["Offers to make amends", "Does the writer offer to put right something that went wrong?", "The writer proposes a concrete repair, replacement, repayment, or corrective action."],
+  quantity: ["Gives a quantity", "Does the message state how many or how much?", "There is a count of things, people, or payments, expressed in digits or words."],
+  transport: ["Names a vehicle", "Does the text name a vehicle?", "The text names a vehicle, such as a train, bus, bike, car, or boat. Do not infer unfinished words."],
+  sequence: ["Orders two actions", "Does the message explicitly put two actions in order?", "The message says one action should happen before or after another, or gives a first step and then a second."],
+  compare: ["Makes a comparison", "Does the message contain an explicit comparison?", "A comparison is made, for example saying one thing is cheaper, faster, higher, or lower than another."],
+  consequence: ["States a consequence", "Does the message state what will result from an action or event?", "The message explicitly connects an action or event to a resulting outcome."],
+  permission: ["Asks permission", "Does the writer ask permission to do something?", "The writer asks whether they may do a specific action."],
+  compromise: ["Proposes a compromise", "Does the writer propose meeting someone halfway?", "The writer proposes a middle ground or concession that accommodates two different needs or preferences."],
+  choice: ["Offers a choice", "Does the writer give the reader a choice between alternatives?", "The reader is offered two or more specific alternatives to choose from."],
+  money: ["Mentions a price", "Does the text mention an amount of money?", "The text mentions a sum of money, such as $5 or ten dollars."],
+  reassure: ["Reassures someone", "Does the writer reassure someone who might worry?", "The writer explicitly offers reassurance that a situation is safe, manageable, or will be taken care of."],
+  credit: ["Credits someone else", "Does the writer give someone else credit for a contribution?", "Another person or group is acknowledged for a helpful action, idea, or achievement."],
+  instructions: ["Gives an instruction", "Does the message tell the reader to do a specific action?", "The writer directly instructs the reader to do something concrete."]
+};
+function I(e, r, i, ...t) {
+  const s = t.map((l) => _t[l]);
+  return {
+    id: e,
+    title: r,
+    limit: i,
+    labels: s.map(([l]) => l),
+    questions: t.map((l) => {
+      const [, a, u, o] = _t[l];
+      return o != null ? {
+        type: "noul",
+        instruction: a,
+        criteria: [u, o]
+      } : {
+        type: "noul",
+        instruction: `${a} Answer yes if ${u[0].toLowerCase()}${u.slice(1)} Answer no otherwise.`,
+        criteria: ["Yes", "No"]
+      };
+    })
+  };
+}
+const qn = [
+  { id: 1, title: "Make yourself understood", skill: "Combine a topic, a purpose, and a tone.", rounds: [
+    I("1-1", "A small emergency", 120, "animal", "help", "urgent"),
+    I("1-2", "Change of plans", 110, "apology", "weather", "alternative"),
+    I("1-3", "A bright idea", 100, "food", "question", "excited")
+  ] },
+  { id: 2, title: "Say what you need", skill: "Make requests and invitations precise.", rounds: [
+    I("2-1", "Lunch is on me", 100, "food", "invite", "time"),
+    I("2-2", "A helpful neighbor", 100, "thanks", "animal", "offer"),
+    I("2-3", "A clear handoff", 95, "instructions", "place", "time")
+  ] },
+  { id: 3, title: "Give it a reason", skill: "Connect a request or change to its cause.", rounds: [
+    I("3-1", "The rainy picnic", 125, "weather", "alternative", "reason", "invite"),
+    I("3-2", "Running late", 120, "apology", "transport", "reason", "time"),
+    I("3-3", "A hungry guest", 115, "food", "help", "reason", "thanks")
+  ] },
+  { id: 4, title: "Plan ahead", skill: "Use conditions and sequences without losing clarity.", rounds: [
+    I("4-1", "Weather permitting", 120, "condition", "weather", "invite", "place"),
+    I("4-2", "Dinner in order", 115, "food", "sequence", "instructions", "time"),
+    I("4-3", "The early train", 115, "transport", "condition", "promise", "time"),
+    I("4-4", "A careful crossing", 115, "warning", "sequence", "instructions", "reason")
+  ] },
+  { id: 5, title: "Small repairs", skill: "Take responsibility and propose a useful next step.", rounds: [
+    I("5-1", "The broken mug", 140, "apology", "repair", "promise", "time", "reason"),
+    I("5-2", "Dinner went wrong", 135, "food", "apology", "repair", "choice", "time"),
+    I("5-3", "Sorry I can't make it", 130, "refuse", "apology", "reason", "alternative", "time"),
+    I("5-4", "A borrowed bicycle", 130, "transport", "thanks", "promise", "time", "place")
+  ] },
+  { id: 6, title: "Make room for both", skill: "Compare choices and balance different needs.", rounds: [
+    I("6-1", "A quieter dinner", 135, "food", "contrast", "compare", "choice", "question"),
+    I("6-2", "Meet halfway", 130, "compromise", "place", "time", "invite", "reason"),
+    I("6-3", "The cheaper journey", 125, "transport", "compare", "money", "choice", "question"),
+    I("6-4", "A little reassurance", 125, "animal", "warning", "reassure", "offer", "condition")
+  ] },
+  { id: 7, title: "Useful details", skill: "Fit six pieces of useful information into one message.", rounds: [
+    I("7-1", "Soup for the team", 155, "food", "quantity", "time", "place", "invite", "question"),
+    I("7-2", "A rescue plan", 150, "animal", "help", "urgent", "place", "warning", "instructions"),
+    I("7-3", "A missed delivery", 145, "apology", "repair", "promise", "time", "choice", "place"),
+    I("7-4", "The last bus", 140, "transport", "warning", "condition", "consequence", "alternative", "time"),
+    I("7-5", "A generous offer", 140, "thanks", "credit", "offer", "time", "place", "question")
+  ] },
+  { id: 8, title: "Tact and tradeoffs", skill: "Keep the relationship intact while changing the plan.", rounds: [
+    I("8-1", "A fair split", 150, "compromise", "money", "quantity", "reason", "choice", "time"),
+    I("8-2", "Not tonight", 145, "refuse", "apology", "reason", "alternative", "invite", "time"),
+    I("8-3", "A safer outing", 145, "weather", "warning", "alternative", "reason", "invite", "place"),
+    I("8-4", "A careful favor", 140, "permission", "animal", "condition", "promise", "place", "time"),
+    I("8-5", "Dinner, revised", 140, "food", "contrast", "compromise", "choice", "time", "question")
+  ] },
+  { id: 9, title: "Seven moving parts", skill: "Combine seven conditions in a coherent message.", rounds: [
+    I("9-1", "The surprise picnic", 175, "food", "excited", "invite", "quantity", "time", "place", "question"),
+    I("9-2", "A wet-weather rescue", 170, "animal", "weather", "help", "urgent", "place", "warning", "instructions"),
+    I("9-3", "Make it right", 165, "apology", "repair", "promise", "time", "money", "choice", "reason"),
+    I("9-4", "Two ways home", 165, "transport", "compare", "money", "time", "choice", "condition", "question"),
+    I("9-5", "A team effort", 160, "thanks", "credit", "offer", "promise", "time", "place", "reason"),
+    I("9-6", "A safe sequence", 160, "food", "warning", "sequence", "instructions", "condition", "consequence", "reason")
+  ] },
+  { id: 10, title: "Every word earns its place", skill: "Keep the same meaning while trimming seven-part messages.", rounds: [
+    I("10-1", "The short invitation", 135, "food", "invite", "time", "place", "quantity", "excited", "question"),
+    I("10-2", "The short apology", 135, "apology", "refuse", "reason", "alternative", "invite", "time", "place"),
+    I("10-3", "The short rescue", 130, "animal", "help", "urgent", "place", "warning", "instructions", "reason"),
+    I("10-4", "The short bargain", 130, "compromise", "compare", "money", "choice", "condition", "promise", "time"),
+    I("10-5", "The short handoff", 130, "instructions", "sequence", "time", "place", "quantity", "food", "thanks"),
+    I("10-6", "The short reassurance", 130, "animal", "reassure", "offer", "condition", "promise", "time", "place")
+  ] },
+  { id: 11, title: "The final edit", skill: "Eight different situations. Seven conditions. Make each message count.", rounds: [
+    I("11-1", "The gathering", 145, "food", "invite", "excited", "quantity", "time", "place", "question"),
+    I("11-2", "The setback", 140, "weather", "apology", "reason", "alternative", "invite", "time", "place"),
+    I("11-3", "The emergency", 140, "animal", "help", "urgent", "warning", "place", "instructions", "reason"),
+    I("11-4", "The repair", 140, "apology", "repair", "promise", "time", "choice", "money", "reason"),
+    I("11-5", "The negotiation", 140, "compromise", "refuse", "reason", "alternative", "condition", "promise", "money"),
+    I("11-6", "The journey", 135, "transport", "compare", "choice", "money", "time", "condition", "question"),
+    I("11-7", "The handover", 135, "food", "sequence", "instructions", "warning", "reason", "time", "thanks"),
+    I("11-8", "The thank-you", 135, "thanks", "credit", "offer", "promise", "invite", "time", "place")
+  ] }
+], Gt = {
+  praise: ["Praise", "Does the quoted Text contain any praise or compliment, even if it also contains criticism?"],
+  complaint: ["Complaint", "Does the quoted Text complain about a problem the writer has experienced? A warning about a possible danger is not a complaint."],
+  question: ["Question", "Does the quoted Text contain an interrogative sentence?"],
+  apology: ["Apology", "Does the writer explicitly apologize, such as saying sorry or I apologize?"],
+  invitation: ["Invitation", "Does the quoted Text directly ask another person to join the writer in an activity?"],
+  warning: ["Warning", "Does the text warn of a danger?"],
+  thanks: ["Gratitude", "Is there an expression of gratitude anywhere in the quoted Text?"],
+  offer: ["Offer of help", 'Does the quoted Text explicitly volunteer help to another person, such as "I can help you"?'],
+  request: ["Request for help", "Does the writer ask the reader to provide help? Offering help is different."],
+  promise: ["Promise", "Does the writer explicitly commit to a future action, such as saying I promise or I will? Describing a current activity is not a promise."],
+  refusal: ["Refusal", "Does the writer turn down an invitation, offer, or request?"],
+  food: ["Food", "Is a food item or ingredient named anywhere in the text?"],
+  nature: ["Nature", "Does the text mention wild animals, wild plants, or a natural landscape?"],
+  pets: ["Pets", "Does the text mention a pet?"],
+  travel: ["Travel", "Does the text describe a person taking a journey or visiting a different place? Mentioning a location alone is not travel."],
+  work: ["Work", "Does the text explicitly mention a paid job, employment, or professional duties?"],
+  leisure: ["Leisure", "Does the text explicitly say an activity is done for fun, pleasure, or as a hobby? Performing an activity alone does not say it is recreation."],
+  shopping: ["Shopping", "Does the text explicitly describe buying, selling, or ordering goods?"],
+  learning: ["Learning", "Does the text explicitly describe someone learning, studying, or being taught? Performing an activity alone is not evidence of learning."],
+  science: ["Science", "Does the text mention a scientific fact, scientific process, experiment, or scientific study?"],
+  music: ["Music", "Does the text mention singing or playing music?"],
+  sport: ["Sport", "Does the text mention a sport or physical exercise?"],
+  art: ["Art", "Does the text mention drawing, painting, or sculpture?"],
+  technology: ["Technology", "Does the text mention computers, software, or electronic devices?"],
+  health: ["Health", "Does the text describe an illness, injury, or medical treatment?"],
+  gardening: ["Gardening", "Does the text describe cultivating plants in a garden? Look for an actual gardening action, such as planting seeds or watering flowers."],
+  cooking: ["Cooking", "Does the text explicitly describe preparing or cooking food, such as chopping, mixing, baking, or boiling? Eating or tasting food alone does not count."],
+  repair: ["Repair", "Does the quoted Text identify a broken object and describe repairing it? Do not infer or complete missing text."],
+  transport: ["Transport", "Does the text mention a vehicle?"],
+  weather: ["Weather", "Does the text mention a weather condition?"],
+  celebration: ["Celebration", "Does the text describe celebrating a special occasion?"],
+  family: ["Family", "Does the text mention a family member?"],
+  history: ["History", "Does the quoted Text name a particular ancient civilization or a specific historical event?"]
+}, jt = {
+  question: ["The text contains a question.", "The text contains no questions."],
+  praise: ["The writer gives a compliment or positive feedback.", "The writer gives no compliment or positive feedback."],
+  complaint: ["An actual complaint about a bad experience.", "No complaint about a bad experience."],
+  learning: ["Someone is explicitly learning, studying, or receiving a lesson.", "No learning, study, or lesson is described."],
+  offer: ["An explicit offer to help another person.", "A personal activity or other message without an offer of help."],
+  leisure: ["An activity is explicitly done for fun or as a hobby.", "No recreational purpose is stated. This includes unrelated text or fragments without enough information."],
+  shopping: ["Goods are bought, sold, or ordered.", "No goods are bought, sold, or ordered."],
+  apology: ["The writer explicitly apologizes.", "The writer does not apologize."],
+  invitation: ["A direct invitation addressed to another person.", "No direct invitation is addressed to another person."],
+  warning: ["The text warns someone about a specific danger.", "The text does not warn of a danger."],
+  thanks: ["Thanks, thank you, or being grateful is expressed.", "No expression of gratitude is present."],
+  promise: ["The writer commits to a future action.", "No commitment to a future action is made."],
+  refusal: ["The writer says no to an invitation, offer, or request.", "The writer does not turn down an invitation, offer, or request."],
+  request: ["The writer asks someone else for assistance.", "The writer does not ask for assistance."],
+  food: ["A food or ingredient is named, such as bread, rice, cake, or lemon.", "No actual food or ingredient is named; the text may be unrelated or unfinished."],
+  nature: ["Wild animals, wild plants, or a natural landscape are mentioned.", "No wild animals, wild plants, or natural landscape are mentioned."],
+  pets: ["The text mentions an animal kept as a pet.", "No pet is mentioned."],
+  travel: ["Someone is traveling or visiting a place.", "No one is traveling or visiting a place."],
+  work: ["The text explicitly describes paid work, employment, or professional duties.", "The text does not describe paid work, employment, or professional duties."],
+  science: ["A scientific process, finding, experiment, or study is described.", "No scientific process, finding, experiment, or study is described."],
+  music: ["Singing, playing music, or a musical instrument is mentioned.", "No singing, music, or musical instrument is mentioned."],
+  sport: ["A sport or physical exercise is mentioned.", "No sport or physical exercise is mentioned."],
+  art: ["Drawing, painting, or sculpture is mentioned.", "No drawing, painting, or sculpture is mentioned."],
+  technology: ["Computers, software, or electronic devices are mentioned.", "No computers, software, or electronic devices are mentioned. This includes unrelated text or fragments without enough information."],
+  health: ["An illness, injury, or medical treatment is described.", "No illness, injury, or medical treatment is described."],
+  gardening: ["An actual gardening action is described.", "No gardening action is described."],
+  cooking: ["Preparing or cooking food is described.", "No preparation or cooking of food is described."],
+  repair: ["The text identifies a broken object and describes a repair.", "No specific broken object and repair are described; the text may be unrelated or unfinished."],
+  transport: ["The text names a vehicle, such as a car, bus, bicycle, or train.", "No vehicle is named."],
+  weather: ["A specific weather condition is mentioned.", "No weather condition is mentioned."],
+  celebration: ["Someone celebrates a special occasion.", "No celebration of a special occasion is described."],
+  family: ["A family member is mentioned.", "No family member is mentioned."],
+  history: ["The text names an ancient civilization or a historical event.", "No ancient civilization or historical event is named in the text."]
+};
+function $(e, r, i, ...t) {
+  const s = t.map((l) => Gt[l]);
+  return {
+    id: e,
+    title: r,
+    limit: i,
+    labels: s.map(([l]) => l),
+    questions: t.map((l) => ({
+      type: "choice",
+      instruction: Gt[l][1],
+      // Absence first reduces false matches on ambiguous, unfinished input.
+      criteria: [jt[l][1], jt[l][0]]
+    }))
+  };
+}
+const Nn = [
+  { id: 1, title: "Two meanings at once", skill: "Blend two clear meanings and avoid the distractions.", rounds: [
+    $("1-1", "Praise and criticism", 120, "praise", "complaint", "question", "apology"),
+    $("1-2", "Work can be fun", 110, "work", "leisure", "shopping", "warning"),
+    $("1-3", "An invitation with a catch", 110, "invitation", "warning", "apology", "refusal")
+  ] },
+  { id: 2, title: "Cross the topics", skill: "Make one activity connect two different subjects.", rounds: [
+    $("2-1", "Edible experiments", 110, "food", "science", "shopping", "complaint"),
+    $("2-2", "A musical lesson", 100, "music", "learning", "work", "shopping"),
+    $("2-3", "The active pet", 100, "pets", "sport", "shopping", "warning")
+  ] },
+  { id: 3, title: "Purpose and subject", skill: "Give a familiar topic a distinct purpose.", rounds: [
+    $("3-1", "A helpful meal", 110, "food", "offer", "request", "apology", "shopping"),
+    $("3-2", "A digital question", 105, "technology", "question", "complaint", "shopping", "promise"),
+    $("3-3", "A grateful patient", 105, "health", "thanks", "complaint", "question", "warning")
+  ] },
+  { id: 4, title: "The obvious wrong answer", skill: "Make the distinction that the distractor tries to blur.", rounds: [
+    $("4-1", "Making it, not buying it", 105, "cooking", "leisure", "shopping", "work", "request"),
+    $("4-2", "Practice without a paycheck", 100, "learning", "technology", "work", "shopping", "complaint"),
+    $("4-3", "A stroll through time", 100, "travel", "history", "shopping", "work", "sport"),
+    $("4-4", "Helping, not asking", 100, "repair", "offer", "request", "shopping", "apology")
+  ] },
+  { id: 5, title: "Mixed feelings", skill: "Combine two intentions without accidentally adding a third.", rounds: [
+    $("5-1", "A grateful critic", 105, "thanks", "complaint", "apology", "request", "question"),
+    $("5-2", "No, but thank you", 100, "refusal", "thanks", "apology", "question", "promise"),
+    $("5-3", "Sorry, let me help", 100, "apology", "offer", "request", "warning", "promise"),
+    $("5-4", "A promise of praise", 100, "promise", "praise", "invitation", "question", "thanks")
+  ] },
+  { id: 6, title: "Find the connection", skill: "Connect subjects through one concrete detail.", rounds: [
+    $("6-1", "A living laboratory", 105, "gardening", "science", "shopping", "work", "food", "warning"),
+    $("6-2", "A painted past", 100, "art", "history", "shopping", "travel", "work", "music"),
+    $("6-3", "A family melody", 100, "family", "music", "shopping", "work", "question", "complaint"),
+    $("6-4", "Recover through movement", 100, "health", "sport", "shopping", "work", "warning", "complaint")
+  ] },
+  { id: 7, title: "Six-way distinction", skill: "Keep two signals strong among four plausible alternatives.", rounds: [
+    $("7-1", "A scientific repair", 105, "repair", "science", "shopping", "work", "question", "request"),
+    $("7-2", "The birthday recipe", 100, "cooking", "celebration", "shopping", "work", "invitation", "question"),
+    $("7-3", "A wildlife lesson", 100, "nature", "learning", "travel", "sport", "gardening", "work"),
+    $("7-4", "Rain on the route", 100, "weather", "transport", "travel", "warning", "shopping", "question"),
+    $("7-5", "An artistic hobby", 95, "art", "leisure", "shopping", "work", "learning", "question")
+  ] },
+  { id: 8, title: "Close neighbors", skill: "Separate related meanings with carefully chosen details.", rounds: [
+    $("8-1", "Wild, not a pet", 100, "nature", "science", "pets", "gardening", "travel", "shopping"),
+    $("8-2", "Enjoying, not cooking", 95, "food", "praise", "cooking", "shopping", "thanks", "question"),
+    $("8-3", "Teach, don't take over", 95, "learning", "repair", "offer", "request", "work", "shopping"),
+    $("8-4", "Praise without gratitude", 95, "praise", "art", "thanks", "shopping", "question", "offer"),
+    $("8-5", "A plan, not an invitation", 95, "promise", "transport", "invitation", "offer", "question", "warning")
+  ] },
+  { id: 9, title: "Seven signals", skill: "Keep five distracting meanings out of a two-topic message.", rounds: [
+    $("9-1", "The singing family", 110, "family", "music", "work", "shopping", "invitation", "learning", "complaint"),
+    $("9-2", "The kitchen experiment", 105, "cooking", "science", "shopping", "work", "health", "question", "warning"),
+    $("9-3", "The outdoor painting", 105, "art", "nature", "gardening", "pets", "travel", "shopping", "work"),
+    $("9-4", "A polite no", 105, "refusal", "thanks", "apology", "promise", "question", "complaint", "offer"),
+    $("9-5", "The recovery routine", 100, "health", "sport", "work", "shopping", "complaint", "warning", "request"),
+    $("9-6", "A promised repair", 100, "repair", "promise", "apology", "request", "shopping", "question", "warning")
+  ] },
+  { id: 10, title: "Distill the meaning", skill: "Keep two meanings and lose the spare words.", rounds: [
+    $("10-1", "A concise review", 80, "praise", "complaint", "thanks", "apology", "question", "request", "warning"),
+    $("10-2", "A concise invitation", 80, "invitation", "warning", "apology", "refusal", "complaint", "promise", "thanks"),
+    $("10-3", "A concise lesson", 80, "music", "learning", "work", "shopping", "invitation", "question", "promise"),
+    $("10-4", "A concise offer", 80, "offer", "food", "request", "shopping", "apology", "question", "warning"),
+    $("10-5", "A concise connection", 80, "gardening", "technology", "shopping", "work", "food", "question", "warning"),
+    $("10-6", "A concise experiment", 80, "pets", "science", "work", "shopping", "health", "warning", "question")
+  ] },
+  { id: 11, title: "Perfectly mixed", skill: "Eight blends, with five distractions to avoid in each.", rounds: [
+    $("11-1", "The balanced verdict", 85, "praise", "complaint", "thanks", "apology", "question", "request", "warning"),
+    $("11-2", "The cautious welcome", 85, "invitation", "warning", "apology", "refusal", "complaint", "promise", "thanks"),
+    $("11-3", "The playful profession", 85, "work", "leisure", "shopping", "learning", "apology", "question", "offer"),
+    $("11-4", "The ancient canvas", 85, "art", "history", "travel", "shopping", "work", "learning", "question"),
+    $("11-5", "The growing gadget", 85, "gardening", "technology", "shopping", "work", "food", "question", "warning"),
+    $("11-6", "The family feast", 85, "family", "celebration", "invitation", "shopping", "question", "thanks", "promise"),
+    $("11-7", "The scientific snack", 85, "food", "science", "shopping", "work", "health", "question", "warning"),
+    $("11-8", "The gracious exit", 85, "refusal", "thanks", "apology", "promise", "question", "complaint", "offer")
+  ] }
+], Ee = {
+  lock: { name: "Semantic Golfing", description: "Write a short message that matches every condition within the character limit.", levels: qn },
+  signalMixing: { name: "Signal Mixing", description: "Blend two meanings in a short message while keeping the other categories out.", levels: Nn }
+};
+function Ln(e, r) {
+  if (!Number.isInteger(r) || r < 1 || r > e.limit)
+    throw new Error("The answer must fit the round's character limit.");
+  return Math.max(1, Math.round(1e3 * (1 - r / e.limit)));
+}
+function On(e, r) {
+  if (r.length !== e.rounds.length)
+    throw new Error("Finish every round before saving a level score.");
+  return e.rounds.reduce((i, t, s) => i + Ln(t, r[s]), 0);
+}
+function xn(e, r, i, t) {
+  return e.find((s) => s.modelId === r && s.game === i && s.level === t);
+}
+function kn(e, r, i) {
+  if (r == null || !Object.hasOwn(Ee, r.game) || !Number.isInteger(r.level) || typeof r.modelId != "string" || !Array.isArray(r.characters))
+    throw new Error("Invalid level score.");
+  const t = Ee[r.game].levels.find(({ id: a }) => a === r.level);
+  if (t == null)
+    throw new Error("Unknown level.");
+  const s = On(t, r.characters), l = xn(e, r.modelId, r.game, r.level)?.best ?? 0;
+  return { previousBest: l, record: {
+    modelId: r.modelId,
+    modelName: i,
+    game: r.game,
+    level: r.level,
+    latest: s,
+    best: Math.max(l, s),
+    completedAt: (/* @__PURE__ */ new Date()).toISOString()
+  } };
+}
+function Dn(e) {
+  if (e == null || typeof e != "object" || !("version" in e) || e.version !== 1 || !("records" in e) || !Array.isArray(e.records))
+    throw new Error("The saved score file has an unsupported format.");
+  const r = /* @__PURE__ */ new Set(), i = e.records.map((t) => t?.game === "camouflage" ? { ...t, game: "signalMixing" } : t);
+  for (const t of i) {
+    const s = t != null && Object.hasOwn(Ee, t.game) ? Ee[t.game].levels.find(({ id: a }) => a === t.level) : void 0;
+    if (s == null || typeof t.modelId != "string" || !(de.some(({ id: a }) => a === t.modelId) || /^local:[a-f0-9]{64}$/.test(t.modelId)) || typeof t.modelName != "string" || !t.modelName.trim() || t.modelName.length > 512 || !Number.isInteger(t.latest) || !Number.isInteger(t.best) || t.latest < s.rounds.length || t.best < t.latest || t.best > s.rounds.length * 1e3 || typeof t.completedAt != "string" || !Number.isFinite(Date.parse(t.completedAt)))
+      throw new Error("The saved score file contains an invalid score.");
+    const l = `${t.modelId}/${t.game}/${t.level}`;
+    if (r.has(l))
+      throw new Error("The saved score file contains duplicate scores.");
+    r.add(l);
+  }
+  return i;
+}
+const jr = () => M.join(P.getPath("userData"), "scores.json");
+async function Pn() {
+  try {
+    const e = Dn(JSON.parse(await re.readFile(jr(), "utf8")));
+    v.state = { ...v.state, scores: e };
+  } catch (e) {
+    e.code !== "ENOENT" && (v.state = { ...v.state, scoreError: `Unable to read saved scores: ${String(e)}` });
+  }
+}
+async function Cn(e) {
+  return await se([v, "scores"], async () => {
+    if (v.state.scoreError != null)
+      throw new Error("Saved scores could not be read. The existing score file has been left untouched.");
+    const r = de.find(({ id: u }) => u === e?.modelId), i = r == null ? v.state.localModels.find(({ id: u }) => u === e?.modelId)?.name : `${r.name} ${r.parameters} ${r.quant}`;
+    if (i == null)
+      throw new Error("Unknown model for this score.");
+    const t = kn(v.state.scores, e, i), s = v.state.scores.filter((u) => u.modelId !== e.modelId || u.game !== e.game || u.level !== e.level).concat(t.record), l = jr(), a = `${l}.${Kr()}.tmp`;
+    await re.mkdir(M.dirname(l), { recursive: !0 });
+    try {
+      await re.writeFile(a, JSON.stringify({ version: 1, records: s }, null, 2), { encoding: "utf8", mode: 384 }), await re.rename(a, l);
+    } finally {
+      await re.rm(a, { force: !0 });
+    }
+    return v.state = { ...v.state, scores: s }, t;
+  });
+}
+var me = { exports: {} }, be, Mt;
+function he() {
+  if (Mt) return be;
+  Mt = 1;
+  const e = "2.0.0", r = 256, i = Number.MAX_SAFE_INTEGER || /* istanbul ignore next */
+  9007199254740991, t = 16, s = r - 6;
+  return be = {
+    MAX_LENGTH: r,
+    MAX_SAFE_COMPONENT_LENGTH: t,
+    MAX_SAFE_BUILD_LENGTH: s,
+    MAX_SAFE_INTEGER: i,
+    RELEASE_TYPES: [
+      "major",
+      "premajor",
+      "minor",
+      "preminor",
+      "patch",
+      "prepatch",
+      "prerelease"
+    ],
+    SEMVER_SPEC_VERSION: e,
+    FLAG_INCLUDE_PRERELEASE: 1,
+    FLAG_LOOSE: 2
+  }, be;
+}
+var qe, Ut;
+function Te() {
+  return Ut || (Ut = 1, qe = typeof process == "object" && process.env && process.env.NODE_DEBUG && /\bsemver\b/i.test(process.env.NODE_DEBUG) ? (...r) => console.error("SEMVER", ...r) : () => {
+  }), qe;
+}
+var Ft;
+function fe() {
+  return Ft || (Ft = 1, (function(e, r) {
+    const {
+      MAX_SAFE_COMPONENT_LENGTH: i,
+      MAX_SAFE_BUILD_LENGTH: t,
+      MAX_LENGTH: s
+    } = he(), l = Te();
+    r = e.exports = {};
+    const a = r.re = [], u = r.safeRe = [], o = r.src = [], g = r.safeSrc = [], n = r.t = {};
+    let c = 0;
+    const d = "[a-zA-Z0-9-]", p = [
+      ["\\s", 1],
+      ["\\d", s],
+      [d, t]
+    ], A = (q) => {
+      for (const [x, _] of p)
+        q = q.split(`${x}*`).join(`${x}{0,${_}}`).split(`${x}+`).join(`${x}{1,${_}}`);
+      return q;
+    }, h = (q, x, _) => {
+      const U = A(x), j = c++;
+      l(q, j, x), n[q] = j, o[j] = x, g[j] = U, a[j] = new RegExp(x, _ ? "g" : void 0), u[j] = new RegExp(U, _ ? "g" : void 0);
+    };
+    h("NUMERICIDENTIFIER", "0|[1-9]\\d*"), h("NUMERICIDENTIFIERLOOSE", "\\d+"), h("NONNUMERICIDENTIFIER", `\\d*[a-zA-Z-]${d}*`), h("MAINVERSION", `(${o[n.NUMERICIDENTIFIER]})\\.(${o[n.NUMERICIDENTIFIER]})\\.(${o[n.NUMERICIDENTIFIER]})`), h("MAINVERSIONLOOSE", `(${o[n.NUMERICIDENTIFIERLOOSE]})\\.(${o[n.NUMERICIDENTIFIERLOOSE]})\\.(${o[n.NUMERICIDENTIFIERLOOSE]})`), h("PRERELEASEIDENTIFIER", `(?:${o[n.NONNUMERICIDENTIFIER]}|${o[n.NUMERICIDENTIFIER]})`), h("PRERELEASEIDENTIFIERLOOSE", `(?:${o[n.NONNUMERICIDENTIFIER]}|${o[n.NUMERICIDENTIFIERLOOSE]})`), h("PRERELEASE", `(?:-(${o[n.PRERELEASEIDENTIFIER]}(?:\\.${o[n.PRERELEASEIDENTIFIER]})*))`), h("PRERELEASELOOSE", `(?:-?(${o[n.PRERELEASEIDENTIFIERLOOSE]}(?:\\.${o[n.PRERELEASEIDENTIFIERLOOSE]})*))`), h("BUILDIDENTIFIER", `${d}+`), h("BUILD", `(?:\\+(${o[n.BUILDIDENTIFIER]}(?:\\.${o[n.BUILDIDENTIFIER]})*))`), h("FULLPLAIN", `v?${o[n.MAINVERSION]}${o[n.PRERELEASE]}?${o[n.BUILD]}?`), h("FULL", `^${o[n.FULLPLAIN]}$`), h("LOOSEPLAIN", `[v=\\s]*${o[n.MAINVERSIONLOOSE]}${o[n.PRERELEASELOOSE]}?${o[n.BUILD]}?`), h("LOOSE", `^${o[n.LOOSEPLAIN]}$`), h("GTLT", "((?:<|>)?=?)"), h("XRANGEIDENTIFIERLOOSE", `${o[n.NUMERICIDENTIFIERLOOSE]}|x|X|\\*`), h("XRANGEIDENTIFIER", `${o[n.NUMERICIDENTIFIER]}|x|X|\\*`), h("XRANGEPLAIN", `[v=\\s]*(${o[n.XRANGEIDENTIFIER]})(?:\\.(${o[n.XRANGEIDENTIFIER]})(?:\\.(${o[n.XRANGEIDENTIFIER]})(?:${o[n.PRERELEASE]})?${o[n.BUILD]}?)?)?`), h("XRANGEPLAINLOOSE", `[v=\\s]*(${o[n.XRANGEIDENTIFIERLOOSE]})(?:\\.(${o[n.XRANGEIDENTIFIERLOOSE]})(?:\\.(${o[n.XRANGEIDENTIFIERLOOSE]})(?:${o[n.PRERELEASELOOSE]})?${o[n.BUILD]}?)?)?`), h("XRANGE", `^${o[n.GTLT]}\\s*${o[n.XRANGEPLAIN]}$`), h("XRANGELOOSE", `^${o[n.GTLT]}\\s*${o[n.XRANGEPLAINLOOSE]}$`), h("COERCEPLAIN", `(^|[^\\d])(\\d{1,${i}})(?:\\.(\\d{1,${i}}))?(?:\\.(\\d{1,${i}}))?`), h("COERCE", `${o[n.COERCEPLAIN]}(?:$|[^\\d])`), h("COERCEFULL", o[n.COERCEPLAIN] + `(?:${o[n.PRERELEASE]})?(?:${o[n.BUILD]})?(?:$|[^\\d])`), h("COERCERTL", o[n.COERCE], !0), h("COERCERTLFULL", o[n.COERCEFULL], !0), h("LONETILDE", "(?:~>?)"), h("TILDETRIM", `(\\s*)${o[n.LONETILDE]}\\s+`, !0), r.tildeTrimReplace = "$1~", h("TILDE", `^${o[n.LONETILDE]}${o[n.XRANGEPLAIN]}$`), h("TILDELOOSE", `^${o[n.LONETILDE]}${o[n.XRANGEPLAINLOOSE]}$`), h("LONECARET", "(?:\\^)"), h("CARETTRIM", `(\\s*)${o[n.LONECARET]}\\s+`, !0), r.caretTrimReplace = "$1^", h("CARET", `^${o[n.LONECARET]}${o[n.XRANGEPLAIN]}$`), h("CARETLOOSE", `^${o[n.LONECARET]}${o[n.XRANGEPLAINLOOSE]}$`), h("COMPARATORLOOSE", `^${o[n.GTLT]}\\s*(${o[n.LOOSEPLAIN]})$|^$`), h("COMPARATOR", `^${o[n.GTLT]}\\s*(${o[n.FULLPLAIN]})$|^$`), h("COMPARATORTRIM", `(\\s*)${o[n.GTLT]}\\s*(${o[n.LOOSEPLAIN]}|${o[n.XRANGEPLAIN]})`, !0), r.comparatorTrimReplace = "$1$2$3", h("HYPHENRANGE", `^\\s*(${o[n.XRANGEPLAIN]})\\s+-\\s+(${o[n.XRANGEPLAIN]})\\s*$`), h("HYPHENRANGELOOSE", `^\\s*(${o[n.XRANGEPLAINLOOSE]})\\s+-\\s+(${o[n.XRANGEPLAINLOOSE]})\\s*$`), h("STAR", "(<|>)?=?\\s*\\*"), h("GTE0", "^\\s*>=\\s*0\\.0\\.0\\s*$"), h("GTE0PRE", "^\\s*>=\\s*0\\.0\\.0-0\\s*$");
+  })(me, me.exports)), me.exports;
+}
+var Ne, Vt;
+function At() {
+  if (Vt) return Ne;
+  Vt = 1;
+  const e = Object.freeze({ loose: !0 }), r = Object.freeze({});
+  return Ne = (t) => t ? typeof t != "object" ? e : t : r, Ne;
+}
+var Le, Bt;
+function Mr() {
+  if (Bt) return Le;
+  Bt = 1;
+  const e = /^[0-9]+$/, r = (t, s) => {
+    if (typeof t == "number" && typeof s == "number")
+      return t === s ? 0 : t < s ? -1 : 1;
+    const l = e.test(t), a = e.test(s);
+    return l && a && (t = +t, s = +s), t === s ? 0 : l && !a ? -1 : a && !l ? 1 : t < s ? -1 : 1;
+  };
+  return Le = {
+    compareIdentifiers: r,
+    rcompareIdentifiers: (t, s) => r(s, t)
+  }, Le;
+}
+var Oe, Xt;
+function V() {
+  if (Xt) return Oe;
+  Xt = 1;
+  const e = Te(), { MAX_LENGTH: r, MAX_SAFE_INTEGER: i } = he(), { safeRe: t, t: s } = fe(), l = At(), { compareIdentifiers: a } = Mr(), u = (g, n) => {
+    const c = n.split(".");
+    if (c.length > g.length)
+      return !1;
+    for (let d = 0; d < c.length; d++)
+      if (a(g[d], c[d]) !== 0)
+        return !1;
+    return !0;
+  };
+  class o {
+    constructor(n, c) {
+      if (c = l(c), n instanceof o) {
+        if (n.loose === !!c.loose && n.includePrerelease === !!c.includePrerelease)
+          return n;
+        n = n.version;
+      } else if (typeof n != "string")
+        throw new TypeError(`Invalid version. Must be a string. Got type "${typeof n}".`);
+      if (n.length > r)
+        throw new TypeError(
+          `version is longer than ${r} characters`
+        );
+      e("SemVer", n, c), this.options = c, this.loose = !!c.loose, this.includePrerelease = !!c.includePrerelease;
+      const d = n.trim().match(c.loose ? t[s.LOOSE] : t[s.FULL]);
+      if (!d)
+        throw new TypeError(`Invalid Version: ${n}`);
+      if (this.raw = n, this.major = +d[1], this.minor = +d[2], this.patch = +d[3], this.major > i || this.major < 0)
+        throw new TypeError("Invalid major version");
+      if (this.minor > i || this.minor < 0)
+        throw new TypeError("Invalid minor version");
+      if (this.patch > i || this.patch < 0)
+        throw new TypeError("Invalid patch version");
+      d[4] ? this.prerelease = d[4].split(".").map((p) => {
+        if (/^[0-9]+$/.test(p)) {
+          const A = +p;
+          if (A >= 0 && A < i)
+            return A;
+        }
+        return p;
+      }) : this.prerelease = [], this.build = d[5] ? d[5].split(".") : [], this.format();
+    }
+    format() {
+      return this.version = `${this.major}.${this.minor}.${this.patch}`, this.prerelease.length && (this.version += `-${this.prerelease.join(".")}`), this.version;
+    }
+    toString() {
+      return this.version;
+    }
+    compare(n) {
+      if (e("SemVer.compare", this.version, this.options, n), !(n instanceof o)) {
+        if (typeof n == "string" && n === this.version)
+          return 0;
+        n = new o(n, this.options);
+      }
+      return n.version === this.version ? 0 : this.compareMain(n) || this.comparePre(n);
+    }
+    compareMain(n) {
+      return n instanceof o || (n = new o(n, this.options)), this.major < n.major ? -1 : this.major > n.major ? 1 : this.minor < n.minor ? -1 : this.minor > n.minor ? 1 : this.patch < n.patch ? -1 : this.patch > n.patch ? 1 : 0;
+    }
+    comparePre(n) {
+      if (n instanceof o || (n = new o(n, this.options)), this.prerelease.length && !n.prerelease.length)
+        return -1;
+      if (!this.prerelease.length && n.prerelease.length)
+        return 1;
+      if (!this.prerelease.length && !n.prerelease.length)
+        return 0;
+      let c = 0;
+      do {
+        const d = this.prerelease[c], p = n.prerelease[c];
+        if (e("prerelease compare", c, d, p), d === void 0 && p === void 0)
+          return 0;
+        if (p === void 0)
+          return 1;
+        if (d === void 0)
+          return -1;
+        if (d === p)
+          continue;
+        return a(d, p);
+      } while (++c);
+    }
+    compareBuild(n) {
+      n instanceof o || (n = new o(n, this.options));
+      let c = 0;
+      do {
+        const d = this.build[c], p = n.build[c];
+        if (e("build compare", c, d, p), d === void 0 && p === void 0)
+          return 0;
+        if (p === void 0)
+          return 1;
+        if (d === void 0)
+          return -1;
+        if (d === p)
+          continue;
+        return a(d, p);
+      } while (++c);
+    }
+    // preminor will bump the version up to the next minor release, and immediately
+    // down to pre-release. premajor and prepatch work the same way.
+    inc(n, c, d) {
+      if (n.startsWith("pre")) {
+        if (!c && d === !1)
+          throw new Error("invalid increment argument: identifier is empty");
+        if (c) {
+          const p = `-${c}`.match(this.options.loose ? t[s.PRERELEASELOOSE] : t[s.PRERELEASE]);
+          if (!p || p[1] !== c)
+            throw new Error(`invalid identifier: ${c}`);
+        }
+      }
+      switch (n) {
+        case "premajor":
+          this.prerelease.length = 0, this.patch = 0, this.minor = 0, this.major++, this.inc("pre", c, d);
+          break;
+        case "preminor":
+          this.prerelease.length = 0, this.patch = 0, this.minor++, this.inc("pre", c, d);
+          break;
+        case "prepatch":
+          this.prerelease.length = 0, this.inc("patch", c, d), this.inc("pre", c, d);
+          break;
+        // If the input is a non-prerelease version, this acts the same as
+        // prepatch.
+        case "prerelease":
+          this.prerelease.length === 0 && this.inc("patch", c, d), this.inc("pre", c, d);
+          break;
+        case "release":
+          if (this.prerelease.length === 0)
+            throw new Error(`version ${this.raw} is not a prerelease`);
+          this.prerelease.length = 0;
+          break;
+        case "major":
+          (this.minor !== 0 || this.patch !== 0 || this.prerelease.length === 0) && this.major++, this.minor = 0, this.patch = 0, this.prerelease = [];
+          break;
+        case "minor":
+          (this.patch !== 0 || this.prerelease.length === 0) && this.minor++, this.patch = 0, this.prerelease = [];
+          break;
+        case "patch":
+          this.prerelease.length === 0 && this.patch++, this.prerelease = [];
+          break;
+        // This probably shouldn't be used publicly.
+        // 1.0.0 'pre' would become 1.0.0-0 which is the wrong direction.
+        case "pre": {
+          const p = Number(d) ? 1 : 0;
+          if (this.prerelease.length === 0)
+            this.prerelease = [p];
+          else {
+            let A = this.prerelease.length;
+            for (; --A >= 0; )
+              typeof this.prerelease[A] == "number" && (this.prerelease[A]++, A = -2);
+            if (A === -1) {
+              if (c === this.prerelease.join(".") && d === !1)
+                throw new Error("invalid increment argument: identifier already exists");
+              this.prerelease.push(p);
+            }
+          }
+          if (c) {
+            let A = [c, p];
+            if (d === !1 && (A = [c]), u(this.prerelease, c)) {
+              const h = this.prerelease[c.split(".").length];
+              isNaN(h) && (this.prerelease = A);
+            } else
+              this.prerelease = A;
+          }
+          break;
+        }
+        default:
+          throw new Error(`invalid increment argument: ${n}`);
+      }
+      return this.raw = this.format(), this.build.length && (this.raw += `+${this.build.join(".")}`), this;
+    }
+  }
+  return Oe = o, Oe;
+}
+var xe, zt;
+function ae() {
+  if (zt) return xe;
+  zt = 1;
+  const e = V();
+  return xe = (i, t, s = !1) => {
+    if (i instanceof e)
+      return i;
+    try {
+      return new e(i, t);
+    } catch (l) {
+      if (!s)
+        return null;
+      throw l;
+    }
+  }, xe;
+}
+var ke, Ht;
+function _n() {
+  if (Ht) return ke;
+  Ht = 1;
+  const e = ae();
+  return ke = (i, t) => {
+    const s = e(i, t);
+    return s ? s.version : null;
+  }, ke;
+}
+var De, Wt;
+function Gn() {
+  if (Wt) return De;
+  Wt = 1;
+  const e = ae();
+  return De = (i, t) => {
+    const s = e(i.trim().replace(/^[=v]+/, ""), t);
+    return s ? s.version : null;
+  }, De;
+}
+var Pe, Qt;
+function jn() {
+  if (Qt) return Pe;
+  Qt = 1;
+  const e = V();
+  return Pe = (i, t, s, l, a) => {
+    typeof s == "string" && (a = l, l = s, s = void 0);
+    try {
+      return new e(
+        i instanceof e ? i.version : i,
+        s
+      ).inc(t, l, a).version;
+    } catch {
+      return null;
+    }
+  }, Pe;
+}
+var Ce, Yt;
+function Mn() {
+  if (Yt) return Ce;
+  Yt = 1;
+  const e = ae();
+  return Ce = (i, t) => {
+    const s = e(i, null, !0), l = e(t, null, !0), a = s.compare(l);
+    if (a === 0)
+      return null;
+    const u = a > 0, o = u ? s : l, g = u ? l : s, n = !!o.prerelease.length;
+    if (!!g.prerelease.length && !n) {
+      if (!g.patch && !g.minor)
+        return "major";
+      if (g.compareMain(o) === 0)
+        return g.minor && !g.patch ? "minor" : "patch";
+    }
+    const d = n ? "pre" : "";
+    return s.major !== l.major ? d + "major" : s.minor !== l.minor ? d + "minor" : s.patch !== l.patch ? d + "patch" : "prerelease";
+  }, Ce;
+}
+var _e, Kt;
+function Un() {
+  if (Kt) return _e;
+  Kt = 1;
+  const e = V();
+  return _e = (i, t) => new e(i, t).major, _e;
+}
+var Ge, Jt;
+function Fn() {
+  if (Jt) return Ge;
+  Jt = 1;
+  const e = V();
+  return Ge = (i, t) => new e(i, t).minor, Ge;
+}
+var je, Zt;
+function Vn() {
+  if (Zt) return je;
+  Zt = 1;
+  const e = V();
+  return je = (i, t) => new e(i, t).patch, je;
+}
+var Me, er;
+function Bn() {
+  if (er) return Me;
+  er = 1;
+  const e = ae();
+  return Me = (i, t) => {
+    const s = e(i, t);
+    return s && s.prerelease.length ? s.prerelease : null;
+  }, Me;
+}
+var Ue, tr;
+function J() {
+  if (tr) return Ue;
+  tr = 1;
+  const e = V();
+  return Ue = (i, t, s) => new e(i, s).compare(new e(t, s)), Ue;
+}
+var Fe, rr;
+function Xn() {
+  if (rr) return Fe;
+  rr = 1;
+  const e = J();
+  return Fe = (i, t, s) => e(t, i, s), Fe;
+}
+var Ve, nr;
+function zn() {
+  if (nr) return Ve;
+  nr = 1;
+  const e = J();
+  return Ve = (i, t) => e(i, t, !0), Ve;
+}
+var Be, ir;
+function St() {
+  if (ir) return Be;
+  ir = 1;
+  const e = V();
+  return Be = (i, t, s) => {
+    const l = new e(i, s), a = new e(t, s);
+    return l.compare(a) || l.compareBuild(a);
+  }, Be;
+}
+var Xe, sr;
+function Hn() {
+  if (sr) return Xe;
+  sr = 1;
+  const e = St();
+  return Xe = (i, t) => i.sort((s, l) => e(s, l, t)), Xe;
+}
+var ze, or;
+function Wn() {
+  if (or) return ze;
+  or = 1;
+  const e = St();
+  return ze = (i, t) => i.sort((s, l) => e(l, s, t)), ze;
+}
+var He, ar;
+function Ie() {
+  if (ar) return He;
+  ar = 1;
+  const e = J();
+  return He = (i, t, s) => e(i, t, s) > 0, He;
+}
+var We, lr;
+function bt() {
+  if (lr) return We;
+  lr = 1;
+  const e = J();
+  return We = (i, t, s) => e(i, t, s) < 0, We;
+}
+var Qe, cr;
+function Ur() {
+  if (cr) return Qe;
+  cr = 1;
+  const e = J();
+  return Qe = (i, t, s) => e(i, t, s) === 0, Qe;
+}
+var Ye, ur;
+function Fr() {
+  if (ur) return Ye;
+  ur = 1;
+  const e = J();
+  return Ye = (i, t, s) => e(i, t, s) !== 0, Ye;
+}
+var Ke, dr;
+function qt() {
+  if (dr) return Ke;
+  dr = 1;
+  const e = J();
+  return Ke = (i, t, s) => e(i, t, s) >= 0, Ke;
+}
+var Je, hr;
+function Nt() {
+  if (hr) return Je;
+  hr = 1;
+  const e = J();
+  return Je = (i, t, s) => e(i, t, s) <= 0, Je;
+}
+var Ze, fr;
+function Vr() {
+  if (fr) return Ze;
+  fr = 1;
+  const e = Ur(), r = Fr(), i = Ie(), t = qt(), s = bt(), l = Nt();
+  return Ze = (u, o, g, n) => {
+    switch (o) {
+      case "===":
+        return typeof u == "object" && (u = u.version), typeof g == "object" && (g = g.version), u === g;
+      case "!==":
+        return typeof u == "object" && (u = u.version), typeof g == "object" && (g = g.version), u !== g;
+      case "":
+      case "=":
+      case "==":
+        return e(u, g, n);
+      case "!=":
+        return r(u, g, n);
+      case ">":
+        return i(u, g, n);
+      case ">=":
+        return t(u, g, n);
+      case "<":
+        return s(u, g, n);
+      case "<=":
+        return l(u, g, n);
+      default:
+        throw new TypeError(`Invalid operator: ${o}`);
+    }
+  }, Ze;
+}
+var et, pr;
+function Qn() {
+  if (pr) return et;
+  pr = 1;
+  const e = V(), r = ae(), { safeRe: i, t } = fe();
+  return et = (l, a) => {
+    if (l instanceof e)
+      return l;
+    if (typeof l == "number" && (l = String(l)), typeof l != "string")
+      return null;
+    a = a || {};
+    let u = null;
+    if (!a.rtl)
+      u = l.match(a.includePrerelease ? i[t.COERCEFULL] : i[t.COERCE]);
+    else {
+      const p = a.includePrerelease ? i[t.COERCERTLFULL] : i[t.COERCERTL];
+      let A;
+      for (; (A = p.exec(l)) && (!u || u.index + u[0].length !== l.length); )
+        (!u || A.index + A[0].length !== u.index + u[0].length) && (u = A), p.lastIndex = A.index + A[1].length + A[2].length;
+      p.lastIndex = -1;
+    }
+    if (u === null)
+      return null;
+    const o = u[2], g = u[3] || "0", n = u[4] || "0", c = a.includePrerelease && u[5] ? `-${u[5]}` : "", d = a.includePrerelease && u[6] ? `+${u[6]}` : "";
+    return r(`${o}.${g}.${n}${c}${d}`, a);
+  }, et;
+}
+var tt, mr;
+function Yn() {
+  if (mr) return tt;
+  mr = 1;
+  const e = ae(), r = he(), i = V(), t = (u, o, g) => {
+    if (!r.RELEASE_TYPES.includes(o))
+      return null;
+    const n = s(u, g);
+    return n && l(n, o);
+  }, s = (u, o) => {
+    const g = u instanceof i ? u.version : u;
+    return e(g, o);
+  }, l = (u, o) => {
+    if (a(o))
+      return u.version;
+    switch (u.prerelease = [], o) {
+      case "major":
+        u.minor = 0, u.patch = 0;
+        break;
+      case "minor":
+        u.patch = 0;
+        break;
+    }
+    return u.format();
+  }, a = (u) => u.startsWith("pre");
+  return tt = t, tt;
+}
+var rt, gr;
+function Kn() {
+  if (gr) return rt;
+  gr = 1;
+  class e {
+    constructor() {
+      this.max = 1e3, this.map = /* @__PURE__ */ new Map();
+    }
+    get(i) {
+      const t = this.map.get(i);
+      if (t !== void 0)
+        return this.map.delete(i), this.map.set(i, t), t;
+    }
+    delete(i) {
+      return this.map.delete(i);
+    }
+    set(i, t) {
+      if (!this.delete(i) && t !== void 0) {
+        if (this.map.size >= this.max) {
+          const l = this.map.keys().next().value;
+          this.delete(l);
+        }
+        this.map.set(i, t);
+      }
+      return this;
+    }
+  }
+  return rt = e, rt;
+}
+var nt, wr;
+function Z() {
+  if (wr) return nt;
+  wr = 1;
+  const e = /\s+/g;
+  class r {
+    constructor(f, T) {
+      if (T = s(T), f instanceof r)
+        return f.loose === !!T.loose && f.includePrerelease === !!T.includePrerelease ? f : new r(f.raw, T);
+      if (f instanceof l)
+        return this.raw = f.value, this.set = [[f]], this.formatted = void 0, this;
+      if (this.options = T, this.loose = !!T.loose, this.includePrerelease = !!T.includePrerelease, this.raw = f.trim().replace(e, " "), this.set = this.raw.split("||").map((R) => this.parseRange(R.trim())).filter((R) => R.length), !this.set.length)
+        throw new TypeError(`Invalid SemVer Range: ${this.raw}`);
+      if (this.set.length > 1) {
+        const R = this.set[0];
+        if (this.set = this.set.filter((N) => !x(N[0])), this.set.length === 0)
+          this.set = [R];
+        else if (this.set.length > 1) {
+          for (const N of this.set)
+            if (N.length === 1 && _(N[0])) {
+              this.set = [N];
+              break;
+            }
+        }
+      }
+      this.formatted = void 0;
+    }
+    get range() {
+      if (this.formatted === void 0) {
+        this.formatted = "";
+        for (let f = 0; f < this.set.length; f++) {
+          f > 0 && (this.formatted += "||");
+          const T = this.set[f];
+          for (let R = 0; R < T.length; R++)
+            R > 0 && (this.formatted += " "), this.formatted += T[R].toString().trim();
+        }
+      }
+      return this.formatted;
+    }
+    format() {
+      return this.range;
+    }
+    toString() {
+      return this.range;
+    }
+    parseRange(f) {
+      f = f.replace(q, "");
+      const R = ((this.options.includePrerelease && A) | (this.options.loose && h)) + ":" + f, N = t.get(R);
+      if (N)
+        return N;
+      const y = this.options.loose, b = y ? o[n.HYPHENRANGELOOSE] : o[n.HYPHENRANGE];
+      f = f.replace(b, te(this.options.includePrerelease)), a("hyphen replace", f), f = f.replace(o[n.COMPARATORTRIM], c), a("comparator trim", f), f = f.replace(o[n.TILDETRIM], d), a("tilde trim", f), f = f.replace(o[n.CARETTRIM], p), a("caret trim", f);
+      let k = f.split(" ").map((G) => j(G, this.options)).join(" ").split(/\s+/).map((G) => F(G, this.options));
+      y && (k = k.filter((G) => (a("loose invalid filter", G, this.options), !!G.match(o[n.COMPARATORLOOSE])))), a("range list", k);
+      const O = /* @__PURE__ */ new Map(), D = k.map((G) => new l(G, this.options));
+      for (const G of D) {
+        if (x(G))
+          return [G];
+        O.set(G.value, G);
+      }
+      O.size > 1 && O.has("") && O.delete("");
+      const H = [...O.values()];
+      return t.set(R, H), H;
+    }
+    intersects(f, T) {
+      if (!(f instanceof r))
+        throw new TypeError("a Range is required");
+      return this.set.some((R) => U(R, T) && f.set.some((N) => U(N, T) && R.every((y) => N.every((b) => y.intersects(b, T)))));
+    }
+    // if ANY of the sets match ALL of its comparators, then pass
+    test(f) {
+      if (!f)
+        return !1;
+      if (typeof f == "string")
+        try {
+          f = new u(f, this.options);
+        } catch {
+          return !1;
+        }
+      for (let T = 0; T < this.set.length; T++)
+        if (le(this.set[T], f, this.options))
+          return !0;
+      return !1;
+    }
+  }
+  nt = r;
+  const i = Kn(), t = new i(), s = At(), l = $e(), a = Te(), u = V(), {
+    safeRe: o,
+    src: g,
+    t: n,
+    comparatorTrimReplace: c,
+    tildeTrimReplace: d,
+    caretTrimReplace: p
+  } = fe(), { FLAG_INCLUDE_PRERELEASE: A, FLAG_LOOSE: h } = he(), q = new RegExp(g[n.BUILD], "g"), x = (m) => m.value === "<0.0.0-0", _ = (m) => m.value === "", U = (m, f) => {
+    let T = !0;
+    const R = m.slice();
+    let N = R.pop();
+    for (; T && R.length; )
+      T = R.every((y) => N.intersects(y, f)), N = R.pop();
+    return T;
+  }, j = (m, f) => (m = m.replace(o[n.BUILD], ""), a("comp", m, f), m = C(m, f), a("caret", m), m = L(m, f), a("tildes", m), m = B(m, f), a("xrange", m), m = ee(m, f), a("stars", m), m), E = (m) => !m || m.toLowerCase() === "x" || m === "*", S = (m, f, T) => E(m) && !E(f) || E(f) && T && !E(T), L = (m, f) => m.trim().split(/\s+/).map((T) => w(T, f)).join(" "), w = (m, f) => {
+    const T = f.loose ? o[n.TILDELOOSE] : o[n.TILDE], R = f.includePrerelease ? "-0" : "";
+    return m.replace(T, (N, y, b, k, O) => {
+      a("tilde", m, N, y, b, k, O);
+      let D;
+      return E(y) ? D = "" : E(b) ? D = `>=${y}.0.0${R} <${+y + 1}.0.0-0` : E(k) ? D = `>=${y}.${b}.0${R} <${y}.${+b + 1}.0-0` : O ? (a("replaceTilde pr", O), D = `>=${y}.${b}.${k}-${O} <${y}.${+b + 1}.0-0`) : D = `>=${y}.${b}.${k} <${y}.${+b + 1}.0-0`, a("tilde return", D), D;
+    });
+  }, C = (m, f) => m.trim().split(/\s+/).map((T) => K(T, f)).join(" "), K = (m, f) => {
+    a("caret", m, f);
+    const T = f.loose ? o[n.CARETLOOSE] : o[n.CARET], R = f.includePrerelease ? "-0" : "";
+    return m.replace(T, (N, y, b, k, O) => {
+      a("caret", m, N, y, b, k, O);
+      let D;
+      return E(y) ? D = "" : E(b) ? D = `>=${y}.0.0${R} <${+y + 1}.0.0-0` : E(k) ? y === "0" ? D = `>=${y}.${b}.0${R} <${y}.${+b + 1}.0-0` : D = `>=${y}.${b}.0${R} <${+y + 1}.0.0-0` : O ? (a("replaceCaret pr", O), y === "0" ? b === "0" ? D = `>=${y}.${b}.${k}-${O} <${y}.${b}.${+k + 1}-0` : D = `>=${y}.${b}.${k}-${O} <${y}.${+b + 1}.0-0` : D = `>=${y}.${b}.${k}-${O} <${+y + 1}.0.0-0`) : (a("no pr"), y === "0" ? b === "0" ? D = `>=${y}.${b}.${k} <${y}.${b}.${+k + 1}-0` : D = `>=${y}.${b}.${k} <${y}.${+b + 1}.0-0` : D = `>=${y}.${b}.${k} <${+y + 1}.0.0-0`), a("caret return", D), D;
+    });
+  }, B = (m, f) => (a("replaceXRanges", m, f), m.split(/\s+/).map((T) => X(T, f)).join(" ")), X = (m, f) => {
+    m = m.trim();
+    const T = f.loose ? o[n.XRANGELOOSE] : o[n.XRANGE];
+    return m.replace(T, (R, N, y, b, k, O) => {
+      if (a("xRange", m, R, N, y, b, k, O), S(y, b, k))
+        return m;
+      const D = E(y), H = D || E(b), G = H || E(k), ue = G;
+      return N === "=" && ue && (N = ""), O = f.includePrerelease ? "-0" : "", D ? N === ">" || N === "<" ? R = "<0.0.0-0" : R = "*" : N && ue ? (H && (b = 0), k = 0, N === ">" ? (N = ">=", H ? (y = +y + 1, b = 0, k = 0) : (b = +b + 1, k = 0)) : N === "<=" && (N = "<", H ? y = +y + 1 : b = +b + 1), N === "<" && (O = "-0"), R = `${N + y}.${b}.${k}${O}`) : H ? R = `>=${y}.0.0${O} <${+y + 1}.0.0-0` : G && (R = `>=${y}.${b}.0${O} <${y}.${+b + 1}.0-0`), a("xRange return", R), R;
+    });
+  }, ee = (m, f) => (a("replaceStars", m, f), m.trim().replace(o[n.STAR], "")), F = (m, f) => (a("replaceGTE0", m, f), m.trim().replace(o[f.includePrerelease ? n.GTE0PRE : n.GTE0], "")), te = (m) => (f, T, R, N, y, b, k, O, D, H, G, ue) => (E(R) ? T = "" : E(N) ? T = `>=${R}.0.0${m ? "-0" : ""}` : E(y) ? T = `>=${R}.${N}.0${m ? "-0" : ""}` : b ? T = `>=${T}` : T = `>=${T}${m ? "-0" : ""}`, E(D) ? O = "" : E(H) ? O = `<${+D + 1}.0.0-0` : E(G) ? O = `<${D}.${+H + 1}.0-0` : ue ? O = `<=${D}.${H}.${G}-${ue}` : m ? O = `<${D}.${H}.${+G + 1}-0` : O = `<=${O}`, `${T} ${O}`.trim()), le = (m, f, T) => {
+    for (let R = 0; R < m.length; R++)
+      if (!m[R].test(f))
+        return !1;
+    if (f.prerelease.length && !T.includePrerelease) {
+      for (let R = 0; R < m.length; R++)
+        if (a(m[R].semver), m[R].semver !== l.ANY && m[R].semver.prerelease.length > 0) {
+          const N = m[R].semver;
+          if (N.major === f.major && N.minor === f.minor && N.patch === f.patch)
+            return !0;
+        }
+      return !1;
+    }
+    return !0;
+  };
+  return nt;
+}
+var it, vr;
+function $e() {
+  if (vr) return it;
+  vr = 1;
+  const e = /* @__PURE__ */ Symbol("SemVer ANY");
+  class r {
+    static get ANY() {
+      return e;
+    }
+    constructor(n, c) {
+      if (c = i(c), n instanceof r) {
+        if (n.loose === !!c.loose)
+          return n;
+        n = n.value;
+      }
+      n = n.trim().split(/\s+/).join(" "), a("comparator", n, c), this.options = c, this.loose = !!c.loose, this.parse(n), this.semver === e ? this.value = "" : this.value = this.operator + this.semver.version, a("comp", this);
+    }
+    parse(n) {
+      const c = this.options.loose ? t[s.COMPARATORLOOSE] : t[s.COMPARATOR], d = n.match(c);
+      if (!d)
+        throw new TypeError(`Invalid comparator: ${n}`);
+      this.operator = d[1] !== void 0 ? d[1] : "", this.operator === "=" && (this.operator = ""), d[2] ? this.semver = new u(d[2], this.options.loose) : this.semver = e;
+    }
+    toString() {
+      return this.value;
+    }
+    test(n) {
+      if (a("Comparator.test", n, this.options.loose), this.semver === e || n === e)
+        return !0;
+      if (typeof n == "string")
+        try {
+          n = new u(n, this.options);
+        } catch {
+          return !1;
+        }
+      return l(n, this.operator, this.semver, this.options);
+    }
+    intersects(n, c) {
+      if (!(n instanceof r))
+        throw new TypeError("a Comparator is required");
+      return this.operator === "" ? this.value === "" ? !0 : new o(n.value, c).test(this.value) : n.operator === "" ? n.value === "" ? !0 : new o(this.value, c).test(n.semver) : (c = i(c), c.includePrerelease && (this.value === "<0.0.0-0" || n.value === "<0.0.0-0") || !c.includePrerelease && (this.value.startsWith("<0.0.0") || n.value.startsWith("<0.0.0")) ? !1 : !!(this.operator.startsWith(">") && n.operator.startsWith(">") || this.operator.startsWith("<") && n.operator.startsWith("<") || this.semver.version === n.semver.version && this.operator.includes("=") && n.operator.includes("=") || l(this.semver, "<", n.semver, c) && this.operator.startsWith(">") && n.operator.startsWith("<") || l(this.semver, ">", n.semver, c) && this.operator.startsWith("<") && n.operator.startsWith(">")));
+    }
+  }
+  it = r;
+  const i = At(), { safeRe: t, t: s } = fe(), l = Vr(), a = Te(), u = V(), o = Z();
+  return it;
+}
+var st, Er;
+function Ae() {
+  if (Er) return st;
+  Er = 1;
+  const e = Z();
+  return st = (i, t, s) => {
+    try {
+      t = new e(t, s);
+    } catch {
+      return !1;
+    }
+    return t.test(i);
+  }, st;
+}
+var ot, yr;
+function Jn() {
+  if (yr) return ot;
+  yr = 1;
+  const e = Z();
+  return ot = (i, t) => new e(i, t).set.map((s) => s.map((l) => l.value).join(" ").trim().split(" ")), ot;
+}
+var at, Rr;
+function Zn() {
+  if (Rr) return at;
+  Rr = 1;
+  const e = V(), r = Z();
+  return at = (t, s, l) => {
+    let a = null, u = null, o = null;
+    try {
+      o = new r(s, l);
+    } catch {
+      return null;
+    }
+    return t.forEach((g) => {
+      o.test(g) && (!a || u.compare(g) === -1) && (a = g, u = new e(a, l));
+    }), a;
+  }, at;
+}
+var lt, Tr;
+function ei() {
+  if (Tr) return lt;
+  Tr = 1;
+  const e = V(), r = Z();
+  return lt = (t, s, l) => {
+    let a = null, u = null, o = null;
+    try {
+      o = new r(s, l);
+    } catch {
+      return null;
+    }
+    return t.forEach((g) => {
+      o.test(g) && (!a || u.compare(g) === 1) && (a = g, u = new e(a, l));
+    }), a;
+  }, lt;
+}
+var ct, Ir;
+function ti() {
+  if (Ir) return ct;
+  Ir = 1;
+  const e = V(), r = Z(), i = Ie();
+  return ct = (s, l) => {
+    s = new r(s, l);
+    let a = new e("0.0.0");
+    if (s.test(a) || (a = new e("0.0.0-0"), s.test(a)))
+      return a;
+    a = null;
+    for (let u = 0; u < s.set.length; ++u) {
+      const o = s.set[u];
+      let g = null;
+      o.forEach((n) => {
+        const c = new e(n.semver.version);
+        switch (n.operator) {
+          case ">":
+            c.prerelease.length === 0 ? c.patch++ : c.prerelease.push(0), c.raw = c.format();
+          /* fallthrough */
+          case "":
+          case ">=":
+            (!g || i(c, g)) && (g = c);
+            break;
+          case "<":
+          case "<=":
+            break;
+          /* istanbul ignore next */
+          default:
+            throw new Error(`Unexpected operation: ${n.operator}`);
+        }
+      }), g && (!a || i(a, g)) && (a = g);
+    }
+    return a && s.test(a) ? a : null;
+  }, ct;
+}
+var ut, $r;
+function ri() {
+  if ($r) return ut;
+  $r = 1;
+  const e = Z();
+  return ut = (i, t) => {
+    try {
+      return new e(i, t).range || "*";
+    } catch {
+      return null;
+    }
+  }, ut;
+}
+var dt, Ar;
+function Lt() {
+  if (Ar) return dt;
+  Ar = 1;
+  const e = V(), r = $e(), { ANY: i } = r, t = Z(), s = Ae(), l = Ie(), a = bt(), u = Nt(), o = qt();
+  return dt = (n, c, d, p) => {
+    n = new e(n, p), c = new t(c, p);
+    let A, h, q, x, _;
+    switch (d) {
+      case ">":
+        A = l, h = u, q = a, x = ">", _ = ">=";
+        break;
+      case "<":
+        A = a, h = o, q = l, x = "<", _ = "<=";
+        break;
+      default:
+        throw new TypeError('Must provide a hilo val of "<" or ">"');
+    }
+    if (s(n, c, p))
+      return !1;
+    for (let U = 0; U < c.set.length; ++U) {
+      const j = c.set[U];
+      let E = null, S = null;
+      if (j.forEach((L) => {
+        L.semver === i && (L = new r(">=0.0.0")), E = E || L, S = S || L, A(L.semver, E.semver, p) ? E = L : q(L.semver, S.semver, p) && (S = L);
+      }), E.operator === x || E.operator === _ || (!S.operator || S.operator === x) && h(n, S.semver))
+        return !1;
+      if (S.operator === _ && q(n, S.semver))
+        return !1;
+    }
+    return !0;
+  }, dt;
+}
+var ht, Sr;
+function ni() {
+  if (Sr) return ht;
+  Sr = 1;
+  const e = Lt();
+  return ht = (i, t, s) => e(i, t, ">", s), ht;
+}
+var ft, br;
+function ii() {
+  if (br) return ft;
+  br = 1;
+  const e = Lt();
+  return ft = (i, t, s) => e(i, t, "<", s), ft;
+}
+var pt, qr;
+function si() {
+  if (qr) return pt;
+  qr = 1;
+  const e = Z();
+  return pt = (i, t, s) => (i = new e(i, s), t = new e(t, s), i.intersects(t, s)), pt;
+}
+var mt, Nr;
+function oi() {
+  if (Nr) return mt;
+  Nr = 1;
+  const e = Ae(), r = J();
+  return mt = (i, t, s) => {
+    const l = [];
+    let a = null, u = null;
+    const o = i.sort((d, p) => r(d, p, s));
+    for (const d of o)
+      e(d, t, s) ? (u = d, a || (a = d)) : (u && l.push([a, u]), u = null, a = null);
+    a && l.push([a, null]);
+    const g = [];
+    for (const [d, p] of l)
+      d === p ? g.push(d) : !p && d === o[0] ? g.push("*") : p ? d === o[0] ? g.push(`<=${p}`) : g.push(`${d} - ${p}`) : g.push(`>=${d}`);
+    const n = g.join(" || "), c = typeof t.raw == "string" ? t.raw : String(t);
+    return n.length < c.length ? n : t;
+  }, mt;
+}
+var gt, Lr;
+function ai() {
+  if (Lr) return gt;
+  Lr = 1;
+  const e = Z(), r = $e(), { ANY: i } = r, t = Ae(), s = J(), l = (c, d, p = {}) => {
+    if (c === d)
+      return !0;
+    c = new e(c, p), d = new e(d, p);
+    let A = !1;
+    e: for (const h of c.set) {
+      for (const q of d.set) {
+        const x = o(h, q, p);
+        if (A = A || x !== null, x)
+          continue e;
+      }
+      if (A)
+        return !1;
+    }
+    return !0;
+  }, a = [new r(">=0.0.0-0")], u = [new r(">=0.0.0")], o = (c, d, p) => {
+    if (c === d)
+      return !0;
+    if (c.length === 1 && c[0].semver === i) {
+      if (d.length === 1 && d[0].semver === i)
+        return !0;
+      p.includePrerelease ? c = a : c = u;
+    }
+    if (d.length === 1 && d[0].semver === i) {
+      if (p.includePrerelease)
+        return !0;
+      d = u;
+    }
+    const A = /* @__PURE__ */ new Set();
+    let h, q;
+    for (const w of c)
+      w.operator === ">" || w.operator === ">=" ? h = g(h, w, p) : w.operator === "<" || w.operator === "<=" ? q = n(q, w, p) : A.add(w.semver);
+    if (A.size > 1)
+      return null;
+    let x;
+    if (h && q) {
+      if (x = s(h.semver, q.semver, p), x > 0)
+        return null;
+      if (x === 0 && (h.operator !== ">=" || q.operator !== "<="))
+        return null;
+    }
+    for (const w of A) {
+      if (h && !t(w, String(h), p) || q && !t(w, String(q), p))
+        return null;
+      for (const C of d)
+        if (!t(w, String(C), p))
+          return !1;
+      return !0;
+    }
+    let _, U, j, E, S = q && !p.includePrerelease && q.semver.prerelease.length ? q.semver : !1, L = h && !p.includePrerelease && h.semver.prerelease.length ? h.semver : !1;
+    S && S.prerelease.length === 1 && q.operator === "<" && S.prerelease[0] === 0 && (S = !1);
+    for (const w of d) {
+      if (E = E || w.operator === ">" || w.operator === ">=", j = j || w.operator === "<" || w.operator === "<=", h) {
+        if (L && w.semver.prerelease && w.semver.prerelease.length && w.semver.major === L.major && w.semver.minor === L.minor && w.semver.patch === L.patch && (L = !1), w.operator === ">" || w.operator === ">=") {
+          if (_ = g(h, w, p), _ === w && _ !== h)
+            return !1;
+        } else if (h.operator === ">=" && !w.test(h.semver))
+          return !1;
+      }
+      if (q) {
+        if (S && w.semver.prerelease && w.semver.prerelease.length && w.semver.major === S.major && w.semver.minor === S.minor && w.semver.patch === S.patch && (S = !1), w.operator === "<" || w.operator === "<=") {
+          if (U = n(q, w, p), U === w && U !== q)
+            return !1;
+        } else if (q.operator === "<=" && !w.test(q.semver))
+          return !1;
+      }
+      if (!w.operator && (q || h) && x !== 0)
+        return !1;
+    }
+    return !(h && j && !q && x !== 0 || q && E && !h && x !== 0 || L || S);
+  }, g = (c, d, p) => {
+    if (!c)
+      return d;
+    const A = s(c.semver, d.semver, p);
+    return A > 0 ? c : A < 0 || d.operator === ">" && c.operator === ">=" ? d : c;
+  }, n = (c, d, p) => {
+    if (!c)
+      return d;
+    const A = s(c.semver, d.semver, p);
+    return A < 0 ? c : A > 0 || d.operator === "<" && c.operator === "<=" ? d : c;
+  };
+  return gt = l, gt;
+}
+var wt, Or;
+function li() {
+  if (Or) return wt;
+  Or = 1;
+  const e = fe(), r = he(), i = V(), t = Mr(), s = ae(), l = _n(), a = Gn(), u = jn(), o = Mn(), g = Un(), n = Fn(), c = Vn(), d = Bn(), p = J(), A = Xn(), h = zn(), q = St(), x = Hn(), _ = Wn(), U = Ie(), j = bt(), E = Ur(), S = Fr(), L = qt(), w = Nt(), C = Vr(), K = Qn(), B = Yn(), X = $e(), ee = Z(), F = Ae(), te = Jn(), le = Zn(), m = ei(), f = ti(), T = ri(), R = Lt(), N = ni(), y = ii(), b = si(), k = oi(), O = ai();
+  return wt = {
+    parse: s,
+    valid: l,
+    clean: a,
+    inc: u,
+    diff: o,
+    major: g,
+    minor: n,
+    patch: c,
+    prerelease: d,
+    compare: p,
+    rcompare: A,
+    compareLoose: h,
+    compareBuild: q,
+    sort: x,
+    rsort: _,
+    gt: U,
+    lt: j,
+    eq: E,
+    neq: S,
+    gte: L,
+    lte: w,
+    cmp: C,
+    coerce: K,
+    truncate: B,
+    Comparator: X,
+    Range: ee,
+    satisfies: F,
+    toComparators: te,
+    maxSatisfying: le,
+    minSatisfying: m,
+    minVersion: f,
+    validRange: T,
+    outside: R,
+    gtr: N,
+    ltr: y,
+    intersects: b,
+    simplifyRange: k,
+    subset: O,
+    SemVer: i,
+    re: e.re,
+    src: e.src,
+    tokens: e.t,
+    SEMVER_SPEC_VERSION: r.SEMVER_SPEC_VERSION,
+    RELEASE_TYPES: r.RELEASE_TYPES,
+    compareIdentifiers: t.compareIdentifiers,
+    rcompareIdentifiers: t.rcompareIdentifiers
+  }, wt;
+}
+var ie = li();
+const xr = "https://github.com/giladgd/semantic-golfer";
+function ci(e, r) {
+  if (!ie.valid(r))
+    throw new Error("The current app version is invalid.");
+  const i = ie.prerelease(r) != null, t = Array.isArray(e) ? e : [e], s = [];
+  for (const l of t) {
+    if (l == null || typeof l != "object" || l.draft !== !1 || l.prerelease !== i || typeof l.tag_name != "string")
+      continue;
+    const a = ie.valid(l.tag_name);
+    a && ie.prerelease(a) != null === i && ie.gt(a, r) && s.push({ version: a, tag: l.tag_name });
+  }
+  return s.sort((l, a) => ie.rcompare(l.version, a.version))[0];
+}
+async function ui(e) {
+  const r = ie.prerelease(e) != null;
+  let i = `https://api.github.com/repos/giladgd/semantic-golfer/releases${r ? "?per_page=100" : "/latest"}`;
+  for (; i; ) {
+    const t = await fetch(i, {
+      headers: { Accept: "application/vnd.github+json", "X-GitHub-Api-Version": "2022-11-28" },
+      signal: AbortSignal.timeout(15e3)
+    });
+    if (t.status === 404)
+      return;
+    if (!t.ok)
+      throw new Error(`GitHub update check failed (${t.status}). Try again later.`);
+    const s = await t.json(), l = ci(s, e);
+    if (l || !r)
+      return l;
+    const a = t.headers.get("link")?.match(/<([^>]+)>; rel="next"/)?.[1];
+    i = a?.startsWith("https://api.github.com/repos/giladgd/semantic-golfer/releases?") ? a : void 0;
+  }
+}
+const ye = [v, "updates"];
+let ne, Q;
+function z(e) {
+  v.state = { ...v.state, update: e };
+}
+function di() {
+  const e = v.state.update;
+  e && z({ ...e, dismissed: !0 });
+}
+async function hi() {
+  if (process.env.SEMANTIC_GOLFER_LAUNCHER === "1")
+    return process.connected && process.env.npm_execpath ? void 0 : "Run npx semantic-golfer@latest to update this installation.";
+  if (!P.isPackaged)
+    return "Update the source checkout to use a newer development build.";
+  if (process.platform === "darwin") {
+    const e = await sn(nn)("/usr/bin/codesign", ["-dv", "--verbose=2", P.getPath("exe")]).catch(() => ({ stderr: "" }));
+    if (!/^TeamIdentifier=(?!not set$)\S+$/m.test(e.stderr))
+      return "This unsigned macOS build needs to be replaced with the downloaded app.";
+  }
+  if (process.platform === "linux" && !process.env.APPIMAGE && (await Qr(M.join(process.resourcesPath, "package-type"), "utf8").catch(() => "")).trim() !== "deb")
+    return process.env.SNAP ? "Update this installation through Snap." : "Replace this installation with the downloaded app.";
+}
+function fi() {
+  return Q || (Q = on.autoUpdater, Q.autoDownload = !1, Q.autoInstallOnAppQuit = !1, Q.autoRunAppAfterInstall = !0, Q.allowDowngrade = !1, Q.allowPrerelease = ie.prerelease(P.getVersion()) != null, Q.disableWebInstaller = !0, Q.on("error", (e) => {
+    console.error("App update:", e), ["downloading", "installing"].includes(v.state.update?.status ?? "") && z({ status: "error", version: ne?.version, error: String(e) });
+  }), Q.on("download-progress", ({ percent: e }) => {
+    v.state.update?.status === "downloading" && z({ ...v.state.update, progress: Math.max(0, Math.min(1, e / 100)) });
+  }), Q);
+}
+async function Ot(e = !1) {
+  Dr(ye) || ["downloading", "installing"].includes(v.state.update?.status ?? "") || await se(ye, async () => {
+    const r = v.state.update;
+    z({ status: "checking", dismissed: !e });
+    try {
+      if (ne = await ui(P.getVersion()), !ne) {
+        z({ status: "current", dismissed: !e });
+        return;
+      }
+      z({
+        status: "available",
+        version: ne.version,
+        manual: await hi(),
+        dismissed: !e && r?.version === ne.version && r.dismissed
+      });
+    } catch (i) {
+      z({ status: "error", error: String(i), dismissed: !e });
+    }
+  });
+}
+function pi() {
+  if (Dr(ye) || !ne || !["available", "error"].includes(v.state.update?.status ?? ""))
+    return;
+  const e = ne, r = v.state.update;
+  if (r.manual) {
+    It.openExternal(`${xr}/releases/tag/${encodeURIComponent(e.tag)}`).catch((i) => {
+      z({ ...r, status: "error", error: String(i), dismissed: !1 });
+    });
+    return;
+  }
+  z({ status: "downloading", version: e.version }), se(ye, async () => {
+    try {
+      if (process.env.SEMANTIC_GOLFER_LAUNCHER === "1") {
+        if (!process.connected || !process.send)
+          throw new Error("The npm launcher is no longer connected. Restart the app and try again.");
+        process.send({ type: "semantic-golfer:update", version: e.version }, (s) => {
+          s && z({ status: "error", version: e.version, error: String(s) });
+        });
+        return;
+      }
+      const i = fi();
+      i.setFeedURL({ provider: "generic", url: `${xr}/releases/download/${encodeURIComponent(e.tag)}/` });
+      const t = await i.checkForUpdates();
+      if (!t?.isUpdateAvailable || t.updateInfo.version !== e.version)
+        throw new Error("The release update files do not match this version. Try again later.");
+      await i.downloadUpdate(), z({ status: "installing", version: e.version, progress: 1 }), await se([v, "scores"], () => {
+      }), i.quitAndInstall(!1, !0);
+    } catch (i) {
+      z({ status: "error", version: e.version, error: String(i) });
+    }
+  });
+}
+function mi() {
+  if (process.on("message", (i) => {
+    process.env.SEMANTIC_GOLFER_LAUNCHER !== "1" || v.state.update?.status !== "downloading" || i == null || typeof i != "object" || !("type" in i) || (i.type === "semantic-golfer:update-ready" ? (z({ status: "installing", version: ne?.version, progress: 1 }), se([v, "scores"], () => P.quit())) : i.type === "semantic-golfer:update-error" && "error" in i && typeof i.error == "string" && z({ status: "error", version: ne?.version, error: i.error }));
+  }), !P.isPackaged && process.env.SEMANTIC_GOLFER_LAUNCHER !== "1")
+    return;
+  let e;
+  const r = async () => {
+    await Ot(), e = new kt(r, 14400 * 1e3);
+  };
+  e = new kt(r, 5e3), P.once("will-quit", () => e.dispose());
+}
+const gi = (e) => ({
+  getState: () => v.state,
+  checkForUpdates: () => {
+    Ot(!0);
+  },
+  dismissUpdate: di,
+  installUpdate: pi,
+  saveLevelScore: Cn,
+  downloadModel: fn,
+  cancelDownload: pn,
+  loadModel: _r,
+  evaluateDecision: mn,
+  openModelsDirectory: wn,
+  selectModelFile: () => gn(e),
+  deleteModel: vn
+});
+function wi(e) {
+  const r = bn("llmRpc", "llmRpc", e, gi(e)), i = v.createChangeListener((t) => {
+    e.isDestroyed() || r.updateState.asEvent(t);
+  });
+  e.once("closed", () => {
+    i.dispose(), r.$close();
+  });
+}
+function vi(e) {
+  if (process.platform !== "darwin") {
+    Se.setApplicationMenu(null);
+    return;
+  }
+  Se.setApplicationMenu(Se.buildFromTemplate([
+    { label: P.name, submenu: [
+      { role: "about" },
+      { label: "Check for Updates…", click: () => {
+        e(), Ot(!0);
+      } },
+      { type: "separator" },
+      { role: "services" },
+      { type: "separator" },
+      { role: "hide" },
+      { role: "hideOthers" },
+      { role: "unhide" },
+      { type: "separator" },
+      { role: "quit" }
+    ] },
+    { role: "editMenu" },
+    { role: "viewMenu" },
+    { role: "windowMenu" }
+  ]));
+}
+const Br = M.dirname(Hr(import.meta.url));
+P.getPath("userData") === M.join(P.getPath("appData"), P.getName()) && P.setPath("userData", M.join(P.getPath("appData"), "semantic-golfer"));
+P.setName("Semantic Golfer");
+v.state = { ...v.state, appVersion: P.getVersion() };
+process.env.SEMANTIC_GOLFER_LAUNCHER === "1" && (process.once("disconnect", () => P.quit()), process.connected || P.quit());
+process.platform === "win32" && P.setAppUserModelId("ai.withcat.semantic-golfer");
+process.env.APP_ROOT = M.join(Br, "..");
+const Rt = process.env.VITE_DEV_SERVER_URL, Ni = M.join(process.env.APP_ROOT, "dist-electron"), Xr = M.join(process.env.APP_ROOT, "dist"), zr = M.join(Rt ? M.join(process.env.APP_ROOT, "assets") : Xr, "icon.png");
+let W;
+function Tt() {
+  const e = () => ({
+    color: pe.shouldUseDarkColors ? "#1a211c" : "#edf1eb",
+    symbolColor: pe.shouldUseDarkColors ? "#e2eee5" : "#263c32",
+    height: 60
+  });
+  W = new kr({
+    webPreferences: {
+      preload: M.join(Br, "preload.mjs"),
+      scrollBounce: !0
+    },
+    width: 1380,
+    height: 900,
+    minWidth: 760,
+    minHeight: 600,
+    title: "Semantic Golfer",
+    icon: zr,
+    titleBarStyle: "hidden",
+    ...process.platform === "darwin" ? { trafficLightPosition: { x: 20, y: 22 } } : { titleBarOverlay: e() },
+    autoHideMenuBar: !0,
+    backgroundColor: e().color
+  });
+  const r = W;
+  process.platform !== "darwin" && r.removeMenu();
+  const i = () => {
+    r.setBackgroundColor(e().color), process.platform !== "darwin" && r.setTitleBarOverlay(e());
+  };
+  pe.on("updated", i), r.once("closed", () => pe.off("updated", i)), wi(W), W.webContents.setWindowOpenHandler(({ url: t }) => t.startsWith("file://") ? { action: "allow" } : (It.openExternal(t), { action: "deny" })), Rt ? W.loadURL(Rt) : W.loadFile(M.join(Xr, "index.html"));
+}
+P.on("window-all-closed", () => {
+  (process.platform !== "darwin" || process.env.SEMANTIC_GOLFER_LAUNCHER === "1") && (P.quit(), W = null);
+});
+P.on("activate", () => {
+  kr.getAllWindows().length === 0 && Tt();
+});
+P.whenReady().then(async () => {
+  P.isPackaged || P.dock?.setIcon(zr), await Promise.all([hn(), Pn()]), vi(() => {
+    (!W || W.isDestroyed()) && Tt(), W.isMinimized() && W.restore(), W.show(), W.focus();
+  }), Tt(), mi();
+});
+export {
+  Ni as MAIN_DIST,
+  Xr as RENDERER_DIST,
+  Rt as VITE_DEV_SERVER_URL
+};