@oidoid/void 0.1.0-3 → 0.1.0-6

package/dist/public/index.js

@@ -0,0 +1,3844 @@
+new EventSource('/esbuild').addEventListener('change', () => location.reload());
+
+// <define:globalThis.voidVersion>
+var define_globalThis_voidVersion_default = { hash: "2eb97a3", published: "20250824", version: "0.1.0-4" };
+
+// src/types/void-version.ts
+var voidVersion = define_globalThis_voidVersion_default;
+
+// node_modules/mem-font/dist/mem-prop-5x6.json
+var mem_prop_5x6_default = {
+  id: "mem-prop-5x6",
+  name: "mem 5x6",
+  cellWidth: 5,
+  cellHeight: 6,
+  leading: 1,
+  lineHeight: 7,
+  baseline: 1,
+  kerning: {
+    " 0": 0,
+    " 1": 0,
+    " 2": 0,
+    " 3": 0,
+    " 4": 0,
+    " 5": 0,
+    " 6": 0,
+    " 7": 0,
+    " 8": 0,
+    " 9": 0,
+    "##": -1,
+    "#_": 0,
+    "',": 0,
+    "'.": 0,
+    "'/": 0,
+    "'J": 0,
+    "'S": 0,
+    "'_": 0,
+    "'j": 0,
+    "'s": 0,
+    "(+": 0,
+    "(-": 0,
+    "(<": 0,
+    "(f": 0,
+    "({": 0,
+    "(~": 0,
+    ")_": 0,
+    "*,": 0,
+    "*.": 0,
+    "*/": 0,
+    "*S": 0,
+    "*_": 0,
+    "*j": 0,
+    "*s": 0,
+    "+)": 0,
+    "+,": 0,
+    "+.": 0,
+    "+/": 0,
+    "+>": 0,
+    "+?": 0,
+    "+I": 0,
+    "+S": 0,
+    "+T": 0,
+    "+Z": 0,
+    "+]": 0,
+    "+_": 0,
+    "+`": 0,
+    "+j": 0,
+    "+s": 0,
+    "+}": 0,
+    ",'": 0,
+    ",*": 0,
+    ",+": 0,
+    ",-": 0,
+    ",<": 0,
+    ",?": 0,
+    ",T": 0,
+    ",Y": 0,
+    ",Z": 0,
+    ',"': 0,
+    ",\\": 0,
+    ",^": 0,
+    ",`": 0,
+    ",f": 0,
+    ",t": 0,
+    ",z": 0,
+    ",{": 0,
+    ",~": 0,
+    "-)": 0,
+    "-,": 0,
+    "--": 0,
+    "-.": 0,
+    "-/": 0,
+    "->": 0,
+    "-?": 0,
+    "-I": 0,
+    "-S": 0,
+    "-T": 0,
+    "-Z": 0,
+    "-]": 0,
+    "-_": 0,
+    "-`": 0,
+    "-j": 0,
+    "-s": 0,
+    "-}": 0,
+    ".'": 0,
+    ".*": 0,
+    ".+": 0,
+    ".-": 0,
+    ".<": 0,
+    ".?": 0,
+    ".T": 0,
+    ".Y": 0,
+    ".Z": 0,
+    '."': 0,
+    ".\\": 0,
+    ".^": 0,
+    ".`": 0,
+    ".f": 0,
+    ".t": 0,
+    ".z": 0,
+    ".{": 0,
+    ".~": 0,
+    "/,": 0,
+    "/.": 0,
+    "//": 0,
+    "/J": 0,
+    "/S": 0,
+    "/_": 0,
+    "/j": 0,
+    "/s": 0,
+    "0 ": 0,
+    "1 ": 0,
+    "1T": 0,
+    "1Y": 0,
+    "1Z": 0,
+    "1f": 0,
+    "1t": 0,
+    "1z": 0,
+    "2 ": 0,
+    "3 ": 0,
+    "4 ": 0,
+    "5 ": 0,
+    "6 ": 0,
+    "7 ": 0,
+    "8 ": 0,
+    "9 ": 0,
+    ":?": 0,
+    ":T": 0,
+    ":Z": 0,
+    ":`": 0,
+    ";?": 0,
+    ";T": 0,
+    ";Z": 0,
+    "<+": 0,
+    "<-": 0,
+    "<<": 0,
+    "<f": 0,
+    "<{": 0,
+    "<~": 0,
+    "==": 0,
+    "=_": 0,
+    ">)": 0,
+    ">,": 0,
+    ">.": 0,
+    ">/": 0,
+    ">>": 0,
+    ">?": 0,
+    ">I": 0,
+    ">S": 0,
+    ">T": 0,
+    ">Z": 0,
+    ">]": 0,
+    ">_": 0,
+    ">`": 0,
+    ">j": 0,
+    ">s": 0,
+    ">}": 0,
+    "?,": 0,
+    "?.": 0,
+    "?/": 0,
+    "?S": 0,
+    "?_": 0,
+    "?j": 0,
+    "?s": 0,
+    "@_": 0,
+    "C+": 0,
+    "C-": 0,
+    "C<": 0,
+    Cf: 0,
+    "C{": 0,
+    "C~": 0,
+    D_: 0,
+    "E+": 0,
+    "E-": 0,
+    "E<": 0,
+    Ef: 0,
+    "E{": 0,
+    "E~": 0,
+    "F&": 0,
+    "F+": 0,
+    "F,": 0,
+    "F-": 0,
+    "F.": 0,
+    "F/": 0,
+    "F:": 0,
+    "F;": 0,
+    "F<": 0,
+    FJ: 0,
+    FS: 0,
+    F_: 0,
+    Fa: 0,
+    Fe: 0,
+    Ff: 0,
+    Fg: 0,
+    Fj: 0,
+    Fq: 0,
+    Fs: 0,
+    "F{": 0,
+    "F~": 0,
+    "I+": 0,
+    "I-": 0,
+    "I<": 0,
+    If: 0,
+    "I{": 0,
+    "I~": 0,
+    "L'": 0,
+    "L*": 0,
+    "L+": 0,
+    "L-": 0,
+    L4: 0,
+    L7: 0,
+    "L<": 0,
+    "L?": 0,
+    LT: 0,
+    LY: 0,
+    LZ: 0,
+    'L"': 0,
+    "L\\": 0,
+    "L^": 0,
+    "L`": 0,
+    Lf: 0,
+    Lt: 0,
+    Lz: 0,
+    "L{": 0,
+    "L~": 0,
+    "P,": 0,
+    "P.": 0,
+    "P/": 0,
+    PS: 0,
+    P_: 0,
+    Pj: 0,
+    Ps: 0,
+    "S&": 0,
+    "S+": 0,
+    "S,": 0,
+    "S-": 0,
+    "S.": 0,
+    "S/": 0,
+    "S:": 0,
+    "S;": 0,
+    "S<": 0,
+    SJ: 0,
+    SS: 0,
+    S_: 0,
+    Sa: 0,
+    Se: 0,
+    Sf: 0,
+    Sg: 0,
+    Sj: 0,
+    Sq: 0,
+    Ss: 0,
+    "S{": 0,
+    "S~": 0,
+    "T&": 0,
+    "T+": 0,
+    "T,": 0,
+    "T-": 0,
+    "T.": 0,
+    "T/": 0,
+    "T:": 0,
+    "T;": 0,
+    "T<": 0,
+    TJ: 0,
+    TS: 0,
+    T_: 0,
+    Ta: 0,
+    Te: 0,
+    Tf: 0,
+    Tg: 0,
+    Tj: 0,
+    Tq: 0,
+    Ts: 0,
+    "T{": 0,
+    "T~": 0,
+    V_: 0,
+    "Y,": 0,
+    "Y.": 0,
+    "Y/": 0,
+    YS: 0,
+    Y_: 0,
+    Yj: 0,
+    Ys: 0,
+    "Z'": 0,
+    "Z*": 0,
+    "Z+": 0,
+    "Z-": 0,
+    Z4: 0,
+    Z7: 0,
+    "Z<": 0,
+    "Z?": 0,
+    ZT: 0,
+    ZY: 0,
+    ZZ: 0,
+    'Z"': 0,
+    "Z\\": 0,
+    "Z^": 0,
+    "Z`": 0,
+    Zf: 0,
+    Zt: 0,
+    Zz: 0,
+    "Z{": 0,
+    "Z~": 0,
+    "[+": 0,
+    "[-": 0,
+    "[<": 0,
+    "[f": 0,
+    "[{": 0,
+    "[~": 0,
+    '",': 0,
+    '".': 0,
+    '"/': 0,
+    '"J': 0,
+    '"S': 0,
+    '"_': 0,
+    '"j': 0,
+    '"s': 0,
+    "\\'": 0,
+    "\\*": 0,
+    "\\+": 0,
+    "\\-": 0,
+    "\\<": 0,
+    "\\?": 0,
+    "\\T": 0,
+    "\\Y": 0,
+    "\\Z": 0,
+    '\\"': 0,
+    "\\\\": 0,
+    "\\^": 0,
+    "\\`": 0,
+    "\\f": 0,
+    "\\t": 0,
+    "\\z": 0,
+    "\\{": 0,
+    "\\~": 0,
+    "^,": 0,
+    "^.": 0,
+    "^/": 0,
+    "^J": 0,
+    "^S": 0,
+    "^_": 0,
+    "^j": 0,
+    "^s": 0,
+    "_#": 0,
+    "_%": 0,
+    "_'": 0,
+    "_(": 0,
+    "_*": 0,
+    "_+": 0,
+    "_-": 0,
+    "_<": 0,
+    "_=": 0,
+    "_?": 0,
+    "_@": 0,
+    _T: 0,
+    _V: 0,
+    _Y: 0,
+    _Z: 0,
+    '_"': 0,
+    "_\\": 0,
+    "_^": 0,
+    __: 0,
+    "_`": 0,
+    _a: 0,
+    _e: 0,
+    _f: 0,
+    _t: 0,
+    _v: 0,
+    _z: 0,
+    "_{": 0,
+    "_~": 0,
+    "`,": 0,
+    "`.": 0,
+    "`/": 0,
+    "`J": 0,
+    "`S": 0,
+    "`_": 0,
+    "`j": 0,
+    "`s": 0,
+    "f,": 0,
+    "f.": 0,
+    "f/": 0,
+    fS: 0,
+    f_: 0,
+    fj: 0,
+    fs: 0,
+    "q#": 0,
+    q$: 0,
+    "q%": 0,
+    "q&": 0,
+    "q'": 0,
+    "q(": 0,
+    "q*": 0,
+    "q+": 0,
+    "q-": 0,
+    q0: 0,
+    q1: 0,
+    q2: 0,
+    q3: 0,
+    q4: 0,
+    q5: 0,
+    q6: 0,
+    q7: 0,
+    q8: 0,
+    q9: 0,
+    "q<": 0,
+    "q=": 0,
+    "q?": 0,
+    "q@": 0,
+    qA: 0,
+    qB: 0,
+    qC: 0,
+    qD: 0,
+    qE: 0,
+    qF: 0,
+    qG: 0,
+    qH: 0,
+    qI: 0,
+    qJ: 0,
+    qK: 0,
+    qL: 0,
+    qM: 0,
+    qN: 0,
+    qO: 0,
+    qP: 0,
+    qQ: 0,
+    qR: 0,
+    qS: 0,
+    qT: 0,
+    qU: 0,
+    qV: 0,
+    qW: 0,
+    qX: 0,
+    qY: 0,
+    qZ: 0,
+    "q[": 0,
+    'q"': 0,
+    "q\\": 0,
+    "q]": 0,
+    "q^": 0,
+    "q`": 0,
+    qa: 0,
+    qb: 0,
+    qc: 0,
+    qd: 0,
+    qe: 0,
+    qf: 0,
+    qh: 0,
+    qk: 0,
+    qm: 0,
+    qn: 0,
+    qo: 0,
+    qq: 0,
+    qr: 0,
+    qs: 0,
+    qt: 0,
+    qu: 0,
+    qv: 0,
+    qw: 0,
+    qx: 0,
+    qz: 0,
+    "q{": 0,
+    "q}": 0,
+    "q~": 0,
+    "r,": 0,
+    "r.": 0,
+    "r/": 0,
+    rS: 0,
+    r_: 0,
+    rj: -1,
+    rs: 0,
+    "s,": 0,
+    "s.": 0,
+    "s/": 0,
+    sJ: 0,
+    sS: 0,
+    s_: 0,
+    sj: 0,
+    ss: 0,
+    "z'": 0,
+    "z*": 0,
+    "z+": 0,
+    "z-": 0,
+    z4: 0,
+    z7: 0,
+    "z<": 0,
+    "z?": 0,
+    zT: 0,
+    zY: 0,
+    zZ: 0,
+    'z"': 0,
+    "z\\": 0,
+    "z^": 0,
+    "z`": 0,
+    zf: 0,
+    zt: 0,
+    zz: 0,
+    "z{": 0,
+    "z~": 0,
+    "{+": 0,
+    "{-": 0,
+    "{<": 0,
+    "{f": 0,
+    "{{": 0,
+    "{~": 0,
+    "})": 0,
+    "},": 0,
+    "}.": 0,
+    "}/": 0,
+    "}>": 0,
+    "}?": 0,
+    "}I": 0,
+    "}S": 0,
+    "}T": 0,
+    "}Z": 0,
+    "}]": 0,
+    "}_": 0,
+    "}`": 0,
+    "}j": 0,
+    "}s": 0,
+    "}}": 0,
+    "~'": 0,
+    "~?": 0,
+    "~T": 0,
+    "~Z": 0,
+    '~"': 0,
+    "~\\": 0,
+    "~^": 0,
+    "~_": 0,
+    "~`": 0,
+    "~t": 0,
+    "~z": 0
+  },
+  defaultKerning: 1,
+  defaultWhitespaceKerning: -1,
+  endOfLineKerning: 0,
+  charWidth: {
+    " ": 4,
+    "!": 1,
+    "#": 5,
+    "&": 4,
+    "'": 1,
+    "(": 2,
+    ")": 2,
+    ",": 1,
+    ".": 1,
+    ":": 1,
+    ";": 1,
+    "@": 5,
+    M: 5,
+    W: 5,
+    "[": 2,
+    "\n": 0,
+    "]": 2,
+    "`": 2,
+    i: 1,
+    l: 1,
+    m: 5,
+    q: 4,
+    w: 5,
+    "|": 1
+  },
+  defaultCharWidth: 3
+};
+
+// node_modules/mem-font/dist/index.js
+var memProp5x6 = mem_prop_5x6_default;
+
+// src/graphics/layer.ts
+var Layer = {
+  Top: 0,
+  UIA: 1,
+  UIB: 2,
+  UIC: 3,
+  UID: 4,
+  UIE: 5,
+  UIF: 6,
+  UIG: 7,
+  A: 8,
+  B: 9,
+  C: 10,
+  D: 11,
+  E: 12,
+  F: 13,
+  Bottom: 14,
+  Hidden: 15
+};
+function layerOffset(layer, offset) {
+  return Math.max(Layer.Top, Math.min(Layer.Bottom, layer + offset));
+}
+
+// src/types/geo.ts
+function boxHits(l, r) {
+  const rWH = { w: r.w ?? 1, h: r.h ?? 1 };
+  if (!l.w || !l.h || !rWH.w || !rWH.h) return false;
+  const lXY = { x: l.x ?? 0, y: l.y ?? 0 };
+  return lXY.x < r.x + rWH.w && lXY.x + l.w > r.x && lXY.y < r.y + rWH.h && lXY.y + l.h > r.y;
+}
+function whAssign(l, r) {
+  l.w = r.w;
+  l.h = r.h;
+}
+function whEq(l, r) {
+  return l.w === r.w && l.h === r.h;
+}
+function xyAdd(l, r) {
+  return { x: l.x + r.x, y: l.y + r.y };
+}
+function xyAssign(l, r) {
+  l.x = r.x;
+  l.y = r.y;
+}
+function xyDistance(from, to) {
+  return xyMagnitude(xySub(from, to));
+}
+function xyEq(l, r) {
+  return l.x === r.x && l.y === r.y;
+}
+function xyMagnitude(xy) {
+  return Math.hypot(xy.x, xy.y);
+}
+function xyMax(l, r) {
+  return { x: Math.max(l.x, r.x), y: Math.max(l.y, r.y) };
+}
+function xyMin(l, r) {
+  return { x: Math.min(l.x, r.x), y: Math.min(l.y, r.y) };
+}
+function xySub(l, r) {
+  return { x: l.x - r.x, y: l.y - r.y };
+}
+
+// src/ents/nine-patch-ent.ts
+var NinePatchEnt = class {
+  #dir;
+  #margin;
+  #invalid = true;
+  constructor(v2, opts) {
+    this.#dir = {
+      w: v2.sprites.alloc(),
+      nw: v2.sprites.alloc(),
+      n: v2.sprites.alloc(),
+      ne: v2.sprites.alloc(),
+      e: v2.sprites.alloc(),
+      se: v2.sprites.alloc(),
+      s: v2.sprites.alloc(),
+      sw: v2.sprites.alloc(),
+      origin: v2.sprites.alloc()
+    };
+    this.#dir.w.tag = opts.w?.tag ?? opts.e?.tag ?? opts.n.tag;
+    this.#dir.n.tag = opts.n.tag;
+    this.#dir.e.tag = opts.e?.tag ?? this.#dir.w.tag;
+    this.#dir.s.tag = opts.s?.tag ?? this.#dir.n.tag;
+    this.#dir.nw.tag = opts.nw?.tag ?? opts.se?.tag ?? opts.n.tag;
+    this.#dir.ne.tag = opts.ne?.tag ?? opts.sw?.tag ?? opts.nw?.tag ?? opts.n.tag;
+    this.#dir.se.tag = opts.se?.tag ?? this.#dir.nw.tag;
+    this.#dir.sw.tag = opts.sw?.tag ?? this.#dir.ne.tag;
+    this.#dir.origin.tag = opts.origin.tag;
+    this.#dir.w.z = this.#dir.nw.z = this.#dir.n.z = this.#dir.ne.z = this.#dir.e.z = this.#dir.se.z = this.#dir.s.z = this.#dir.sw.z = this.#dir.origin.z = opts.z ?? 0;
+    this.#dir.w.stretch = opts.w?.stretch ?? opts.e?.stretch ?? false;
+    this.#dir.n.stretch = opts.n.stretch ?? opts.s?.stretch ?? false;
+    this.#dir.e.stretch = opts.e?.stretch ?? this.#dir.w.stretch;
+    this.#dir.s.stretch = opts.s?.stretch ?? this.#dir.n.stretch;
+    this.#dir.nw.stretch = opts.nw?.stretch ?? opts.se?.stretch ?? false;
+    this.#dir.ne.stretch = opts.ne?.stretch ?? opts.sw?.stretch ?? false;
+    this.#dir.se.stretch = opts.se?.stretch ?? this.#dir.nw.stretch;
+    this.#dir.sw.stretch = opts.sw?.stretch ?? this.#dir.ne.stretch;
+    this.#dir.origin.stretch = opts.origin.stretch ?? false;
+    this.#dir.w.flipX = opts.w?.flip?.x ?? !opts.e?.flip?.x;
+    this.#dir.w.flipY = opts.w?.flip?.y ?? !!opts.e?.flip?.y;
+    this.#dir.n.flipX = opts.n.flip?.x ?? !!opts.s?.flip?.x;
+    this.#dir.n.flipY = opts.n.flip?.y ?? !opts.s?.flip?.y;
+    this.#dir.e.flipX = opts.e?.flip?.x ?? !this.#dir.w.flipX;
+    this.#dir.e.flipY = opts.e?.flip?.y ?? this.#dir.w.flipY;
+    this.#dir.s.flipX = opts.s?.flip?.x ?? this.#dir.n.flipX;
+    this.#dir.s.flipY = opts.s?.flip?.y ?? !this.#dir.n.flipY;
+    this.#dir.origin.flipX = !!opts.origin.flip?.x;
+    this.#dir.origin.flipY = !!opts.origin.flip?.y;
+    this.#dir.n.h = opts.border?.n ?? opts.border?.s ?? this.#dir.n.h;
+    this.#dir.w.w = opts.border?.w ?? opts.border?.e ?? this.#dir.n.h;
+    this.#dir.e.w = opts.border?.e ?? this.#dir.w.w;
+    this.#dir.s.h = opts.border?.s ?? this.#dir.n.h;
+    this.#dir.nw.w = this.#dir.w.w;
+    this.#dir.nw.h = this.#dir.n.h;
+    this.#dir.ne.w = this.#dir.e.w;
+    this.#dir.ne.h = this.#dir.n.h;
+    this.#dir.se.w = this.#dir.e.w;
+    this.#dir.se.h = this.#dir.s.h;
+    this.#dir.sw.w = this.#dir.w.w;
+    this.#dir.sw.h = this.#dir.s.h;
+    this.#margin = { w: opts.margin?.w ?? 0, h: opts.margin?.h ?? 0 };
+    const w = opts.wh?.w == null ? this.#dir.w.w + this.#dir.n.w + this.#dir.e.w : opts.wh.w;
+    this.#dir.n.w = w - 1;
+    this.wh = {
+      w,
+      h: opts.wh?.h == null ? this.#dir.n.h + this.#dir.e.h + this.#dir.s.h : opts.wh.h
+    };
+    this.#dir.nw.x = (opts.x ?? 0) - 1;
+    this.xy = { x: opts.x ?? 0, y: opts.y ?? 0 };
+  }
+  free(v2) {
+    v2.sprites.free(
+      this.#dir.w,
+      this.#dir.nw,
+      this.#dir.n,
+      this.#dir.ne,
+      this.#dir.e,
+      this.#dir.se,
+      this.#dir.s,
+      this.#dir.sw,
+      this.#dir.origin
+    );
+  }
+  update() {
+    if (!this.#invalid) return;
+    this.#invalid = false;
+    return true;
+  }
+  get wh() {
+    return {
+      w: this.#dir.w.w + this.#dir.n.w + this.#dir.e.w + this.#margin.w,
+      h: this.#dir.n.h + this.#dir.w.h + this.#dir.s.h + this.#margin.h
+    };
+  }
+  set wh(wh) {
+    if (whEq(wh, this.wh)) return;
+    this.#dir.w.h = wh.h - this.#dir.n.h - this.#dir.s.h - this.#margin.h;
+    this.#dir.n.w = wh.w - this.#dir.w.w - this.#dir.e.w - this.#margin.w;
+    this.#dir.s.w = this.#dir.n.w;
+    this.#dir.e.h = this.#dir.w.h;
+    this.#dir.origin.w = this.#dir.n.w;
+    this.#dir.origin.h = this.#dir.e.h;
+    this.#setXYRight();
+    this.#invalid = true;
+  }
+  get xy() {
+    return {
+      x: this.#dir.nw.x - this.#margin.w / 2,
+      y: this.#dir.nw.y - this.#margin.h / 2
+    };
+  }
+  set xy(xy) {
+    if (xyEq(xy, this.xy)) return;
+    this.#dir.nw.x = xy.x + this.#margin.w / 2;
+    this.#dir.nw.y = xy.y + this.#margin.h / 2;
+    this.#dir.w.x = this.#dir.nw.x;
+    this.#dir.w.y = this.#dir.nw.y + this.#dir.nw.h;
+    this.#dir.n.x = this.#dir.nw.x + this.#dir.nw.w;
+    this.#dir.n.y = this.#dir.nw.y;
+    this.#dir.origin.x = this.#dir.n.x;
+    this.#dir.origin.y = this.#dir.nw.y + this.#dir.ne.h;
+    this.#setXYRight();
+    this.#invalid = true;
+  }
+  #setXYRight() {
+    this.#dir.ne.x = this.#dir.n.x + this.#dir.n.w;
+    this.#dir.ne.y = this.#dir.nw.y;
+    this.#dir.e.x = this.#dir.ne.x;
+    this.#dir.e.y = this.#dir.nw.y + this.#dir.ne.h;
+    this.#dir.se.x = this.#dir.e.x;
+    this.#dir.se.y = this.#dir.e.y + this.#dir.e.h;
+    this.#dir.s.x = this.#dir.n.x;
+    this.#dir.s.y = this.#dir.se.y;
+    this.#dir.sw.x = this.#dir.nw.x;
+    this.#dir.sw.y = this.#dir.se.y;
+  }
+};
+
+// src/text/font.ts
+function fontCharToTag(font, char) {
+  let pt = char.codePointAt(0);
+  if (pt == null || pt > 255) pt = 63;
+  return `${font.id}--${pt.toString(16).padStart(2, "0")}`;
+}
+function fontKerning(font, l, r) {
+  if (r == null) return font.endOfLineKerning;
+  if (font.kerning[l + r] != null) return font.kerning[l + r];
+  if (/^\s?$/.test(l) || /^\s?$/.test(r)) return font.defaultWhitespaceKerning;
+  return font.defaultKerning;
+}
+function fontCharWidth(font, letter) {
+  return font.charWidth[letter] ?? font.defaultCharWidth;
+}
+
+// src/text/text-layout.ts
+function layoutText(opts) {
+  const chars = [];
+  const scale = opts.scale ?? 1;
+  const start = opts.start ?? { x: 0, y: 0 };
+  const maxW = opts.maxW ?? Infinity;
+  let cursor = { x: start.x, y: start.y };
+  let w = 0;
+  while (chars.length < opts.str.length) {
+    const i = chars.length;
+    const char = opts.str[i];
+    let layout;
+    if (char === "\n") layout = layoutNewline(opts.font, cursor, start.x, scale);
+    else if (/^\s*$/.test(char)) {
+      layout = layoutSpace(
+        opts.font,
+        cursor,
+        maxW,
+        tracking(opts.font, char, opts.str[i + 1], scale),
+        start.x,
+        scale
+      );
+    } else {
+      layout = layoutWord(opts.font, cursor, maxW, opts.str, i, start.x, scale);
+      if (cursor.x > 0 && layout.cursor.y === nextLine(opts.font, start.x, cursor.y, scale).y) {
+        const wordW = maxW - cursor.x + layout.cursor.x;
+        if (wordW <= maxW) {
+          cursor = nextLine(opts.font, start.x, cursor.y, scale);
+          layout = layoutWord(
+            opts.font,
+            cursor,
+            maxW,
+            opts.str,
+            i,
+            start.x,
+            scale
+          );
+        }
+      }
+    }
+    chars.push(...layout.chars);
+    cursor.x = layout.cursor.x;
+    cursor.y = layout.cursor.y;
+    w = Math.max(w, layout.cursor.x - start.x);
+  }
+  return {
+    chars,
+    cursor,
+    wh: { w, h: nextLine(opts.font, start.x, cursor.y, scale).y - start.y }
+  };
+}
+function layoutWord(font, cursor, maxW, word, index, startX, scale) {
+  const chars = [];
+  let { x, y } = cursor;
+  for (; ; index++) {
+    const char = word[index];
+    if (!char || /^\s*$/.test(char)) break;
+    const span = tracking(font, char, word[index + 1], scale);
+    if (x > startX && x + span > startX + maxW)
+      ({ x, y } = nextLine(font, startX, y, scale));
+    chars.push({ x, y, w: fontCharWidth(font, char), h: font.cellHeight });
+    x += span;
+  }
+  return { chars, cursor: { x, y } };
+}
+function nextLine(font, startX, curY, scale) {
+  return { x: startX, y: curY + font.lineHeight * scale };
+}
+function layoutNewline(font, cursor, startX, scale) {
+  return { chars: [void 0], cursor: nextLine(font, startX, cursor.y, scale) };
+}
+function layoutSpace(font, cursor, w, span, startX, scale) {
+  const nextCursor = cursor.x > 0 && cursor.x + span >= w ? nextLine(font, startX, cursor.y, scale) : { x: cursor.x + span, y: cursor.y };
+  return { chars: [void 0], cursor: nextCursor };
+}
+function tracking(font, l, r, scale) {
+  return scale * (fontCharWidth(font, l) + fontKerning(font, l, r));
+}
+
+// src/ents/text-ent.ts
+var TextEnt = class {
+  #maxW = Infinity;
+  #layout = "Outdated";
+  #z = Layer.UIA;
+  #scale = 1;
+  #sprites = [];
+  #str = "";
+  #wh = { w: 0, h: 0 };
+  #xy = { x: 0, y: 0 };
+  free(v2) {
+    v2.sprites.free(...this.#sprites);
+  }
+  layout(v2) {
+    if (this.#layout !== "Outdated") return false;
+    let len = 0;
+    const layout = layoutText({
+      font: memProp5x6,
+      maxW: this.#maxW,
+      scale: this.#scale,
+      start: this.#xy,
+      str: this.#str
+    });
+    this.#wh = { w: layout.wh.w, h: layout.wh.h };
+    for (const [i, char] of layout.chars.entries()) {
+      if (char == null) continue;
+      const sprite = this.#sprites[len] ??= v2.sprites.alloc();
+      sprite.x = char.x;
+      sprite.y = char.y;
+      sprite.tag = fontCharToTag(memProp5x6, this.#str[i]);
+      sprite.stretch = true;
+      sprite.w *= this.#scale;
+      sprite.h *= this.#scale;
+      sprite.z = this.#z;
+      len++;
+    }
+    while (this.#sprites.length > len) v2.sprites.free(this.#sprites.pop());
+    this.#layout = "Updated";
+    return true;
+  }
+  get maxW() {
+    return this.#maxW;
+  }
+  set maxW(w) {
+    if (w === this.#maxW) return;
+    this.#maxW = w;
+    this.#layout = "Outdated";
+  }
+  get scale() {
+    return this.#scale;
+  }
+  set scale(scale) {
+    if (scale === this.#scale) return;
+    this.#scale = scale;
+    this.#layout = "Outdated";
+  }
+  get text() {
+    return this.#str;
+  }
+  set text(str) {
+    if (str === this.#str) return;
+    this.#str = str;
+    this.#layout = "Outdated";
+  }
+  update(v2) {
+    if (this.#layout === "Rendered") return;
+    if (this.#layout === "Outdated") this.layout(v2);
+    this.#layout = "Rendered";
+    return true;
+  }
+  get scaledLeading() {
+    return memProp5x6.leading * this.#scale;
+  }
+  get wh() {
+    return this.#wh;
+  }
+  get xy() {
+    return this.#xy;
+  }
+  set xy(xy) {
+    if (xyEq(xy, this.#xy)) return;
+    this.#xy.x = xy.x;
+    this.#xy.y = xy.y;
+    this.#layout = "Outdated";
+  }
+  get z() {
+    return this.#z;
+  }
+  set z(layer) {
+    if (layer === this.#z) return;
+    this.#z = layer;
+    this.#layout = "Outdated";
+  }
+};
+
+// src/ents/button-ent.ts
+var ButtonEnt = class {
+  #button;
+  #invalid = true;
+  #pressed;
+  #selected;
+  #started = false;
+  #toggle = false;
+  #text = new TextEnt();
+  #xy = { x: 0, y: 0 };
+  constructor(v2, opts) {
+    const buttonZ = opts.button.z ?? Layer.UID;
+    this.#button = new NinePatchEnt(v2, {
+      ...opts.button,
+      x: opts.x,
+      y: opts.y,
+      z: buttonZ,
+      wh: { w: opts.w, h: opts.h }
+    });
+    this.#pressed = {
+      sprite: v2.sprites.alloc(),
+      z: opts.pressed.z ?? layerOffset(buttonZ, 2)
+    };
+    this.#selected = {
+      sprite: v2.sprites.alloc(),
+      z: opts.selected.z ?? layerOffset(this.#pressed.z, -1)
+    };
+    this.#pressed.sprite.tag = opts.pressed.tag;
+    this.#pressed.sprite.x = opts.x ?? 0;
+    this.#pressed.sprite.y = opts.y ?? 0;
+    this.#pressed.sprite.w = opts.w ?? this.#button.wh.w;
+    this.#pressed.sprite.h = opts.h ?? this.#button.wh.h;
+    this.#pressed.sprite.z = Layer.Hidden;
+    this.#selected.sprite.tag = opts.selected.tag;
+    this.#selected.sprite.x = opts.x ?? 0;
+    this.#selected.sprite.y = opts.y ?? 0;
+    this.#selected.sprite.w = opts.w ?? this.#button.wh.w;
+    this.#selected.sprite.h = opts.h ?? this.#button.wh.h;
+    this.#selected.sprite.z = Layer.Hidden;
+    this.#text.text = opts.text?.text ?? "";
+    this.#text.scale = opts.text?.scale ?? 1;
+    this.#text.layout(v2);
+    this.#moveText(v2);
+    this.#text.maxW = opts.w ?? this.#button.wh.w;
+    this.#text.z = opts.text?.z ?? layerOffset(buttonZ, -1);
+    this.#toggle = opts.toggle ?? false;
+  }
+  get selected() {
+    return this.#selected.z !== Layer.Hidden;
+  }
+  free(v2) {
+    this.#button.free(v2);
+    this.#text.free(v2);
+    v2.sprites.free(this.#selected.sprite, this.#pressed.sprite);
+  }
+  get on() {
+    return this.#pressed.sprite.z !== Layer.Hidden;
+  }
+  // to-do: offStart() for pointer up listen? would need a boundary check too.
+  get onStart() {
+    return this.on && this.#started;
+  }
+  set text(str) {
+    this.#text.text = str;
+  }
+  update(v2) {
+    let invalid = this.#invalid;
+    if (this.#button.update()) invalid = true;
+    if (this.#text.update(v2)) invalid = true;
+    const hitsCursor = !v2.input.handled && !!v2.zoo.cursor?.hits(v2, this.#selected.sprite, "UI");
+    const clickStarted = hitsCursor && v2.input.isOnStart("Click") || v2.zoo.cursor?.keyboard && v2.input.isOnStart("A");
+    const on = clickStarted ? this.#toggle ? !this.on : true : this.#toggle ? this.on : v2.input.isOn("Click") || v2.zoo.cursor?.keyboard && v2.input.isOn("A");
+    this.#started = this.on !== on;
+    if (this.#started) {
+      this.#pressed.sprite.z = on ? this.#pressed.z : Layer.Hidden;
+      invalid = true;
+    }
+    if (hitsCursor && (v2.input.point?.click || v2.input.point?.type === "Mouse")) {
+      invalid ||= this.#selected.sprite.z !== this.#selected.z;
+      this.#selected.sprite.z = this.#selected.z;
+    } else {
+      invalid ||= this.#selected.z !== Layer.Hidden;
+      this.#selected.sprite.z = Layer.Hidden;
+    }
+    v2.input.handled ||= hitsCursor;
+    this.#invalid = false;
+    return invalid;
+  }
+  setXY(v2, xy) {
+    if (xyEq(xy, this.#xy)) return;
+    this.#xy.x = xy.x;
+    this.#xy.y = xy.y;
+    this.#button.xy = xy;
+    this.#moveText(v2);
+    this.#pressed.sprite.xy = xy;
+    this.#selected.sprite.xy = xy;
+    this.#invalid = true;
+  }
+  #moveText(v2) {
+    this.#text.layout(v2);
+    this.#text.xy = {
+      x: this.#button.xy.x + this.#button.wh.w / 2 - this.#text.wh.w / 2,
+      y: this.#button.xy.y + this.#button.wh.h / 2 - (this.#text.wh.h - this.#text.scaledLeading) / 2
+    };
+  }
+};
+
+// src/ents/cursor-ent.ts
+var CursorEnt = class {
+  keyboard = false;
+  #sprite;
+  constructor(v2, tag) {
+    this.#sprite = v2.sprites.alloc();
+    this.#sprite.tag = tag;
+    this.#sprite.z = Layer.Hidden;
+  }
+  free(v2) {
+    v2.sprites.free(this.#sprite);
+  }
+  hitbox(v2, coords) {
+    const lvl = coords === "Level";
+    const hitbox = this.#sprite.hitbox;
+    if (!hitbox) throw Error("cursor has no hitbox");
+    return {
+      x: (lvl ? v2.cam.x : 0) + hitbox.x,
+      y: (lvl ? v2.cam.y : 0) + hitbox.y,
+      w: hitbox.w,
+      h: hitbox.h
+    };
+  }
+  hits(v2, box, coords) {
+    return this.visible && boxHits(this.hitbox(v2, coords), box);
+  }
+  update(v2) {
+    if (v2.input.point?.invalid) {
+      this.#sprite.xy = v2.input.point.local;
+      this.#sprite.z = v2.input.point?.type === "Mouse" ? Layer.Top : Layer.Hidden;
+      return true;
+    }
+    if (this.keyboard && v2.input.isAnyOn("L", "R", "U", "D")) {
+      const epsilon = 1;
+      if (v2.input.isOn("L")) this.#sprite.x -= epsilon;
+      if (v2.input.isOn("R")) this.#sprite.x += epsilon;
+      if (v2.input.isOn("U")) this.#sprite.y -= epsilon;
+      if (v2.input.isOn("D")) this.#sprite.y += epsilon;
+      this.#sprite.z = Layer.Top;
+      return true;
+    }
+  }
+  get visible() {
+    return this.#sprite.z !== Layer.Hidden;
+  }
+};
+
+// src/ents/follow-cam-ent.ts
+var FollowCamEnt = class {
+  #fill;
+  #invalid = true;
+  #margin = { w: 0, h: 0 };
+  #modulo = { x: 0, y: 0 };
+  #pivot;
+  #sprite;
+  constructor(v2, tag, pivot) {
+    this.#sprite = v2.sprites.alloc();
+    this.#sprite.tag = tag;
+    this.#pivot = pivot;
+  }
+  get fill() {
+    return this.#fill;
+  }
+  set fill(fill) {
+    if (this.#fill === fill) return;
+    this.#fill = fill;
+    this.#invalid = true;
+  }
+  free(v2) {
+    v2.sprites.free(this.#sprite);
+  }
+  get h() {
+    return this.#sprite.h;
+  }
+  set h(h) {
+    if (this.#sprite.h === h) return;
+    this.#sprite.h = h;
+    this.#invalid = true;
+  }
+  get margin() {
+    return this.#margin;
+  }
+  set margin(margin) {
+    if (whEq(margin, this.#margin)) return;
+    whAssign(this.#margin, margin);
+    this.#invalid = true;
+  }
+  get modulo() {
+    return this.#modulo;
+  }
+  set modulo(modulo) {
+    if (xyEq(modulo, this.#modulo)) return;
+    xyAssign(this.#modulo, modulo);
+    this.#invalid = true;
+  }
+  get pivot() {
+    return this.#pivot;
+  }
+  set pivot(pivot) {
+    if (this.#pivot === pivot) return;
+    this.#pivot = pivot;
+    this.#invalid = true;
+  }
+  update(v2) {
+    if (!this.#invalid && !v2.cam.invalid) return;
+    const follow = v2.cam.follow(
+      { w: this.#sprite.w, h: this.#sprite.h },
+      this.#sprite.z,
+      this.#pivot,
+      { fill: this.#fill, modulo: this.#modulo, margin: this.#margin }
+    );
+    this.#sprite.x = follow.x;
+    this.#sprite.y = follow.y;
+    this.#invalid = false;
+    return true;
+  }
+  get w() {
+    return this.#sprite.w;
+  }
+  set w(w) {
+    if (this.#sprite.w === w) return;
+    this.#sprite.w = w;
+    this.#invalid = true;
+  }
+  get z() {
+    return this.#sprite.z;
+  }
+  set z(z) {
+    this.#sprite.z = z;
+  }
+};
+
+// src/ents/zoo.ts
+var Zoo = class {
+  #cursor;
+  #ents = /* @__PURE__ */ new Set();
+  add(...ents) {
+    for (const ent of ents) {
+      this.#ents.add(ent);
+      if (ent instanceof CursorEnt) this.#cursor = ent;
+    }
+  }
+  clear() {
+    this.#cursor = void 0;
+    this.#ents.clear();
+  }
+  get cursor() {
+    return this.#cursor;
+  }
+  remove(...ents) {
+    for (const ent of ents) {
+      this.#ents.delete(ent);
+      if (ent === this.#cursor) this.#cursor = void 0;
+    }
+  }
+  update(v2) {
+    let invalid = false;
+    for (const ent of this.#ents) if (ent.update?.(v2)) invalid = true;
+    return invalid;
+  }
+};
+
+// src/graphics/atlas.ts
+var animCels = 16;
+var animMillis = 1e3;
+var celMillis = animMillis / animCels;
+
+// src/graphics/atlas-parser.ts
+function parseAtlas(json) {
+  return {
+    anim: json.anim,
+    celXYWH: parseCelXYWH(json),
+    tags: Object.keys(json.anim)
+  };
+}
+function parseCelXYWH(json) {
+  const cels = [];
+  let i = 0;
+  for (const anim of Object.values(json.anim)) {
+    cels.push(...parseXYWH(anim, json.celXY, i));
+    i += anim.cels * 2;
+  }
+  return cels;
+}
+function parseXYWH(anim, celXY, i) {
+  const xywh = [];
+  for (let ii = 0; ii < animCels; ii++) {
+    const iii = i + 2 * (ii % anim.cels);
+    xywh.push(celXY[iii], celXY[iii + 1], anim.w, anim.h);
+  }
+  return xywh;
+}
+
+// src/graphics/cam.ts
+var Cam = class {
+  #h = 1;
+  #invalid = true;
+  #minScale = 1;
+  #minWH = { w: Infinity, h: Infinity };
+  #mode = "Int";
+  #scale = 1;
+  #w = 1;
+  #whClient = { w: 1, h: 1 };
+  #x = 0;
+  #y = 0;
+  #zoomOut = 0;
+  center(xy) {
+    this.x = Math.floor(xy.x - this.w / 2);
+    this.y = Math.floor(xy.y - this.h / 2);
+  }
+  /** position in fractional level coordinates. */
+  clientToXY(client) {
+    const local = this.clientToXYLocal(client);
+    return { x: this.#x + local.x, y: this.#y + local.y };
+  }
+  /**
+   * position relative canvas top-left in level scale (like level xy but no cam
+   * offset). often used for UI that is fixed within the cam.
+   */
+  clientToXYLocal(client) {
+    return {
+      x: client.x / this.#whClient.w * this.#w,
+      y: client.y / this.#whClient.h * this.#h
+    };
+  }
+  follow(wh, z, pivot, opts) {
+    const marginW = opts?.margin?.w ?? 0;
+    let x = z > Layer.UIG ? Math.trunc(this.x) : 0;
+    switch (pivot) {
+      case "SW":
+      case "W":
+      case "NW":
+        x += marginW;
+        break;
+      case "SE":
+      case "E":
+      case "NE":
+        x += this.w - (wh.w + marginW);
+        break;
+      case "N":
+      case "S":
+      case "Origin":
+        x += Math.trunc(this.w / 2) - Math.trunc(wh.w / 2);
+        break;
+    }
+    x -= x % ((opts?.modulo?.x ?? x) || 1);
+    const marginH = opts?.margin?.h ?? 0;
+    let y = z > Layer.UIG ? Math.trunc(this.y) : 0;
+    switch (pivot) {
+      case "N":
+      case "NE":
+      case "NW":
+        y += marginH;
+        break;
+      case "SE":
+      case "S":
+      case "SW":
+        y += this.h - (wh.h + marginH);
+        break;
+      case "E":
+      case "W":
+      case "Origin":
+        y += Math.trunc(this.h / 2) - Math.trunc(wh.h / 2);
+        break;
+    }
+    y -= y % ((opts?.modulo?.y ?? y) || 1);
+    const w = opts?.fill === "X" || opts?.fill === "XY" ? this.w - 2 * marginW : wh.w;
+    const h = opts?.fill === "Y" || opts?.fill === "XY" ? this.h - 2 * marginH : wh.h;
+    return { x, y, w, h };
+  }
+  /** positive int in level px. */
+  get h() {
+    return this.#h;
+  }
+  isVisible(box) {
+    return boxHits(this, box);
+  }
+  /** true if cam moved or resized since last update. */
+  get invalid() {
+    return this.#invalid;
+  }
+  /** positive int or fraction depending on mode. */
+  get minScale() {
+    return this.#minScale;
+  }
+  set minScale(scale) {
+    if (this.#scale === scale) return;
+    this.#scale = scale;
+    this.#invalidateWH();
+  }
+  /**
+   * positive int or infinite min dimensions. set to
+   * `{w: Infinity, h: Infinity}` to always use min scale.
+   */
+  get minWH() {
+    return this.#minWH;
+  }
+  set minWH(wh) {
+    if (this.#minWH.w === wh.w && this.#minWH.h === wh.h) return;
+    this.#minWH.w = wh.w;
+    this.#minWH.h = wh.h;
+    this.#invalidateWH();
+  }
+  get mode() {
+    return this.#mode;
+  }
+  set mode(mode) {
+    if (this.#mode === mode) return;
+    this.#mode = mode;
+    this.#invalidateWH();
+  }
+  get portrait() {
+    return this.h > this.w;
+  }
+  postupdate() {
+    this.#invalid = false;
+  }
+  /** positive int or fraction depending on mode. */
+  get scale() {
+    return this.#scale;
+  }
+  toString() {
+    return `Cam{(${this.x} ${this.y}) ${this.w}\xD7${this.h}}`;
+  }
+  /**
+   * call after input processing but before ent processing. ents that move the
+   * camera should be called immediately after update so that the invalid state
+   * can be considered.
+   */
+  update(canvas) {
+    if (!canvas.parentElement) throw Error("canvas has no parent");
+    const { clientWidth, clientHeight } = canvas.parentElement;
+    this.#invalid ||= this.#whClient.w !== clientWidth || this.#whClient.h !== clientHeight;
+    if (!this.#invalid) return;
+    this.#whClient.w = clientWidth;
+    this.#whClient.h = clientHeight;
+    this.#invalidateWH();
+    canvas.width = this.#w;
+    canvas.height = this.#h;
+    canvas.style.width = `${this.#w * this.#scale / devicePixelRatio}px`;
+    canvas.style.height = `${this.#h * this.#scale / devicePixelRatio}px`;
+  }
+  /** positive int in level px. */
+  get w() {
+    return this.#w;
+  }
+  /**
+   * positive int dimensions in client px of canvas (often
+   * `canvas.parentElement.clientWidth/Height` since the canvas is resized)
+   * which is assumed to be max WH.
+   */
+  get whClient() {
+    return this.#whClient;
+  }
+  /** fractional. */
+  get x() {
+    return this.#x;
+  }
+  set x(x) {
+    this.#invalid ||= this.x !== x;
+    this.#x = x;
+  }
+  /** fractional. */
+  get y() {
+    return this.#y;
+  }
+  set y(y) {
+    this.#invalid ||= this.y !== y;
+    this.#y = y;
+  }
+  /** nonnegative int or fraction depending on mode. */
+  get zoomOut() {
+    return this.#zoomOut;
+  }
+  set zoomOut(out) {
+    out = Math.max(0, out);
+    if (this.#zoomOut === out) return;
+    this.#zoomOut = out;
+    this.#invalidateWH();
+  }
+  #invalidateWH() {
+    this.#invalid = true;
+    const phy = {
+      w: this.#whClient.w * devicePixelRatio,
+      h: this.#whClient.h * devicePixelRatio
+    };
+    const scale = Math.max(
+      this.#minScale,
+      Math.min(phy.w / this.#minWH.w, phy.h / this.#minWH.h) - (this.#mode === "Int" ? Math.trunc(this.#zoomOut) : this.#zoomOut)
+    );
+    this.#scale = this.#mode === "Int" ? Math.trunc(scale) : scale;
+    this.#w = Math.ceil(phy.w / this.#scale);
+    this.#h = Math.ceil(phy.h / this.#scale);
+  }
+};
+
+// src/utils/math.ts
+function mod(dividend, divisor) {
+  return (dividend % divisor + divisor) % divisor;
+}
+
+// src/graphics/sprite.ts
+var drawableBytes = 12;
+var drawableEpsilon = 1 / 64;
+var drawableMaxWH = { w: 4095, h: 4095 };
+var Drawable = class {
+  i;
+  #pool;
+  constructor(pool, i) {
+    this.#pool = pool;
+    this.i = i;
+  }
+  above(draw) {
+    const compare = this.z === draw.z ? (draw.zend ? draw.y + draw.h : draw.y) - (this.zend ? this.y + this.h : this.y) : this.z - draw.z;
+    return compare < 0;
+  }
+  get cel() {
+    const iiic_cccc = this.#pool.view.getUint8(this.i + 10);
+    return iiic_cccc & 31;
+  }
+  /**
+   * [0, 31]. rendered cel offset. call reset() to play animation from start.
+   */
+  set cel(cel) {
+    const iiic_cccc = this.#pool.view.getUint8(this.i + 10);
+    this.#pool.view.setUint8(this.i + 10, iiic_cccc & ~31 | cel & 31);
+  }
+  /** test if render area overlaps box or sprite render area. */
+  clips(box) {
+    return boxHits(this, box);
+  }
+  get flipX() {
+    const sxyz_llll = this.#pool.view.getUint8(this.i + 6);
+    return !!(sxyz_llll & 64);
+  }
+  set flipX(flip) {
+    const sxyz_llll = this.#pool.view.getUint8(this.i + 6);
+    this.#pool.view.setUint8(this.i + 6, sxyz_llll & ~64 | -flip & 64);
+  }
+  get flipY() {
+    const sxyz_llll = this.#pool.view.getUint8(this.i + 6);
+    return !!(sxyz_llll & 32);
+  }
+  set flipY(flip) {
+    const sxyz_llll = this.#pool.view.getUint8(this.i + 6);
+    this.#pool.view.setUint8(this.i + 6, sxyz_llll & ~32 | -flip & 32);
+  }
+  get h() {
+    const h12_wwww = this.#pool.view.getUint16(this.i + 8, true);
+    return h12_wwww >>> 4;
+  }
+  /** [0, 4095]. */
+  set h(h) {
+    const h12_wwww = this.#pool.view.getUint16(this.i + 8, true);
+    this.#pool.view.setUint16(
+      this.i + 8,
+      h12_wwww & ~(4095 << 4) | (h & 4095) << 4,
+      true
+    );
+  }
+  get id() {
+    const i11_c5 = this.#pool.view.getUint16(this.i + 10, true);
+    return i11_c5 >>> 5 & 2047;
+  }
+  /** [0, 2047]. */
+  set id(id) {
+    const i11_c5 = this.#pool.view.getUint16(this.i + 10, true);
+    this.#pool.view.setUint16(
+      this.i + 10,
+      i11_c5 & ~(2047 << 5) | (id & 2047) << 5,
+      true
+    );
+  }
+  get stretch() {
+    const sxyz_llll = this.#pool.view.getUint8(this.i + 6);
+    return !!(sxyz_llll & 128);
+  }
+  /** wrap texture (default) or stretch to width and height. */
+  set stretch(stretch) {
+    const sxyz_llll = this.#pool.view.getUint8(this.i + 6);
+    this.#pool.view.setUint8(
+      this.i + 6,
+      sxyz_llll & ~128 | -stretch & 128
+    );
+  }
+  get w() {
+    const hhhh_w12 = this.#pool.view.getUint16(this.i + 7, true);
+    return hhhh_w12 & 4095;
+  }
+  /** [0, 4095]. */
+  set w(w) {
+    const hhhh_w12 = this.#pool.view.getUint16(this.i + 7, true);
+    this.#pool.view.setUint16(
+      this.i + 7,
+      hhhh_w12 & ~4095 | w & 4095,
+      true
+    );
+  }
+  get x() {
+    const y8_x24 = this.#pool.view.getUint32(this.i + 0, true);
+    return (y8_x24 << 8 >> 8) / 64;
+  }
+  /** [-131072, 131071.984375] with 1/64th (0.015625) granularity. */
+  set x(x) {
+    const y8_x24 = this.#pool.view.getUint32(this.i + 0, true);
+    this.#pool.view.setUint32(
+      this.i + 0,
+      y8_x24 & ~16777215 | x * 64 & 16777215,
+      true
+    );
+  }
+  get xy() {
+    return { x: this.x, y: this.y };
+  }
+  set xy(xy) {
+    this.x = xy.x;
+    this.y = xy.y;
+  }
+  get y() {
+    const sxyz_llll_y24 = this.#pool.view.getUint32(this.i + 3, true);
+    return (sxyz_llll_y24 << 8 >> 8) / 64;
+  }
+  /** [-131072, 131071.984375] with 1/64th (0.015625) granularity. */
+  set y(y) {
+    const sxyz_llll_y24 = this.#pool.view.getUint32(this.i + 3, true);
+    this.#pool.view.setUint32(
+      this.i + 3,
+      sxyz_llll_y24 & ~16777215 | y * 64 & 16777215,
+      true
+    );
+  }
+  get z() {
+    const sxyz_llll = this.#pool.view.getUint8(this.i + 6);
+    return sxyz_llll & 15;
+  }
+  /** layer [0 (closest), 14 (furthest)]; 15 is hidden. */
+  set z(z) {
+    const sxyz_llll = this.#pool.view.getUint8(this.i + 6);
+    this.#pool.view.setUint8(this.i + 6, sxyz_llll & ~15 | z & 15);
+  }
+  get zend() {
+    const sxyz_llll = this.#pool.view.getUint8(this.i + 6);
+    return !!(sxyz_llll & 16);
+  }
+  /** z-order by top (default) or bottom of box. */
+  set zend(end) {
+    const sxyz_llll = this.#pool.view.getUint8(this.i + 6);
+    this.#pool.view.setUint8(this.i + 6, sxyz_llll & ~16 | -end & 16);
+  }
+};
+var Sprite = class _Sprite extends Drawable {
+  #atlas;
+  #framer;
+  #hitbox;
+  #hurtbox;
+  constructor(pool, i, atlas, framer) {
+    super(pool, i);
+    this.#atlas = atlas;
+    this.#framer = framer;
+  }
+  get anim() {
+    return this.#atlas.anim[this.tag];
+  }
+  get flipX() {
+    return super.flipX;
+  }
+  set flipX(flip) {
+    if (this.flipX === flip) return;
+    super.flipX = flip;
+    this.#hitbox = void 0;
+    this.#hurtbox = void 0;
+  }
+  get flipY() {
+    return super.flipY;
+  }
+  set flipY(flip) {
+    if (this.flipY === flip) return;
+    super.flipY = flip;
+    this.#hitbox = void 0;
+    this.#hurtbox = void 0;
+  }
+  get h() {
+    return super.h;
+  }
+  set h(h) {
+    if (this.h === h) return;
+    super.h = h;
+    this.#hitbox = void 0;
+    this.#hurtbox = void 0;
+  }
+  get hitbox() {
+    if (this.#hitbox) return this.#hitbox;
+    const { hitbox } = this.anim;
+    if (!hitbox) return;
+    return this.#hitbox ??= {
+      x: this.x + (this.flipX ? this.w - hitbox.w - hitbox.x : hitbox.x),
+      y: this.y + (this.flipY ? this.h - hitbox.h - hitbox.y : hitbox.y),
+      w: hitbox.w,
+      h: hitbox.h
+    };
+  }
+  hits(box) {
+    const hitbox = this.hitbox;
+    if (!hitbox) return false;
+    const hurtbox = box instanceof _Sprite ? box.hurtbox : box;
+    return !!hurtbox && boxHits(hitbox, hurtbox);
+  }
+  get hurtbox() {
+    if (this.#hurtbox) return this.#hurtbox;
+    const { hurtbox } = this.anim;
+    if (!hurtbox) return;
+    return this.#hurtbox ??= {
+      x: this.x + (this.flipX ? this.w - hurtbox.w - hurtbox.x : hurtbox.x),
+      y: this.y + (this.flipY ? this.h - hurtbox.h - hurtbox.y : hurtbox.y),
+      w: hurtbox.w,
+      h: hurtbox.h
+    };
+  }
+  get id() {
+    return super.id;
+  }
+  set id(id) {
+    if (this.id === id) return;
+    super.id = id;
+    this.#hitbox = void 0;
+    this.#hurtbox = void 0;
+  }
+  /** true if animation has played once. */
+  get looped() {
+    return mod(this.#currentCel - this.cel, animCels * 2) >= this.anim.cels;
+  }
+  /** sets cel to animation start. */
+  reset() {
+    this.cel = this.#currentCel;
+  }
+  // to-do: unit test and catch up on unit tests elsewhere.
+  get tag() {
+    return this.#atlas.tags[this.id];
+  }
+  /** sets animation, resets cel, dimensions, hitbox, and hurtbox. */
+  set tag(tag) {
+    const anim = this.#atlas.anim[tag];
+    this.w = anim.w;
+    this.h = anim.h;
+    this.id = anim.id;
+    this.reset();
+  }
+  toString() {
+    return `Sprite{${this.tag} (${this.x} ${this.y} ${this.z}) ${this.w}\xD7${this.h}}`;
+  }
+  get w() {
+    return super.w;
+  }
+  set w(w) {
+    if (this.w === w) return;
+    super.w = w;
+    this.#hitbox = void 0;
+    this.#hurtbox = void 0;
+  }
+  get x() {
+    return super.x;
+  }
+  set x(x) {
+    if (this.x === x) return;
+    super.x = x;
+    this.#hitbox = void 0;
+    this.#hurtbox = void 0;
+  }
+  get y() {
+    return super.y;
+  }
+  set y(y) {
+    if (this.y === y) return;
+    super.y = y;
+    this.#hitbox = void 0;
+    this.#hurtbox = void 0;
+  }
+  /** current fractional cel in [0, 2 * anim.cels). */
+  get #currentCel() {
+    const cel = this.#framer.age / celMillis;
+    return cel % (this.anim.cels * 2);
+  }
+};
+
+// src/input/context-menu.ts
+var ContextMenu = class {
+  enable = false;
+  #target;
+  constructor(target) {
+    this.#target = target;
+  }
+  register(op) {
+    const fn = this.#target[`${op}EventListener`].bind(this.#target);
+    fn("contextmenu", this.#onContextMenu);
+    fn("touchstart", this.#onContextMenu, { passive: false });
+    return this;
+  }
+  [Symbol.dispose]() {
+    this.register("remove");
+  }
+  #onContextMenu = (ev) => {
+    if (!ev.isTrusted || ev.metaKey || ev.altKey || ev.ctrlKey) return;
+    if (!this.enable) ev.preventDefault();
+  };
+};
+
+// src/input/gamepad.ts
+var Gamepad = class {
+  bits = 0;
+  // to-do: support analog button values, expose connected status and vibration,
+  //        and distinct devices. would be nice if vibration could merge with
+  //        navigator.vibrate().
+  bitByAxis = {};
+  bitByButton = {};
+  onEvent = () => {
+  };
+  #target;
+  constructor(target) {
+    this.#target = target;
+  }
+  get connected() {
+    return isSecureContext && navigator.getGamepads().filter(Boolean).length > 0;
+  }
+  register(op) {
+    const fn = this.#target[`${op}EventListener`].bind(this.#target);
+    fn("gamepadconnected", this.onEvent);
+    fn("gamepaddisconnected", this.onEvent);
+    return this;
+  }
+  reset() {
+    this.bits = 0;
+  }
+  [Symbol.dispose]() {
+    this.register("remove");
+  }
+  update() {
+    if (!isSecureContext) return;
+    for (const pad of navigator.getGamepads()) {
+      for (const [index, axis] of pad?.axes.entries() ?? []) {
+        const lessMore = this.bitByAxis[index];
+        if (!lessMore) continue;
+        const bit = axis < 0 ? lessMore[0] : axis === 0 ? 0 : lessMore[1];
+        this.bits |= Math.abs(axis) >= 0.5 ? bit : 0;
+      }
+      for (const [index, btn] of pad?.buttons.entries() ?? []) {
+        const bit = this.bitByButton[index];
+        if (bit == null) continue;
+        this.bits |= btn.pressed ? bit : 0;
+      }
+    }
+  }
+};
+
+// src/input/keyboard.ts
+var Keyboard = class {
+  /** KeyboardEvent.code to bit. */
+  bitByCode = {};
+  invalid = false;
+  /** KeyboardEvent.code to state. Multiple keys may map to the same bit. */
+  onEvent = () => {
+  };
+  #on = {};
+  #target;
+  constructor(target) {
+    this.#target = target;
+  }
+  get bits() {
+    let bits = 0;
+    for (const k in this.bitByCode) bits |= this.#on[k] ? this.bitByCode[k] : 0;
+    return bits;
+  }
+  postupdate() {
+    this.invalid = false;
+  }
+  register(op) {
+    const fn = this.#target[`${op}EventListener`].bind(this.#target);
+    for (const ev of ["keydown", "keyup"]) fn(ev, this.#onKey);
+    return this;
+  }
+  reset() {
+    this.invalid = false;
+    this.#on = {};
+  }
+  [Symbol.dispose]() {
+    this.register("remove");
+  }
+  #onKey = (ev) => {
+    if (!ev.isTrusted || this.bitByCode[ev.code] == null) return;
+    if (ev.type === "keydown" && (ev.metaKey || ev.altKey || ev.ctrlKey)) return;
+    this.invalid = true;
+    this.#on[ev.code] = ev.type === "keydown";
+    ev.preventDefault();
+    this.onEvent();
+  };
+};
+
+// src/input/pointer.ts
+var pointTypeByPointerType = {
+  mouse: "Mouse",
+  pen: "Pen",
+  touch: "Touch"
+};
+var pointEvents = [
+  "pointercancel",
+  "pointerdown",
+  "pointermove",
+  "pointerup"
+];
+var Pointer = class {
+  bitByButton = {};
+  dragMinClient = 5;
+  invalid = false;
+  onEvent = () => {
+  };
+  /** primary may be on or off. */
+  primary;
+  /**
+   * secondaries are deleted when buttons are off. secondaries are only present
+   * when primary is defined.
+   */
+  secondary = {};
+  /** nonnegative. */
+  #pinchStartClient;
+  #target;
+  constructor(target) {
+    this.#target = target;
+  }
+  get boundsClient() {
+    if (!this.primary?.bits && !Object.keys(this.secondary).length) return;
+    let min = { x: Infinity, y: Infinity };
+    let max = { x: -Infinity, y: -Infinity };
+    for (const pt of [this.primary, ...Object.values(this.secondary)]) {
+      if (!pt?.bits) continue;
+      min = xyMin(min, pt.xyClient);
+      max = xyMax(max, pt.xyClient);
+    }
+    return { x: min.x, y: min.y, w: max.x - min.x, h: max.y - min.y };
+  }
+  get centerClient() {
+    const bounds = this.boundsClient;
+    if (!bounds) return this.primary?.xyClient;
+    return xyAdd(bounds, { x: bounds.w / 2, y: bounds.h / 2 });
+  }
+  get locked() {
+    return this.#target.ownerDocument.pointerLockElement === this.#target;
+  }
+  get pinchClient() {
+    if (!this.#pinchStartClient) return;
+    const end = this.#newPinchClient;
+    return end ? xySub(end, this.#pinchStartClient) : void 0;
+  }
+  postupdate() {
+    this.invalid = false;
+  }
+  register(op) {
+    const fn = this.#target[`${op}EventListener`].bind(this.#target);
+    for (const ev of pointEvents) fn(ev, this.#onInput);
+    return this;
+  }
+  reset() {
+    this.invalid = false;
+    this.primary = void 0;
+    for (const pt in this.secondary) delete this.secondary[pt];
+    this.#pinchStartClient = void 0;
+  }
+  update() {
+    const on = (this.primary?.bits ? 1 : 0) + Object.values(this.secondary).length;
+    if (on < 2 || !this.#pinchStartClient)
+      this.#pinchStartClient = this.#newPinchClient;
+  }
+  [Symbol.dispose]() {
+    this.register("remove");
+  }
+  #evButtonsToBits(btns) {
+    let bits = 0;
+    for (let btn = 1; btn <= btns; btn <<= 1)
+      if ((btn & btns) === btn) bits |= this.bitByButton[btn] ?? 0;
+    return bits;
+  }
+  #onInput = (ev) => {
+    if (!ev.isTrusted) return;
+    this.invalid = true;
+    const bits = ev.metaKey || ev.altKey || ev.ctrlKey ? 0 : this.#evButtonsToBits(ev.buttons);
+    if (bits) ev.preventDefault();
+    const locked = this.locked;
+    if (ev.type === "pointerdown" && !locked)
+      try {
+        this.#target.setPointerCapture(ev.pointerId);
+      } catch {
+      }
+    const prevPt = ev.isPrimary ? this.primary : this.secondary[ev.pointerId];
+    let xyClient;
+    if (locked) {
+      const scale = 1 / devicePixelRatio;
+      xyClient = {
+        x: Math.min(
+          Math.max(
+            0,
+            (prevPt?.xyClient.x ?? ev.offsetX) + ev.movementX * scale
+          ),
+          this.#target.clientWidth
+        ),
+        y: Math.min(
+          Math.max(
+            0,
+            (prevPt?.xyClient.y ?? ev.offsetY) + ev.movementY * scale
+          ),
+          this.#target.clientHeight
+        )
+      };
+    } else xyClient = { x: ev.offsetX, y: ev.offsetY };
+    const evType = ev.type;
+    const type = pointTypeByPointerType[ev.pointerType];
+    let clickClient;
+    if (ev.type === "pointerdown") clickClient = { x: xyClient.x, y: xyClient.y };
+    else if (ev.type === "pointermove") clickClient = prevPt?.clickClient;
+    const drag = !!bits && (prevPt?.drag || !!clickClient && xyDistance(clickClient, xyClient) >= this.dragMinClient);
+    const pt = {
+      clickClient,
+      bits,
+      drag,
+      ev: evType,
+      id: ev.pointerId,
+      primary: ev.isPrimary,
+      type,
+      xyClient
+    };
+    if (ev.isPrimary) this.primary = pt;
+    else if (!bits) delete this.secondary[ev.pointerId];
+    else this.secondary[ev.pointerId] = pt;
+    this.onEvent();
+  };
+  get #newPinchClient() {
+    if ((this.primary?.bits ? 1 : 0) + Object.values(this.secondary).length < 2)
+      return;
+    const bounds = this.boundsClient;
+    return bounds ? { x: bounds.w, y: bounds.h } : void 0;
+  }
+};
+
+// src/input/wheel.ts
+var Wheel = class {
+  deltaClient;
+  onEvent = () => {
+  };
+  #target;
+  constructor(target) {
+    this.#target = target;
+  }
+  postupdate() {
+    this.deltaClient = void 0;
+  }
+  register(op) {
+    const fn = this.#target[`${op}EventListener`].bind(this.#target);
+    fn("wheel", this.#onInput, { passive: true });
+    return this;
+  }
+  reset() {
+    this.deltaClient = void 0;
+  }
+  [Symbol.dispose]() {
+    this.register("remove");
+  }
+  #onInput = (ev) => {
+    if (!ev.isTrusted || ev.metaKey || ev.altKey || ev.ctrlKey) return;
+    this.deltaClient = { x: ev.deltaX, y: ev.deltaY, z: ev.deltaZ };
+    this.onEvent();
+  };
+};
+
+// src/input/input.ts
+var Input = class {
+  /** time allowed between combo inputs. */
+  comboMaxIntervalMillis = 300;
+  /**
+   * true if any button, key, or click was _ever_ on. doesn't consider handled.
+   */
+  gestured = false;
+  /** clear buttonish inputs for rest of frame. */
+  handled = false;
+  /** true if _any_ input has changed since previous update. */
+  invalid = false;
+  /**
+   * minimum duration for an input to be considered held. durations are
+   * calculated at frame boundaries, not on actual press. devices are treated
+   * strictly as polled aggregates.
+   */
+  minHeldMillis = 300;
+  #bitByButton = {};
+  #buttonByBit = {};
+  #bits = 0;
+  #cam;
+  /**
+   * sequence of nonzero bits ordered from oldest to latest. combos end only by
+   * expiration.
+   */
+  #combo = [];
+  #contextMenu;
+  #gamepad;
+  /** time since buttons changed. */
+  #heldMillis = 0;
+  #keyboard;
+  #pointer;
+  #pointerState;
+  /** bits last update. may not be equal to `#combo.at(-1)`. */
+  #prevBits = 0;
+  #wheel;
+  #wheelState;
+  constructor(cam, target) {
+    this.#cam = cam;
+    this.#contextMenu = new ContextMenu(target);
+    this.#gamepad = new Gamepad(globalThis);
+    this.#keyboard = new Keyboard(target.ownerDocument);
+    this.#pointer = new Pointer(target);
+    this.#wheel = new Wheel(target);
+  }
+  get anyOn() {
+    return this.#bits !== 0;
+  }
+  /** for debugging. */
+  get combo() {
+    const chords = [];
+    for (const bits of this.#combo) {
+      const chord = [];
+      for (let bit = 1; bit <= bits; bit <<= 1) {
+        if ((bit & bits) === bit && this.#buttonByBit[bit])
+          chord.push(this.#buttonByBit[bit]);
+      }
+      chord.sort();
+      chords.push(chord);
+    }
+    return chords;
+  }
+  /**
+   * enable when game is paused or in photo mode to allow right clicks and long
+   * presses to save canvas.
+   */
+  get contextMenu() {
+    return this.#contextMenu;
+  }
+  /** doesn't consider handled. gamepads must be polled. */
+  get gamepad() {
+    return this.#gamepad.connected ? {} : void 0;
+  }
+  /** true if bits hasn't changed for a while. */
+  get held() {
+    return !this.handled && this.#heldMillis >= this.minHeldMillis;
+  }
+  isAnyOn(...btns) {
+    return !this.handled && !!(this.#bits & this.#mapBits(btns));
+  }
+  isAnyOnStart(...btns) {
+    return this.started && this.isAnyOn(...btns);
+  }
+  /**
+   * buttons are exact. eg, up won't match up AND down like `isOn('U')` will.
+   * combo is exact too. `['A'], ['A']` will match `['A'], ['A']` but not
+   * `['A'], ['A'], ['A']`.
+   */
+  isCombo(...combo) {
+    return combo.length === this.#combo.length && this.isComboEndsWith(...combo);
+  }
+  /**
+   * `['A'], ['A']` will match `['A'], ['A']` and `['B'], ['A'], ['A']`. eg,
+   * double-clicks often don't care about any preceding buttons.
+   */
+  isComboEndsWith(...combo) {
+    for (const [i, btns] of combo.entries()) {
+      const bits = this.#mapBits(btns);
+      if (this.#combo.at(-combo.length + i) !== bits) return false;
+    }
+    return !this.handled && (this.#combo.at(-1) === this.#bits || !this.#bits);
+  }
+  /** like isComboEndsWith() but test if the last button is triggered. */
+  isComboEndsWithStart(...combo) {
+    return this.isOnStart(...combo.at(-1)) && this.isComboEndsWith(...combo);
+  }
+  /** like isCombo() but test if the last button is triggered. */
+  isComboStart(...combo) {
+    return this.isOnStart(...combo.at(-1)) && this.isCombo(...combo);
+  }
+  /*:
+   * true if any button in chord is not on. this is usually what's wanted. eg:
+   * ```ts
+   * if (isOn('A', 'B')) console.log('on')
+   * if (isOff('A', 'B')) console.log('not A+B; A and/or B is off')
+   * ```
+   */
+  isOff(...btns) {
+    return !this.handled && !this.isOn(...btns);
+  }
+  isOffStart(...btns) {
+    const bits = this.#mapBits(btns);
+    const wasOn = (this.#prevBits & bits) === bits;
+    return wasOn && this.started && this.isOff(...btns);
+  }
+  /**
+   * true if all buttons are on inclusively. eg, `isOn('U')` is true when up is
+   * pressed or when up and down are pressed.
+   */
+  isOn(...btns) {
+    const bits = this.#mapBits(btns);
+    return !this.handled && (this.#bits & bits) === bits;
+  }
+  isOnStart(...btns) {
+    return this.started && this.isOn(...btns);
+  }
+  get key() {
+    return { invalid: this.#keyboard.invalid };
+  }
+  mapDefault() {
+    const input = this;
+    input.mapKeyboardCode("L", "ArrowLeft");
+    input.mapKeyboardCode("R", "ArrowRight");
+    input.mapKeyboardCode("U", "ArrowUp");
+    input.mapKeyboardCode("D", "ArrowDown");
+    input.mapKeyboardCode("C", "KeyC");
+    input.mapKeyboardCode("A", "KeyX");
+    input.mapKeyboardCode("B", "KeyZ");
+    input.mapKeyboardCode("Menu", "Enter");
+    input.mapKeyboardCode("Back", "Escape");
+    input.mapGamepadAxis("L", "R", 0, 2);
+    input.mapGamepadAxis("U", "D", 1, 3);
+    input.mapGamepadButton("L", 14);
+    input.mapGamepadButton("R", 15);
+    input.mapGamepadButton("U", 12);
+    input.mapGamepadButton("D", 13);
+    input.mapGamepadButton("C", 2);
+    input.mapGamepadButton("B", 0);
+    input.mapGamepadButton("A", 1);
+    input.mapGamepadButton("Menu", 9);
+    input.mapGamepadButton("Back", 8);
+    input.mapPointerClick("Click", 1);
+    input.mapPointerClick("Click2", 2);
+    input.mapPointerClick("ClickMiddle", 4);
+    return input;
+  }
+  // to-do: support analog values.
+  mapGamepadAxis(less, more, ...axes) {
+    for (const axis of axes) {
+      this.#gamepad.bitByAxis[axis] = [
+        this.#mapButton(less),
+        this.#mapButton(more)
+      ];
+    }
+  }
+  mapGamepadButton(btn, ...indices) {
+    for (const index of indices)
+      this.#gamepad.bitByButton[index] = this.#mapButton(btn);
+  }
+  /** @arg codes union of KeyboardEvent.code. */
+  mapKeyboardCode(btn, ...codes) {
+    for (const code of codes)
+      this.#keyboard.bitByCode[code] = this.#mapButton(btn);
+  }
+  mapPointerClick(btn, ...clicks) {
+    for (const click of clicks)
+      this.#pointer.bitByButton[click] = this.#mapButton(btn);
+  }
+  get on() {
+    const on = [];
+    for (const btn in this.#bitByButton) if (this.isOn(btn)) on.push(btn);
+    return on.sort();
+  }
+  set onEvent(cb) {
+    this.#gamepad.onEvent = cb;
+    this.#keyboard.onEvent = cb;
+    this.#pointer.onEvent = cb;
+    this.#wheel.onEvent = cb;
+  }
+  /** doesn't consider handled. */
+  get point() {
+    return this.#pointerState;
+  }
+  get pointer() {
+    return this.#pointer;
+  }
+  register(op) {
+    globalThis[`${op}EventListener`]("blur", this.reset);
+    this.#contextMenu.register(op);
+    this.#gamepad.register(op);
+    this.#keyboard.register(op);
+    this.#pointer.register(op);
+    this.#wheel.register(op);
+    return this;
+  }
+  reset = () => {
+    this.#bits = 0;
+    this.#prevBits = 0;
+    this.handled = false;
+    this.#heldMillis = 0;
+    this.#combo.length = 0;
+    this.#gamepad.reset();
+    this.#keyboard.reset();
+    this.#pointer.reset();
+    this.#pointerState = void 0;
+    this.#wheel.reset();
+    this.#wheelState = void 0;
+  };
+  /** true if bits has changed. */
+  get started() {
+    return !this.handled && this.#bits !== this.#prevBits;
+  }
+  /**
+   * call on new frame before altering cam. dispatches always occur before an
+   * update.
+   * @arg millis duration since last update.
+   */
+  update(millis) {
+    this.handled = false;
+    this.#gamepad.update();
+    this.#pointer.update();
+    this.#prevBits = this.#bits;
+    this.#bits = this.#gamepad.bits | this.#keyboard.bits | (this.#pointer.primary?.bits ?? 0);
+    this.invalid = this.#bits !== this.#prevBits || this.#pointer.invalid || !!this.#wheel.deltaClient;
+    this.gestured ||= !!this.#bits;
+    if (millis > this.comboMaxIntervalMillis && this.#bits !== this.#prevBits || this.#heldMillis + millis > this.comboMaxIntervalMillis && !this.#bits)
+      this.#combo.length = 0;
+    if (this.#bits === this.#prevBits)
+      this.#heldMillis = this.#heldMillis + millis;
+    else this.#heldMillis = millis;
+    if (this.#bits && this.#bits !== this.#prevBits) {
+      if (this.#prevBits) this.#combo.length = 0;
+      this.#combo.push(this.#bits);
+    }
+    if (this.#pointer.primary) {
+      const pinchClient = this.#pointer.pinchClient;
+      const dragOn = this.#pointer.primary.drag && !Object.values(this.#pointer.secondary).length;
+      const secondary = [];
+      for (const pt of Object.values(this.#pointer.secondary)) {
+        secondary.push({
+          type: pt.type,
+          click: pt.clickClient ? {
+            client: pt.clickClient,
+            local: this.#cam.clientToXYLocal(pt.clickClient),
+            ...this.#cam.clientToXY(pt.clickClient)
+          } : void 0,
+          ...this.#cam.clientToXY(pt.xyClient),
+          client: pt.xyClient,
+          local: this.#cam.clientToXYLocal(pt.xyClient)
+        });
+      }
+      const centerClient = this.#pointer.centerClient;
+      const center = {
+        client: centerClient,
+        local: this.#cam.clientToXYLocal(centerClient),
+        ...this.#cam.clientToXY(centerClient)
+      };
+      this.#pointerState = {
+        center,
+        click: this.#pointer.primary.clickClient ? {
+          client: this.#pointer.primary.clickClient,
+          local: this.#cam.clientToXYLocal(
+            this.#pointer.primary.clickClient
+          ),
+          ...this.#cam.clientToXY(this.#pointer.primary.clickClient)
+        } : void 0,
+        drag: {
+          on: dragOn,
+          start: !this.#pointerState?.drag.on && dragOn,
+          end: !!this.#pointerState?.drag.on && !dragOn
+        },
+        invalid: this.#pointer.invalid,
+        pinch: pinchClient ? { client: pinchClient, xy: this.#cam.clientToXY(pinchClient) } : void 0,
+        secondary,
+        type: this.#pointer.primary.type,
+        ...this.#cam.clientToXY(this.#pointer.primary.xyClient),
+        client: this.#pointer.primary.xyClient,
+        local: this.#cam.clientToXYLocal(this.#pointer.primary.xyClient)
+      };
+    } else this.#pointerState = void 0;
+    this.#wheelState = this.#wheel.deltaClient ? {
+      delta: {
+        client: this.#wheel.deltaClient,
+        xy: this.#cam.clientToXY(this.#wheel.deltaClient)
+      }
+    } : void 0;
+    this.#keyboard.postupdate();
+    this.#pointer.postupdate();
+    this.#wheel.postupdate();
+  }
+  [Symbol.dispose]() {
+    this.register("remove");
+  }
+  /** doesn't consider handled. */
+  get wheel() {
+    return this.#wheelState;
+  }
+  /** get bits for buttons. */
+  #mapBits(btns) {
+    let bits = 0;
+    for (const btn of btns) bits |= this.#bitByButton[btn] ?? 0;
+    return bits;
+  }
+  /** assign button to bit. */
+  #mapButton(btn) {
+    const bit = this.#bitByButton[btn] ??= 1 << Object.keys(this.#bitByButton).length;
+    this.#buttonByBit[bit] = btn;
+    return bit;
+  }
+};
+
+// src/utils/debug.ts
+var debug = Debug(
+  globalThis.location?.href
+);
+function Debug(url) {
+  if (!url) return;
+  const csv = [...new URL(url).searchParams].find(
+    ([k]) => k.toLowerCase() === "debug"
+  )?.[1];
+  if (csv == null) return;
+  const map = Object.fromEntries(
+    csv.split(",").filter(Boolean).map((kv) => kv.split("="))
+    // split each pair.
+  );
+  const target = {};
+  for (const k in map) target[k.toLowerCase()] = map[k] || "true";
+  const voidKeyset = {
+    cam: void 0,
+    input: void 0,
+    mem: void 0,
+    render: void 0
+  };
+  return new Proxy(target, {
+    get(target2, k) {
+      if (typeof k !== "string") return target2[k];
+      k = k.toLowerCase();
+      return !csv || "all" in map || k in voidKeyset && "void" in map ? target2[k] || "true" : target2[k];
+    }
+  });
+}
+
+// src/mem/pool.ts
+var Pool = class {
+  /** the next free block is always at size. */
+  #blocks;
+  #opts;
+  #size = 0;
+  #u8;
+  #view;
+  constructor(opts) {
+    if (opts.allocBytes <= 0) throw Error("byte allocation must be > 0");
+    if (opts.pageBlocks <= 0) throw Error("page blocks must be > 0");
+    this.#opts = { ...opts, minPages: opts.minPages ?? 1 };
+    const initSize = this.#opts.minPages * opts.pageBlocks;
+    this.#blocks = new Array(initSize);
+    this.#u8 = new Uint8Array();
+    this.#resize(initSize, "Init");
+  }
+  alloc() {
+    if (this.#size >= this.#currentCapacity)
+      this.#resize(this.#currentCapacity + this.#opts.pageBlocks, "Call");
+    const block = this.#blocks[this.#size];
+    block.i = this.#size * this.#opts.allocBytes;
+    this.#size++;
+    return block;
+  }
+  clear() {
+    this.#size = 0;
+    const minCapacity = this.#opts.minPages * this.#opts.pageBlocks;
+    if (this.#currentCapacity > minCapacity) this.#resize(minCapacity, "Call");
+  }
+  free(...blocks) {
+    for (const block of blocks) this.#freeBlock(block);
+  }
+  get size() {
+    return this.#size;
+  }
+  get view() {
+    return this.#view;
+  }
+  toDebugString() {
+    let str = "";
+    for (let i = 0; i < this.#u8.buffer.byteLength; i++) {
+      if (i && !(i % this.#opts.allocBytes)) str += " ";
+      str += this.#u8[i].toString(16).padStart(2, "0");
+    }
+    return str;
+  }
+  get #currentCapacity() {
+    return this.#u8.buffer.byteLength / this.#opts.allocBytes;
+  }
+  #freeBlock(block) {
+    if (!this.#size) throw Error("pool underflow");
+    this.#size--;
+    const start = this.#size * this.#opts.allocBytes;
+    this.#u8.copyWithin(block.i, start, start + this.#opts.allocBytes);
+    this.#blocks[this.#size].i = block.i;
+    [this.#blocks[block.i], this.#blocks[this.#size]] = [
+      this.#blocks[this.#size],
+      this.#blocks[block.i]
+    ];
+    const free = Math.floor(
+      (this.#currentCapacity - this.#size) / this.#opts.pageBlocks
+    );
+    if (free && this.#currentCapacity / this.#opts.pageBlocks - free >= this.#opts.minPages)
+      this.#resize(this.#currentCapacity - free * this.#opts.pageBlocks, "Call");
+  }
+  #resize(capacity, origin) {
+    if (origin === "Call" && debug?.mem)
+      console.debug(
+        `[mem] ${capacity < this.#currentCapacity ? "shrinking" : "growing"} pool to ${capacity}`
+      );
+    this.#blocks.length = capacity;
+    for (let i = this.#currentCapacity; i < capacity; i++)
+      this.#blocks[i] = this.#opts.alloc(this);
+    const buffer = new ArrayBuffer(capacity * this.#opts.allocBytes);
+    const u8 = new Uint8Array(buffer);
+    u8.set(this.#u8.subarray(0, capacity * this.#opts.allocBytes));
+    this.#u8 = u8;
+    this.#view = new DataView(buffer);
+  }
+};
+
+// src/utils/color-util.ts
+function rgbaHex(rgba) {
+  return `#${rgba.toString(16).padStart(8, "0")}`;
+}
+
+// src/utils/dom-util.ts
+function initMetaViewport() {
+  if (document.querySelector('meta[name="viewport"]')) return;
+  const meta = document.createElement("meta");
+  meta.name = "viewport";
+  meta.content = "width=device-width, maximum-scale=1, minimum-scale=1, user-scalable=no";
+  document.head.appendChild(meta);
+}
+function initBody(canvas, rgba) {
+  if (canvas.parentNode !== document.body) return;
+  document.body.style.margin = "0";
+  document.body.style.width = "100dvw";
+  document.body.style.height = "100dvh";
+  document.body.style.overflow = "hidden";
+  document.body.style.background = rgbaHex(rgba);
+}
+
+// src/utils/canvas-util.ts
+function initCanvas(canvas, mode) {
+  canvas ??= document.createElement("canvas");
+  canvas.width = 0;
+  canvas.style.cursor = "none";
+  canvas.style.display = "block";
+  canvas.style.outline = "none";
+  canvas.style.cursor = "none";
+  if (mode === "Int") canvas.style.imageRendering = "pixelated";
+  canvas.style.touchAction = "none";
+  canvas.tabIndex = 0;
+  canvas.focus();
+  if (!canvas.parentNode) document.body.append(canvas);
+  return canvas;
+}
+
+// src/utils/fetch-util.ts
+async function loadImage(img) {
+  const promise = new Promise((fulfil, reject) => {
+    img.onload = () => fulfil(img);
+    img.onerror = () => reject(Error(`image load error for ${img.src}`));
+  });
+  return img.complete ? img : await promise;
+}
+
+// src/graphics/gl.ts
+function Shader(gl, vertGLSL, fragGLSL, textures) {
+  const program = loadProgram(gl, vertGLSL, fragGLSL);
+  gl.useProgram(program);
+  return {
+    buffer: gl.createBuffer(),
+    program,
+    textures,
+    uniform: GLUniformMap(gl, program),
+    vao: gl.createVertexArray()
+  };
+}
+function GLUniformMap(gl, pgm) {
+  const len = pgm ? gl.getProgramParameter(pgm, gl.ACTIVE_UNIFORMS) : 0;
+  const map = debug?.render ? new Proxy(
+    {},
+    {
+      get(target, k) {
+        if (target[k] == null) throw Error(`no shader uniform "${k}"`);
+        return target[k];
+      }
+    }
+  ) : {};
+  for (let i = 0; i < len; ++i) {
+    const uniform = gl.getActiveUniform(pgm, i);
+    if (!uniform) throw Error(`no shader uniform at index ${i}`);
+    const location = gl.getUniformLocation(pgm, uniform.name);
+    if (!location) throw Error(`no shader uniform "${uniform.name}"`);
+    const name = uniform.name.replace("[0]", "");
+    map[name] = location;
+  }
+  return map;
+}
+function loadProgram(gl, vertGLSL, fragGLSL) {
+  const pgm = gl.createProgram();
+  if (!pgm) return null;
+  const vert = compileShader(gl, "VERTEX_SHADER", vertGLSL);
+  const frag = compileShader(gl, "FRAGMENT_SHADER", fragGLSL);
+  if (!vert || !frag) return null;
+  gl.attachShader(pgm, vert);
+  gl.attachShader(pgm, frag);
+  gl.linkProgram(pgm);
+  if (debug?.render && !gl.getProgramParameter(pgm, gl.LINK_STATUS)) {
+    const log = gl.getProgramInfoLog(pgm)?.slice(0, -1);
+    throw Error(`shader link failure; ${log}`);
+  }
+  gl.detachShader(pgm, frag);
+  gl.detachShader(pgm, vert);
+  gl.deleteShader(frag);
+  gl.deleteShader(vert);
+  return pgm;
+}
+function compileShader(gl, type, glsl) {
+  const shader = gl.createShader(gl[type]);
+  if (!shader) return shader;
+  gl.shaderSource(shader, glsl.trim());
+  gl.compileShader(shader);
+  if (debug?.render && !gl.getShaderParameter(shader, gl.COMPILE_STATUS)) {
+    const log = gl.getShaderInfoLog(shader)?.slice(0, -1);
+    throw Error(`shader compile failure; ${log}`);
+  }
+  return shader;
+}
+
+// src/graphics/sprite-frag.glsl.ts
+var spriteFragGLSL = `#version 300 es
+#pragma debug(${debug?.render ? "on" : "off"})   
+#pragma optimize(${debug?.render ? "off" : "on"})
+
+precision highp int;
+precision highp float;
+precision highp usampler2D;
+
+uniform sampler2D uTex;
+uniform uvec2 uTexWH;
+
+flat in uint vStretch;
+flat in ivec4 vTexXYWH;
+flat in int vZ;
+in vec2 vDstWH;
+flat in ivec2 vDstWHFixed;
+
+out vec4 oRGBA;
+
+void main() {
+  if (vZ == ${Layer.Hidden} || vDstWHFixed.x == 0 || vDstWHFixed.y == 0)
+    discard;
+
+  vec2 px = vec2(vTexXYWH.xy) + (
+    vStretch == 1u ? (vDstWH * vec2(vTexXYWH.zw) / vec2(vDstWHFixed))
+                   : mod(vDstWH, vec2(vTexXYWH.zw))
+  );
+
+  oRGBA = texture(uTex, px / vec2(uTexWH));
+  if(oRGBA.a < .001) discard;
+}
+`;
+
+// src/graphics/sprite-vert.glsl.ts
+var spriteVertGLSL = `#version 300 es
+#pragma debug(${debug?.render ? "on" : "off"})   
+#pragma optimize(${debug?.render ? "off" : "on"})
+
+// https://developer.mozilla.org/en-US/docs/Web/API/WebGL_API/WebGL_best_practices#essl300_minimum_requirements_webgl_2
+precision highp int;
+precision highp float;
+precision highp usampler2D;
+
+uniform ivec4 uCam;
+uniform usampler2D uCels;
+uniform float uAge;
+
+layout (location=0) in ivec2 iUV;
+layout (location=1) in uint iy8_x24;
+layout (location=2) in uint iw8_sxyz_llll_y16;
+layout (location=3) in uint ii11_c5_h12_w4;
+
+const int maxY = 0x20000;
+const int layers = 16;
+const int maxDepth = maxY * layers;
+
+flat out uint vStretch;
+flat out ivec4 vTexXYWH;
+flat out int vZ;
+out vec2 vDstWH;
+flat out ivec2 vDstWHFixed;
+
+void main() {
+  int x = (int((iy8_x24 & 0xffffffu) << 8) >> 8) / 64;
+  int y = (int(iy8_x24 >> 24) | (int(iw8_sxyz_llll_y16 & 0xffffu) << 16 >> 8)) / 64;
+  int z = int((iw8_sxyz_llll_y16 >> 16) & 0xfu);
+  bool zend = bool(iw8_sxyz_llll_y16 & 0x100000u);
+  bool flipY = bool(iw8_sxyz_llll_y16 & 0x200000u);
+  bool flipX = bool(iw8_sxyz_llll_y16 & 0x400000u);
+  bool stretch = bool(iw8_sxyz_llll_y16 & 0x800000u);
+  int id = int((ii11_c5_h12_w4 >> 17) & 0x7ff0u); // ignore cel.
+  int cel = int((ii11_c5_h12_w4 >> 16) & 0xfu); // ignore the MSB.
+  int w = int(((ii11_c5_h12_w4 & 0xfu) << 8) | (iw8_sxyz_llll_y16 >> 24));
+  int h = int((ii11_c5_h12_w4 >> 4) & 0xfffu);
+
+  // https://www.patternsgameprog.com/opengl-2d-facade-25-get-the-z-of-a-pixel
+  float depth = float((z + 1) * maxY - (y + (zend ? 0 : h))) / float(maxDepth);
+
+  ivec2 targetWH = iUV * ivec2(w, h);
+
+  vec2 end = vec2(x + targetWH.x, y + targetWH.y);
+  // UI layers are always given in screen coordinates.
+  // to-do: how to handle non-int mode?
+  vec2 camXY = z < ${Layer.A} ? vec2(0, 0) : vec2(uCam.xy);
+  vec2 clip = ((-2. * camXY  + 2. * end) / vec2(uCam.zw) - 1.) * vec2(1, -1);
+  gl_Position = vec4(clip, depth, 1);
+
+  int frame = (((int(uAge / ${celMillis}) & 0x1f) - cel) + ${animCels}) & 0xf;
+  uvec4 texXYWH = texelFetch(uCels, ivec2(0, id + frame), 0);
+  vTexXYWH = ivec4(texXYWH);
+  vZ = z;
+
+  vDstWH = vec2(targetWH * ivec2(flipX ? -1 : 1, flipY ? -1 : 1));
+  vDstWHFixed = ivec2(w, h) * ivec2(flipX ? -1 : 1, flipY ? -1 : 1);
+
+  vStretch = stretch ? 1u : 0u;
+}
+`;
+
+// src/graphics/renderer.ts
+var uv = new Int8Array([1, 1, 0, 1, 1, 0, 0, 0]);
+var Renderer = class {
+  /** when off, ents should avoid requesting renders. */
+  always = false;
+  invalid = false;
+  loseContext;
+  #canvas;
+  #clearRGBA = 0;
+  #ctx;
+  #preloadAtlas;
+  #preloadAtlasImage;
+  constructor(preloadAtlas, canvas) {
+    this.#preloadAtlas = preloadAtlas;
+    this.#canvas = canvas;
+    this.#ctx = this.#Context();
+  }
+  clear(rgba) {
+    if (!this.#ctx) return;
+    const { gl } = this.#ctx;
+    if (this.#clearRGBA !== rgba) {
+      this.#clearRGBA = rgba;
+      gl.clearColor(
+        (rgba >>> 24 & 255) / 255,
+        (rgba >>> 16 & 255) / 255,
+        (rgba >>> 8 & 255) / 255,
+        (rgba >>> 0 & 255) / 255
+      );
+    }
+    gl.clear(gl.COLOR_BUFFER_BIT | gl.DEPTH_BUFFER_BIT);
+  }
+  draw(pool) {
+    if (!this.#preloadAtlasImage || !this.#ctx) return;
+    const { gl, spriteShader } = this.#ctx;
+    gl.bindBuffer(gl.ARRAY_BUFFER, spriteShader.buffer);
+    gl.bufferData(
+      gl.ARRAY_BUFFER,
+      pool.view,
+      gl.DYNAMIC_DRAW,
+      0,
+      pool.size * drawableBytes
+    );
+    gl.bindBuffer(gl.ARRAY_BUFFER, null);
+    gl.bindVertexArray(spriteShader.vao);
+    gl.drawArraysInstanced(
+      gl.TRIANGLE_STRIP,
+      0,
+      uv.length / 2,
+      // d
+      pool.size
+    );
+    gl.bindVertexArray(null);
+    this.invalid = false;
+  }
+  load(preloadAtlas) {
+    this.#preloadAtlasImage = preloadAtlas;
+    this.#ctx = this.#Context();
+  }
+  predraw(cam, framer) {
+    if (!this.#ctx) return;
+    const { gl, spriteShader, viewport } = this.#ctx;
+    if (!whEq(viewport, cam)) {
+      gl.viewport(0, 0, cam.w, cam.h);
+      viewport.w = cam.w;
+      viewport.h = cam.h;
+    }
+    gl.useProgram(spriteShader.program);
+    gl.uniform4i(spriteShader.uniform.uCam, cam.x, cam.y, cam.w, cam.h);
+    gl.uniform1f(spriteShader.uniform.uAge, framer.age);
+    for (const [i, tex] of spriteShader.textures.entries()) {
+      gl.activeTexture(gl.TEXTURE0 + i);
+      gl.bindTexture(gl.TEXTURE_2D, tex);
+    }
+  }
+  register(op) {
+    this.#canvas[`${op}EventListener`]("webglcontextlost", this.#onContextLost);
+    this.#canvas[`${op}EventListener`](
+      "webglcontextrestored",
+      this.#onContextRestored
+    );
+    return this;
+  }
+  setDepth(enable) {
+    if (!this.#ctx) return;
+    if (enable) this.#ctx.gl.enable(this.#ctx.gl.DEPTH_TEST);
+    else this.#ctx.gl.disable(this.#ctx.gl.DEPTH_TEST);
+  }
+  [Symbol.dispose]() {
+    this.register("remove");
+  }
+  #Context() {
+    const gl = this.#ctx?.gl ?? GL2(this.#canvas);
+    if (!gl) return;
+    const shader = Shader(gl, spriteVertGLSL, spriteFragGLSL, [
+      gl.createTexture(),
+      gl.createTexture()
+    ]);
+    gl.enable(gl.BLEND);
+    gl.blendFuncSeparate(
+      gl.SRC_ALPHA,
+      gl.ONE_MINUS_SRC_ALPHA,
+      gl.ONE,
+      gl.ONE_MINUS_SRC_ALPHA
+    );
+    gl.depthRange(0, 1);
+    gl.clearDepth(1);
+    gl.depthFunc(gl.LESS);
+    gl.pixelStorei(gl.UNPACK_COLORSPACE_CONVERSION_WEBGL, false);
+    gl.bindVertexArray(shader.vao);
+    gl.bindBuffer(gl.ARRAY_BUFFER, gl.createBuffer());
+    gl.bufferData(gl.ARRAY_BUFFER, uv, gl.STATIC_DRAW);
+    gl.enableVertexAttribArray(0);
+    gl.vertexAttribIPointer(0, 2, gl.BYTE, 0, 0);
+    gl.bindBuffer(gl.ARRAY_BUFFER, null);
+    gl.bindBuffer(gl.ARRAY_BUFFER, shader.buffer);
+    gl.enableVertexAttribArray(1);
+    gl.vertexAttribIPointer(1, 1, gl.UNSIGNED_INT, drawableBytes, 0);
+    gl.vertexAttribDivisor(1, 1);
+    gl.enableVertexAttribArray(2);
+    gl.vertexAttribIPointer(2, 1, gl.UNSIGNED_INT, drawableBytes, 4);
+    gl.vertexAttribDivisor(2, 1);
+    gl.enableVertexAttribArray(3);
+    gl.vertexAttribIPointer(3, 1, gl.UNSIGNED_INT, drawableBytes, 8);
+    gl.vertexAttribDivisor(3, 1);
+    gl.bindBuffer(gl.ARRAY_BUFFER, null);
+    gl.bindTexture(gl.TEXTURE_2D, shader.textures[0]);
+    gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.NEAREST);
+    gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.NEAREST);
+    if (this.#preloadAtlasImage)
+      gl.texImage2D(
+        gl.TEXTURE_2D,
+        0,
+        gl.RGBA,
+        gl.RGBA,
+        gl.UNSIGNED_BYTE,
+        this.#preloadAtlasImage
+      );
+    gl.bindTexture(gl.TEXTURE_2D, null);
+    gl.bindTexture(gl.TEXTURE_2D, shader.textures[1]);
+    gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.NEAREST);
+    gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.NEAREST);
+    gl.texImage2D(
+      gl.TEXTURE_2D,
+      0,
+      gl.RGBA16UI,
+      // source XYWH cannot be > 65535.
+      1,
+      this.#preloadAtlas.celXYWH.length / 4,
+      // 4 u16s per row
+      0,
+      gl.RGBA_INTEGER,
+      gl.UNSIGNED_SHORT,
+      new Uint16Array(this.#preloadAtlas.celXYWH)
+    );
+    gl.bindTexture(gl.TEXTURE_2D, null);
+    gl.bindVertexArray(null);
+    gl.uniform1i(shader.uniform.uTex, 0);
+    gl.uniform1i(shader.uniform.uCels, 1);
+    if (this.#preloadAtlasImage)
+      gl.uniform2ui(
+        shader.uniform.uTexWH,
+        this.#preloadAtlasImage.naturalWidth,
+        this.#preloadAtlasImage.naturalHeight
+      );
+    this.invalid = true;
+    this.loseContext = gl.getExtension("WEBGL_lose_context") ?? void 0;
+    return this.#ctx = { gl, spriteShader: shader, viewport: { w: 0, h: 0 } };
+  }
+  #onContextLost = (ev) => {
+    ev.preventDefault();
+    console.debug("[render] WebGL context lost");
+    this.#ctx = void 0;
+  };
+  #onContextRestored = () => {
+    console.debug("[render] WebGL context restored");
+    this.#ctx = this.#Context();
+  };
+};
+function GL2(canvas) {
+  const gl = canvas.getContext("webgl2", {
+    // to-do: expose.
+    antialias: false,
+    powerPreference: "low-power",
+    // avoid flicker caused by clearing the drawing buffer. see
+    // https://developer.chrome.com/blog/desynchronized/.
+    preserveDrawingBuffer: true,
+    ...!debug?.render && { desynchronized: true }
+  });
+  if (!gl) {
+    console.debug("[render] no GL context");
+    return;
+  }
+  if (debug?.render && !gl.getContextAttributes()?.desynchronized)
+    console.debug("[render] no WebGL DOM desynchronization");
+  return gl;
+}
+
+// src/looper.ts
+var Looper = class {
+  /** duration of frames observed. */
+  age = 0;
+  onFrame;
+  #req = 0;
+  #registered = false;
+  register(op) {
+    const fn = `${op}EventListener`;
+    document[fn]("visibilitychange", this.#onVisibility);
+    if (op === "remove") this.#cancel();
+    this.#registered = op === "add";
+    return this;
+  }
+  requestFrame() {
+    if (this.#req || document.hidden || !this.#registered) return;
+    this.#req = requestAnimationFrame(this.#onFrame);
+  }
+  [Symbol.dispose]() {
+    this.register("remove");
+  }
+  #cancel() {
+    if (this.#req) cancelAnimationFrame(this.#req);
+    this.#req = 0;
+  }
+  #onFrame = (now) => {
+    this.age = now;
+    this.#req = 0;
+    this.onFrame?.(now - (this.age || now));
+  };
+  #onVisibility = (ev) => {
+    if (!ev.isTrusted) return;
+    if (document.hidden) this.#cancel();
+    else this.requestFrame();
+  };
+};
+
+// src/pixel-ratio-observer.ts
+var PixelRatioObserver = class {
+  onChange = () => {
+  };
+  #mediaQuery;
+  register(op) {
+    this.#mediaQuery?.removeEventListener("change", this.#onChange);
+    if (op === "add") {
+      this.#mediaQuery = matchMedia(`not (resolution: ${devicePixelRatio}dppx)`);
+      this.#mediaQuery.addEventListener("change", this.#onChange);
+    } else this.#mediaQuery = void 0;
+    return this;
+  }
+  [Symbol.dispose]() {
+    this.register("remove");
+  }
+  #onChange = () => {
+    this.register("add");
+    this.onChange();
+  };
+};
+
+// src/void.ts
+var Void = class {
+  cam = new Cam();
+  canvas;
+  framer = new Looper();
+  input;
+  preload;
+  renderer;
+  sprites;
+  zoo = new Zoo();
+  #pixelRatioObserver = new PixelRatioObserver();
+  #preloadAtlasImage;
+  #resizeObserver = new ResizeObserver(() => this.onResize());
+  constructor(opts) {
+    initMetaViewport();
+    this.canvas = initCanvas(opts.canvas, opts.mode ?? "Int");
+    initBody(this.canvas, opts.backgroundRGBA ?? 255);
+    if (opts.minWH) this.cam.minWH = opts.minWH;
+    this.cam.mode = opts.mode ?? "Int";
+    this.cam.update(this.canvas);
+    this.input = new Input(this.cam, this.canvas);
+    if (opts.input !== "Custom") this.input.mapDefault();
+    this.input.onEvent = () => this.onEvent();
+    this.#pixelRatioObserver.onChange = () => this.onResize();
+    if (opts.preloadAtlas) this.#preloadAtlasImage = opts.preloadAtlas.image;
+    this.preload = opts.preloadAtlas ? parseAtlas(opts.preloadAtlas.json) : { anim: {}, celXYWH: [], tags: [] };
+    this.renderer = new Renderer(this.preload ?? {}, this.canvas);
+    this.sprites = new Pool({
+      alloc: (pool) => this.onAllocSprite(pool),
+      allocBytes: drawableBytes,
+      minPages: opts.sprites?.minPages ?? 3,
+      pageBlocks: opts.sprites?.pageBlocks ?? 1e3
+    });
+    this.framer.onFrame = (millis) => this.onFrame(millis);
+  }
+  onAllocSprite(pool) {
+    return new Sprite(pool, 0, this.preload, this.framer);
+  }
+  onEvent() {
+    this.framer.requestFrame();
+  }
+  /** update input, update canvas, update cam, update world, then render. */
+  onFrame(millis) {
+    if (document.hidden) return;
+    this.input.update(millis);
+    this.onLoop(millis);
+    this.cam.postupdate();
+  }
+  // biome-ignore lint/correctness/noUnusedFunctionParameters:;
+  onLoop(millis) {
+  }
+  onResize() {
+    this.framer.requestFrame();
+  }
+  async register(op) {
+    this.input.register(op);
+    this.renderer.register(op);
+    this.framer.register(op);
+    if (!this.canvas.parentElement) throw Error("no canvas parent");
+    if (op === "add") this.#resizeObserver.observe(this.canvas.parentElement);
+    else this.#resizeObserver.unobserve(this.canvas.parentElement);
+    this.#pixelRatioObserver.register(op);
+    this.framer.requestFrame();
+    if (this.#preloadAtlasImage) await loadImage(this.#preloadAtlasImage);
+    this.renderer.load(this.#preloadAtlasImage);
+  }
+  requestFrame() {
+    if (this.renderer.always || this.input.anyOn || this.input.gamepad)
+      this.framer.requestFrame();
+  }
+  async [Symbol.asyncDispose]() {
+    await this.register("remove");
+  }
+};
+
+// src/index.ts
+var version = voidVersion ? `${voidVersion.version}+${voidVersion.published}.${voidVersion.hash}` : "?";
+
+// src/demo/assets/preload-atlas.json
+var preload_atlas_default = {
+  anim: {
+    "background--OrangeCheckerboard": { cels: 1, h: 2, id: 0, w: 2 },
+    "background--GreyCheckerboard": { cels: 1, h: 2, id: 1, w: 2 },
+    "background--Kiwi": { cels: 1, h: 2, id: 2, w: 2 },
+    "background--Strawberry": { cels: 1, h: 2, id: 3, w: 2 },
+    "background--Grape": { cels: 1, h: 2, id: 4, w: 2 },
+    "background--Blueberry": { cels: 1, h: 2, id: 5, w: 2 },
+    "background--Bubblegum": { cels: 1, h: 2, id: 6, w: 2 },
+    "background--Transparent": { cels: 1, h: 2, id: 7, w: 2 },
+    "background--Black": { cels: 1, h: 2, id: 8, w: 2 },
+    "backpacker--WalkRight": {
+      cels: 16,
+      h: 13,
+      hitbox: { x: 2, y: 0, w: 4, h: 4 },
+      id: 9,
+      w: 8
+    },
+    "backpacker--WalkDown": {
+      cels: 16,
+      h: 13,
+      hitbox: { x: 2, y: 0, w: 4, h: 4 },
+      id: 10,
+      w: 8
+    },
+    "backpacker--WalkUp": {
+      cels: 16,
+      h: 13,
+      hitbox: { x: 2, y: 0, w: 4, h: 4 },
+      id: 11,
+      w: 8
+    },
+    "cursor--Pointer": {
+      cels: 1,
+      h: 14,
+      hitbox: { x: 0, y: 0, w: 2, h: 2 },
+      hurtbox: { x: 0, y: 0, w: 2, h: 2 },
+      id: 12,
+      w: 8
+    },
+    "mem-prop-5x6--00": { cels: 1, h: 6, id: 13, w: 5 },
+    "mem-prop-5x6--01": { cels: 1, h: 6, id: 14, w: 5 },
+    "mem-prop-5x6--02": { cels: 1, h: 6, id: 15, w: 5 },
+    "mem-prop-5x6--03": { cels: 1, h: 6, id: 16, w: 5 },
+    "mem-prop-5x6--04": { cels: 1, h: 6, id: 17, w: 5 },
+    "mem-prop-5x6--05": { cels: 1, h: 6, id: 18, w: 5 },
+    "mem-prop-5x6--06": { cels: 1, h: 6, id: 19, w: 5 },
+    "mem-prop-5x6--07": { cels: 1, h: 6, id: 20, w: 5 },
+    "mem-prop-5x6--08": { cels: 1, h: 6, id: 21, w: 5 },
+    "mem-prop-5x6--09": { cels: 1, h: 6, id: 22, w: 5 },
+    "mem-prop-5x6--0a": { cels: 1, h: 6, id: 23, w: 5 },
+    "mem-prop-5x6--0b": { cels: 1, h: 6, id: 24, w: 5 },
+    "mem-prop-5x6--0c": { cels: 1, h: 6, id: 25, w: 5 },
+    "mem-prop-5x6--0d": { cels: 1, h: 6, id: 26, w: 5 },
+    "mem-prop-5x6--0e": { cels: 1, h: 6, id: 27, w: 5 },
+    "mem-prop-5x6--0f": { cels: 1, h: 6, id: 28, w: 5 },
+    "mem-prop-5x6--10": { cels: 1, h: 6, id: 29, w: 5 },
+    "mem-prop-5x6--11": { cels: 1, h: 6, id: 30, w: 5 },
+    "mem-prop-5x6--12": { cels: 1, h: 6, id: 31, w: 5 },
+    "mem-prop-5x6--13": { cels: 1, h: 6, id: 32, w: 5 },
+    "mem-prop-5x6--14": { cels: 1, h: 6, id: 33, w: 5 },
+    "mem-prop-5x6--15": { cels: 1, h: 6, id: 34, w: 5 },
+    "mem-prop-5x6--16": { cels: 1, h: 6, id: 35, w: 5 },
+    "mem-prop-5x6--17": { cels: 1, h: 6, id: 36, w: 5 },
+    "mem-prop-5x6--18": { cels: 1, h: 6, id: 37, w: 5 },
+    "mem-prop-5x6--19": { cels: 1, h: 6, id: 38, w: 5 },
+    "mem-prop-5x6--1a": { cels: 1, h: 6, id: 39, w: 5 },
+    "mem-prop-5x6--1b": { cels: 1, h: 6, id: 40, w: 5 },
+    "mem-prop-5x6--1c": { cels: 1, h: 6, id: 41, w: 5 },
+    "mem-prop-5x6--1d": { cels: 1, h: 6, id: 42, w: 5 },
+    "mem-prop-5x6--1e": { cels: 1, h: 6, id: 43, w: 5 },
+    "mem-prop-5x6--1f": { cels: 1, h: 6, id: 44, w: 5 },
+    "mem-prop-5x6--20": { cels: 1, h: 6, id: 45, w: 5 },
+    "mem-prop-5x6--21": { cels: 1, h: 6, id: 46, w: 5 },
+    "mem-prop-5x6--22": { cels: 1, h: 6, id: 47, w: 5 },
+    "mem-prop-5x6--23": { cels: 1, h: 6, id: 48, w: 5 },
+    "mem-prop-5x6--24": { cels: 1, h: 6, id: 49, w: 5 },
+    "mem-prop-5x6--25": { cels: 1, h: 6, id: 50, w: 5 },
+    "mem-prop-5x6--26": { cels: 1, h: 6, id: 51, w: 5 },
+    "mem-prop-5x6--27": { cels: 1, h: 6, id: 52, w: 5 },
+    "mem-prop-5x6--28": { cels: 1, h: 6, id: 53, w: 5 },
+    "mem-prop-5x6--29": { cels: 1, h: 6, id: 54, w: 5 },
+    "mem-prop-5x6--2a": { cels: 1, h: 6, id: 55, w: 5 },
+    "mem-prop-5x6--2b": { cels: 1, h: 6, id: 56, w: 5 },
+    "mem-prop-5x6--2c": { cels: 1, h: 6, id: 57, w: 5 },
+    "mem-prop-5x6--2d": { cels: 1, h: 6, id: 58, w: 5 },
+    "mem-prop-5x6--2e": { cels: 1, h: 6, id: 59, w: 5 },
+    "mem-prop-5x6--2f": { cels: 1, h: 6, id: 60, w: 5 },
+    "mem-prop-5x6--30": { cels: 1, h: 6, id: 61, w: 5 },
+    "mem-prop-5x6--31": { cels: 1, h: 6, id: 62, w: 5 },
+    "mem-prop-5x6--32": { cels: 1, h: 6, id: 63, w: 5 },
+    "mem-prop-5x6--33": { cels: 1, h: 6, id: 64, w: 5 },
+    "mem-prop-5x6--34": { cels: 1, h: 6, id: 65, w: 5 },
+    "mem-prop-5x6--35": { cels: 1, h: 6, id: 66, w: 5 },
+    "mem-prop-5x6--36": { cels: 1, h: 6, id: 67, w: 5 },
+    "mem-prop-5x6--37": { cels: 1, h: 6, id: 68, w: 5 },
+    "mem-prop-5x6--38": { cels: 1, h: 6, id: 69, w: 5 },
+    "mem-prop-5x6--39": { cels: 1, h: 6, id: 70, w: 5 },
+    "mem-prop-5x6--3a": { cels: 1, h: 6, id: 71, w: 5 },
+    "mem-prop-5x6--3b": { cels: 1, h: 6, id: 72, w: 5 },
+    "mem-prop-5x6--3c": { cels: 1, h: 6, id: 73, w: 5 },
+    "mem-prop-5x6--3d": { cels: 1, h: 6, id: 74, w: 5 },
+    "mem-prop-5x6--3e": { cels: 1, h: 6, id: 75, w: 5 },
+    "mem-prop-5x6--3f": { cels: 1, h: 6, id: 76, w: 5 },
+    "mem-prop-5x6--40": { cels: 1, h: 6, id: 77, w: 5 },
+    "mem-prop-5x6--41": { cels: 1, h: 6, id: 78, w: 5 },
+    "mem-prop-5x6--42": { cels: 1, h: 6, id: 79, w: 5 },
+    "mem-prop-5x6--43": { cels: 1, h: 6, id: 80, w: 5 },
+    "mem-prop-5x6--44": { cels: 1, h: 6, id: 81, w: 5 },
+    "mem-prop-5x6--45": { cels: 1, h: 6, id: 82, w: 5 },
+    "mem-prop-5x6--46": { cels: 1, h: 6, id: 83, w: 5 },
+    "mem-prop-5x6--47": { cels: 1, h: 6, id: 84, w: 5 },
+    "mem-prop-5x6--48": { cels: 1, h: 6, id: 85, w: 5 },
+    "mem-prop-5x6--49": { cels: 1, h: 6, id: 86, w: 5 },
+    "mem-prop-5x6--4a": { cels: 1, h: 6, id: 87, w: 5 },
+    "mem-prop-5x6--4b": { cels: 1, h: 6, id: 88, w: 5 },
+    "mem-prop-5x6--4c": { cels: 1, h: 6, id: 89, w: 5 },
+    "mem-prop-5x6--4d": { cels: 1, h: 6, id: 90, w: 5 },
+    "mem-prop-5x6--4e": { cels: 1, h: 6, id: 91, w: 5 },
+    "mem-prop-5x6--4f": { cels: 1, h: 6, id: 92, w: 5 },
+    "mem-prop-5x6--50": { cels: 1, h: 6, id: 93, w: 5 },
+    "mem-prop-5x6--51": { cels: 1, h: 6, id: 94, w: 5 },
+    "mem-prop-5x6--52": { cels: 1, h: 6, id: 95, w: 5 },
+    "mem-prop-5x6--53": { cels: 1, h: 6, id: 96, w: 5 },
+    "mem-prop-5x6--54": { cels: 1, h: 6, id: 97, w: 5 },
+    "mem-prop-5x6--55": { cels: 1, h: 6, id: 98, w: 5 },
+    "mem-prop-5x6--56": { cels: 1, h: 6, id: 99, w: 5 },
+    "mem-prop-5x6--57": { cels: 1, h: 6, id: 100, w: 5 },
+    "mem-prop-5x6--58": { cels: 1, h: 6, id: 101, w: 5 },
+    "mem-prop-5x6--59": { cels: 1, h: 6, id: 102, w: 5 },
+    "mem-prop-5x6--5a": { cels: 1, h: 6, id: 103, w: 5 },
+    "mem-prop-5x6--5b": { cels: 1, h: 6, id: 104, w: 5 },
+    "mem-prop-5x6--5c": { cels: 1, h: 6, id: 105, w: 5 },
+    "mem-prop-5x6--5d": { cels: 1, h: 6, id: 106, w: 5 },
+    "mem-prop-5x6--5e": { cels: 1, h: 6, id: 107, w: 5 },
+    "mem-prop-5x6--5f": { cels: 1, h: 6, id: 108, w: 5 },
+    "mem-prop-5x6--60": { cels: 1, h: 6, id: 109, w: 5 },
+    "mem-prop-5x6--61": { cels: 1, h: 6, id: 110, w: 5 },
+    "mem-prop-5x6--62": { cels: 1, h: 6, id: 111, w: 5 },
+    "mem-prop-5x6--63": { cels: 1, h: 6, id: 112, w: 5 },
+    "mem-prop-5x6--64": { cels: 1, h: 6, id: 113, w: 5 },
+    "mem-prop-5x6--65": { cels: 1, h: 6, id: 114, w: 5 },
+    "mem-prop-5x6--66": { cels: 1, h: 6, id: 115, w: 5 },
+    "mem-prop-5x6--67": { cels: 1, h: 6, id: 116, w: 5 },
+    "mem-prop-5x6--68": { cels: 1, h: 6, id: 117, w: 5 },
+    "mem-prop-5x6--69": { cels: 1, h: 6, id: 118, w: 5 },
+    "mem-prop-5x6--6a": { cels: 1, h: 6, id: 119, w: 5 },
+    "mem-prop-5x6--6b": { cels: 1, h: 6, id: 120, w: 5 },
+    "mem-prop-5x6--6c": { cels: 1, h: 6, id: 121, w: 5 },
+    "mem-prop-5x6--6d": { cels: 1, h: 6, id: 122, w: 5 },
+    "mem-prop-5x6--6e": { cels: 1, h: 6, id: 123, w: 5 },
+    "mem-prop-5x6--6f": { cels: 1, h: 6, id: 124, w: 5 },
+    "mem-prop-5x6--70": { cels: 1, h: 6, id: 125, w: 5 },
+    "mem-prop-5x6--71": { cels: 1, h: 6, id: 126, w: 5 },
+    "mem-prop-5x6--72": { cels: 1, h: 6, id: 127, w: 5 },
+    "mem-prop-5x6--73": { cels: 1, h: 6, id: 128, w: 5 },
+    "mem-prop-5x6--74": { cels: 1, h: 6, id: 129, w: 5 },
+    "mem-prop-5x6--75": { cels: 1, h: 6, id: 130, w: 5 },
+    "mem-prop-5x6--76": { cels: 1, h: 6, id: 131, w: 5 },
+    "mem-prop-5x6--77": { cels: 1, h: 6, id: 132, w: 5 },
+    "mem-prop-5x6--78": { cels: 1, h: 6, id: 133, w: 5 },
+    "mem-prop-5x6--79": { cels: 1, h: 6, id: 134, w: 5 },
+    "mem-prop-5x6--7a": { cels: 1, h: 6, id: 135, w: 5 },
+    "mem-prop-5x6--7b": { cels: 1, h: 6, id: 136, w: 5 },
+    "mem-prop-5x6--7c": { cels: 1, h: 6, id: 137, w: 5 },
+    "mem-prop-5x6--7d": { cels: 1, h: 6, id: 138, w: 5 },
+    "mem-prop-5x6--7e": { cels: 1, h: 6, id: 139, w: 5 },
+    "mem-prop-5x6--7f": { cels: 1, h: 6, id: 140, w: 5 },
+    "oidoid--Default": { cels: 1, h: 16, id: 141, w: 16 }
+  },
+  celXY: [
+    22,
+    37,
+    21,
+    27,
+    21,
+    29,
+    21,
+    31,
+    20,
+    33,
+    22,
+    33,
+    20,
+    35,
+    22,
+    35,
+    20,
+    37,
+    24,
+    26,
+    24,
+    26,
+    8,
+    16,
+    8,
+    16,
+    0,
+    16,
+    0,
+    16,
+    16,
+    14,
+    16,
+    14,
+    72,
+    13,
+    72,
+    13,
+    32,
+    26,
+    32,
+    26,
+    0,
+    16,
+    0,
+    16,
+    64,
+    13,
+    64,
+    13,
+    56,
+    13,
+    56,
+    13,
+    48,
+    13,
+    48,
+    13,
+    40,
+    13,
+    40,
+    13,
+    32,
+    13,
+    32,
+    13,
+    56,
+    13,
+    56,
+    13,
+    24,
+    13,
+    24,
+    13,
+    72,
+    0,
+    72,
+    0,
+    64,
+    0,
+    64,
+    0,
+    24,
+    0,
+    24,
+    0,
+    56,
+    0,
+    56,
+    0,
+    48,
+    0,
+    48,
+    0,
+    48,
+    0,
+    48,
+    0,
+    24,
+    0,
+    24,
+    0,
+    40,
+    0,
+    40,
+    0,
+    32,
+    0,
+    32,
+    0,
+    32,
+    0,
+    32,
+    0,
+    16,
+    0,
+    45,
+    56,
+    45,
+    56,
+    45,
+    56,
+    45,
+    56,
+    45,
+    56,
+    45,
+    56,
+    45,
+    56,
+    45,
+    56,
+    45,
+    56,
+    45,
+    56,
+    45,
+    56,
+    45,
+    56,
+    45,
+    56,
+    45,
+    56,
+    45,
+    56,
+    45,
+    56,
+    45,
+    56,
+    45,
+    56,
+    45,
+    56,
+    45,
+    56,
+    45,
+    56,
+    45,
+    56,
+    45,
+    56,
+    45,
+    56,
+    45,
+    56,
+    45,
+    56,
+    45,
+    56,
+    45,
+    56,
+    45,
+    56,
+    45,
+    56,
+    45,
+    56,
+    45,
+    56,
+    45,
+    56,
+    40,
+    56,
+    10,
+    53,
+    5,
+    53,
+    0,
+    53,
+    35,
+    51,
+    30,
+    51,
+    25,
+    51,
+    20,
+    51,
+    15,
+    51,
+    35,
+    45,
+    70,
+    50,
+    65,
+    50,
+    60,
+    50,
+    55,
+    50,
+    50,
+    50,
+    45,
+    50,
+    40,
+    50,
+    10,
+    47,
+    5,
+    47,
+    0,
+    47,
+    70,
+    62,
+    50,
+    56,
+    65,
+    62,
+    60,
+    62,
+    55,
+    62,
+    50,
+    62,
+    45,
+    62,
+    40,
+    62,
+    10,
+    59,
+    5,
+    59,
+    0,
+    59,
+    35,
+    57,
+    70,
+    32,
+    30,
+    57,
+    25,
+    57,
+    20,
+    57,
+    15,
+    57,
+    75,
+    56,
+    70,
+    56,
+    65,
+    56,
+    60,
+    56,
+    75,
+    50,
+    55,
+    56,
+    10,
+    35,
+    75,
+    32,
+    15,
+    33,
+    0,
+    35,
+    5,
+    35,
+    40,
+    38,
+    45,
+    38,
+    65,
+    32,
+    60,
+    32,
+    55,
+    32,
+    50,
+    32,
+    45,
+    32,
+    40,
+    26,
+    50,
+    26,
+    55,
+    26,
+    60,
+    26,
+    65,
+    26,
+    70,
+    26,
+    75,
+    26,
+    16,
+    27,
+    0,
+    29,
+    5,
+    29,
+    10,
+    29,
+    40,
+    32,
+    45,
+    26,
+    10,
+    41,
+    30,
+    45,
+    25,
+    45,
+    20,
+    45,
+    15,
+    45,
+    75,
+    44,
+    70,
+    44,
+    65,
+    44,
+    60,
+    44,
+    55,
+    44,
+    50,
+    44,
+    45,
+    44,
+    40,
+    44,
+    50,
+    38,
+    5,
+    41,
+    0,
+    41,
+    35,
+    39,
+    30,
+    39,
+    25,
+    39,
+    20,
+    39,
+    15,
+    39,
+    75,
+    38,
+    70,
+    38,
+    65,
+    38,
+    60,
+    38,
+    55,
+    38,
+    45,
+    56,
+    0,
+    0
+  ]
+};
+
+// src/demo/ents/clock-ent.ts
+var ClockEnt = class {
+  #time = new TextEnt();
+  constructor() {
+    this.#time.scale = 3;
+    this.#time.z = Layer.A;
+  }
+  free(v2) {
+    this.#time.free(v2);
+  }
+  update(v2) {
+    const now = /* @__PURE__ */ new Date();
+    this.#time.text = timeString(now);
+    if (this.#time.layout(v2) || v2.cam.invalid)
+      this.#time.xy = v2.cam.follow(
+        { w: this.#time.wh.w, h: this.#time.wh.h - this.#time.scaledLeading },
+        this.#time.z,
+        "N",
+        { margin: { h: 8 } }
+      );
+    return this.#time.update(v2);
+  }
+};
+function timeString(time) {
+  const hh = `${time.getHours() % 12 || 12}`.padStart(2, " ");
+  const mm = `${time.getMinutes()}`.padStart(2, "0");
+  const ss = `${time.getSeconds()}`.padStart(2, "0");
+  return `${hh}:${mm}:${ss}`;
+}
+
+// src/demo/ents/render-toggle-ent.ts
+var RenderToggleEnt = class {
+  #toggle;
+  constructor(v2) {
+    this.#toggle = new ButtonEnt(v2, {
+      button: {
+        w: { tag: "background--Strawberry" },
+        nw: { tag: "background--Transparent" },
+        n: { tag: "background--Bubblegum" },
+        e: { tag: "background--Blueberry" },
+        s: { tag: "background--Kiwi" },
+        origin: { tag: "background--Grape" },
+        border: { n: 1 },
+        margin: { w: 2, h: 2 }
+      },
+      selected: { tag: "background--OrangeCheckerboard" },
+      toggle: true,
+      text: { text: "render", scale: 2 },
+      w: 64,
+      h: 22,
+      x: 50,
+      y: 25,
+      pressed: { tag: "background--Bubblegum" }
+    });
+  }
+  get on() {
+    return this.#toggle.on;
+  }
+  free(v2) {
+    this.#toggle.free(v2);
+  }
+  /** always updates but never invalidates. */
+  update(v2) {
+    return this.#toggle.update(v2);
+  }
+};
+
+// src/demo/ents/work-counter-ent.ts
+var WorkCounterEnt = class {
+  #renders = 0;
+  #text = new TextEnt();
+  #updates = 0;
+  constructor() {
+    this.#text.z = Layer.A;
+  }
+  free(v2) {
+    this.#text.free(v2);
+  }
+  incrementRender() {
+    this.#renders++;
+  }
+  /** always updates but never invalidates. */
+  update(v2) {
+    this.#updates++;
+    this.#text.text = `${this.#updates} updates
+${this.#renders + 1} renders`;
+    this.#text.layout(v2);
+    this.#text.xy = v2.cam.follow(
+      { w: this.#text.wh.w, h: this.#text.wh.h - this.#text.scaledLeading },
+      this.#text.z,
+      "NE",
+      { margin: { w: 8, h: 8 } }
+    );
+    this.#text.update(v2);
+  }
+};
+
+// src/demo/game.ts
+var Game = class extends Void {
+  #filterSprites;
+  #interval = 0;
+  #renderToggle;
+  #timer = 0;
+  #workCounter;
+  constructor() {
+    super({
+      preloadAtlas: {
+        image: document.querySelector("#preload-atlas"),
+        json: preload_atlas_default
+      },
+      backgroundRGBA: 4294947327,
+      minWH: { w: 320, h: 240 }
+    });
+    this.#filterSprites = new Pool({
+      alloc: (pool) => new Sprite(pool, 0, this.preload, this.framer),
+      allocBytes: drawableBytes,
+      pageBlocks: 10
+    });
+    this.#renderToggle = new RenderToggleEnt(this);
+    this.#workCounter = new WorkCounterEnt();
+    this.#initZoo();
+  }
+  async register(op) {
+    await super.register(op);
+    if (op === "add") {
+      this.framer.requestFrame();
+      this.#startTimer();
+    } else {
+      this.#stopTimer();
+    }
+  }
+  onLoop(_millis) {
+    this.renderer.always = this.#renderToggle.on || !!debug?.invalid;
+    let render = this.#updateCam();
+    const updated = this.zoo.update(this);
+    if (debug?.input) this.#printInput();
+    render ||= updated || this.cam.invalid || this.renderer.invalid || this.renderer.always;
+    if (render) {
+      this.#workCounter.incrementRender();
+      this.renderer.clear(4294947327);
+      this.renderer.predraw(this.cam, this.framer);
+      this.renderer.setDepth(true);
+      this.renderer.draw(this.sprites);
+      this.renderer.setDepth(false);
+      this.renderer.draw(this.#filterSprites);
+    }
+    this.requestFrame();
+  }
+  #initZoo() {
+    const border = new NinePatchEnt(this, {
+      n: { tag: "background--Black" },
+      origin: { tag: "background--Transparent" },
+      border: { n: 1 },
+      z: Layer.UIA
+      // to-do: default 0 layer is dumb.
+    });
+    this.zoo.add(border);
+    const box = this.cam.follow({ w: 0, h: 0 }, Layer.UIA, "NW", { fill: "XY" });
+    border.xy = box;
+    border.wh = box;
+    const backpacker = this.sprites.alloc();
+    backpacker.tag = "backpacker--WalkRight";
+    backpacker.x = 7;
+    backpacker.y = 7;
+    backpacker.z = Layer.C;
+    backpacker.stretch = true;
+    backpacker.w *= 5;
+    backpacker.h *= 5;
+    const oidoid = new FollowCamEnt(this, "oidoid--Default", "SW");
+    oidoid.z = Layer.UIG;
+    oidoid.margin = { w: 4, h: 4 };
+    this.zoo.add(
+      new CursorEnt(this, "cursor--Pointer"),
+      this.#renderToggle,
+      new ClockEnt(),
+      this.#workCounter,
+      oidoid
+    );
+    const overlay = this.#filterSprites.alloc();
+    overlay.tag = "background--GreyCheckerboard";
+    overlay.w = drawableMaxWH.w;
+    overlay.h = drawableMaxWH.h;
+    overlay.z = Layer.UIA;
+  }
+  #printInput() {
+    if (this.input.started) {
+      const on = !!this.input.on.length;
+      if (on) console.debug(`[input] buttons on: ${this.input.on.join(" ")}.`);
+      else console.debug(`[input] buttons off.`);
+      const combo = this.input.combo;
+      if (combo.length > 1 && on)
+        console.debug(
+          `[input] combo: ${combo.map((set) => set.join("+")).join(" ")}.`
+        );
+    }
+    if (this.input.point?.invalid && this.input.point?.click && !this.input.point.pinch)
+      console.debug(
+        `[input] ${this.input.point.drag.on ? "drag" : "click"} xy: ${this.input.point.x} ${this.input.point.y}.`
+      );
+    if (this.input.point?.pinch)
+      console.debug(
+        `[input] pinch xy: ${this.input.point.pinch.xy.x} ${this.input.point.pinch.xy.y}.`
+      );
+    if (this.input.wheel)
+      console.debug(
+        `[input] wheel xy: ${this.input.wheel.delta.xy.x} ${this.input.wheel.delta.xy.y}.`
+      );
+  }
+  #startTimer() {
+    this.#timer = setTimeout(
+      () => {
+        this.framer.requestFrame();
+        this.#interval = setInterval(
+          () => this.framer.requestFrame(),
+          (debug?.seconds ? 1 : 60) * 1e3
+        );
+      },
+      renderDelayMillis(/* @__PURE__ */ new Date(), debug?.seconds)
+    );
+  }
+  #stopTimer() {
+    clearTimeout(this.#timer);
+    clearInterval(this.#interval);
+  }
+  #updateCam() {
+    let render = this.input.isAnyOn("L", "R", "U", "D");
+    if (this.input.isAnyOnStart("L", "R", "U", "D")) {
+      this.cam.x = Math.trunc(this.cam.x);
+      this.cam.y = Math.trunc(this.cam.y);
+    }
+    const d = 1 / 4;
+    if (this.input.isOn("L")) this.cam.x -= d;
+    if (this.input.isOn("R")) this.cam.x += d;
+    if (this.input.isOn("U")) this.cam.y -= d;
+    if (this.input.isOn("D")) this.cam.y += d;
+    if (this.input.wheel?.delta.xy.y) {
+      render = true;
+      this.cam.zoomOut -= this.input.wheel.delta.client.y * 0.01;
+    }
+    this.cam.update(this.canvas);
+    return render;
+  }
+};
+function renderDelayMillis(time, debugSecs) {
+  return ((debugSecs ? 0 : (59 - time.getSeconds() % 60) * 1e3) + 1e3 - time.getMilliseconds() % 1e3) % (debugSecs ? 1e3 : 6e4);
+}
+
+// src/demo/index.ts
+console.debug(`void v${version} \u2500\u2500\u2500oidoid>\xB0\u2500\u2500`);
+var v = new Game();
+await v.register("add");
+if (debug) globalThis.v = v;
+//# sourceMappingURL=index.js.map