1681-engine 0.0.0-stage → 0.5.9

package/dist/fx/Afterimages.js

@@ -0,0 +1,82 @@
+import { solidSilhouette as u, fillSolid as c } from "../core/silhouette.js";
+let g = 0;
+class x {
+  constructor(t, s = {}) {
+    this.stage = t, this.tints = s.tints?.length ? s.tints : [16777215], this.alpha = s.alpha ?? 0.6, this.durationMs = s.durationMs ?? 260, this.spacingMs = s.spacingMs ?? 22, this.endScale = s.endScale ?? 0.85, this.blend = s.blend ?? "add", this.slots = Math.max(1, s.slots ?? 16);
+  }
+  stage;
+  tints;
+  alpha;
+  durationMs;
+  spacingMs;
+  endScale;
+  blend;
+  slots;
+  prefix = `afterimage${++g}_`;
+  /** The copy wearing each ring slot's texture: it goes before its texture is painted over. */
+  slotUsers = [];
+  slot = 0;
+  fading = /* @__PURE__ */ new Set();
+  free = [];
+  lastAt = Number.NEGATIVE_INFINITY;
+  count = 0;
+  /**
+   * Leaves a copy of `body` as drawn now, standing at world (x, y) with draw order `depth` (default just behind a
+   * body sorted by `y`), unless one was left less than `spacingMs` before `now`. Answers the copy, or null when none
+   * was laid (too soon, or the frame could not be read): a caller drawing its own speed streaks between copies
+   * follows that.
+   */
+  trail(t, s, i, r, l = i - 1) {
+    if (r - this.lastAt < this.spacingMs) return null;
+    const e = this.copyOf(t, s, i);
+    return e ? (this.lastAt = r, e.setOrigin(t.originX, t.originY).setFlipX(t.flipX).setScale(t.scaleX, t.scaleY).setRotation(t.rotation).setAlpha(this.alpha).setDepth(l).setBlendMode(this.blend), e.tint = this.tints[this.count++ % this.tints.length], this.fading.add(e), this.stage.tweens.add({
+      targets: e,
+      alpha: 0,
+      scaleX: t.scaleX * this.endScale,
+      scaleY: t.scaleY * this.endScale,
+      duration: this.durationMs,
+      onComplete: () => this.spend(e)
+    }), e) : null;
+  }
+  /** Copies still fading. */
+  get active() {
+    return this.fading.size;
+  }
+  copyOf(t, s, i) {
+    const r = this.stage.textures;
+    if (!r.isLive(t.textureKey)) {
+      const f = u(t.texture);
+      if (!f) return null;
+      const n = this.free.pop(), d = n && !n.destroyed ? n.setTexture(t.textureKey, t.frameName) : this.stage.add.image(s, i, t.textureKey, t.frameName);
+      return d.texture = f, d.setPosition(s, i).setVisible(!0);
+    }
+    const l = this.slot;
+    this.slot = (l + 1) % this.slots;
+    const e = this.slotUsers[l];
+    e && !e.destroyed && (this.stage.tweens.killTweensOf(e), this.fading.delete(e), e.setVisible(!1));
+    const a = this.prefix + l;
+    r.snapshotInto(t.textureKey, t.frameName, a);
+    const h = r.get(a, "0");
+    c(h.source.resource), h.source.update();
+    const o = e && !e.destroyed ? e.setTexture(a, "0").setPosition(s, i).setVisible(!0) : this.stage.add.image(s, i, a, "0");
+    return this.slotUsers[l] = o, o;
+  }
+  /** A faded copy: hidden and kept for the next one (a ring slot's copy stays with its slot). */
+  spend(t) {
+    this.fading.delete(t), !t.destroyed && (t.setVisible(!1), !this.slotUsers.includes(t) && (this.free.length < this.slots ? this.free.push(t) : t.destroy()));
+  }
+  /** Takes every copy off the stage and frees the ring's textures. */
+  destroy() {
+    for (const t of this.fading)
+      this.stage.tweens.killTweensOf(t), this.slotUsers.includes(t) || t.destroy();
+    this.fading.clear();
+    for (const t of this.free) t.destroy();
+    this.free.length = 0;
+    for (const t of this.slotUsers) t && !t.destroyed && t.destroy();
+    for (let t = 0; t < this.slotUsers.length; t++) this.stage.textures.remove(this.prefix + t);
+    this.slotUsers.length = 0;
+  }
+}
+export {
+  x as Afterimages
+};

package/dist/fx/FloatingText.js

@@ -0,0 +1,71 @@
+import { installLabelFont as k } from "../core/BitmapLabel.js";
+const d = (n) => `${n.size}|${n.color}`;
+class m {
+  constructor(t, s) {
+    this.stage = t, this.options = s, this.stroke = s.stroke ?? "#140e18", this.strokeWidth = s.strokeWidth ?? ((i) => Math.max(2, Math.round(i / 5))), this.resolution = s.resolution ?? 4, this.keep = s.keepPerStyle ?? 24;
+  }
+  stage;
+  options;
+  pools = /* @__PURE__ */ new Map();
+  stroke;
+  strokeWidth;
+  resolution;
+  keep;
+  /**
+   * Bakes the fonts of `styles`, one a task starting `delayMs` from now, so no frame pays for them all at once — ten
+   * at once froze a world's first frame half a second (each font measures and kerns every glyph). Returns a cancel.
+   */
+  warm(t, s = 1e3, i = 50) {
+    const o = [...t];
+    let r;
+    const e = () => {
+      const h = o.shift();
+      h && (this.install(h), r = setTimeout(e, i));
+    };
+    return r = setTimeout(e, s), () => clearTimeout(r);
+  }
+  /** Bakes one style's font now. */
+  install(t) {
+    k(this.options.fontFamily, t.size, t.color, this.stroke, this.strokeWidth(t.size), this.resolution, this.options.glyphs);
+  }
+  /** A label ready to animate: shown, opaque, unscaled, anchored at its bottom centre on (x, y). */
+  take(t, s, i, o) {
+    const r = this.pools.get(d(o));
+    let e = r?.pop();
+    for (; e && e.destroyed; ) e = r?.pop();
+    return e ? (e.setText(i), e.position.set(t, s), e.alpha = 1, e.setScale(1), e.visible = !0) : (e = this.stage.add.label(t, s, i, this.options.fontFamily, o.size, o.color, this.stroke, this.strokeWidth(o.size), this.resolution, this.options.glyphs).setOrigin(0.5, 1), this.options.parent && this.options.parent.addChild(e)), this.options.depth !== void 0 && e.setDepth(this.options.depth), e;
+  }
+  /** Hands a finished label back for reuse. */
+  release(t, s) {
+    if (t.destroyed) return;
+    const i = d(s);
+    let o = this.pools.get(i);
+    if (o || this.pools.set(i, o = []), o.length >= this.keep) {
+      t.destroy();
+      return;
+    }
+    t.visible = !1, o.push(t);
+  }
+  /** A label that pops, rises, fades and goes back to the pool by itself, on the stage's own tweens. */
+  float(t, s, i, o, r = {}) {
+    const { rise: e = 16, driftX: h = 0, pop: a = 1.4, popMs: c = 120, holdMs: f = 350, fadeMs: u = 500 } = r, l = this.take(t, s, i, o), p = this.stage.tweens;
+    return a !== 1 && (l.setScale(a), p.add({ targets: l, scale: 1, duration: c, ease: "Back.Out" })), p.add({
+      targets: l,
+      x: t + h,
+      y: s - e,
+      alpha: 0,
+      delay: f,
+      duration: u,
+      ease: "Sine.In",
+      onComplete: () => this.release(l, o)
+    }), l;
+  }
+  /** Destroys every pooled label (a scene ending); labels still out are the scene's to free. */
+  clear() {
+    for (const t of this.pools.values()) for (const s of t) s.destroyed || s.destroy();
+    this.pools.clear();
+  }
+}
+export {
+  m as FloatingText
+};

package/dist/fx/hitStop.js

@@ -0,0 +1,27 @@
+function o(n, r) {
+  const t = Math.min(140, 40 + Math.max(0, n) * 400);
+  return Math.round(t + (r ? 40 : 0));
+}
+function e(n, r, t) {
+  return n ? t ? 2 : 1 : Math.min(3, 2 + (r > 0.2 ? 1 : 0) + (t ? 1 : 0));
+}
+const i = 120;
+function h(n, r) {
+  return r >= 1 || n <= 0 ? 0 : Math.round(n * (1 - r) * (1 - r));
+}
+const u = 400;
+function M(n, r, t) {
+  return t ? 0 : n ? r ? 60 : 0 : r ? 140 : 70;
+}
+function a(n) {
+  return n ? u : 0;
+}
+export {
+  u as HEAVY_FLASH_GAP_MS,
+  i as RECOIL_MS,
+  o as hitStopMs,
+  a as hurtFlashGapMs,
+  M as hurtFlashMs,
+  h as recoilAt,
+  e as recoilPx
+};

package/dist/fx/viewCull.js

@@ -0,0 +1,9 @@
+function u(o, e, n, t) {
+  const s = o.width, l = o.height;
+  if (!s || !l || !(o.zoom > 0)) return !0;
+  const r = o.scrollX ?? 0, h = o.scrollY ?? 0;
+  return e >= r - t && n >= h - t && e <= r + s / o.zoom + t && n <= h + l / o.zoom + t;
+}
+export {
+  u as inView
+};

package/dist/i18n/Translator.js

@@ -0,0 +1,71 @@
+import { sourceText as n, formatMessage as o } from "./formatMessage.js";
+class c {
+  source;
+  lang;
+  catalogs = /* @__PURE__ */ new Map();
+  listeners = /* @__PURE__ */ new Set();
+  rules = /* @__PURE__ */ new Map();
+  reported = /* @__PURE__ */ new Set();
+  onMissing;
+  constructor(t = {}) {
+    this.source = t.source ?? "en", this.lang = t.language ?? this.source, this.onMissing = t.onMissing;
+  }
+  get language() {
+    return this.lang;
+  }
+  /** Languages with a catalog, plus the source. */
+  get languages() {
+    return [.../* @__PURE__ */ new Set([this.source, ...this.catalogs.keys()])];
+  }
+  /** Adds (or merges into) a language's catalog; subscribers hear of it when it is the language shown. */
+  addCatalog(t, e) {
+    const s = this.catalogs.get(t);
+    this.catalogs.set(t, s ? { ...s, ...e } : e), t === this.lang && this.notify();
+  }
+  setLanguage(t) {
+    t !== this.lang && (this.lang = t, this.notify());
+  }
+  /** Calls `fn` with the language after every switch; the returned function stops it. */
+  subscribe(t) {
+    return this.listeners.add(t), () => this.listeners.delete(t);
+  }
+  /** Whether the current language has its own line for `key`. */
+  has(t) {
+    return this.catalogs.get(this.lang)?.[t] !== void 0;
+  }
+  tr = (t, ...e) => {
+    const s = this.lookup(t);
+    let i;
+    return s === void 0 ? i = n(t) : typeof s == "string" ? i = s : i = s.other ?? n(t), o(i, e);
+  };
+  trn = (t, e, s, ...i) => {
+    const r = this.lookup(e), a = [s, ...i];
+    if (r === void 0) return o(n(this.category(this.source, s) === "one" ? t : e), a);
+    if (typeof r == "string") return o(r, a);
+    const l = r[this.category(this.lang, s)] ?? r.other ?? n(e);
+    return o(l, a);
+  };
+  lookup(t) {
+    const e = this.catalogs.get(this.lang)?.[t];
+    if (e === void 0 && this.lang !== this.source && this.onMissing) {
+      const s = `${this.lang}\0${t}`;
+      this.reported.has(s) || (this.reported.add(s), this.onMissing(t, this.lang));
+    }
+    return e;
+  }
+  category(t, e) {
+    let s = this.rules.get(t);
+    return s || (s = new Intl.PluralRules(t), this.rules.set(t, s)), s.select(e);
+  }
+  notify() {
+    for (const t of [...this.listeners])
+      try {
+        t(this.lang);
+      } catch (e) {
+        console.error("[i18n] a language listener failed", e);
+      }
+  }
+}
+export {
+  c as Translator
+};

package/dist/i18n/extractStrings.js

@@ -0,0 +1,57 @@
+function v(n, i = {}) {
+  const f = i.single ?? ["tr"], u = i.plural ?? ["trn"], o = [...f, ...u].map((l) => l.replace(/[$.*+?^()[\]{}|\\]/g, "\\$&"));
+  if (o.length === 0) return [];
+  const e = new RegExp(`(?<![\\w$])(${o.join("|")})\\s*\\(`, "g"), c = [];
+  let r = 1, t = 0;
+  for (const l of n.matchAll(e)) {
+    const s = l[1], a = h(n, l.index + l[0].length);
+    if (!a) continue;
+    for (; t < l.index; t++) n.charCodeAt(t) === 10 && r++;
+    if (!u.includes(s)) {
+      c.push({ key: a.value, fn: s, line: r });
+      continue;
+    }
+    let d = p(n, a.end);
+    if (n[d] !== ",") continue;
+    const g = h(n, d + 1);
+    g && c.push({ key: g.value, one: a.value, fn: s, line: r });
+  }
+  return c;
+}
+function p(n, i) {
+  for (; i < n.length && /\s/.test(n[i]); ) i++;
+  return i;
+}
+const m = { n: `
+`, t: "	", r: "\r", b: "\b", f: "\f", v: "\v", 0: "\0" };
+function h(n, i) {
+  const f = p(n, i), u = n[f];
+  if (u !== "'" && u !== '"' && u !== "`") return null;
+  let o = "";
+  for (let e = f + 1; e < n.length; e++) {
+    const c = n[e];
+    if (c === u) return { value: o, end: e + 1 };
+    if (u !== "`" && c === `
+` || u === "`" && c === "$" && n[e + 1] === "{") return null;
+    if (c !== "\\") {
+      o += c;
+      continue;
+    }
+    const r = n[++e];
+    if (r === void 0) return null;
+    if (r !== `
+`) {
+      if (r === "u" || r === "x") {
+        const t = r === "u" && n[e + 1] === "{", l = t ? n.slice(e + 2, n.indexOf("}", e)) : n.slice(e + 1, e + (r === "u" ? 5 : 3)), s = Number.parseInt(l, 16);
+        if (Number.isNaN(s)) return null;
+        o += String.fromCodePoint(s), e += t ? l.length + 2 : l.length;
+        continue;
+      }
+      o += m[r] ?? r;
+    }
+  }
+  return null;
+}
+export {
+  v as extractStrings
+};

package/dist/i18n/formatMessage.js

@@ -0,0 +1,18 @@
+const u = "|";
+function f(n) {
+  const r = n.lastIndexOf("|");
+  return r < 0 ? n : n.slice(0, r);
+}
+function c(n, r) {
+  return n.indexOf("{") < 0 && n.indexOf("}") < 0 ? n : n.replace(/\{\{|\}\}|\{(\d+)\}/g, (e, t) => {
+    if (e === "{{") return "{";
+    if (e === "}}") return "}";
+    const i = Number(t);
+    return i < r.length ? String(r[i]) : e;
+  });
+}
+export {
+  u as CONTEXT_MARK,
+  c as formatMessage,
+  f as sourceText
+};

package/dist/input/Actions.js

@@ -0,0 +1,139 @@
+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() : []);
+  }
+  keyboard;
+  bindings;
+  virtual = /* @__PURE__ */ new Set();
+  virtualDown = /* @__PURE__ */ new Set();
+  /** Analog value of each action this step (0–1), and last step's, for edges. */
+  now = /* @__PURE__ */ new Map();
+  before = /* @__PURE__ */ new Map();
+  deadZone;
+  gamepads;
+  /** Parsed chords by binding string; null for a plain key. */
+  chords = /* @__PURE__ */ new Map();
+  /** Keys a chord holds this step: their bare bindings read 0 until the key comes up. */
+  claimed = /* @__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]);
+  }
+  bindingsOf(t) {
+    return this.bindings.get(t) ?? [];
+  }
+  /** A touch UI's virtual button went down: `touch:<name>` bindings read it. */
+  press(t) {
+    this.virtual.add(t), this.virtualDown.add(t);
+  }
+  release(t) {
+    this.virtual.delete(t);
+  }
+  /**
+   * 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];
+    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);
+    this.claimChords();
+    for (const [e, s] 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);
+    }
+  }
+  /** Held this step. */
+  down(t) {
+    return (this.now.get(t) ?? 0) > 0;
+  }
+  /** How far it is held (0–1): 1 for a key, the trigger or stick amount for analog input. */
+  value(t) {
+    return this.now.get(t) ?? 0;
+  }
+  /** Went down this step. */
+  pressed(t) {
+    return this.down(t) && !((this.before.get(t) ?? 0) > 0);
+  }
+  /** Came up this step. */
+  released(t) {
+    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);
+  }
+  /** 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);
+    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. */
+  endStep() {
+    this.keyboard?.endStep(), this.virtualDown.clear();
+  }
+  /**
+   * Drops every pending edge: what went down or up since the last step is forgotten, and what is held now counts as
+   * already held, so the next `poll` reports no `pressed` or `released` for it. For input that sat unread while
+   * something else had the keys (a pause menu over the level; `SceneManager.pop` calls it through `Scene.useInput`).
+   */
+  flush() {
+    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;
+  }
+  /** 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);
+        }
+  }
+  read(t, e) {
+    if (t.startsWith("touch:")) {
+      const i = t.slice(6);
+      return this.virtual.has(i) || this.virtualDown.has(i) ? 1 : 0;
+    }
+    if (t.startsWith("pad:")) {
+      const i = t.slice(4);
+      let o = 0;
+      const r = i.endsWith("+") ? 1 : i.endsWith("-") ? -1 : 0;
+      if (r !== 0) {
+        const h = w.indexOf(i.slice(0, -1));
+        if (h < 0) return 0;
+        for (const a of e) {
+          const d = (a.axes[h] ?? 0) * r;
+          d > this.deadZone && (o = Math.max(o, (d - this.deadZone) / (1 - this.deadZone)));
+        }
+        return Math.min(1, o);
+      }
+      const n = u.indexOf(i);
+      if (n < 0) return 0;
+      for (const h of e) {
+        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;
+  }
+}
+export {
+  g as Actions,
+  u as PAD_BUTTONS
+};

package/dist/input/AimGesture.js

@@ -0,0 +1,74 @@
+const u = 10, y = 28, d = 180, S = 0.2;
+function o(s, t = !0, n = 10, i = 28, e = 180) {
+  return t && s < e ? i : n;
+}
+class _ {
+  dragged = !1;
+  over = !1;
+  /** Where the knob is drawn, clamped to the circle, relative to the button's centre. */
+  knob = { x: 0, y: 0 };
+  /** The knob as a vector of length ≤ 1: what the world reads. */
+  share = { x: 0, y: 0 };
+  radius;
+  sensitivity;
+  centreCancels;
+  tapSlop;
+  earlySlop;
+  pressMs;
+  centre;
+  constructor(t) {
+    this.radius = Math.max(1e-6, t.radius), this.sensitivity = t.sensitivity ?? 1, this.centreCancels = t.centreCancels ?? !0, this.tapSlop = t.tapSlop ?? 10, this.earlySlop = t.earlySlop ?? 28, this.pressMs = t.pressMs ?? 180, this.centre = t.centre ?? 0.2;
+  }
+  /**
+   * The thumb at `rawX, rawY` from the button's centre, `overCancel` when it is over the cancel zone, `ms` since it
+   * went down (Infinity skips the landing slop). Once a drag, always a drag for this press.
+   */
+  move(t, n, i = !1, e = 1 / 0) {
+    Math.hypot(t, n) > o(e, !0, this.tapSlop, this.earlySlop, this.pressMs) && (this.dragged = !0), this.over = i;
+    const r = t * this.sensitivity, a = n * this.sensitivity, c = Math.hypot(r, a), h = c > this.radius ? this.radius / c : 1;
+    this.knob = { x: r * h, y: a * h }, this.share = { x: this.knob.x / this.radius, y: this.knob.y / this.radius };
+  }
+  /** A drag has begun: show the aim from now on. */
+  get aiming() {
+    return this.dragged;
+  }
+  get centred() {
+    return Math.hypot(this.share.x, this.share.y) < this.centre;
+  }
+  /** Letting go now would cast nothing (draw the cancel zone lit). */
+  get cancelling() {
+    return this.dragged && (this.over || this.centreCancels && this.centred);
+  }
+  up() {
+    return this.dragged ? this.cancelling ? "cancel" : this.centred ? "tap" : "cast" : "tap";
+  }
+}
+function l(s, t = 0.2) {
+  return Math.max(0, Math.min(1, (s - t) / (1 - t)));
+}
+function g(s, t, n, i = 0.2) {
+  const e = Math.hypot(s, t);
+  if (e < 1e-6) return { x: 0, y: 0 };
+  const r = i + (1 - i) * Math.min(1, e / n);
+  return { x: s / e * r, y: t / e * r };
+}
+function p(s, t, n, i, e = 0.2) {
+  const r = Math.hypot(n.x, n.y), a = r > 1e-6 ? Math.atan2(n.y, n.x) : i;
+  if (t.kind === "point") {
+    const M = l(r, e) * t.range;
+    return { aim: a, x: s.x + Math.cos(a) * M, y: s.y + Math.sin(a) * M };
+  }
+  const c = t.snap ? Math.round(a / t.snap) * t.snap : a, h = t.backwards ? c + Math.PI : c;
+  return { aim: h, x: s.x + Math.cos(h) * t.length, y: s.y + Math.sin(h) * t.length };
+}
+export {
+  S as AIM_CENTRE,
+  y as AIM_EARLY_SLOP,
+  d as AIM_PRESS_MS,
+  u as AIM_TAP_SLOP,
+  _ as AimGesture,
+  p as aimPoint,
+  o as dragSlop,
+  l as spotReach,
+  g as spotShare
+};

package/dist/input/Keyboard.js

@@ -0,0 +1,53 @@
+class h {
+  held = /* @__PURE__ */ new Set();
+  down = /* @__PURE__ */ new Set();
+  up = /* @__PURE__ */ new Set();
+  cleanup = [];
+  constructor(e = window) {
+    const n = (t) => {
+      const s = t.code;
+      t.repeat || this.held.has(s) || (this.held.add(s), this.down.add(s));
+    }, d = (t) => {
+      const s = t.code;
+      this.held.delete(s) && this.up.add(s);
+    }, r = () => {
+      for (const t of this.held) this.up.add(t);
+      this.held.clear();
+    };
+    e.addEventListener("keydown", n), e.addEventListener("keyup", d), window.addEventListener("blur", r), this.cleanup.push(
+      () => e.removeEventListener("keydown", n),
+      () => e.removeEventListener("keyup", d),
+      () => window.removeEventListener("blur", r)
+    );
+  }
+  isDown(e) {
+    return this.held.has(e);
+  }
+  /** Any of these keys is held. */
+  anyDown(...e) {
+    return e.some((n) => this.held.has(n));
+  }
+  /** Went down since the last `endStep`. */
+  pressed(e) {
+    return this.down.has(e);
+  }
+  /** Came up since the last `endStep`. */
+  released(e) {
+    return this.up.has(e);
+  }
+  /** -1, 0 or 1 from two sets of keys: `axis(['KeyA', 'ArrowLeft'], ['KeyD', 'ArrowRight'])`. */
+  axis(e, n) {
+    return (this.anyDown(...n) ? 1 : 0) - (this.anyDown(...e) ? 1 : 0);
+  }
+  /** Forgets this step's edges; held keys stay held. */
+  endStep() {
+    this.down.clear(), this.up.clear();
+  }
+  destroy() {
+    for (const e of this.cleanup.splice(0)) e();
+    this.held.clear(), this.endStep();
+  }
+}
+export {
+  h as Keyboard
+};