1681-engine 0.0.0-stage → 0.5.8

package/dist/ui/dom/DomOverlay.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"DomOverlay.js","sources":["../../../src/ui/dom/DomOverlay.ts"],"sourcesContent":["export interface DomOverlayOptions {\n  /** Added to the root element (for the game's CSS). */\n  className?: string;\n  /** Stacking order over the canvas (default 1). */\n  zIndex?: number;\n  /**\n   * The canvas's size in screen pixels (`() => app.screen`): when CSS stretches the canvas past it (a small fixed\n   * canvas scaled up), `cssScale` is how much, and world placement follows it. Default: no stretch.\n   */\n  logicalSize?: () => { width: number; height: number };\n}\n\n/**\n * The element a DOM (or React) UI is mounted in, laid exactly over the canvas and resized with it. It sits beside the\n * canvas in the same parent, so it shares the canvas's positioned ancestor and needs no change to the page's CSS.\n *\n * The root lets presses through (`pointer-events: none`) so the world stays playable between panels; give what the\n * player presses `pointer-events: auto` (`DomOverlay.interactive`). `content` is drawn at `scale` (a whole multiple\n * for pixel-art UI): laid out on a box `1 / scale` the overlay and scaled back up, so a window sized for 320 × 180\n * fills the screen at ×4 with sharp edges.\n */\nexport class DomOverlay {\n  readonly root: HTMLDivElement;\n  /** Where the UI goes: scaled by `scale`. */\n  readonly content: HTMLDivElement;\n  private scaleNow = 1;\n  private cssW = 0;\n  private cssH = 0;\n  private stretch = 1;\n  private readonly observer: ResizeObserver | null;\n  private readonly onWindow = () => this.sync();\n\n  constructor(\n    readonly canvas: HTMLCanvasElement,\n    private readonly options: DomOverlayOptions = {},\n  ) {\n    const doc = canvas.ownerDocument;\n    this.root = doc.createElement('div');\n    this.content = doc.createElement('div');\n    if (options.className) this.root.className = options.className;\n    Object.assign(this.root.style, { position: 'absolute', overflow: 'hidden', pointerEvents: 'none', zIndex: String(options.zIndex ?? 1) });\n    Object.assign(this.content.style, { position: 'absolute', left: '0', top: '0', transformOrigin: '0 0', pointerEvents: 'none' });\n    this.root.appendChild(this.content);\n    canvas.insertAdjacentElement('afterend', this.root);\n    // the canvas's box changes on its own (a resizeTo parent, CSS), not only with the window\n    this.observer = typeof ResizeObserver === 'function' ? new ResizeObserver(this.onWindow) : null;\n    this.observer?.observe(canvas);\n    window.addEventListener('resize', this.onWindow);\n    this.sync();\n  }\n\n  /** Lets presses on `el` reach it (the overlay's root and content let them through to the canvas). */\n  static interactive(el: HTMLElement): HTMLElement {\n    el.style.pointerEvents = 'auto';\n    return el;\n  }\n\n  /** The overlay's size in CSS pixels (the canvas's box). */\n  get width(): number {\n    return this.cssW;\n  }\n\n  get height(): number {\n    return this.cssH;\n  }\n\n  /** CSS pixels per screen pixel of the canvas: 1 unless CSS stretches it. */\n  get cssScale(): number {\n    return this.stretch;\n  }\n\n  get scale(): number {\n    return this.scaleNow;\n  }\n\n  /** Draws `content` at `scale` (also published as the CSS variable `--ui-scale`). */\n  setScale(scale: number): void {\n    if (scale === this.scaleNow || !(scale > 0)) return;\n    this.scaleNow = scale;\n    this.applySize();\n  }\n\n  /** Lines the overlay up with the canvas again; resizes do it by themselves. */\n  sync(): void {\n    const c = this.canvas;\n    const w = c.clientWidth;\n    const h = c.clientHeight;\n    const s = this.root.style;\n    s.left = `${c.offsetLeft + c.clientLeft}px`;\n    s.top = `${c.offsetTop + c.clientTop}px`;\n    if (w === this.cssW && h === this.cssH) return;\n    this.cssW = w;\n    this.cssH = h;\n    s.width = `${w}px`;\n    s.height = `${h}px`;\n    const logical = this.options.logicalSize?.();\n    this.stretch = logical && logical.width > 0 ? w / logical.width : 1;\n    this.applySize();\n  }\n\n  destroy(): void {\n    this.observer?.disconnect();\n    window.removeEventListener('resize', this.onWindow);\n    this.root.remove();\n  }\n\n  private applySize(): void {\n    const k = this.scaleNow;\n    const s = this.content.style;\n    s.width = `${this.cssW / k}px`;\n    s.height = `${this.cssH / k}px`;\n    s.transform = k === 1 ? '' : `scale(${k})`;\n    this.root.style.setProperty('--ui-scale', String(k));\n  }\n}\n"],"names":["DomOverlay","canvas","options","doc","el","scale","c","w","h","s","logical","k"],"mappings":"AAqBO,MAAMA,EAAW;AAAA,EAWtB,YACWC,GACQC,IAA6B,IAC9C;AAFS,SAAA,SAAAD,GACQ,KAAA,UAAAC;AAEjB,UAAMC,IAAMF,EAAO;AACnB,SAAK,OAAOE,EAAI,cAAc,KAAK,GACnC,KAAK,UAAUA,EAAI,cAAc,KAAK,GAClCD,EAAQ,cAAW,KAAK,KAAK,YAAYA,EAAQ,YACrD,OAAO,OAAO,KAAK,KAAK,OAAO,EAAE,UAAU,YAAY,UAAU,UAAU,eAAe,QAAQ,QAAQ,OAAOA,EAAQ,UAAU,CAAC,GAAG,GACvI,OAAO,OAAO,KAAK,QAAQ,OAAO,EAAE,UAAU,YAAY,MAAM,KAAK,KAAK,KAAK,iBAAiB,OAAO,eAAe,QAAQ,GAC9H,KAAK,KAAK,YAAY,KAAK,OAAO,GAClCD,EAAO,sBAAsB,YAAY,KAAK,IAAI,GAElD,KAAK,WAAW,OAAO,kBAAmB,aAAa,IAAI,eAAe,KAAK,QAAQ,IAAI,MAC3F,KAAK,UAAU,QAAQA,CAAM,GAC7B,OAAO,iBAAiB,UAAU,KAAK,QAAQ,GAC/C,KAAK,KAAA;AAAA,EACP;AAAA,EAhBW;AAAA,EACQ;AAAA,EAZV;AAAA;AAAA,EAEA;AAAA,EACD,WAAW;AAAA,EACX,OAAO;AAAA,EACP,OAAO;AAAA,EACP,UAAU;AAAA,EACD;AAAA,EACA,WAAW,MAAM,KAAK,KAAA;AAAA;AAAA,EAsBvC,OAAO,YAAYG,GAA8B;AAC/C,WAAAA,EAAG,MAAM,gBAAgB,QAClBA;AAAA,EACT;AAAA;AAAA,EAGA,IAAI,QAAgB;AAClB,WAAO,KAAK;AAAA,EACd;AAAA,EAEA,IAAI,SAAiB;AACnB,WAAO,KAAK;AAAA,EACd;AAAA;AAAA,EAGA,IAAI,WAAmB;AACrB,WAAO,KAAK;AAAA,EACd;AAAA,EAEA,IAAI,QAAgB;AAClB,WAAO,KAAK;AAAA,EACd;AAAA;AAAA,EAGA,SAASC,GAAqB;AAC5B,IAAIA,MAAU,KAAK,YAAY,EAAEA,IAAQ,OACzC,KAAK,WAAWA,GAChB,KAAK,UAAA;AAAA,EACP;AAAA;AAAA,EAGA,OAAa;AACX,UAAMC,IAAI,KAAK,QACTC,IAAID,EAAE,aACNE,IAAIF,EAAE,cACNG,IAAI,KAAK,KAAK;AAGpB,QAFAA,EAAE,OAAO,GAAGH,EAAE,aAAaA,EAAE,UAAU,MACvCG,EAAE,MAAM,GAAGH,EAAE,YAAYA,EAAE,SAAS,MAChCC,MAAM,KAAK,QAAQC,MAAM,KAAK,KAAM;AACxC,SAAK,OAAOD,GACZ,KAAK,OAAOC,GACZC,EAAE,QAAQ,GAAGF,CAAC,MACdE,EAAE,SAAS,GAAGD,CAAC;AACf,UAAME,IAAU,KAAK,QAAQ,cAAA;AAC7B,SAAK,UAAUA,KAAWA,EAAQ,QAAQ,IAAIH,IAAIG,EAAQ,QAAQ,GAClE,KAAK,UAAA;AAAA,EACP;AAAA,EAEA,UAAgB;AACd,SAAK,UAAU,WAAA,GACf,OAAO,oBAAoB,UAAU,KAAK,QAAQ,GAClD,KAAK,KAAK,OAAA;AAAA,EACZ;AAAA,EAEQ,YAAkB;AACxB,UAAMC,IAAI,KAAK,UACT,IAAI,KAAK,QAAQ;AACvB,MAAE,QAAQ,GAAG,KAAK,OAAOA,CAAC,MAC1B,EAAE,SAAS,GAAG,KAAK,OAAOA,CAAC,MAC3B,EAAE,YAAYA,MAAM,IAAI,KAAK,SAASA,CAAC,KACvC,KAAK,KAAK,MAAM,YAAY,cAAc,OAAOA,CAAC,CAAC;AAAA,EACrD;AACF;"}

package/dist/ui/dom/DomWorldAnchors.js

@@ -0,0 +1,59 @@
+import { UPDATE_PRIORITY as h } from "pixi.js";
+import { worldToScreen as l, onScreen as c } from "./worldToScreen.js";
+const i = { x: 0, y: 0 };
+class m {
+  constructor(s, o) {
+    this.overlay = s, this.layer = o;
+  }
+  overlay;
+  layer;
+  anchors = [];
+  ticker = null;
+  onTick = () => this.update();
+  /** Places `el` (put inside the overlay's content if it is not already there) on `target`. Returns the remover. */
+  add(s, o, a = {}) {
+    s.parentElement || this.overlay.content.appendChild(s), s.style.position = "absolute", s.style.left = "0", s.style.top = "0";
+    const t = (a.alignX ?? 0.5) * 100, e = (a.alignY ?? 1) * 100, n = {
+      el: s,
+      target: o,
+      ox: a.offsetX ?? 0,
+      oy: a.offsetY ?? 0,
+      align: t === 0 && e === 0 ? "" : ` translate(${-t}%, ${-e}%)`,
+      margin: a.margin ?? 64,
+      lastX: NaN,
+      lastY: NaN,
+      shown: !0
+    };
+    return this.anchors.push(n), () => this.remove(s);
+  }
+  remove(s) {
+    const o = this.anchors.findIndex((a) => a.el === s);
+    o >= 0 && this.anchors.splice(o, 1);
+  }
+  /**
+   * Runs `update` on `ticker` after Pixi renders (`UTILITY` priority), so it reads the camera as this frame drew it,
+   * shake included. The returned function stops it.
+   */
+  attach(s) {
+    return this.detach(), this.ticker = s, s.add(this.onTick, void 0, h.UTILITY), () => this.detach();
+  }
+  detach() {
+    this.ticker?.remove(this.onTick), this.ticker = null;
+  }
+  /** Places every element for this frame. */
+  update() {
+    const s = this.overlay.cssScale / this.overlay.scale, o = this.overlay.width / this.overlay.scale, a = this.overlay.height / this.overlay.scale;
+    for (const t of this.anchors) {
+      l(this.layer, t.target.x, t.target.y, i, s);
+      const e = Math.round(i.x + t.ox), n = Math.round(i.y + t.oy), r = c(e, n, o, a, t.margin);
+      r !== t.shown && (t.shown = r, t.el.style.display = r ? "" : "none"), !(!r || e === t.lastX && n === t.lastY) && (t.lastX = e, t.lastY = n, t.el.style.transform = `translate3d(${e}px, ${n}px, 0)${t.align}`);
+    }
+  }
+  destroy() {
+    this.detach(), this.anchors.length = 0;
+  }
+}
+export {
+  m as DomWorldAnchors
+};
+//# sourceMappingURL=DomWorldAnchors.js.map

package/dist/ui/dom/DomWorldAnchors.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"DomWorldAnchors.js","sources":["../../../src/ui/dom/DomWorldAnchors.ts"],"sourcesContent":["import { UPDATE_PRIORITY, type Ticker } from 'pixi.js';\nimport type { DomOverlay } from './DomOverlay';\nimport { onScreen, worldToScreen, type LayerTransform } from './worldToScreen';\n\nexport interface WorldAnchorOptions {\n  /** Moved this far after projecting (CSS px): a name 20 px over the feet. */\n  offsetX?: number;\n  offsetY?: number;\n  /**\n   * Which point of the element sits on the spot, as fractions of its size (default 0.5, 1: centred above it).\n   * Written as a CSS translate in percent, so the element is never measured.\n   */\n  alignX?: number;\n  alignY?: number;\n  /** Kept shown this far past the screen's edge (default 64 px), so a wide label does not pop out early. */\n  margin?: number;\n}\n\n/** Anything with a world position read every frame: an entity's position object, a sprite. */\nexport interface WorldPoint {\n  readonly x: number;\n  readonly y: number;\n}\n\ninterface Anchor {\n  el: HTMLElement;\n  target: WorldPoint;\n  ox: number;\n  oy: number;\n  align: string;\n  margin: number;\n  lastX: number;\n  lastY: number;\n  shown: boolean;\n}\n\nconst point = { x: 0, y: 0 };\n\n/**\n * DOM elements that follow points in the world (names over heads, speech bubbles, markers): placed every frame\n * through the world layer's own transform, on whole CSS pixels, and hidden off screen. A style is written only when\n * the rounded position or visibility changed, so a still crowd costs no DOM writes.\n */\nexport class DomWorldAnchors {\n  private readonly anchors: Anchor[] = [];\n  private ticker: Ticker | null = null;\n  private readonly onTick = () => this.update();\n\n  constructor(\n    private readonly overlay: DomOverlay,\n    /** The layer the points are in: `engine.stage.world`. */\n    private readonly layer: LayerTransform,\n  ) {}\n\n  /** Places `el` (put inside the overlay's content if it is not already there) on `target`. Returns the remover. */\n  add(el: HTMLElement, target: WorldPoint, options: WorldAnchorOptions = {}): () => void {\n    if (!el.parentElement) this.overlay.content.appendChild(el);\n    el.style.position = 'absolute';\n    el.style.left = '0';\n    el.style.top = '0';\n    const ax = (options.alignX ?? 0.5) * 100;\n    const ay = (options.alignY ?? 1) * 100;\n    const a: Anchor = {\n      el,\n      target,\n      ox: options.offsetX ?? 0,\n      oy: options.offsetY ?? 0,\n      align: ax === 0 && ay === 0 ? '' : ` translate(${-ax}%, ${-ay}%)`,\n      margin: options.margin ?? 64,\n      lastX: NaN,\n      lastY: NaN,\n      shown: true,\n    };\n    this.anchors.push(a);\n    return () => this.remove(el);\n  }\n\n  remove(el: HTMLElement): void {\n    const i = this.anchors.findIndex((a) => a.el === el);\n    if (i >= 0) this.anchors.splice(i, 1);\n  }\n\n  /**\n   * Runs `update` on `ticker` after Pixi renders (`UTILITY` priority), so it reads the camera as this frame drew it,\n   * shake included. The returned function stops it.\n   */\n  attach(ticker: Ticker): () => void {\n    this.detach();\n    this.ticker = ticker;\n    ticker.add(this.onTick, undefined, UPDATE_PRIORITY.UTILITY);\n    return () => this.detach();\n  }\n\n  detach(): void {\n    this.ticker?.remove(this.onTick);\n    this.ticker = null;\n  }\n\n  /** Places every element for this frame. */\n  update(): void {\n    // the overlay's content is scaled: positions are written in its own units\n    const k = this.overlay.cssScale / this.overlay.scale;\n    const w = this.overlay.width / this.overlay.scale;\n    const h = this.overlay.height / this.overlay.scale;\n    for (const a of this.anchors) {\n      worldToScreen(this.layer, a.target.x, a.target.y, point, k);\n      const x = Math.round(point.x + a.ox);\n      const y = Math.round(point.y + a.oy);\n      const show = onScreen(x, y, w, h, a.margin);\n      if (show !== a.shown) {\n        a.shown = show;\n        a.el.style.display = show ? '' : 'none';\n      }\n      if (!show || (x === a.lastX && y === a.lastY)) continue;\n      a.lastX = x;\n      a.lastY = y;\n      a.el.style.transform = `translate3d(${x}px, ${y}px, 0)${a.align}`;\n    }\n  }\n\n  destroy(): void {\n    this.detach();\n    this.anchors.length = 0;\n  }\n}\n"],"names":["point","DomWorldAnchors","overlay","layer","el","target","options","ax","ay","a","i","ticker","UPDATE_PRIORITY","k","w","h","worldToScreen","x","y","show","onScreen"],"mappings":";;AAoCA,MAAMA,IAAQ,EAAE,GAAG,GAAG,GAAG,EAAA;AAOlB,MAAMC,EAAgB;AAAA,EAK3B,YACmBC,GAEAC,GACjB;AAHiB,SAAA,UAAAD,GAEA,KAAA,QAAAC;AAAA,EAChB;AAAA,EAHgB;AAAA,EAEA;AAAA,EAPF,UAAoB,CAAA;AAAA,EAC7B,SAAwB;AAAA,EACf,SAAS,MAAM,KAAK,OAAA;AAAA;AAAA,EASrC,IAAIC,GAAiBC,GAAoBC,IAA8B,CAAA,GAAgB;AACrF,IAAKF,EAAG,sBAAoB,QAAQ,QAAQ,YAAYA,CAAE,GAC1DA,EAAG,MAAM,WAAW,YACpBA,EAAG,MAAM,OAAO,KAChBA,EAAG,MAAM,MAAM;AACf,UAAMG,KAAMD,EAAQ,UAAU,OAAO,KAC/BE,KAAMF,EAAQ,UAAU,KAAK,KAC7BG,IAAY;AAAA,MAChB,IAAAL;AAAA,MACA,QAAAC;AAAA,MACA,IAAIC,EAAQ,WAAW;AAAA,MACvB,IAAIA,EAAQ,WAAW;AAAA,MACvB,OAAOC,MAAO,KAAKC,MAAO,IAAI,KAAK,cAAc,CAACD,CAAE,MAAM,CAACC,CAAE;AAAA,MAC7D,QAAQF,EAAQ,UAAU;AAAA,MAC1B,OAAO;AAAA,MACP,OAAO;AAAA,MACP,OAAO;AAAA,IAAA;AAET,gBAAK,QAAQ,KAAKG,CAAC,GACZ,MAAM,KAAK,OAAOL,CAAE;AAAA,EAC7B;AAAA,EAEA,OAAOA,GAAuB;AAC5B,UAAMM,IAAI,KAAK,QAAQ,UAAU,CAAC,MAAM,EAAE,OAAON,CAAE;AACnD,IAAIM,KAAK,KAAG,KAAK,QAAQ,OAAOA,GAAG,CAAC;AAAA,EACtC;AAAA;AAAA;AAAA;AAAA;AAAA,EAMA,OAAOC,GAA4B;AACjC,gBAAK,OAAA,GACL,KAAK,SAASA,GACdA,EAAO,IAAI,KAAK,QAAQ,QAAWC,EAAgB,OAAO,GACnD,MAAM,KAAK,OAAA;AAAA,EACpB;AAAA,EAEA,SAAe;AACb,SAAK,QAAQ,OAAO,KAAK,MAAM,GAC/B,KAAK,SAAS;AAAA,EAChB;AAAA;AAAA,EAGA,SAAe;AAEb,UAAMC,IAAI,KAAK,QAAQ,WAAW,KAAK,QAAQ,OACzCC,IAAI,KAAK,QAAQ,QAAQ,KAAK,QAAQ,OACtCC,IAAI,KAAK,QAAQ,SAAS,KAAK,QAAQ;AAC7C,eAAWN,KAAK,KAAK,SAAS;AAC5B,MAAAO,EAAc,KAAK,OAAOP,EAAE,OAAO,GAAGA,EAAE,OAAO,GAAGT,GAAOa,CAAC;AAC1D,YAAMI,IAAI,KAAK,MAAMjB,EAAM,IAAIS,EAAE,EAAE,GAC7BS,IAAI,KAAK,MAAMlB,EAAM,IAAIS,EAAE,EAAE,GAC7BU,IAAOC,EAASH,GAAGC,GAAGJ,GAAGC,GAAGN,EAAE,MAAM;AAK1C,MAJIU,MAASV,EAAE,UACbA,EAAE,QAAQU,GACVV,EAAE,GAAG,MAAM,UAAUU,IAAO,KAAK,SAE/B,GAACA,KAASF,MAAMR,EAAE,SAASS,MAAMT,EAAE,WACvCA,EAAE,QAAQQ,GACVR,EAAE,QAAQS,GACVT,EAAE,GAAG,MAAM,YAAY,eAAeQ,CAAC,OAAOC,CAAC,SAAST,EAAE,KAAK;AAAA,IACjE;AAAA,EACF;AAAA,EAEA,UAAgB;AACd,SAAK,OAAA,GACL,KAAK,QAAQ,SAAS;AAAA,EACxB;AACF;"}

package/dist/ui/dom/InputShield.js

@@ -0,0 +1,27 @@
+import { isEditable as s, isInside as i, shouldShield as c } from "./shieldDecision.js";
+const n = ["keydown", "keypress", "pointerdown", "mousedown", "touchstart", "click", "dblclick", "wheel", "contextmenu"];
+class a {
+  constructor(t, o = {}) {
+    this.root = t, this.options = o;
+    for (const e of n) t.addEventListener(e, this.handler, { passive: !1 });
+  }
+  root;
+  options;
+  handler = (t) => this.check(t);
+  /** Whether the player is typing in a field of the UI now (a game may also skip its hotkeys). */
+  get typing() {
+    const t = this.root.ownerDocument.activeElement;
+    return s(t) && i(t, this.root);
+  }
+  destroy() {
+    for (const t of n) this.root.removeEventListener(t, this.handler);
+  }
+  check(t) {
+    const o = t.target, e = t.code, r = { insideUi: i(o, this.root), editable: s(o), ...e === void 0 ? {} : { code: e } };
+    c(t.type, r, this.options) && t.stopPropagation();
+  }
+}
+export {
+  a as InputShield
+};
+//# sourceMappingURL=InputShield.js.map

package/dist/ui/dom/InputShield.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"InputShield.js","sources":["../../../src/ui/dom/InputShield.ts"],"sourcesContent":["import { isEditable, isInside, shouldShield, type ShieldOptions } from './shieldDecision';\n\n/** The events checked on their way up out of the overlay. */\nconst EVENTS = ['keydown', 'keypress', 'pointerdown', 'mousedown', 'touchstart', 'click', 'dblclick', 'wheel', 'contextmenu'] as const;\n\n/**\n * Keeps input meant for the DOM UI from reaching the engine. It listens on the overlay's root as events bubble out\n * of it and stops the ones `shouldShield` names, so the element under them still gets them (a text field still\n * types) but listeners on the window and document (`Keyboard`, a game's own) never hear them.\n *\n * Presses on the overlay never reach `Pointer` anyway, which counts presses only on the canvas; the shield covers\n * keys, wheel and window-level listeners. Releases always pass, or a key held when a field took focus would stick.\n */\nexport class InputShield {\n  private readonly handler = (e: Event) => this.check(e);\n\n  constructor(\n    private readonly root: HTMLElement,\n    private readonly options: ShieldOptions = {},\n  ) {\n    for (const type of EVENTS) root.addEventListener(type, this.handler, { passive: false });\n  }\n\n  /** Whether the player is typing in a field of the UI now (a game may also skip its hotkeys). */\n  get typing(): boolean {\n    const active = this.root.ownerDocument.activeElement;\n    return isEditable(active as HTMLElement | null) && isInside(active as HTMLElement | null, this.root);\n  }\n\n  destroy(): void {\n    for (const type of EVENTS) this.root.removeEventListener(type, this.handler);\n  }\n\n  private check(e: Event): void {\n    const target = e.target as HTMLElement | null;\n    const code = (e as KeyboardEvent).code;\n    const facts = { insideUi: isInside(target, this.root), editable: isEditable(target), ...(code === undefined ? {} : { code }) };\n    if (shouldShield(e.type, facts, this.options)) e.stopPropagation();\n  }\n}\n"],"names":["EVENTS","InputShield","root","options","type","e","active","isEditable","isInside","target","code","facts","shouldShield"],"mappings":";AAGA,MAAMA,IAAS,CAAC,WAAW,YAAY,eAAe,aAAa,cAAc,SAAS,YAAY,SAAS,aAAa;AAUrH,MAAMC,EAAY;AAAA,EAGvB,YACmBC,GACAC,IAAyB,IAC1C;AAFiB,SAAA,OAAAD,GACA,KAAA,UAAAC;AAEjB,eAAWC,KAAQJ,EAAQ,CAAAE,EAAK,iBAAiBE,GAAM,KAAK,SAAS,EAAE,SAAS,GAAA,CAAO;AAAA,EACzF;AAAA,EAJmB;AAAA,EACA;AAAA,EAJF,UAAU,CAACC,MAAa,KAAK,MAAMA,CAAC;AAAA;AAAA,EAUrD,IAAI,SAAkB;AACpB,UAAMC,IAAS,KAAK,KAAK,cAAc;AACvC,WAAOC,EAAWD,CAA4B,KAAKE,EAASF,GAA8B,KAAK,IAAI;AAAA,EACrG;AAAA,EAEA,UAAgB;AACd,eAAWF,KAAQJ,EAAQ,MAAK,KAAK,oBAAoBI,GAAM,KAAK,OAAO;AAAA,EAC7E;AAAA,EAEQ,MAAMC,GAAgB;AAC5B,UAAMI,IAASJ,EAAE,QACXK,IAAQL,EAAoB,MAC5BM,IAAQ,EAAE,UAAUH,EAASC,GAAQ,KAAK,IAAI,GAAG,UAAUF,EAAWE,CAAM,GAAG,GAAIC,MAAS,SAAY,CAAA,IAAK,EAAE,MAAAA,IAAK;AAC1H,IAAIE,EAAaP,EAAE,MAAMM,GAAO,KAAK,OAAO,OAAK,gBAAA;AAAA,EACnD;AACF;"}

package/dist/ui/dom/createStore.js

@@ -0,0 +1,42 @@
+function l(f) {
+  let t = f, s = [];
+  const i = {
+    getState: () => t,
+    setState(e) {
+      const r = typeof e == "function" ? e(t) : e;
+      let c = !1;
+      for (const o in r)
+        if (!Object.is(r[o], t[o])) {
+          c = !0;
+          break;
+        }
+      if (!c) return;
+      const n = t;
+      t = { ...t, ...r };
+      for (const o of s) o(t, n);
+    },
+    subscribe(e) {
+      return s = [...s, e], () => {
+        s = s.filter((r) => r !== e);
+      };
+    },
+    select(e, r, c = Object.is) {
+      let n = e(t);
+      return i.subscribe((o) => {
+        const u = e(o);
+        if (c(u, n)) return;
+        const b = n;
+        n = u, r(u, b);
+      });
+    },
+    reset() {
+      const e = t;
+      if (t = f, e !== f) for (const r of s) r(t, e);
+    }
+  };
+  return i;
+}
+export {
+  l as createStore
+};
+//# sourceMappingURL=createStore.js.map

package/dist/ui/dom/createStore.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"createStore.js","sources":["../../../src/ui/dom/createStore.ts"],"sourcesContent":["export type StoreListener<T> = (state: T, previous: T) => void;\n\n/**\n * A tiny shared state store between the game and its UI, framework-free. Same shape as the engine's settings store\n * and as zustand's vanilla stores (`getState`, `setState`, `subscribe`), so React reads it with\n * `useSyncExternalStore(store.subscribe, store.getState)`.\n */\nexport interface Store<T extends object> {\n  getState(): T;\n  /**\n   * Merges a patch (or what a function of the state returns) into a new state object. A patch that changes nothing\n   * notifies nobody: a game may set the player's health every frame and the UI renders only when it moved.\n   */\n  setState(patch: Partial<T> | ((state: T) => Partial<T>)): void;\n  /** Calls `listener` after every change; the returned function unsubscribes. */\n  subscribe(listener: StoreListener<T>): () => void;\n  /** Calls `listener` only when `select(state)` changes (by `equals`, default `Object.is`). */\n  select<S>(select: (state: T) => S, listener: (value: S, previous: S) => void, equals?: (a: S, b: S) => boolean): () => void;\n  /** Back to the state it was made with. */\n  reset(): void;\n}\n\nexport function createStore<T extends object>(initial: T): Store<T> {\n  let state = initial;\n  // replaced, never edited, on (un)subscribe: setState walks it without a copy, and a listener that unsubscribes\n  // while it runs does not shift the walk\n  let listeners: readonly StoreListener<T>[] = [];\n\n  const store: Store<T> = {\n    getState: () => state,\n    setState(patch) {\n      const p = typeof patch === 'function' ? patch(state) : patch;\n      let changed = false;\n      for (const k in p) {\n        if (!Object.is(p[k], state[k])) {\n          changed = true;\n          break;\n        }\n      }\n      if (!changed) return;\n      const previous = state;\n      state = { ...state, ...p };\n      for (const l of listeners) l(state, previous);\n    },\n    subscribe(listener) {\n      listeners = [...listeners, listener];\n      return () => {\n        listeners = listeners.filter((l) => l !== listener);\n      };\n    },\n    select(select, listener, equals = Object.is) {\n      let current = select(state);\n      return store.subscribe((s) => {\n        const next = select(s);\n        if (equals(next, current)) return;\n        const previous = current;\n        current = next;\n        listener(next, previous);\n      });\n    },\n    reset() {\n      const previous = state;\n      state = initial;\n      if (previous !== initial) for (const l of listeners) l(state, previous);\n    },\n  };\n  return store;\n}\n"],"names":["createStore","initial","state","listeners","store","patch","p","changed","k","previous","l","listener","select","equals","current","s","next"],"mappings":"AAsBO,SAASA,EAA8BC,GAAsB;AAClE,MAAIC,IAAQD,GAGRE,IAAyC,CAAA;AAE7C,QAAMC,IAAkB;AAAA,IACtB,UAAU,MAAMF;AAAA,IAChB,SAASG,GAAO;AACd,YAAMC,IAAI,OAAOD,KAAU,aAAaA,EAAMH,CAAK,IAAIG;AACvD,UAAIE,IAAU;AACd,iBAAWC,KAAKF;AACd,YAAI,CAAC,OAAO,GAAGA,EAAEE,CAAC,GAAGN,EAAMM,CAAC,CAAC,GAAG;AAC9B,UAAAD,IAAU;AACV;AAAA,QACF;AAEF,UAAI,CAACA,EAAS;AACd,YAAME,IAAWP;AACjB,MAAAA,IAAQ,EAAE,GAAGA,GAAO,GAAGI,EAAA;AACvB,iBAAWI,KAAKP,EAAW,CAAAO,EAAER,GAAOO,CAAQ;AAAA,IAC9C;AAAA,IACA,UAAUE,GAAU;AAClB,aAAAR,IAAY,CAAC,GAAGA,GAAWQ,CAAQ,GAC5B,MAAM;AACX,QAAAR,IAAYA,EAAU,OAAO,CAACO,MAAMA,MAAMC,CAAQ;AAAA,MACpD;AAAA,IACF;AAAA,IACA,OAAOC,GAAQD,GAAUE,IAAS,OAAO,IAAI;AAC3C,UAAIC,IAAUF,EAAOV,CAAK;AAC1B,aAAOE,EAAM,UAAU,CAACW,MAAM;AAC5B,cAAMC,IAAOJ,EAAOG,CAAC;AACrB,YAAIF,EAAOG,GAAMF,CAAO,EAAG;AAC3B,cAAML,IAAWK;AACjB,QAAAA,IAAUE,GACVL,EAASK,GAAMP,CAAQ;AAAA,MACzB,CAAC;AAAA,IACH;AAAA,IACA,QAAQ;AACN,YAAMA,IAAWP;AAEjB,UADAA,IAAQD,GACJQ,MAAaR,EAAS,YAAWS,KAAKP,EAAW,CAAAO,EAAER,GAAOO,CAAQ;AAAA,IACxE;AAAA,EAAA;AAEF,SAAOL;AACT;"}

package/dist/ui/dom/shieldDecision.js

@@ -0,0 +1,36 @@
+const n = /* @__PURE__ */ new Set(["text", "search", "email", "password", "number", "url", "tel", "date", "time", "datetime-local", "month", "week", ""]);
+function a(t) {
+  if (!t) return !1;
+  if (t.isContentEditable) return !0;
+  const e = t.tagName?.toUpperCase();
+  return e === "TEXTAREA" || e === "SELECT" ? !0 : e === "INPUT" && n.has((t.type ?? "").toLowerCase());
+}
+function i(t, e) {
+  for (let r = t; r; r = r.parentElement) if (r === e) return !0;
+  return !1;
+}
+const s = ["Enter", "NumpadEnter", "Space"];
+function u(t, e, r = {}) {
+  if (!e.insideUi) return !1;
+  switch (t) {
+    case "keydown":
+    case "keypress":
+      return e.editable ? !0 : e.code !== void 0 && (r.uiKeys ?? s).includes(e.code);
+    case "pointerdown":
+    case "mousedown":
+    case "touchstart":
+    case "click":
+    case "dblclick":
+    case "wheel":
+    case "contextmenu":
+      return !0;
+    default:
+      return !1;
+  }
+}
+export {
+  a as isEditable,
+  i as isInside,
+  u as shouldShield
+};
+//# sourceMappingURL=shieldDecision.js.map

package/dist/ui/dom/shieldDecision.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"shieldDecision.js","sources":["../../../src/ui/dom/shieldDecision.ts"],"sourcesContent":["/** The few fields of a DOM element the decision reads; real elements fit, and tests pass plain objects. */\nexport interface ElementLike {\n  readonly tagName?: string;\n  readonly type?: string;\n  readonly isContentEditable?: boolean;\n  readonly parentElement?: ElementLike | null;\n}\n\n/** `<input>` types that take typing; the rest (checkbox, range, button…) are pressed, not typed into. */\nconst TYPED_INPUTS = new Set(['text', 'search', 'email', 'password', 'number', 'url', 'tel', 'date', 'time', 'datetime-local', 'month', 'week', '']);\n\n/** Whether keys pressed on this element are typing (a text field, a text area, a select, editable content). */\nexport function isEditable(el: ElementLike | null | undefined): boolean {\n  if (!el) return false;\n  if (el.isContentEditable) return true;\n  const tag = el.tagName?.toUpperCase();\n  if (tag === 'TEXTAREA' || tag === 'SELECT') return true;\n  return tag === 'INPUT' && TYPED_INPUTS.has((el.type ?? '').toLowerCase());\n}\n\n/** Whether `el` is `root` or inside it. */\nexport function isInside(el: ElementLike | null | undefined, root: ElementLike): boolean {\n  for (let e = el; e; e = e.parentElement) if (e === root) return true;\n  return false;\n}\n\nexport interface ShieldFacts {\n  /** The event's target is in the DOM UI overlay. */\n  insideUi: boolean;\n  /** The target takes typing (`isEditable`). */\n  editable: boolean;\n  /** `KeyboardEvent.code`, for key events. */\n  code?: string;\n}\n\nexport interface ShieldOptions {\n  /**\n   * Keys a focused, non-typing UI element (a button) keeps from the game: the ones that press it (default Enter,\n   * Space). Others still reach the game, so a button left focused after a click does not stop the hero walking.\n   */\n  uiKeys?: readonly string[];\n}\n\nconst UI_KEYS = ['Enter', 'NumpadEnter', 'Space'];\n\n/**\n * Whether an event on the DOM UI must be kept from the engine's input. Releases (`keyup`, `pointerup`,\n * `pointercancel`) always go through, or a key or button held when the UI took over would stay down for good; moves\n * go through so aiming follows the pointer over a panel. Presses, wheel and context menus on the UI stay in the UI,\n * and so does every key typed into a field.\n */\nexport function shouldShield(type: string, facts: ShieldFacts, options: ShieldOptions = {}): boolean {\n  if (!facts.insideUi) return false;\n  switch (type) {\n    case 'keydown':\n    case 'keypress':\n      if (facts.editable) return true;\n      return facts.code !== undefined && (options.uiKeys ?? UI_KEYS).includes(facts.code);\n    case 'pointerdown':\n    case 'mousedown':\n    case 'touchstart':\n    case 'click':\n    case 'dblclick':\n    case 'wheel':\n    case 'contextmenu':\n      return true;\n    default:\n      return false;\n  }\n}\n"],"names":["TYPED_INPUTS","isEditable","el","tag","isInside","root","e","UI_KEYS","shouldShield","type","facts","options"],"mappings":"AASA,MAAMA,IAAe,oBAAI,IAAI,CAAC,QAAQ,UAAU,SAAS,YAAY,UAAU,OAAO,OAAO,QAAQ,QAAQ,kBAAkB,SAAS,QAAQ,EAAE,CAAC;AAG5I,SAASC,EAAWC,GAA6C;AACtE,MAAI,CAACA,EAAI,QAAO;AAChB,MAAIA,EAAG,kBAAmB,QAAO;AACjC,QAAMC,IAAMD,EAAG,SAAS,YAAA;AACxB,SAAIC,MAAQ,cAAcA,MAAQ,WAAiB,KAC5CA,MAAQ,WAAWH,EAAa,KAAKE,EAAG,QAAQ,IAAI,aAAa;AAC1E;AAGO,SAASE,EAASF,GAAoCG,GAA4B;AACvF,WAASC,IAAIJ,GAAII,GAAGA,IAAIA,EAAE,cAAe,KAAIA,MAAMD,EAAM,QAAO;AAChE,SAAO;AACT;AAmBA,MAAME,IAAU,CAAC,SAAS,eAAe,OAAO;AAQzC,SAASC,EAAaC,GAAcC,GAAoBC,IAAyB,CAAA,GAAa;AACnG,MAAI,CAACD,EAAM,SAAU,QAAO;AAC5B,UAAQD,GAAA;AAAA,IACN,KAAK;AAAA,IACL,KAAK;AACH,aAAIC,EAAM,WAAiB,KACpBA,EAAM,SAAS,WAAcC,EAAQ,UAAUJ,GAAS,SAASG,EAAM,IAAI;AAAA,IACpF,KAAK;AAAA,IACL,KAAK;AAAA,IACL,KAAK;AAAA,IACL,KAAK;AAAA,IACL,KAAK;AAAA,IACL,KAAK;AAAA,IACL,KAAK;AACH,aAAO;AAAA,IACT;AACE,aAAO;AAAA,EAAA;AAEb;"}

package/dist/ui/dom/worldToScreen.js

@@ -0,0 +1,11 @@
+function x(n, o, t, c, e = 1) {
+  return c.x = (n.x + o * n.scale.x) * e, c.y = (n.y + t * n.scale.y) * e, c;
+}
+function f(n, o, t, c, e = 0) {
+  return n >= -e && o >= -e && n <= t + e && o <= c + e;
+}
+export {
+  f as onScreen,
+  x as worldToScreen
+};
+//# sourceMappingURL=worldToScreen.js.map

package/dist/ui/dom/worldToScreen.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"worldToScreen.js","sources":["../../../src/ui/dom/worldToScreen.ts"],"sourcesContent":["/** A layer's transform as drawn: `stage.world` (a Pixi container) fits it, with the camera and its shake applied. */\nexport interface LayerTransform {\n  readonly x: number;\n  readonly y: number;\n  readonly scale: { readonly x: number; readonly y: number };\n}\n\n/**\n * Where a world point is on the overlay, in CSS pixels: through the world layer's own transform (so the camera's\n * zoom, scroll and shake are all in it), times how much CSS stretches the canvas (`cssScale`, 1 normally). Writes\n * into `out`: called for every placed element every frame.\n */\nexport function worldToScreen(layer: LayerTransform, wx: number, wy: number, out: { x: number; y: number }, cssScale = 1): { x: number; y: number } {\n  out.x = (layer.x + wx * layer.scale.x) * cssScale;\n  out.y = (layer.y + wy * layer.scale.y) * cssScale;\n  return out;\n}\n\n/** Whether a point is on a `width` × `height` screen, or within `margin` of it (an element's own size past the point). */\nexport function onScreen(x: number, y: number, width: number, height: number, margin = 0): boolean {\n  return x >= -margin && y >= -margin && x <= width + margin && y <= height + margin;\n}\n"],"names":["worldToScreen","layer","wx","wy","out","cssScale","onScreen","x","y","width","height","margin"],"mappings":"AAYO,SAASA,EAAcC,GAAuBC,GAAYC,GAAYC,GAA+BC,IAAW,GAA6B;AAClJ,SAAAD,EAAI,KAAKH,EAAM,IAAIC,IAAKD,EAAM,MAAM,KAAKI,GACzCD,EAAI,KAAKH,EAAM,IAAIE,IAAKF,EAAM,MAAM,KAAKI,GAClCD;AACT;AAGO,SAASE,EAASC,GAAWC,GAAWC,GAAeC,GAAgBC,IAAS,GAAY;AACjG,SAAOJ,KAAK,CAACI,KAAUH,KAAK,CAACG,KAAUJ,KAAKE,IAAQE,KAAUH,KAAKE,IAASC;AAC9E;"}

package/dist/ui/layout/anchor.js

@@ -0,0 +1,20 @@
+import { insets as s, snapPx as c } from "./geometry.js";
+const l = {
+  "top-left": [0, 0],
+  top: [0.5, 0],
+  "top-right": [1, 0],
+  left: [0, 0.5],
+  center: [0.5, 0.5],
+  right: [1, 0.5],
+  "bottom-left": [0, 1],
+  bottom: [0.5, 1],
+  "bottom-right": [1, 1]
+};
+function b(e, t, o, g = 0, n = !1) {
+  const h = s(g), [i, f] = l[e], r = i === 0 ? h.left : i === 1 ? o.width - h.right - t.width : (o.width - t.width) / 2, m = f === 0 ? h.top : f === 1 ? o.height - h.bottom - t.height : (o.height - t.height) / 2;
+  return { x: c(r, n), y: c(m, n) };
+}
+export {
+  b as anchorPosition
+};
+//# sourceMappingURL=anchor.js.map

package/dist/ui/layout/anchor.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"anchor.js","sources":["../../../src/ui/layout/anchor.ts"],"sourcesContent":["import { insets, snapPx, type Insets, type Point, type Size } from './geometry';\n\n/** A spot on the screen a HUD piece is pinned to; it stays there whatever the screen's size. */\nexport type ScreenAnchor = 'top-left' | 'top' | 'top-right' | 'left' | 'center' | 'right' | 'bottom-left' | 'bottom' | 'bottom-right';\n\n/** Fractions of the free space for each anchor: 0 hugs the left/top edge, 1 the right/bottom, 0.5 centres. */\nconst FRACTIONS: Record<ScreenAnchor, readonly [number, number]> = {\n  'top-left': [0, 0],\n  top: [0.5, 0],\n  'top-right': [1, 0],\n  left: [0, 0.5],\n  center: [0.5, 0.5],\n  right: [1, 0.5],\n  'bottom-left': [0, 1],\n  bottom: [0.5, 1],\n  'bottom-right': [1, 1],\n};\n\n/**\n * Top-left of a box of `size` pinned to `anchor` of the viewport, `margin` in from the edges (a number, or per side\n * for a phone's notch). Centred anchors ignore the margins of the sides they do not touch.\n */\nexport function anchorPosition(anchor: ScreenAnchor, size: Size, viewport: Size, margin: number | Partial<Insets> = 0, snap = false): Point {\n  const m = insets(margin);\n  const [fx, fy] = FRACTIONS[anchor];\n  const x = fx === 0 ? m.left : fx === 1 ? viewport.width - m.right - size.width : (viewport.width - size.width) / 2;\n  const y = fy === 0 ? m.top : fy === 1 ? viewport.height - m.bottom - size.height : (viewport.height - size.height) / 2;\n  return { x: snapPx(x, snap), y: snapPx(y, snap) };\n}\n"],"names":["FRACTIONS","anchorPosition","anchor","size","viewport","margin","snap","m","insets","fx","fy","x","y","snapPx"],"mappings":";AAMA,MAAMA,IAA6D;AAAA,EACjE,YAAY,CAAC,GAAG,CAAC;AAAA,EACjB,KAAK,CAAC,KAAK,CAAC;AAAA,EACZ,aAAa,CAAC,GAAG,CAAC;AAAA,EAClB,MAAM,CAAC,GAAG,GAAG;AAAA,EACb,QAAQ,CAAC,KAAK,GAAG;AAAA,EACjB,OAAO,CAAC,GAAG,GAAG;AAAA,EACd,eAAe,CAAC,GAAG,CAAC;AAAA,EACpB,QAAQ,CAAC,KAAK,CAAC;AAAA,EACf,gBAAgB,CAAC,GAAG,CAAC;AACvB;AAMO,SAASC,EAAeC,GAAsBC,GAAYC,GAAgBC,IAAmC,GAAGC,IAAO,IAAc;AAC1I,QAAMC,IAAIC,EAAOH,CAAM,GACjB,CAACI,GAAIC,CAAE,IAAIV,EAAUE,CAAM,GAC3BS,IAAIF,MAAO,IAAIF,EAAE,OAAOE,MAAO,IAAIL,EAAS,QAAQG,EAAE,QAAQJ,EAAK,SAASC,EAAS,QAAQD,EAAK,SAAS,GAC3GS,IAAIF,MAAO,IAAIH,EAAE,MAAMG,MAAO,IAAIN,EAAS,SAASG,EAAE,SAASJ,EAAK,UAAUC,EAAS,SAASD,EAAK,UAAU;AACrH,SAAO,EAAE,GAAGU,EAAOF,GAAGL,CAAI,GAAG,GAAGO,EAAOD,GAAGN,CAAI,EAAA;AAChD;"}

package/dist/ui/layout/barDrain.js

@@ -0,0 +1,25 @@
+function u(i = 1) {
+  return { value: i, trail: i, holdMs: 0 };
+}
+function d(i, l, n = {}) {
+  const r = l < 0 ? 0 : l > 1 ? 1 : l;
+  r < i.value && (i.holdMs = n.delayMs ?? 400), r > i.trail && (i.trail = r), i.value = r;
+}
+function f(i, l, n = {}) {
+  if (i.trail <= i.value) {
+    i.trail = i.value;
+    return;
+  }
+  let r = l;
+  if (i.holdMs > 0) {
+    const o = Math.min(i.holdMs, r);
+    i.holdMs -= o, r -= o;
+  }
+  r <= 0 || (i.trail = Math.max(i.value, i.trail - (n.rate ?? 0.6) * r / 1e3));
+}
+export {
+  u as drainState,
+  d as setDrainValue,
+  f as stepDrain
+};
+//# sourceMappingURL=barDrain.js.map

package/dist/ui/layout/barDrain.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"barDrain.js","sources":["../../../src/ui/layout/barDrain.ts"],"sourcesContent":["/**\n * A bar's two lengths: what it holds now (`value`) and the trail behind it (`trail`) that drains down to it after a\n * short hold, so a hit shows how much it took. Fractions 0–1. Mutated in place: a health bar is set every frame.\n */\nexport interface DrainState {\n  value: number;\n  trail: number;\n  /** What is left of the hold before the trail starts to drain (ms). */\n  holdMs: number;\n}\n\nexport interface DrainOptions {\n  /** How long the trail holds after a loss before draining (default 400 ms). */\n  delayMs?: number;\n  /** How fast it drains, in whole bars a second (default 0.6). */\n  rate?: number;\n}\n\nexport function drainState(value = 1): DrainState {\n  return { value, trail: value, holdMs: 0 };\n}\n\n/**\n * Sets the bar. A loss restarts the hold, so blows in quick succession show one trail for all of them; a gain fills\n * at once and pulls the trail up with it (a heal has nothing to show behind it).\n */\nexport function setDrainValue(state: DrainState, value: number, options: DrainOptions = {}): void {\n  const v = value < 0 ? 0 : value > 1 ? 1 : value;\n  if (v < state.value) state.holdMs = options.delayMs ?? 400;\n  if (v > state.trail) state.trail = v;\n  state.value = v;\n}\n\n/** Advances the trail by a frame `dtMs` long. */\nexport function stepDrain(state: DrainState, dtMs: number, options: DrainOptions = {}): void {\n  if (state.trail <= state.value) {\n    state.trail = state.value;\n    return;\n  }\n  let dt = dtMs;\n  if (state.holdMs > 0) {\n    const used = Math.min(state.holdMs, dt);\n    state.holdMs -= used;\n    dt -= used;\n  }\n  if (dt <= 0) return;\n  state.trail = Math.max(state.value, state.trail - ((options.rate ?? 0.6) * dt) / 1000);\n}\n"],"names":["drainState","value","setDrainValue","state","options","v","stepDrain","dtMs","dt","used"],"mappings":"AAkBO,SAASA,EAAWC,IAAQ,GAAe;AAChD,SAAO,EAAE,OAAAA,GAAO,OAAOA,GAAO,QAAQ,EAAA;AACxC;AAMO,SAASC,EAAcC,GAAmBF,GAAeG,IAAwB,CAAA,GAAU;AAChG,QAAMC,IAAIJ,IAAQ,IAAI,IAAIA,IAAQ,IAAI,IAAIA;AAC1C,EAAII,IAAIF,EAAM,UAAOA,EAAM,SAASC,EAAQ,WAAW,MACnDC,IAAIF,EAAM,UAAOA,EAAM,QAAQE,IACnCF,EAAM,QAAQE;AAChB;AAGO,SAASC,EAAUH,GAAmBI,GAAcH,IAAwB,CAAA,GAAU;AAC3F,MAAID,EAAM,SAASA,EAAM,OAAO;AAC9B,IAAAA,EAAM,QAAQA,EAAM;AACpB;AAAA,EACF;AACA,MAAIK,IAAKD;AACT,MAAIJ,EAAM,SAAS,GAAG;AACpB,UAAMM,IAAO,KAAK,IAAIN,EAAM,QAAQK,CAAE;AACtC,IAAAL,EAAM,UAAUM,GAChBD,KAAMC;AAAA,EACR;AACA,EAAID,KAAM,MACVL,EAAM,QAAQ,KAAK,IAAIA,EAAM,OAAOA,EAAM,SAAUC,EAAQ,QAAQ,OAAOI,IAAM,GAAI;AACvF;"}

package/dist/ui/layout/fitToViewport.js

@@ -0,0 +1,17 @@
+import { clamp as o, snapPx as w } from "./geometry.js";
+function W(h, a, n = {}) {
+  const t = n.margin ?? 8, s = n.scale ?? 1, e = Math.min(n.minScale ?? s, s), c = n.snap ?? !1, d = Math.max(0, a.width - 2 * t), g = Math.max(0, a.height - 2 * t), f = h.width > 0 && h.height > 0 ? Math.min(d / h.width, g / h.height) : s, i = o(f, e, s), m = Math.min(h.width, d / i), l = Math.min(h.height, g / i), x = m * i, M = l * i, y = n.centre || !("x" in h) ? (a.width - x) / 2 : h.x, r = n.centre || !("y" in h) ? (a.height - M) / 2 : h.y, u = o(y, t, Math.max(t, a.width - t - x)), H = o(r, t, Math.max(t, a.height - t - M));
+  return {
+    x: w(u, c),
+    y: w(H, c),
+    width: c ? Math.floor(m) : m,
+    height: c ? Math.floor(l) : l,
+    scale: i,
+    scrollX: m < h.width,
+    scrollY: l < h.height
+  };
+}
+export {
+  W as fitToViewport
+};
+//# sourceMappingURL=fitToViewport.js.map

package/dist/ui/layout/fitToViewport.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"fitToViewport.js","sources":["../../../src/ui/layout/fitToViewport.ts"],"sourcesContent":["import { clamp, snapPx, type Rect, type Size } from './geometry';\n\nexport interface FitOptions {\n  /** Kept clear between the window and the screen's edges (default 8). */\n  margin?: number;\n  /**\n   * The scale the window is meant to be drawn at (default 1): a player's \"window size\" setting, or a whole multiple\n   * for pixel art. The window is laid out on a box `1 / scale` the screen and drawn back at `scale`.\n   */\n  scale?: number;\n  /**\n   * The smallest scale it may shrink to before it starts scrolling instead (default: `scale`, never shrinks). A\n   * pixel-art game keeps it at its whole scale: a fractional one smears every texel.\n   */\n  minScale?: number;\n  /** Centre it on the screen instead of keeping `rect.x/y` (default false). */\n  centre?: boolean;\n  snap?: boolean;\n}\n\nexport interface FitResult extends Rect {\n  /** The scale to draw the window at; `x`, `y` are screen pixels, `width`, `height` the window's own units. */\n  scale: number;\n  /** The window was cut shorter (narrower) than it wanted: its body must scroll. */\n  scrollY: boolean;\n  scrollX: boolean;\n}\n\n/**\n * Fits a window into the screen so it never overflows it: shrunk down to `minScale` if that is allowed, then cut to\n * what is left (the caller scrolls its body), and moved back inside the edges. `rect` is where and how big the\n * window wants to be, in its own units; `x`, `y` are screen pixels.\n */\nexport function fitToViewport(rect: Rect | Size, viewport: Size, options: FitOptions = {}): FitResult {\n  const margin = options.margin ?? 8;\n  const preferred = options.scale ?? 1;\n  const minScale = Math.min(options.minScale ?? preferred, preferred);\n  const snap = options.snap ?? false;\n  const availW = Math.max(0, viewport.width - 2 * margin);\n  const availH = Math.max(0, viewport.height - 2 * margin);\n  const fits = rect.width > 0 && rect.height > 0 ? Math.min(availW / rect.width, availH / rect.height) : preferred;\n  const scale = clamp(fits, minScale, preferred);\n  // what still does not fit at that scale is cut, and the body scrolls\n  const width = Math.min(rect.width, availW / scale);\n  const height = Math.min(rect.height, availH / scale);\n  const drawnW = width * scale;\n  const drawnH = height * scale;\n  const wantX = options.centre || !('x' in rect) ? (viewport.width - drawnW) / 2 : rect.x;\n  const wantY = options.centre || !('y' in rect) ? (viewport.height - drawnH) / 2 : rect.y;\n  const x = clamp(wantX, margin, Math.max(margin, viewport.width - margin - drawnW));\n  const y = clamp(wantY, margin, Math.max(margin, viewport.height - margin - drawnH));\n  return {\n    x: snapPx(x, snap),\n    y: snapPx(y, snap),\n    width: snap ? Math.floor(width) : width,\n    height: snap ? Math.floor(height) : height,\n    scale,\n    scrollX: width < rect.width,\n    scrollY: height < rect.height,\n  };\n}\n"],"names":["fitToViewport","rect","viewport","options","margin","preferred","minScale","snap","availW","availH","fits","scale","clamp","width","height","drawnW","drawnH","wantX","wantY","x","y","snapPx"],"mappings":";AAiCO,SAASA,EAAcC,GAAmBC,GAAgBC,IAAsB,CAAA,GAAe;AACpG,QAAMC,IAASD,EAAQ,UAAU,GAC3BE,IAAYF,EAAQ,SAAS,GAC7BG,IAAW,KAAK,IAAIH,EAAQ,YAAYE,GAAWA,CAAS,GAC5DE,IAAOJ,EAAQ,QAAQ,IACvBK,IAAS,KAAK,IAAI,GAAGN,EAAS,QAAQ,IAAIE,CAAM,GAChDK,IAAS,KAAK,IAAI,GAAGP,EAAS,SAAS,IAAIE,CAAM,GACjDM,IAAOT,EAAK,QAAQ,KAAKA,EAAK,SAAS,IAAI,KAAK,IAAIO,IAASP,EAAK,OAAOQ,IAASR,EAAK,MAAM,IAAII,GACjGM,IAAQC,EAAMF,GAAMJ,GAAUD,CAAS,GAEvCQ,IAAQ,KAAK,IAAIZ,EAAK,OAAOO,IAASG,CAAK,GAC3CG,IAAS,KAAK,IAAIb,EAAK,QAAQQ,IAASE,CAAK,GAC7CI,IAASF,IAAQF,GACjBK,IAASF,IAASH,GAClBM,IAAQd,EAAQ,UAAU,EAAE,OAAOF,MAASC,EAAS,QAAQa,KAAU,IAAId,EAAK,GAChFiB,IAAQf,EAAQ,UAAU,EAAE,OAAOF,MAASC,EAAS,SAASc,KAAU,IAAIf,EAAK,GACjFkB,IAAIP,EAAMK,GAAOb,GAAQ,KAAK,IAAIA,GAAQF,EAAS,QAAQE,IAASW,CAAM,CAAC,GAC3EK,IAAIR,EAAMM,GAAOd,GAAQ,KAAK,IAAIA,GAAQF,EAAS,SAASE,IAASY,CAAM,CAAC;AAClF,SAAO;AAAA,IACL,GAAGK,EAAOF,GAAGZ,CAAI;AAAA,IACjB,GAAGc,EAAOD,GAAGb,CAAI;AAAA,IACjB,OAAOA,IAAO,KAAK,MAAMM,CAAK,IAAIA;AAAA,IAClC,QAAQN,IAAO,KAAK,MAAMO,CAAM,IAAIA;AAAA,IACpC,OAAAH;AAAA,IACA,SAASE,IAAQZ,EAAK;AAAA,IACtB,SAASa,IAASb,EAAK;AAAA,EAAA;AAE3B;"}

package/dist/ui/layout/focusNav.js

@@ -0,0 +1,42 @@
+function h(n) {
+  return n.x + n.width / 2;
+}
+function a(n) {
+  return n.y + n.height / 2;
+}
+function E(n) {
+  let t = -1;
+  for (let o = 0; o < n.length; o++) {
+    const e = n[o], i = t < 0 ? null : n[t];
+    (!i || e.y < i.y || e.y === i.y && e.x < i.x) && (t = o);
+  }
+  return t;
+}
+function F(n, t, o, e = !1) {
+  if (n.length === 0) return -1;
+  const i = n[t];
+  if (!i) return E(n);
+  const y = h(i), g = a(i), S = o === "left" || o === "right", C = o === "right" || o === "down" ? 1 : -1;
+  let r = -1, b = 1 / 0, u = -1, x = 1 / 0;
+  for (let f = 0; f < n.length; f++) {
+    if (f === t) continue;
+    const l = n[f], c = (S ? h(l) - y : a(l) - g) * C, I = Math.abs(S ? a(l) - g : h(l) - y);
+    if (c > 0.5) {
+      const s = c + 2 * I;
+      s < b && (b = s, r = f);
+    } else if (e && c < -0.5) {
+      const s = c + 2 * I;
+      s < x && (x = s, u = f);
+    }
+  }
+  return r >= 0 ? r : u >= 0 ? u : t;
+}
+function G(n, t, o) {
+  return n === 0 ? -1 : t < 0 || t >= n ? o > 0 ? 0 : n - 1 : (t + o + n) % n;
+}
+export {
+  E as firstFocus,
+  G as linearFocus,
+  F as nextFocus
+};
+//# sourceMappingURL=focusNav.js.map

package/dist/ui/layout/focusNav.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"focusNav.js","sources":["../../../src/ui/layout/focusNav.ts"],"sourcesContent":["import type { Rect } from './geometry';\n\nexport type NavDirection = 'up' | 'down' | 'left' | 'right';\n\n/** How much a step off the line of travel costs against a step along it: favours the item straight ahead. */\nconst CROSS_WEIGHT = 2;\n\nfunction cx(r: Rect): number {\n  return r.x + r.width / 2;\n}\n\nfunction cy(r: Rect): number {\n  return r.y + r.height / 2;\n}\n\n/** The item a fresh focus lands on: the top-most, then left-most. */\nexport function firstFocus(rects: readonly Rect[]): number {\n  let best = -1;\n  for (let i = 0; i < rects.length; i++) {\n    const r = rects[i]!;\n    const b = best < 0 ? null : rects[best]!;\n    if (!b || r.y < b.y || (r.y === b.y && r.x < b.x)) best = i;\n  }\n  return best;\n}\n\n/**\n * Spatial navigation (a gamepad's d-pad, the arrow keys): from `current`, the nearest item whose centre lies in\n * `dir`, an item straight ahead preferred over a nearer one off to the side. With `wrap`, going past the last item\n * comes back in from the far side on the same line. Returns `current` when nothing lies that way.\n */\nexport function nextFocus(rects: readonly Rect[], current: number, dir: NavDirection, wrap = false): number {\n  if (rects.length === 0) return -1;\n  const from = rects[current];\n  if (!from) return firstFocus(rects);\n  const fx = cx(from);\n  const fy = cy(from);\n  const horizontal = dir === 'left' || dir === 'right';\n  const sign = dir === 'right' || dir === 'down' ? 1 : -1;\n  let best = -1;\n  let bestScore = Infinity;\n  // wrapping: the item farthest the other way, closest to the line\n  let back = -1;\n  let backScore = Infinity;\n  for (let i = 0; i < rects.length; i++) {\n    if (i === current) continue;\n    const r = rects[i]!;\n    const along = ((horizontal ? cx(r) - fx : cy(r) - fy) * sign);\n    const across = Math.abs(horizontal ? cy(r) - fy : cx(r) - fx);\n    if (along > 0.5) {\n      const score = along + CROSS_WEIGHT * across;\n      if (score < bestScore) {\n        bestScore = score;\n        best = i;\n      }\n    } else if (wrap && along < -0.5) {\n      const score = along + CROSS_WEIGHT * across;\n      if (score < backScore) {\n        backScore = score;\n        back = i;\n      }\n    }\n  }\n  if (best >= 0) return best;\n  return back >= 0 ? back : current;\n}\n\n/** Tab order: the next (`step` 1) or previous (−1) of `count` items, wrapping round. */\nexport function linearFocus(count: number, current: number, step: 1 | -1): number {\n  if (count === 0) return -1;\n  if (current < 0 || current >= count) return step > 0 ? 0 : count - 1;\n  return (current + step + count) % count;\n}\n"],"names":["cx","r","cy","firstFocus","rects","best","i","b","nextFocus","current","dir","wrap","from","fx","fy","horizontal","sign","bestScore","back","backScore","along","across","score","linearFocus","count","step"],"mappings":"AAOA,SAASA,EAAGC,GAAiB;AAC3B,SAAOA,EAAE,IAAIA,EAAE,QAAQ;AACzB;AAEA,SAASC,EAAGD,GAAiB;AAC3B,SAAOA,EAAE,IAAIA,EAAE,SAAS;AAC1B;AAGO,SAASE,EAAWC,GAAgC;AACzD,MAAIC,IAAO;AACX,WAASC,IAAI,GAAGA,IAAIF,EAAM,QAAQE,KAAK;AACrC,UAAML,IAAIG,EAAME,CAAC,GACXC,IAAIF,IAAO,IAAI,OAAOD,EAAMC,CAAI;AACtC,KAAI,CAACE,KAAKN,EAAE,IAAIM,EAAE,KAAMN,EAAE,MAAMM,EAAE,KAAKN,EAAE,IAAIM,EAAE,OAAIF,IAAOC;AAAA,EAC5D;AACA,SAAOD;AACT;AAOO,SAASG,EAAUJ,GAAwBK,GAAiBC,GAAmBC,IAAO,IAAe;AAC1G,MAAIP,EAAM,WAAW,EAAG,QAAO;AAC/B,QAAMQ,IAAOR,EAAMK,CAAO;AAC1B,MAAI,CAACG,EAAM,QAAOT,EAAWC,CAAK;AAClC,QAAMS,IAAKb,EAAGY,CAAI,GACZE,IAAKZ,EAAGU,CAAI,GACZG,IAAaL,MAAQ,UAAUA,MAAQ,SACvCM,IAAON,MAAQ,WAAWA,MAAQ,SAAS,IAAI;AACrD,MAAIL,IAAO,IACPY,IAAY,OAEZC,IAAO,IACPC,IAAY;AAChB,WAASb,IAAI,GAAGA,IAAIF,EAAM,QAAQE,KAAK;AACrC,QAAIA,MAAMG,EAAS;AACnB,UAAMR,IAAIG,EAAME,CAAC,GACXc,KAAUL,IAAaf,EAAGC,CAAC,IAAIY,IAAKX,EAAGD,CAAC,IAAIa,KAAME,GAClDK,IAAS,KAAK,IAAIN,IAAab,EAAGD,CAAC,IAAIa,IAAKd,EAAGC,CAAC,IAAIY,CAAE;AAC5D,QAAIO,IAAQ,KAAK;AACf,YAAME,IAAQF,IAAQ,IAAeC;AACrC,MAAIC,IAAQL,MACVA,IAAYK,GACZjB,IAAOC;AAAA,IAEX,WAAWK,KAAQS,IAAQ,MAAM;AAC/B,YAAME,IAAQF,IAAQ,IAAeC;AACrC,MAAIC,IAAQH,MACVA,IAAYG,GACZJ,IAAOZ;AAAA,IAEX;AAAA,EACF;AACA,SAAID,KAAQ,IAAUA,IACfa,KAAQ,IAAIA,IAAOT;AAC5B;AAGO,SAASc,EAAYC,GAAef,GAAiBgB,GAAsB;AAChF,SAAID,MAAU,IAAU,KACpBf,IAAU,KAAKA,KAAWe,IAAcC,IAAO,IAAI,IAAID,IAAQ,KAC3Df,IAAUgB,IAAOD,KAASA;AACpC;"}

package/dist/ui/layout/geometry.js

@@ -0,0 +1,21 @@
+function h(t) {
+  return t === void 0 ? { top: 0, right: 0, bottom: 0, left: 0 } : typeof t == "number" ? { top: t, right: t, bottom: t, left: t } : { top: t.top ?? 0, right: t.right ?? 0, bottom: t.bottom ?? 0, left: t.left ?? 0 };
+}
+function i(t, o = !0) {
+  return o ? Math.round(t) : t;
+}
+function u(t, o = !0) {
+  if (!o) return { x: t.x, y: t.y, width: t.width, height: t.height };
+  const n = Math.round(t.x), e = Math.round(t.y);
+  return { x: n, y: e, width: Math.round(t.x + t.width) - n, height: Math.round(t.y + t.height) - e };
+}
+function r(t, o, n) {
+  return t < o ? o : t > n ? n : t;
+}
+export {
+  r as clamp,
+  h as insets,
+  i as snapPx,
+  u as snapRect
+};
+//# sourceMappingURL=geometry.js.map

package/dist/ui/layout/geometry.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"geometry.js","sources":["../../../src/ui/layout/geometry.ts"],"sourcesContent":["/**\n * The shapes every UI layout function speaks: plain objects, no Pixi and no DOM, so the same maths places a canvas\n * widget, a DOM panel or a React component.\n */\nexport interface Size {\n  width: number;\n  height: number;\n}\n\nexport interface Point {\n  x: number;\n  y: number;\n}\n\nexport interface Rect extends Point, Size {}\n\n/** Space kept clear on each side (padding, margins, a phone's safe area). */\nexport interface Insets {\n  top: number;\n  right: number;\n  bottom: number;\n  left: number;\n}\n\n/** `8` or `{ top: 8, left: 4 }` → all four sides; a missing side is 0. */\nexport function insets(v: number | Partial<Insets> | undefined): Insets {\n  if (v === undefined) return { top: 0, right: 0, bottom: 0, left: 0 };\n  if (typeof v === 'number') return { top: v, right: v, bottom: v, left: v };\n  return { top: v.top ?? 0, right: v.right ?? 0, bottom: v.bottom ?? 0, left: v.left ?? 0 };\n}\n\n/**\n * Rounds to a whole pixel when `on`. Pixel art laid out at x.5 lands each texel across two screen pixels and reads\n * blurred or a pixel wider on one side, so a pixel-perfect game snaps every UI position and size.\n */\nexport function snapPx(v: number, on = true): number {\n  return on ? Math.round(v) : v;\n}\n\n/**\n * A rect with its edges (not its size) rounded: two neighbours that touch before snapping still touch after, where\n * rounding x and width apart could open or overlap a pixel between them.\n */\nexport function snapRect(r: Rect, on = true): Rect {\n  if (!on) return { x: r.x, y: r.y, width: r.width, height: r.height };\n  const x = Math.round(r.x);\n  const y = Math.round(r.y);\n  return { x, y, width: Math.round(r.x + r.width) - x, height: Math.round(r.y + r.height) - y };\n}\n\nexport function clamp(v: number, min: number, max: number): number {\n  return v < min ? min : v > max ? max : v;\n}\n"],"names":["insets","v","snapPx","on","snapRect","r","x","y","clamp","min","max"],"mappings":"AAyBO,SAASA,EAAOC,GAAiD;AACtE,SAAIA,MAAM,SAAkB,EAAE,KAAK,GAAG,OAAO,GAAG,QAAQ,GAAG,MAAM,EAAA,IAC7D,OAAOA,KAAM,WAAiB,EAAE,KAAKA,GAAG,OAAOA,GAAG,QAAQA,GAAG,MAAMA,EAAA,IAChE,EAAE,KAAKA,EAAE,OAAO,GAAG,OAAOA,EAAE,SAAS,GAAG,QAAQA,EAAE,UAAU,GAAG,MAAMA,EAAE,QAAQ,EAAA;AACxF;AAMO,SAASC,EAAOD,GAAWE,IAAK,IAAc;AACnD,SAAOA,IAAK,KAAK,MAAMF,CAAC,IAAIA;AAC9B;AAMO,SAASG,EAASC,GAASF,IAAK,IAAY;AACjD,MAAI,CAACA,EAAI,QAAO,EAAE,GAAGE,EAAE,GAAG,GAAGA,EAAE,GAAG,OAAOA,EAAE,OAAO,QAAQA,EAAE,OAAA;AAC5D,QAAMC,IAAI,KAAK,MAAMD,EAAE,CAAC,GAClBE,IAAI,KAAK,MAAMF,EAAE,CAAC;AACxB,SAAO,EAAE,GAAAC,GAAG,GAAAC,GAAG,OAAO,KAAK,MAAMF,EAAE,IAAIA,EAAE,KAAK,IAAIC,GAAG,QAAQ,KAAK,MAAMD,EAAE,IAAIA,EAAE,MAAM,IAAIE,EAAA;AAC5F;AAEO,SAASC,EAAMP,GAAWQ,GAAaC,GAAqB;AACjE,SAAOT,IAAIQ,IAAMA,IAAMR,IAAIS,IAAMA,IAAMT;AACzC;"}

package/dist/ui/layout/listWidth.js

@@ -0,0 +1,10 @@
+function m(i, n, t = {}) {
+  let a = 0;
+  for (const h of i) a = Math.max(a, n(h));
+  const e = Math.ceil(a + (t.padding ?? 0));
+  return Math.min(t.max ?? 1 / 0, Math.max(t.min ?? 0, e));
+}
+export {
+  m as listWidth
+};
+//# sourceMappingURL=listWidth.js.map

package/dist/ui/layout/listWidth.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"listWidth.js","sources":["../../../src/ui/layout/listWidth.ts"],"sourcesContent":["export interface ListWidthOptions {\n  /** Added to the longest label: the row's padding, a check mark, a scroll bar (default 0). */\n  padding?: number;\n  min?: number;\n  max?: number;\n}\n\n/**\n * How wide a drop-down list (or a menu) must be so its longest label fits: measured, not guessed, so no label is\n * clipped. `measure` is the caller's (a canvas `measureText`, a bitmap font's advance sum). Rounded up to a whole\n * pixel so the measurement never loses the last half pixel of a letter.\n */\nexport function listWidth(labels: readonly string[], measure: (label: string) => number, options: ListWidthOptions = {}): number {\n  let widest = 0;\n  for (const l of labels) widest = Math.max(widest, measure(l));\n  const w = Math.ceil(widest + (options.padding ?? 0));\n  return Math.min(options.max ?? Infinity, Math.max(options.min ?? 0, w));\n}\n"],"names":["listWidth","labels","measure","options","widest","l","w"],"mappings":"AAYO,SAASA,EAAUC,GAA2BC,GAAoCC,IAA4B,CAAA,GAAY;AAC/H,MAAIC,IAAS;AACb,aAAWC,KAAKJ,EAAQ,CAAAG,IAAS,KAAK,IAAIA,GAAQF,EAAQG,CAAC,CAAC;AAC5D,QAAMC,IAAI,KAAK,KAAKF,KAAUD,EAAQ,WAAW,EAAE;AACnD,SAAO,KAAK,IAAIA,EAAQ,OAAO,OAAU,KAAK,IAAIA,EAAQ,OAAO,GAAGG,CAAC,CAAC;AACxE;"}

package/dist/ui/layout/placeTooltip.js

@@ -0,0 +1,28 @@
+import { clamp as m, snapPx as n } from "./geometry.js";
+const r = { below: "above", above: "below", right: "left", left: "right" };
+function f(e, t, s, h, l) {
+  switch (e) {
+    case "below":
+      return s.height - l - (t.y + t.height + h);
+    case "above":
+      return t.y - h - l;
+    case "right":
+      return s.width - l - (t.x + t.width + h);
+    case "left":
+      return t.x - h - l;
+  }
+}
+function a(e, t, s, h = {}) {
+  const l = h.gap ?? 4, i = h.margin ?? 4, g = h.side ?? "below", b = g === "below" || g === "above", y = b ? t.height : t.width;
+  let x = g;
+  if (f(g, e, s, l, i) < y) {
+    const u = r[g], c = f(u, e, s, l, i);
+    (c >= y || c > f(g, e, s, l, i)) && (x = u);
+  }
+  let d, w;
+  return b ? (w = x === "below" ? e.y + e.height + l : e.y - l - t.height, d = h.align === "center" ? e.x + (e.width - t.width) / 2 : e.x) : (d = x === "right" ? e.x + e.width + l : e.x - l - t.width, w = h.align === "center" ? e.y + (e.height - t.height) / 2 : e.y), d = m(d, i, Math.max(i, s.width - i - t.width)), w = m(w, i, Math.max(i, s.height - i - t.height)), { x: n(d, h.snap ?? !1), y: n(w, h.snap ?? !1), side: x };
+}
+export {
+  a as placeTooltip
+};
+//# sourceMappingURL=placeTooltip.js.map

package/dist/ui/layout/placeTooltip.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"placeTooltip.js","sources":["../../../src/ui/layout/placeTooltip.ts"],"sourcesContent":["import { clamp, snapPx, type Point, type Rect, type Size } from './geometry';\n\nexport type TipSide = 'below' | 'above' | 'right' | 'left';\n\nexport interface TooltipOptions {\n  /** The side tried first (default 'below'); the opposite one when it does not fit. */\n  side?: TipSide;\n  /** Between the anchor and the tip (default 4). */\n  gap?: number;\n  /** Kept clear of the screen's edges (default 4). */\n  margin?: number;\n  /** Across the side: line up with the anchor's start or centre on it (default 'start'). */\n  align?: 'start' | 'center';\n  snap?: boolean;\n}\n\nexport interface TooltipPlacement extends Point {\n  /** The side it went on after flipping. */\n  side: TipSide;\n}\n\nconst OPPOSITE: Record<TipSide, TipSide> = { below: 'above', above: 'below', right: 'left', left: 'right' };\n\n/** Room on `side` of the anchor, inside the margins. */\nfunction room(side: TipSide, a: Rect, view: Size, gap: number, margin: number): number {\n  switch (side) {\n    case 'below':\n      return view.height - margin - (a.y + a.height + gap);\n    case 'above':\n      return a.y - gap - margin;\n    case 'right':\n      return view.width - margin - (a.x + a.width + gap);\n    case 'left':\n      return a.x - gap - margin;\n  }\n}\n\n/**\n * Where a tooltip of `tip` size goes beside `anchor`: on the preferred side when it fits, flipped to the opposite one\n * when it does not, the roomier of the two when neither does; then slid along the edge to stay on screen.\n */\nexport function placeTooltip(anchor: Rect, tip: Size, viewport: Size, options: TooltipOptions = {}): TooltipPlacement {\n  const gap = options.gap ?? 4;\n  const margin = options.margin ?? 4;\n  const want = options.side ?? 'below';\n  const vertical = want === 'below' || want === 'above';\n  const need = vertical ? tip.height : tip.width;\n  let side = want;\n  if (room(want, anchor, viewport, gap, margin) < need) {\n    const other = OPPOSITE[want];\n    const otherRoom = room(other, anchor, viewport, gap, margin);\n    if (otherRoom >= need || otherRoom > room(want, anchor, viewport, gap, margin)) side = other;\n  }\n  let x: number;\n  let y: number;\n  if (vertical) {\n    y = side === 'below' ? anchor.y + anchor.height + gap : anchor.y - gap - tip.height;\n    x = options.align === 'center' ? anchor.x + (anchor.width - tip.width) / 2 : anchor.x;\n  } else {\n    x = side === 'right' ? anchor.x + anchor.width + gap : anchor.x - gap - tip.width;\n    y = options.align === 'center' ? anchor.y + (anchor.height - tip.height) / 2 : anchor.y;\n  }\n  x = clamp(x, margin, Math.max(margin, viewport.width - margin - tip.width));\n  y = clamp(y, margin, Math.max(margin, viewport.height - margin - tip.height));\n  return { x: snapPx(x, options.snap ?? false), y: snapPx(y, options.snap ?? false), side };\n}\n"],"names":["OPPOSITE","room","side","a","view","gap","margin","placeTooltip","anchor","tip","viewport","options","want","vertical","need","other","otherRoom","x","y","clamp","snapPx"],"mappings":";AAqBA,MAAMA,IAAqC,EAAE,OAAO,SAAS,OAAO,SAAS,OAAO,QAAQ,MAAM,QAAA;AAGlG,SAASC,EAAKC,GAAeC,GAASC,GAAYC,GAAaC,GAAwB;AACrF,UAAQJ,GAAA;AAAA,IACN,KAAK;AACH,aAAOE,EAAK,SAASE,KAAUH,EAAE,IAAIA,EAAE,SAASE;AAAA,IAClD,KAAK;AACH,aAAOF,EAAE,IAAIE,IAAMC;AAAA,IACrB,KAAK;AACH,aAAOF,EAAK,QAAQE,KAAUH,EAAE,IAAIA,EAAE,QAAQE;AAAA,IAChD,KAAK;AACH,aAAOF,EAAE,IAAIE,IAAMC;AAAA,EAAA;AAEzB;AAMO,SAASC,EAAaC,GAAcC,GAAWC,GAAgBC,IAA0B,CAAA,GAAsB;AACpH,QAAMN,IAAMM,EAAQ,OAAO,GACrBL,IAASK,EAAQ,UAAU,GAC3BC,IAAOD,EAAQ,QAAQ,SACvBE,IAAWD,MAAS,WAAWA,MAAS,SACxCE,IAAOD,IAAWJ,EAAI,SAASA,EAAI;AACzC,MAAIP,IAAOU;AACX,MAAIX,EAAKW,GAAMJ,GAAQE,GAAUL,GAAKC,CAAM,IAAIQ,GAAM;AACpD,UAAMC,IAAQf,EAASY,CAAI,GACrBI,IAAYf,EAAKc,GAAOP,GAAQE,GAAUL,GAAKC,CAAM;AAC3D,KAAIU,KAAaF,KAAQE,IAAYf,EAAKW,GAAMJ,GAAQE,GAAUL,GAAKC,CAAM,OAAGJ,IAAOa;AAAA,EACzF;AACA,MAAIE,GACAC;AACJ,SAAIL,KACFK,IAAIhB,MAAS,UAAUM,EAAO,IAAIA,EAAO,SAASH,IAAMG,EAAO,IAAIH,IAAMI,EAAI,QAC7EQ,IAAIN,EAAQ,UAAU,WAAWH,EAAO,KAAKA,EAAO,QAAQC,EAAI,SAAS,IAAID,EAAO,MAEpFS,IAAIf,MAAS,UAAUM,EAAO,IAAIA,EAAO,QAAQH,IAAMG,EAAO,IAAIH,IAAMI,EAAI,OAC5ES,IAAIP,EAAQ,UAAU,WAAWH,EAAO,KAAKA,EAAO,SAASC,EAAI,UAAU,IAAID,EAAO,IAExFS,IAAIE,EAAMF,GAAGX,GAAQ,KAAK,IAAIA,GAAQI,EAAS,QAAQJ,IAASG,EAAI,KAAK,CAAC,GAC1ES,IAAIC,EAAMD,GAAGZ,GAAQ,KAAK,IAAIA,GAAQI,EAAS,SAASJ,IAASG,EAAI,MAAM,CAAC,GACrE,EAAE,GAAGW,EAAOH,GAAGN,EAAQ,QAAQ,EAAK,GAAG,GAAGS,EAAOF,GAAGP,EAAQ,QAAQ,EAAK,GAAG,MAAAT,EAAA;AACrF;"}

package/dist/ui/layout/scroll.js

@@ -0,0 +1,24 @@
+import { clamp as r } from "./geometry.js";
+function u(o, n) {
+  return Math.max(0, o - n);
+}
+function f(o, n, c) {
+  return r(o, 0, u(n, c));
+}
+function a(o, n, c, l, e) {
+  let t = o;
+  return n < t ? t = n : n + c > t + l && (t = n + c - l), f(t, e, l);
+}
+const i = 8;
+function p(o, n, c = 0.06) {
+  const l = o * Math.pow(1 - c, n / 16.666666666666668);
+  return Math.abs(l) < i ? 0 : l;
+}
+export {
+  i as FLING_STOP,
+  f as clampScroll,
+  u as maxScroll,
+  a as scrollIntoView,
+  p as stepFling
+};
+//# sourceMappingURL=scroll.js.map

package/dist/ui/layout/scroll.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"scroll.js","sources":["../../../src/ui/layout/scroll.ts"],"sourcesContent":["import { clamp } from './geometry';\n\n/** How far content of `content` length can scroll in a window of `viewport` length. */\nexport function maxScroll(content: number, viewport: number): number {\n  return Math.max(0, content - viewport);\n}\n\n/** A scroll offset kept between the top and the last full window of content. */\nexport function clampScroll(offset: number, content: number, viewport: number): number {\n  return clamp(offset, 0, maxScroll(content, viewport));\n}\n\n/**\n * The smallest scroll that brings an item (`start`, `size` along the scroll axis) fully into view: a list moved by\n * the keyboard follows the focus without jumping when the focus is already visible.\n */\nexport function scrollIntoView(offset: number, start: number, size: number, viewport: number, content: number): number {\n  let next = offset;\n  if (start < next) next = start;\n  else if (start + size > next + viewport) next = start + size - viewport;\n  return clampScroll(next, content, viewport);\n}\n\n/** Below this speed (px a second) a fling has stopped. */\nexport const FLING_STOP = 8;\n\n/**\n * A fling's speed after `dtMs`, losing `friction` of it every 60th of a second: the same glide at any frame rate.\n * 0 once it falls under `FLING_STOP`.\n */\nexport function stepFling(velocity: number, dtMs: number, friction = 0.06): number {\n  const v = velocity * Math.pow(1 - friction, dtMs / (1000 / 60));\n  return Math.abs(v) < FLING_STOP ? 0 : v;\n}\n"],"names":["maxScroll","content","viewport","clampScroll","offset","clamp","scrollIntoView","start","size","next","FLING_STOP","stepFling","velocity","dtMs","friction","v"],"mappings":";AAGO,SAASA,EAAUC,GAAiBC,GAA0B;AACnE,SAAO,KAAK,IAAI,GAAGD,IAAUC,CAAQ;AACvC;AAGO,SAASC,EAAYC,GAAgBH,GAAiBC,GAA0B;AACrF,SAAOG,EAAMD,GAAQ,GAAGJ,EAAUC,GAASC,CAAQ,CAAC;AACtD;AAMO,SAASI,EAAeF,GAAgBG,GAAeC,GAAcN,GAAkBD,GAAyB;AACrH,MAAIQ,IAAOL;AACX,SAAIG,IAAQE,IAAMA,IAAOF,IAChBA,IAAQC,IAAOC,IAAOP,MAAUO,IAAOF,IAAQC,IAAON,IACxDC,EAAYM,GAAMR,GAASC,CAAQ;AAC5C;AAGO,MAAMQ,IAAa;AAMnB,SAASC,EAAUC,GAAkBC,GAAcC,IAAW,MAAc;AACjF,QAAMC,IAAIH,IAAW,KAAK,IAAI,IAAIE,GAAUD,IAAQ,kBAAU;AAC9D,SAAO,KAAK,IAAIE,CAAC,IAAIL,IAAa,IAAIK;AACxC;"}

package/dist/ui/layout/slider.js

@@ -0,0 +1,20 @@
+import { clamp as n } from "./geometry.js";
+function d(u, r, t, o = 0) {
+  const e = n(u, r, t);
+  if (o <= 0) return e;
+  const c = r + Math.round((e - r) / o) * o;
+  return n(Number(c.toFixed(10)), r, t);
+}
+function i(u, r, t) {
+  return t > r ? n((u - r) / (t - r), 0, 1) : 0;
+}
+function s(u, r, t, o, e, c = 0) {
+  const f = t > 0 ? n((u - r) / t, 0, 1) : 0;
+  return d(o + f * (e - o), o, e, c);
+}
+export {
+  d as quantize,
+  i as sliderFraction,
+  s as sliderValueAt
+};
+//# sourceMappingURL=slider.js.map

package/dist/ui/layout/slider.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"slider.js","sources":["../../../src/ui/layout/slider.ts"],"sourcesContent":["import { clamp } from './geometry';\n\n/** A value held to the range and to the nearest `step` above `min` (no step: any value). */\nexport function quantize(value: number, min: number, max: number, step = 0): number {\n  const v = clamp(value, min, max);\n  if (step <= 0) return v;\n  const q = min + Math.round((v - min) / step) * step;\n  // the last step may overshoot max when the range is not a whole number of steps\n  return clamp(Number(q.toFixed(10)), min, max);\n}\n\n/** Where `value` sits along the range, 0–1. */\nexport function sliderFraction(value: number, min: number, max: number): number {\n  return max > min ? clamp((value - min) / (max - min), 0, 1) : 0;\n}\n\n/** The value under a pointer at `px` on a track starting at `trackStart`, `trackLength` long. */\nexport function sliderValueAt(px: number, trackStart: number, trackLength: number, min: number, max: number, step = 0): number {\n  const f = trackLength > 0 ? clamp((px - trackStart) / trackLength, 0, 1) : 0;\n  return quantize(min + f * (max - min), min, max, step);\n}\n"],"names":["quantize","value","min","max","step","v","clamp","q","sliderFraction","sliderValueAt","px","trackStart","trackLength"],"mappings":";AAGO,SAASA,EAASC,GAAeC,GAAaC,GAAaC,IAAO,GAAW;AAClF,QAAMC,IAAIC,EAAML,GAAOC,GAAKC,CAAG;AAC/B,MAAIC,KAAQ,EAAG,QAAOC;AACtB,QAAME,IAAIL,IAAM,KAAK,OAAOG,IAAIH,KAAOE,CAAI,IAAIA;AAE/C,SAAOE,EAAM,OAAOC,EAAE,QAAQ,EAAE,CAAC,GAAGL,GAAKC,CAAG;AAC9C;AAGO,SAASK,EAAeP,GAAeC,GAAaC,GAAqB;AAC9E,SAAOA,IAAMD,IAAMI,GAAOL,IAAQC,MAAQC,IAAMD,IAAM,GAAG,CAAC,IAAI;AAChE;AAGO,SAASO,EAAcC,GAAYC,GAAoBC,GAAqBV,GAAaC,GAAaC,IAAO,GAAW;AAC7H,QAAM,IAAIQ,IAAc,IAAIN,GAAOI,IAAKC,KAAcC,GAAa,GAAG,CAAC,IAAI;AAC3E,SAAOZ,EAASE,IAAM,KAAKC,IAAMD,IAAMA,GAAKC,GAAKC,CAAI;AACvD;"}

package/dist/ui/layout/stack.js

@@ -0,0 +1,27 @@
+import { insets as k, snapPx as o } from "./geometry.js";
+function M(h, s = {}) {
+  const t = (s.direction ?? "vertical") === "vertical", S = s.gap ?? 0, e = k(s.padding), l = s.align ?? "start", c = s.snap ?? !1;
+  let i = 0;
+  for (const n of h) i = Math.max(i, t ? n.width : n.height);
+  s.crossSize !== void 0 && (i = s.crossSize);
+  const f = [];
+  let g = t ? e.top : e.left;
+  const m = t ? e.left : e.top;
+  for (let n = 0; n < h.length; n++) {
+    const a = h[n], x = t ? a.height : a.width;
+    let r = t ? a.width : a.height, d = 0;
+    l === "stretch" ? r = i : l === "center" ? d = (i - r) / 2 : l === "end" && (d = i - r);
+    const u = o(g, c), v = o(m + d, c), b = o(x, c), y = o(r, c);
+    f.push(t ? { x: v, y: u, width: y, height: b } : { x: u, y: v, width: b, height: y }), g += x + (n < h.length - 1 ? S : 0);
+  }
+  const p = g + (t ? e.bottom : e.right), w = m + i + (t ? e.right : e.bottom);
+  return {
+    items: f,
+    width: o(t ? w : p, c),
+    height: o(t ? p : w, c)
+  };
+}
+export {
+  M as stackLayout
+};
+//# sourceMappingURL=stack.js.map

package/dist/ui/layout/stack.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"stack.js","sources":["../../../src/ui/layout/stack.ts"],"sourcesContent":["import { insets, snapPx, type Insets, type Rect, type Size } from './geometry';\n\nexport type StackDirection = 'vertical' | 'horizontal';\n/** Where items sit across the stack: its start, middle or end, or stretched to the widest (tallest) one. */\nexport type StackAlign = 'start' | 'center' | 'end' | 'stretch';\n\nexport interface StackOptions {\n  direction?: StackDirection;\n  /** Between two items (default 0). */\n  gap?: number;\n  /** Inside the stack's edge (default 0). */\n  padding?: number | Partial<Insets>;\n  align?: StackAlign;\n  /** A cross size to align in instead of the widest item's (a column as wide as its window). */\n  crossSize?: number;\n  /** Whole pixels (pixel-perfect UI). */\n  snap?: boolean;\n}\n\nexport interface StackResult extends Size {\n  /** One rect per item, in the order given, relative to the stack's top-left. */\n  items: Rect[];\n}\n\n/**\n * Lays items one after another down (or across) with a gap, inside padding. The stack's size is what the items\n * need, so a parent can lay the stack out in turn. Pure, for canvas widgets and DOM/React layouts alike.\n */\nexport function stackLayout(sizes: readonly Size[], options: StackOptions = {}): StackResult {\n  const vertical = (options.direction ?? 'vertical') === 'vertical';\n  const gap = options.gap ?? 0;\n  const pad = insets(options.padding);\n  const align = options.align ?? 'start';\n  const snap = options.snap ?? false;\n  let cross = 0;\n  for (const s of sizes) cross = Math.max(cross, vertical ? s.width : s.height);\n  if (options.crossSize !== undefined) cross = options.crossSize;\n  const items: Rect[] = [];\n  let main = vertical ? pad.top : pad.left;\n  const crossStart = vertical ? pad.left : pad.top;\n  for (let i = 0; i < sizes.length; i++) {\n    const s = sizes[i]!;\n    const itemMain = vertical ? s.height : s.width;\n    let itemCross = vertical ? s.width : s.height;\n    let offset = 0;\n    if (align === 'stretch') itemCross = cross;\n    else if (align === 'center') offset = (cross - itemCross) / 2;\n    else if (align === 'end') offset = cross - itemCross;\n    const a = snapPx(main, snap);\n    const b = snapPx(crossStart + offset, snap);\n    const len = snapPx(itemMain, snap);\n    const thick = snapPx(itemCross, snap);\n    items.push(vertical ? { x: b, y: a, width: thick, height: len } : { x: a, y: b, width: len, height: thick });\n    main += itemMain + (i < sizes.length - 1 ? gap : 0);\n  }\n  const mainEnd = main + (vertical ? pad.bottom : pad.right);\n  const crossEnd = crossStart + cross + (vertical ? pad.right : pad.bottom);\n  return {\n    items,\n    width: snapPx(vertical ? crossEnd : mainEnd, snap),\n    height: snapPx(vertical ? mainEnd : crossEnd, snap),\n  };\n}\n"],"names":["stackLayout","sizes","options","vertical","gap","pad","insets","align","snap","cross","s","items","main","crossStart","i","itemMain","itemCross","offset","a","snapPx","b","len","thick","mainEnd","crossEnd"],"mappings":";AA4BO,SAASA,EAAYC,GAAwBC,IAAwB,IAAiB;AAC3F,QAAMC,KAAYD,EAAQ,aAAa,gBAAgB,YACjDE,IAAMF,EAAQ,OAAO,GACrBG,IAAMC,EAAOJ,EAAQ,OAAO,GAC5BK,IAAQL,EAAQ,SAAS,SACzBM,IAAON,EAAQ,QAAQ;AAC7B,MAAIO,IAAQ;AACZ,aAAWC,KAAKT,EAAO,CAAAQ,IAAQ,KAAK,IAAIA,GAAON,IAAWO,EAAE,QAAQA,EAAE,MAAM;AAC5E,EAAIR,EAAQ,cAAc,WAAWO,IAAQP,EAAQ;AACrD,QAAMS,IAAgB,CAAA;AACtB,MAAIC,IAAOT,IAAWE,EAAI,MAAMA,EAAI;AACpC,QAAMQ,IAAaV,IAAWE,EAAI,OAAOA,EAAI;AAC7C,WAASS,IAAI,GAAGA,IAAIb,EAAM,QAAQa,KAAK;AACrC,UAAMJ,IAAIT,EAAMa,CAAC,GACXC,IAAWZ,IAAWO,EAAE,SAASA,EAAE;AACzC,QAAIM,IAAYb,IAAWO,EAAE,QAAQA,EAAE,QACnCO,IAAS;AACb,IAAIV,MAAU,YAAWS,IAAYP,IAC5BF,MAAU,WAAUU,KAAUR,IAAQO,KAAa,IACnDT,MAAU,UAAOU,IAASR,IAAQO;AAC3C,UAAME,IAAIC,EAAOP,GAAMJ,CAAI,GACrBY,IAAID,EAAON,IAAaI,GAAQT,CAAI,GACpCa,IAAMF,EAAOJ,GAAUP,CAAI,GAC3Bc,IAAQH,EAAOH,GAAWR,CAAI;AACpC,IAAAG,EAAM,KAAKR,IAAW,EAAE,GAAGiB,GAAG,GAAGF,GAAG,OAAOI,GAAO,QAAQD,MAAQ,EAAE,GAAGH,GAAG,GAAGE,GAAG,OAAOC,GAAK,QAAQC,GAAO,GAC3GV,KAAQG,KAAYD,IAAIb,EAAM,SAAS,IAAIG,IAAM;AAAA,EACnD;AACA,QAAMmB,IAAUX,KAAQT,IAAWE,EAAI,SAASA,EAAI,QAC9CmB,IAAWX,IAAaJ,KAASN,IAAWE,EAAI,QAAQA,EAAI;AAClE,SAAO;AAAA,IACL,OAAAM;AAAA,IACA,OAAOQ,EAAOhB,IAAWqB,IAAWD,GAASf,CAAI;AAAA,IACjD,QAAQW,EAAOhB,IAAWoB,IAAUC,GAAUhB,CAAI;AAAA,EAAA;AAEtD;"}

package/dist/ui/layout/wrapRow.js

@@ -0,0 +1,13 @@
+function p(s, h, u = 0) {
+  const n = [];
+  let e = [], o = 0;
+  for (let t = 0; t < s.length; t++) {
+    const l = s[t], r = e.length === 0 ? l : o + u + l;
+    e.length > 0 && r > h ? (n.push(e), e = [t], o = l) : (e.push(t), o = r);
+  }
+  return e.length > 0 && n.push(e), n;
+}
+export {
+  p as wrapRow
+};
+//# sourceMappingURL=wrapRow.js.map

package/dist/ui/layout/wrapRow.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"wrapRow.js","sources":["../../../src/ui/layout/wrapRow.ts"],"sourcesContent":["/**\n * Breaks a row of items (tabs, chips, buttons) into lines no wider than `maxWidth`: each line holds the indices of\n * its items in order. An item wider than the line still gets a line of its own rather than being dropped.\n */\nexport function wrapRow(widths: readonly number[], maxWidth: number, gap = 0): number[][] {\n  const rows: number[][] = [];\n  let row: number[] = [];\n  let used = 0;\n  for (let i = 0; i < widths.length; i++) {\n    const w = widths[i]!;\n    const next = row.length === 0 ? w : used + gap + w;\n    if (row.length > 0 && next > maxWidth) {\n      rows.push(row);\n      row = [i];\n      used = w;\n    } else {\n      row.push(i);\n      used = next;\n    }\n  }\n  if (row.length > 0) rows.push(row);\n  return rows;\n}\n"],"names":["wrapRow","widths","maxWidth","gap","rows","row","used","i","w","next"],"mappings":"AAIO,SAASA,EAAQC,GAA2BC,GAAkBC,IAAM,GAAe;AACxF,QAAMC,IAAmB,CAAA;AACzB,MAAIC,IAAgB,CAAA,GAChBC,IAAO;AACX,WAASC,IAAI,GAAGA,IAAIN,EAAO,QAAQM,KAAK;AACtC,UAAMC,IAAIP,EAAOM,CAAC,GACZE,IAAOJ,EAAI,WAAW,IAAIG,IAAIF,IAAOH,IAAMK;AACjD,IAAIH,EAAI,SAAS,KAAKI,IAAOP,KAC3BE,EAAK,KAAKC,CAAG,GACbA,IAAM,CAACE,CAAC,GACRD,IAAOE,MAEPH,EAAI,KAAKE,CAAC,GACVD,IAAOG;AAAA,EAEX;AACA,SAAIJ,EAAI,SAAS,KAAGD,EAAK,KAAKC,CAAG,GAC1BD;AACT;"}