1681-engine 0.5.9 → 0.6.0

package/dist/electron/webPatcher.js

@@ -0,0 +1,153 @@
+import { existsSync as b } from "node:fs";
+import { rm as d, mkdir as M, readFile as V, rename as T, readdir as x } from "node:fs/promises";
+import { join as s } from "node:path";
+import { isNewer as y, validManifest as $, fileUrl as P } from "../updates/manifest.js";
+import { planWeb as U } from "../updates/webPlan.js";
+import { fetchWithTimeout as u, hashWeb as D, putFile as g, sha256 as E } from "./webFiles.js";
+import { WebPointers as W } from "./webPointers.js";
+class z {
+  constructor(e) {
+    this.options = e, this.o = {
+      root: e.root,
+      builtinDir: e.builtinDir,
+      appVersion: e.appVersion,
+      channelUrl: e.channelUrl,
+      packaged: e.packaged ?? !0,
+      maxTries: e.maxTries ?? 2,
+      keepPrevious: e.keepPrevious ?? !0,
+      entry: e.entry ?? "index.html",
+      parallel: e.parallel ?? 6,
+      fetchTimeoutMs: e.fetchTimeoutMs ?? 15e3,
+      fetch: e.fetch ?? ((t, i) => globalThis.fetch(t, i)),
+      log: e.log ?? ((...t) => console.error(...t))
+    }, this.pointers = new W(e.root);
+  }
+  options;
+  o;
+  pointers;
+  shellValue = null;
+  /** The web this run loads, and its version (the installed build's own when none is patched in). */
+  loaded = null;
+  /** The tidy a start began: a build waits for it, or it could delete the `.part` folder being filled. */
+  tidying = Promise.resolve();
+  tidyChain = Promise.resolve();
+  /** This shell's identity. */
+  get shell() {
+    const e = this.options.shell;
+    return this.shellValue ??= typeof e == "string" ? e : e(), this.shellValue;
+  }
+  /** Where the window loads the page from: a patched web when there is a good one, else the built-in copy. */
+  startEntry() {
+    if (!this.o.packaged)
+      return this.loaded = { dir: this.o.builtinDir, version: this.o.appVersion }, s(this.o.builtinDir, this.o.entry);
+    try {
+      const e = this.pointers.read("pending");
+      this.usable(e) && this.promote(e, 0), this.pointers.write("pending", null);
+      const t = this.pointers.read("active");
+      if (this.usable(t) && (t.booted || t.tries < this.o.maxTries))
+        t.booted || this.pointers.write("active", { ...t, tries: t.tries + 1 }), this.loaded = { dir: s(this.o.root, t.version), version: t.version };
+      else {
+        t && this.pointers.write("active", null);
+        const i = this.pointers.read("previous");
+        this.pointers.write("previous", null), this.o.keepPrevious && i?.booted && this.usable(i) && (this.pointers.write("active", i), this.loaded = { dir: s(this.o.root, i.version), version: i.version });
+      }
+    } catch (e) {
+      this.o.log("[web] could not read the patched web, using the built-in one", e);
+    }
+    return this.loaded ??= { dir: this.o.builtinDir, version: this.o.appVersion }, this.tidying = this.tidy(), s(this.loaded.dir, this.o.entry);
+  }
+  /** The version of the web running now. */
+  webVersion() {
+    return this.loaded?.version ?? this.o.appVersion;
+  }
+  /** The page came up: the web it was loaded from is kept from now on. Call it from the page's own "booted" message. */
+  markBooted() {
+    const e = this.pointers.read("active");
+    e && this.loaded && e.version === this.loaded.version && !e.booted && this.pointers.write("active", { ...e, booted: !0 });
+  }
+  /** The channel's newest build, or null when the store cannot be read. */
+  async latest() {
+    try {
+      const e = await u(this.o.fetch, `${this.o.channelUrl}/latest.json`, this.o.fetchTimeoutMs);
+      if (!e.ok) return null;
+      const t = await e.json();
+      return typeof t?.version == "string" ? t : null;
+    } catch {
+      return null;
+    }
+  }
+  /** Whether `l`'s web can be patched in here rather than installed: newer than the web running, for this shell. */
+  patchable(e) {
+    return !!e.web && e.web.shell === this.shell && y(e.version, this.webVersion());
+  }
+  /**
+   * Builds `l`'s web beside the one running: the files held are copied, the rest downloaded and checked, into
+   * `<version>.part/`, which becomes `<version>/` and the pending web once whole — a crash mid-way never leaves a
+   * folder that looks finished. `onProgress` gets 0–100. Resolves with the version built; throws on any failure.
+   */
+  async prepare(e, t = () => {
+  }) {
+    if (!e.web) throw new Error("no web in this release");
+    const i = await u(this.o.fetch, `${this.o.channelUrl}/${e.web.manifest}`, this.o.fetchTimeoutMs);
+    if (!i.ok) throw new Error(`web manifest ${i.status}`);
+    const o = await i.json();
+    if (!$(o) || o.version !== e.version || o.shell !== this.shell) throw new Error("bad web manifest");
+    const l = s(this.o.root, o.version), p = { version: o.version, shell: o.shell, booted: !1, tries: 0 };
+    if (b(s(l, this.o.entry)) && this.pointers.read("active")?.version !== o.version)
+      return this.pointers.write("pending", p), t(100), o.version;
+    await this.tidying;
+    const f = this.loaded?.dir ?? this.o.builtinDir, h = U(o, await D(f)), n = s(this.o.root, `${o.version}.part`);
+    await d(n, { recursive: !0, force: !0 }), await M(n, { recursive: !0 });
+    for (const r of h.copy) await g(n, r.path, await V(s(f, ...r.from.split("/"))));
+    let v = 0;
+    const w = /* @__PURE__ */ new Map(), m = [...h.download];
+    t(h.bytes ? 0 : 100);
+    const k = async () => {
+      for (let r = m.shift(); r; r = m.shift()) {
+        let a = w.get(r.sha256);
+        if (!a) {
+          const c = await u(this.o.fetch, P(this.o.channelUrl, r.sha256), this.o.fetchTimeoutMs);
+          if (!c.ok) throw new Error(`${r.path}: ${c.status}`);
+          if (a = new Uint8Array(await c.arrayBuffer()), E(a) !== r.sha256) throw new Error(`${r.path}: checksum`);
+          w.set(r.sha256, a), v += r.size, t(Math.min(99, Math.round(v / Math.max(1, h.bytes) * 100)));
+        }
+        await g(n, r.path, a);
+      }
+    };
+    return await Promise.all(Array.from({ length: Math.max(1, this.o.parallel) }, k)), await d(l, { recursive: !0, force: !0 }), await T(n, l), this.pointers.write("pending", p), t(100), o.version;
+  }
+  /**
+   * Puts the pending web in use now and returns the page to load (reload every window from it), or null when there is
+   * none this shell may load. The switch counts as its first start, so a web that never boots is still dropped.
+   */
+  applyPending() {
+    const e = this.pointers.read("pending");
+    return this.usable(e) ? (this.promote(e, 1), this.pointers.write("pending", null), this.loaded = { dir: s(this.o.root, e.version), version: e.version }, s(this.loaded.dir, this.o.entry)) : null;
+  }
+  /** Makes `p` the active web, keeping the one it replaces as the fallback when that one ever booted. */
+  promote(e, t) {
+    const i = this.pointers.read("active");
+    this.o.keepPrevious && i?.booted && i.version !== e.version && this.pointers.write("previous", i), this.pointers.write("active", { ...e, booted: !1, tries: t });
+  }
+  /** A pointer this shell may load: its own shell, newer than the installed build, its folder whole. */
+  usable(e) {
+    return !!e && e.shell === this.shell && y(e.version, this.o.appVersion) && b(s(this.o.root, e.version, this.o.entry));
+  }
+  /** Removes every patched web but the active, pending and previous one, and any half-made folder. A call made while
+   * one is running waits for it and then runs once more, so two never delete the same folder at once. */
+  tidy() {
+    const e = this.tidyChain.then(() => this.tidyOnce());
+    return this.tidyChain = e, e;
+  }
+  async tidyOnce() {
+    try {
+      const e = ["active", "pending", "previous"], t = new Set([...e.map((i) => this.pointers.read(i)?.version), this.loaded?.version].filter((i) => !!i));
+      for (const i of await x(this.o.root))
+        i.endsWith(".json") || t.has(i) || await d(s(this.o.root, i), { recursive: !0, force: !0 });
+    } catch {
+    }
+  }
+}
+export {
+  z as WebPatcher
+};

package/dist/electron/webPointers.js

@@ -0,0 +1,25 @@
+import { readFileSync as t, mkdirSync as i, writeFileSync as o, rmSync as s } from "node:fs";
+import { join as n } from "node:path";
+class c {
+  constructor(e) {
+    this.root = e;
+  }
+  root;
+  read(e) {
+    try {
+      const r = JSON.parse(t(this.file(e), "utf8"));
+      return typeof r?.version != "string" || typeof r.shell != "string" ? null : { version: r.version, shell: r.shell, booted: r.booted === !0, tries: typeof r.tries == "number" ? r.tries : 0 };
+    } catch {
+      return null;
+    }
+  }
+  write(e, r) {
+    r ? (i(this.root, { recursive: !0 }), o(this.file(e), JSON.stringify(r))) : s(this.file(e), { force: !0 });
+  }
+  file(e) {
+    return n(this.root, `${e}.json`);
+  }
+}
+export {
+  c as WebPointers
+};

package/dist/electron.js

@@ -0,0 +1,19 @@
+import { shellId as r } from "./electron/shellId.js";
+import { WebPatcher as t } from "./electron/webPatcher.js";
+import { SessionStore as l, registerSessionStore as n } from "./electron/sessionStore.js";
+import { DEBUG_SWITCHES as f, debuggerRequested as m, isAllowedExternal as x, isAllowedNavigation as S, isDevToolsKey as a } from "./electron/lockdownRules.js";
+import { denyPermissions as p, lockDownWindow as u, refuseDebugLaunch as w } from "./electron/lockdown.js";
+export {
+  f as DEBUG_SWITCHES,
+  l as SessionStore,
+  t as WebPatcher,
+  m as debuggerRequested,
+  p as denyPermissions,
+  x as isAllowedExternal,
+  S as isAllowedNavigation,
+  a as isDevToolsKey,
+  u as lockDownWindow,
+  w as refuseDebugLaunch,
+  n as registerSessionStore,
+  r as shellId
+};

package/dist/input/Actions.js

@@ -1,9 +1,9 @@
 import { parseChord as c, chordHeld as l } from "./keyChord.js";
 import { rumblePad as f } from "./rumble.js";
 const u = ["a", "b", "x", "y", "lb", "rb", "lt", "rt", "select", "start", "ls", "rs", "up", "down", "left", "right", "home"], w = ["lx", "ly", "rx", "ry"];
-class g {
-  constructor(t, e, s = {}) {
-    this.keyboard = t, this.bindings = new Map(Object.entries(e)), this.deadZone = s.deadZone ?? 0.25, this.gamepads = s.gamepads ?? (() => typeof navigator < "u" && typeof navigator.getGamepads == "function" ? navigator.getGamepads() : []);
+class v {
+  constructor(t, s, e = {}) {
+    this.keyboard = t, this.bindings = new Map(Object.entries(s)), this.deadZone = e.deadZone ?? 0.25, this.gamepads = e.gamepads ?? (() => typeof navigator < "u" && typeof navigator.getGamepads == "function" ? navigator.getGamepads() : []);
   }
   keyboard;
   bindings;
@@ -18,10 +18,14 @@ class g {
   chords = /* @__PURE__ */ new Map();
   /** Keys a chord holds this step: their bare bindings read 0 until the key comes up. */
   claimed = /* @__PURE__ */ new Set();
+  /** Where `poll` takes its values from instead of the devices (a replay), until it returns null. */
+  source = null;
+  /** Handed every step's values after `poll` (a recorder). */
+  taps = /* @__PURE__ */ new Set();
   keyDown = (t) => this.keyboard !== null && (this.keyboard.isDown(t) || this.keyboard.pressed(t));
   /** Replaces one action's bindings (a player's rebinding). */
-  bind(t, e) {
-    this.bindings.set(t, [...e]);
+  bind(t, s) {
+    this.bindings.set(t, [...s]);
   }
   bindingsOf(t) {
     return this.bindings.get(t) ?? [];
@@ -37,19 +41,46 @@ class g {
    * Rumbles the gamepads the actions read: every connected one, or only `padIndex` among them. Resolves true when any
    * played; a pad without rumble is skipped silently.
    */
-  async rumble(t, e) {
-    const s = this.gamepads(), i = e === void 0 ? s : [s[e] ?? null];
+  async rumble(t, s) {
+    const e = this.gamepads(), i = s === void 0 ? e : [e[s] ?? null];
     return (await Promise.all(i.map((r) => r ? f(r, t) : Promise.resolve(!1)))).includes(!0);
   }
   /** Reads every device once; call at the start of each simulation step. */
   poll() {
-    [this.before, this.now] = [this.now, this.before], this.now.clear();
-    const t = this.gamepads().filter((e) => e !== null);
+    if ([this.before, this.now] = [this.now, this.before], this.now.clear(), this.source) {
+      const t = this.source();
+      if (t) {
+        for (const [s, e] of t) e > 0 && this.now.set(s, e);
+        for (const s of this.taps) s(this.now);
+        return;
+      }
+      this.source = null;
+    }
+    this.readDevices();
+    for (const t of this.taps) t(this.now);
+  }
+  /**
+   * Takes each step's values from `source` instead of the devices (an `InputPlayer`), until it returns null; then
+   * the devices answer again. Pass null to stop at once.
+   */
+  replay(t) {
+    this.source = t;
+  }
+  /** Whether a replay is driving the actions now. */
+  get replaying() {
+    return this.source !== null;
+  }
+  /** Calls `tap` with every step's values right after `poll` (an `InputRecorder`); returns the stop. */
+  tap(t) {
+    return this.taps.add(t), () => this.taps.delete(t);
+  }
+  readDevices() {
+    const t = this.gamepads().filter((s) => s !== null);
     this.claimChords();
-    for (const [e, s] of this.bindings) {
+    for (const [s, e] of this.bindings) {
       let i = 0;
-      for (const o of s) i = Math.max(i, this.read(o, t));
-      i > 0 && this.now.set(e, i);
+      for (const o of e) i = Math.max(i, this.read(o, t));
+      i > 0 && this.now.set(s, i);
     }
   }
   /** Held this step. */
@@ -69,12 +100,12 @@ class g {
     return !this.down(t) && (this.before.get(t) ?? 0) > 0;
   }
   /** `value(positive) - value(negative)`, in −1…1. */
-  axis(t, e) {
-    return this.value(e) - this.value(t);
+  axis(t, s) {
+    return this.value(s) - this.value(t);
   }
   /** A 2D direction from four actions, never longer than 1 (a diagonal is not faster). */
-  vector(t, e, s, i) {
-    const o = this.axis(t, e), r = this.axis(s, i), n = Math.hypot(o, r);
+  vector(t, s, e, i) {
+    const o = this.axis(t, s), r = this.axis(e, i), n = Math.hypot(o, r);
     return n > 1 ? [o / n, r / n] : [o, r];
   }
   /** Ends the step: the keyboard forgets its edges; virtual taps shorter than a step have now been seen. */
@@ -90,20 +121,20 @@ class g {
     this.keyboard?.endStep(), this.virtualDown.clear(), this.poll(), this.before = new Map(this.now);
   }
   chordOf(t) {
-    let e = this.chords.get(t);
-    return e === void 0 && (e = t.startsWith("pad:") || t.startsWith("touch:") ? null : c(t), this.chords.set(t, e)), e;
+    let s = this.chords.get(t);
+    return s === void 0 && (s = t.startsWith("pad:") || t.startsWith("touch:") ? null : c(t), this.chords.set(t, s)), s;
   }
   /** Marks the keys held chords use, and frees those whose key has come up. */
   claimChords() {
     for (const t of this.claimed) this.keyDown(t) || this.claimed.delete(t);
     if (this.keyboard)
       for (const t of this.bindings.values())
-        for (const e of t) {
-          const s = this.chordOf(e);
-          s && l(s, this.keyDown) && this.claimed.add(s.code);
+        for (const s of t) {
+          const e = this.chordOf(s);
+          e && l(e, this.keyDown) && this.claimed.add(e.code);
         }
   }
-  read(t, e) {
+  read(t, s) {
     if (t.startsWith("touch:")) {
       const i = t.slice(6);
       return this.virtual.has(i) || this.virtualDown.has(i) ? 1 : 0;
@@ -115,7 +146,7 @@ class g {
       if (r !== 0) {
         const h = w.indexOf(i.slice(0, -1));
         if (h < 0) return 0;
-        for (const a of e) {
+        for (const a of s) {
           const d = (a.axes[h] ?? 0) * r;
           d > this.deadZone && (o = Math.max(o, (d - this.deadZone) / (1 - this.deadZone)));
         }
@@ -123,17 +154,17 @@ class g {
       }
       const n = u.indexOf(i);
       if (n < 0) return 0;
-      for (const h of e) {
+      for (const h of s) {
         const a = h.buttons[n];
         a?.pressed && (o = Math.max(o, a.value > 0 ? a.value : 1));
       }
       return Math.min(1, o);
     }
-    const s = this.chordOf(t);
-    return s ? l(s, this.keyDown) ? 1 : 0 : this.claimed.has(t) ? 0 : this.keyDown(t) ? 1 : 0;
+    const e = this.chordOf(t);
+    return e ? l(e, this.keyDown) ? 1 : 0 : this.claimed.has(t) ? 0 : this.keyDown(t) ? 1 : 0;
   }
 }
 export {
-  g as Actions,
+  v as Actions,
   u as PAD_BUTTONS
 };

package/dist/input/InputCapture.js

@@ -0,0 +1,98 @@
+import { PAD_BUTTONS as r } from "./Actions.js";
+function c(s) {
+  return s.startsWith("pad:") ? "pad" : s.startsWith("touch:") ? "touch" : "keys";
+}
+const h = ["lx", "ly", "rx", "ry"], a = {
+  a: "A",
+  b: "B",
+  x: "X",
+  y: "Y",
+  lb: "LB",
+  rb: "RB",
+  lt: "LT",
+  rt: "RT",
+  select: "Select",
+  start: "Start",
+  ls: "Left stick press",
+  rs: "Right stick press",
+  up: "D-pad up",
+  down: "D-pad down",
+  left: "D-pad left",
+  right: "D-pad right",
+  home: "Home",
+  "lx-": "Left stick left",
+  "lx+": "Left stick right",
+  "ly-": "Left stick up",
+  "ly+": "Left stick down",
+  "rx-": "Right stick left",
+  "rx+": "Right stick right",
+  "ry-": "Right stick up",
+  "ry+": "Right stick down"
+};
+function p(s, t = {}) {
+  if (!s.startsWith("pad:")) return s;
+  const e = s.slice(4);
+  return t[e] ?? a[e] ?? e;
+}
+class l {
+  result;
+  settle;
+  done = !1;
+  held = /* @__PURE__ */ new Set();
+  options;
+  gamepads;
+  target;
+  onKey = (t) => this.key(t);
+  constructor(t = {}) {
+    this.options = {
+      devices: t.devices ?? ["keys", "pad"],
+      ignoreKeys: t.ignoreKeys ?? ["Escape"],
+      cancelKeys: t.cancelKeys ?? ["Escape"],
+      axisThreshold: t.axisThreshold ?? 0.6
+    }, this.gamepads = t.gamepads ?? (() => typeof navigator < "u" && typeof navigator.getGamepads == "function" ? navigator.getGamepads() : []), this.target = t.target ?? (typeof window < "u" ? window : null), this.result = new Promise((e) => this.settle = e);
+    for (const e of this.padInputs()) this.held.add(e);
+    this.options.devices.includes("keys") && this.target?.addEventListener("keydown", this.onKey, { capture: !0 });
+  }
+  /** Reads the gamepads once; call every frame while the capture is open. */
+  poll() {
+    if (this.done || !this.options.devices.includes("pad")) return;
+    const t = new Set(this.padInputs());
+    for (const e of t)
+      if (!this.held.has(e))
+        return this.finish(e);
+    for (const e of [...this.held]) t.has(e) || this.held.delete(e);
+  }
+  /** Stops waiting; the result is null. */
+  cancel() {
+    this.finish(null);
+  }
+  get open() {
+    return !this.done;
+  }
+  key(t) {
+    if (!(this.done || t.repeat)) {
+      if (t.preventDefault(), t.stopImmediatePropagation(), this.options.cancelKeys.includes(t.code)) return this.finish(null);
+      this.options.ignoreKeys.includes(t.code) || !t.code || this.finish(t.code);
+    }
+  }
+  finish(t) {
+    this.done || (this.done = !0, this.target?.removeEventListener("keydown", this.onKey, { capture: !0 }), this.settle(t));
+  }
+  /** Every pad input down on any pad now, as bindings. */
+  padInputs() {
+    const t = [];
+    for (const e of this.gamepads())
+      e && (e.buttons.forEach((i, n) => {
+        (i.pressed || i.value > this.options.axisThreshold) && r[n] && t.push(`pad:${r[n]}`);
+      }), h.forEach((i, n) => {
+        const o = e.axes[n] ?? 0;
+        o > this.options.axisThreshold ? t.push(`pad:${i}+`) : o < -this.options.axisThreshold && t.push(`pad:${i}-`);
+      }));
+    return t;
+  }
+}
+export {
+  l as InputCapture,
+  c as deviceOf,
+  p as padLabel
+};

package/dist/input/Keymap.js

@@ -1,4 +1,5 @@
-class g {
+import { deviceOf as u } from "./InputCapture.js";
+class p {
   binds;
   defaults;
   reserved;
@@ -23,9 +24,13 @@ class g {
   isReserved(t) {
     return this.reserved.has(t);
   }
-  /** The keys of one action; the first is the one a settings screen shows and edits. */
-  keysFor(t) {
-    return this.binds[t] ?? [];
+  /**
+   * The bindings of one action, or only those of one device; the first of a device is the one a settings screen
+   * shows and edits.
+   */
+  keysFor(t, s) {
+    const e = this.binds[t] ?? [];
+    return s ? e.filter((h) => u(h) === s) : e;
   }
   /** The inputs an action always has besides the player's keys (the constructor's `fixed`). */
   fixedFor(t) {
@@ -36,17 +41,18 @@ class g {
     for (const s of this.actions()) if (this.binds[s].includes(t)) return s;
   }
   /**
-   * Puts `code` first on `action`, taking it off whatever else held it; returns the actions that lost it (to tell the
-   * player). A reserved key is refused (returns null). An action stripped of its last key keeps none: it is unbound
-   * until something is put back on it.
+   * Puts `code` first on `action` in place of the action's first binding of the same device (a key replaces its first
+   * key, a pad input its first pad input), taking it off whatever else held it; returns the actions that lost it (to
+   * tell the player). A reserved key is refused (returns null). An action stripped of its last key keeps none: it is
+   * unbound until something is put back on it.
    */
   bind(t, s) {
     if (this.reserved.has(s) || !(t in this.binds)) return null;
     const e = [];
     for (const n of this.actions())
-      n === t || !this.binds[n].includes(s) || (this.binds[n] = this.binds[n].filter((a) => a !== s), e.push(n));
-    const h = this.binds[t].slice(1).filter((n) => n !== s);
-    return this.binds[t] = [s, ...h], this.changed(), e;
+      n === t || !this.binds[n].includes(s) || (this.binds[n] = this.binds[n].filter((r) => r !== s), e.push(n));
+    const h = u(s), f = this.binds[t].find((n) => u(n) === h), a = this.binds[t].filter((n) => n !== f && n !== s);
+    return this.binds[t] = [s, ...a], this.changed(), e;
   }
   /** Takes every key off `action`. */
   unbind(t) {
@@ -68,7 +74,7 @@ class g {
    * (the saved one is what the player chose). Anything malformed is ignored.
    */
   load(t) {
-    this.binds = u(this.defaults, t, this.reserved), this.changed();
+    this.binds = c(this.defaults, t, this.reserved), this.changed();
   }
   /**
    * Hands the bindings to an `Actions`: each action's keys, then its fixed inputs, then its `extra` ones. Only the
@@ -90,19 +96,19 @@ class g {
     for (const t of [...this.listeners]) t();
   }
 }
-function u(i, t, s = /* @__PURE__ */ new Set()) {
-  const e = Object.keys(i), h = {}, n = /* @__PURE__ */ new Set(), a = t && typeof t == "object" ? t : {};
+function c(i, t, s = /* @__PURE__ */ new Set()) {
+  const e = Object.keys(i), h = {}, f = /* @__PURE__ */ new Set(), a = t && typeof t == "object" ? t : {};
   for (const r of e) {
     const o = a[r];
-    Array.isArray(o) && o.every((f) => typeof f == "string") ? (h[r] = [...new Set(o)].filter((f) => !s.has(f)), n.add(r)) : h[r] = i[r].filter((f) => !s.has(f));
+    Array.isArray(o) && o.every((l) => typeof l == "string") ? (h[r] = [...new Set(o)].filter((l) => !s.has(l)), f.add(r)) : h[r] = i[r].filter((l) => !s.has(l));
   }
-  const l = /* @__PURE__ */ new Map();
+  const n = /* @__PURE__ */ new Map();
   for (const r of e)
-    n.has(r) && (h[r] = h[r].filter((o) => l.has(o) ? !1 : (l.set(o, r), !0)));
-  for (const r of e) n.has(r) || (h[r] = h[r].filter((o) => !l.has(o)));
+    f.has(r) && (h[r] = h[r].filter((o) => n.has(o) ? !1 : (n.set(o, r), !0)));
+  for (const r of e) f.has(r) || (h[r] = h[r].filter((o) => !n.has(o)));
   return h;
 }
-function b(i) {
+function S(i) {
   const t = () => {
     try {
       return typeof localStorage > "u" ? null : localStorage;
@@ -133,7 +139,7 @@ function b(i) {
     }
   };
 }
-const c = {
+const d = {
   Space: "Space",
   ShiftLeft: "Shift",
   ShiftRight: "Right Shift",
@@ -157,14 +163,14 @@ const c = {
   BracketLeft: "[",
   BracketRight: "]"
 };
-function d(i, t = {}) {
-  if (i.length > 1 && i.includes("+")) return i.split("+").map((e) => d(e, t)).join("+");
+function b(i, t = {}) {
+  if (i.length > 1 && i.includes("+")) return i.split("+").map((e) => b(e, t)).join("+");
   const s = t[i];
-  return s !== void 0 ? s : i.startsWith("Key") ? i.slice(3) : i.startsWith("Digit") ? i.slice(5) : i.startsWith("Numpad") ? `Num ${i.slice(6)}` : c[i] ?? i;
+  return s !== void 0 ? s : i.startsWith("Key") ? i.slice(3) : i.startsWith("Digit") ? i.slice(5) : i.startsWith("Numpad") ? `Num ${i.slice(6)}` : d[i] ?? i;
 }
 export {
-  g as Keymap,
-  d as keyLabel,
-  b as keymapStorage,
-  u as mergeKeymap
+  p as Keymap,
+  b as keyLabel,
+  S as keymapStorage,
+  c as mergeKeymap
 };

package/dist/input/haptics.js

@@ -0,0 +1,50 @@
+class n {
+  constructor(t = {}) {
+    this.gaps = t;
+  }
+  gaps;
+  last = /* @__PURE__ */ new Map();
+  /** Whether a buzz of `kind` at `now` (ms) may go; one that may is counted. */
+  allow(t, e) {
+    const r = this.last.get(t), s = this.gaps[t] ?? 0;
+    return r !== void 0 && e - r < s ? !1 : (this.last.set(t, e), !0);
+  }
+  /** Forgets every kind's last buzz. */
+  reset() {
+    this.last.clear();
+  }
+}
+function c(a) {
+  const t = typeof navigator > "u" ? void 0 : navigator;
+  if (typeof t?.vibrate != "function") return !1;
+  try {
+    return t.vibrate(typeof a == "number" ? a : [...a]);
+  } catch {
+    return !1;
+  }
+}
+class i {
+  gate;
+  play;
+  enabled;
+  now;
+  constructor(t = {}) {
+    this.gate = new n(t.gaps), this.play = t.play ?? ((e) => c(t.patterns?.[e] ?? 15)), this.enabled = t.enabled ?? (() => !0), this.now = t.now ?? (() => performance.now());
+  }
+  /** Buzzes for `kind`; returns whether it was let through (not whether the device did buzz). */
+  buzz(t) {
+    if (!this.enabled() || !this.gate.allow(t, this.now())) return !1;
+    try {
+      const e = this.play(t);
+      e && typeof e.catch == "function" && e.catch(() => {
+      });
+    } catch {
+    }
+    return !0;
+  }
+}
+export {
+  n as HapticGate,
+  i as Haptics,
+  c as vibrate
+};