lantern-engine 0.0.0-stage → 0.4.0

package/dist/lantern-engine.js

@@ -0,0 +1,3473 @@
+import { Graphics as Lt, Container as M, DynamicBitmapFont as ee, BitmapFont as se, BitmapText as ie, Sprite as R, Text as ne, CanvasSource as re, Texture as C, Rectangle as oe, TextureSource as ae, Application as he, RenderTexture as le } from "pixi.js";
+import { G as V, a as ce, i as ue, p as de, B as fe, b as pe, C as tt, I as me, c as gt, e as q } from "./constants-CjYVdFid.js";
+import { d as Hr, T as Ir, s as _r } from "./constants-CjYVdFid.js";
+class Ht extends V(M) {
+  constructor(t, e, s, n = 1) {
+    super(), this.w = t, this.h = e, this.color = s, this.fillAlpha = n, this.addChild(this.g), this.redraw();
+  }
+  w;
+  h;
+  color;
+  fillAlpha;
+  g = new Lt();
+  ox = 0.5;
+  oy = 0.5;
+  get originX() {
+    return this.ox;
+  }
+  get originY() {
+    return this.oy;
+  }
+  get rectWidth() {
+    return this.w;
+  }
+  get rectHeight() {
+    return this.h;
+  }
+  get fillColor() {
+    return this.color;
+  }
+  get fillOpacity() {
+    return this.fillAlpha;
+  }
+  setOrigin(t = 0.5, e = t) {
+    return this.ox = t, this.oy = e, this.redraw();
+  }
+  setFillStyle(t, e = 1) {
+    return this.color = t, this.fillAlpha = e, this.redraw();
+  }
+  setDisplaySize(t, e) {
+    return this.setScale(t / this.w, e / this.h);
+  }
+  resize(t, e) {
+    return this.w = t, this.h = e, this.redraw();
+  }
+  redraw() {
+    return this.g.clear().rect(-this.w * this.ox, -this.h * this.oy, this.w, this.h).fill({ color: this.color, alpha: this.fillAlpha }), this;
+  }
+}
+class ge {
+  constructor(t, e) {
+    this.world = t, this.screen = e;
+  }
+  world;
+  screen;
+  zoom = 1;
+  /** Backing pixels per screen pixel (the renderer's resolution, `zoomResolution`): what `snap` rounds to. */
+  resolution = 1;
+  /** Lands the view on whole backing pixels (pixel art); off, the world moves smoothly between them. */
+  roundPixels = !1;
+  scrollX = 0;
+  scrollY = 0;
+  width = 0;
+  height = 0;
+  bounds = null;
+  shakeUntil = 0;
+  shakeMs = 1;
+  shakeAngle = void 0;
+  shakeIntensity = 0;
+  flashRect = null;
+  flashStart = 0;
+  flashMs = 1;
+  flashPeak = 1;
+  /** Screen-layer containers laid over the world with its exact transform, shake included (see `follow`). */
+  followers = /* @__PURE__ */ new Set();
+  target = null;
+  trackOpts = { lerp: 1, deadzoneWidth: 0, deadzoneHeight: 0, offsetX: 0, offsetY: 0 };
+  lastApply = -1;
+  get worldView() {
+    const t = this.width / this.zoom, e = this.height / this.zoom;
+    return { x: this.scrollX, y: this.scrollY, width: t, height: e, right: this.scrollX + t, bottom: this.scrollY + e };
+  }
+  setZoom(t) {
+    return this.zoom = t, this;
+  }
+  /** A world coordinate snapped to the nearest backing pixel: one screen pixel, or a half at ×1.5. */
+  snap(t) {
+    const e = this.zoom * this.resolution;
+    return Math.round(t * e) / e;
+  }
+  setBounds(t, e, s, n) {
+    return this.bounds = { x: t, y: e, width: s, height: n }, this;
+  }
+  centerOn(t, e) {
+    return this.scrollX = t - this.width / this.zoom / 2, this.scrollY = e - this.height / this.zoom / 2, this.clamp(), this;
+  }
+  setScroll(t, e) {
+    return this.scrollX = t, this.scrollY = e, this.clamp(), this;
+  }
+  /**
+   * Screen shake: `intensity` is a fraction of the screen size, like before. With an `angle` (the way a blow travelled)
+   * the shake runs back and forth along it instead of at random, so a hit is felt coming from somewhere.
+   */
+  shake(t, e, s) {
+    const n = performance.now();
+    n < this.shakeUntil && e < this.shakeIntensity || (this.shakeUntil = n + t, this.shakeMs = t, this.shakeIntensity = e, this.shakeAngle = s);
+  }
+  /**
+   * Keeps a container on the screen layer placed exactly over the world layer — zoom, scroll and this frame's
+   * shake — for things drawn in world units above the screen-layer night (fireflies). Written in `apply`, after
+   * the scene updated, so it never lags the world by a frame or misses a shake the world takes.
+   */
+  follow(t) {
+    this.followers.add(t);
+  }
+  unfollow(t) {
+    this.followers.delete(t);
+  }
+  /** Full-screen colour flash starting at `peak` alpha and fading out over `ms`. */
+  flash(t, e, s, n, r = !1, o = 1) {
+    (!this.flashRect || this.flashRect.destroyed) && (this.flashRect = new Ht(1, 1, 16777215).setOrigin(0, 0), this.screen.addChild(this.flashRect)), this.flashRect.resize(this.width, this.height).setFillStyle(e << 16 | s << 8 | n).setAlpha(o).setVisible(!0), this.flashStart = performance.now(), this.flashMs = t, this.flashPeak = o;
+  }
+  /**
+   * Keeps `target` (anything with `x` and `y`, read every frame: an entity's position, a sprite) in view, inside the
+   * bounds if there are any. Replaces any target before.
+   */
+  track(t, e = {}) {
+    return this.target = t, this.trackOpts = { lerp: 1, deadzoneWidth: 0, deadzoneHeight: 0, offsetX: 0, offsetY: 0, ...e }, (e.lerp ?? 1) >= 1 && this.centerOn(t.x + this.trackOpts.offsetX, t.y + this.trackOpts.offsetY), this;
+  }
+  untrack() {
+    return this.target = null, this;
+  }
+  /** Moves the view toward the tracked target for a frame `dtMs` long. */
+  follow1(t) {
+    const e = this.target;
+    if (!e) return;
+    const s = this.trackOpts, n = this.width / this.zoom, r = this.height / this.zoom, o = this.scrollX + n / 2, a = this.scrollY + r / 2, h = e.x + s.offsetX, l = e.y + s.offsetY, c = s.deadzoneWidth / 2, u = s.deadzoneHeight / 2, d = h - o > c ? h - o - c : h - o < -c ? h - o + c : 0, m = l - a > u ? l - a - u : l - a < -u ? l - a + u : 0, f = s.lerp >= 1 ? 1 : 1 - Math.pow(1 - Math.max(0, s.lerp), t / (1e3 / 60));
+    this.scrollX += d * f, this.scrollY += m * f, this.clamp();
+  }
+  /** Writes the camera into the world layer; called once per frame after the scene updated. */
+  apply(t) {
+    const e = this.lastApply < 0 ? 16.666666666666668 : Math.min(100, t - this.lastApply);
+    this.lastApply = t, this.follow1(e);
+    let s = 0, n = 0;
+    if (t < this.shakeUntil) {
+      const h = (this.shakeUntil - t) / this.shakeMs;
+      if (this.shakeAngle !== void 0) {
+        const l = Math.cos((t - (this.shakeUntil - this.shakeMs)) / 28 * Math.PI) * this.shakeIntensity * this.width * h;
+        s = Math.round(Math.cos(this.shakeAngle) * l), n = Math.round(Math.sin(this.shakeAngle) * l);
+      } else
+        s = Math.round((Math.random() * 2 - 1) * this.shakeIntensity * this.width * h), n = Math.round((Math.random() * 2 - 1) * this.shakeIntensity * this.height * h);
+    }
+    this.world.scale.set(this.zoom);
+    const r = this.zoom * this.resolution, o = this.roundPixels ? Math.round(this.scrollX * r) / this.resolution : this.scrollX * this.zoom, a = this.roundPixels ? Math.round(this.scrollY * r) / this.resolution : this.scrollY * this.zoom;
+    this.world.position.set(-o + s, -a + n);
+    for (const h of this.followers)
+      h.scale.set(this.zoom), h.position.copyFrom(this.world.position);
+    if (this.flashRect?.visible) {
+      const h = (t - this.flashStart) / this.flashMs;
+      h >= 1 ? this.flashRect.setVisible(!1) : this.flashRect.alpha = this.flashPeak * (1 - h);
+    }
+  }
+  clamp() {
+    const t = this.bounds;
+    if (!t) return;
+    const e = this.width / this.zoom, s = this.height / this.zoom;
+    this.scrollX = e >= t.width ? t.x + (t.width - e) / 2 : Math.min(Math.max(this.scrollX, t.x), t.x + t.width - e), this.scrollY = s >= t.height ? t.y + (t.height - s) / 2 : Math.min(Math.max(this.scrollY, t.y), t.y + t.height - s);
+  }
+}
+class ye {
+  now = performance.now();
+  timers = [];
+  delayedCall(t, e) {
+    const s = { at: this.now + t, fn: e, removed: !1 };
+    return this.timers.push(s), { remove: () => {
+      s.removed = !0;
+    } };
+  }
+  update(t) {
+    this.now = t;
+    const e = this.timers.filter((s) => !s.removed && s.at <= t);
+    if (e.length) {
+      this.timers = this.timers.filter((s) => !s.removed && s.at > t);
+      for (const s of e)
+        try {
+          s.fn();
+        } catch (n) {
+          console.error("[timer] failed", n);
+        }
+    }
+  }
+  clear() {
+    this.timers = [];
+  }
+}
+const yt = /* @__PURE__ */ new Set(), It = [[" ", "~"]];
+function Hn(i) {
+  It.push(i);
+}
+const we = 128;
+function xe(i, t, e, s, n, r) {
+  const o = `label|${i}|${t}|${e}|${s}|${n}|${r}`;
+  if (!yt.has(o)) {
+    const a = ee.defaultOptions, h = a.textureSize;
+    a.textureSize = we;
+    try {
+      se.install({
+        name: o,
+        chars: It,
+        resolution: r,
+        style: { fontFamily: i, fontSize: t, fill: e, stroke: { color: s, width: n, join: "round" } }
+      });
+    } finally {
+      a.textureSize = h;
+    }
+    yt.add(o);
+  }
+  return o;
+}
+class be extends V(ie) {
+  /**
+   * `fontFamily` must already be loaded (`document.fonts.load`), or the glyphs bake in the fallback.
+   * Styled like `worldText`: the same font, size, colour and outline, rasterised at the same resolution.
+   */
+  constructor(t, e, s, n, r, o, a, h, l) {
+    const c = xe(n, r, o, a, h, l);
+    super({ text: s, style: { fontFamily: c, fontSize: r } }), this.position.set(t, e);
+  }
+  setOrigin(t = 0.5, e = t) {
+    return this.anchor.set(t, e), this;
+  }
+  setText(t) {
+    return this.text = t, this;
+  }
+}
+class ve extends V(M) {
+  get list() {
+    return this.children;
+  }
+  add(t) {
+    for (const e of Array.isArray(t) ? t : [t]) this.addChild(e);
+    return this;
+  }
+  addAt(t, e) {
+    return this.addChildAt(t, Math.min(e, this.children.length)), this;
+  }
+  remove(t, e = !1) {
+    return t.parent === this && this.removeChild(t), e && t.destroy({ children: !0, context: !0 }), this;
+  }
+  /** Puts `child` directly below `other` in the draw order. */
+  moveBelow(t, e) {
+    return t.parent !== this || e.parent !== this || t === e ? this : (this.removeChild(t), this.addChildAt(t, this.getChildIndex(e)), this);
+  }
+  /** Puts `child` directly above `other` in the draw order. */
+  moveAbove(t, e) {
+    return t.parent !== this || e.parent !== this || t === e ? this : (this.removeChild(t), this.addChildAt(t, this.getChildIndex(e) + 1), this);
+  }
+}
+class Me extends V(R) {
+  constructor(t, e, s, n, r) {
+    super(t.get(n, r)), this.registry = t, this.textureKey = n, this.frameName = r === void 0 ? "" : String(r), this.anchor.set(0.5), this.position.set(e, s);
+  }
+  registry;
+  textureKey;
+  frameName;
+  get originX() {
+    return this.anchor.x;
+  }
+  get originY() {
+    return this.anchor.y;
+  }
+  /** Width of the frame itself, unscaled. */
+  get frameWidth() {
+    return this.texture.orig.width;
+  }
+  get frameHeight() {
+    return this.texture.orig.height;
+  }
+  get displayWidth() {
+    return Math.abs(this.frameWidth * this.scaleX);
+  }
+  set displayWidth(t) {
+    this.scaleX = t / this.frameWidth;
+  }
+  get displayHeight() {
+    return Math.abs(this.frameHeight * this.scaleY);
+  }
+  set displayHeight(t) {
+    this.scaleY = t / this.frameHeight;
+  }
+  setOrigin(t = 0.5, e = t) {
+    return this.anchor.set(t, e), this;
+  }
+  setDisplaySize(t, e) {
+    return this.setScale(t / this.frameWidth, e / this.frameHeight);
+  }
+  setFrame(t) {
+    return this.frameName = String(t), this.texture = this.registry.get(this.textureKey, t), this;
+  }
+  setTexture(t, e) {
+    return this.textureKey = t, this.frameName = e === void 0 ? "" : String(e), this.texture = this.registry.get(t, e), this;
+  }
+}
+class Ae extends V(ne) {
+  constructor(t, e, s, n) {
+    const r = {
+      fontFamily: n.fontFamily ?? "monospace",
+      fontSize: typeof n.fontSize == "string" ? parseFloat(n.fontSize) : n.fontSize,
+      fill: n.color ?? "#ffffff"
+    };
+    n.stroke && (r.stroke = { color: n.stroke, width: n.strokeThickness ?? 1, join: "round" }), n.align && (r.align = n.align), n.lineSpacing !== void 0 && (r.leading = n.lineSpacing), n.wordWrapWidth !== void 0 && (r.wordWrap = !0, r.wordWrapWidth = n.wordWrapWidth), super({ text: s, resolution: n.resolution ?? 1, style: r }), this.position.set(t, e);
+  }
+  setOrigin(t = 0.5, e = t) {
+    return this.anchor.set(t, e), this;
+  }
+  setText(t) {
+    return this.text = t, this;
+  }
+}
+class ke {
+  constructor(t) {
+    this.stage = t;
+  }
+  stage;
+  image(t, e, s, n) {
+    return this.attach(new Me(this.stage.textures, t, e, s, n));
+  }
+  /**
+   * A copy of `src` as it is drawn right now (afterimages, clones). A live texture, repainted every frame, is
+   * snapshotted first, and the snapshot is freed with the copy.
+   */
+  still(t, e, s) {
+    const n = this.stage.textures;
+    if (!n.isLive(s.textureKey)) return this.image(t, e, s.textureKey, s.frameName);
+    const r = n.snapshot(s.textureKey, s.frameName), o = this.image(t, e, r, "0");
+    return o.once("destroyed", () => n.remove(r)), o;
+  }
+  graphics(t) {
+    const e = this.attach(new ce());
+    return e.position.set(t?.x ?? 0, t?.y ?? 0), e;
+  }
+  container(t = 0, e = 0, s = []) {
+    const n = this.attach(new ve());
+    return n.position.set(t, e), n.add(s), n;
+  }
+  rectangle(t, e, s, n, r, o = 1) {
+    const a = this.attach(new Ht(s, n, r, o));
+    return a.position.set(t, e), a;
+  }
+  text(t, e, s, n) {
+    return this.attach(new Ae(t, e, s, n));
+  }
+  /** A bitmap-font label (`BitmapLabel`): cheap to change, for text rewritten many times a second. */
+  label(t, e, s, n, r, o, a, h, l) {
+    return this.attach(new be(t, e, s, n, r, o, a, h, l));
+  }
+  /** Puts an object made elsewhere on the world layer, as the factory's own are (a `PixelLayer`, a custom class). */
+  existing(t) {
+    return this.attach(t);
+  }
+  attach(t) {
+    return t.scene = this.stage, this.stage.world.addChild(t), t;
+  }
+}
+function U(i) {
+  return i === 1 ? 4 : i === 2 ? 2 : i === 0 ? 1 : 0;
+}
+class pt {
+  constructor(t) {
+    this.canvas = t;
+    const e = ue(), s = (n, r, o) => {
+      const a = (h) => {
+        e && h instanceof PointerEvent && h.pointerType === "touch" || o(h);
+      };
+      n.addEventListener(r, a), this.cleanup.push(() => n.removeEventListener(r, a));
+    };
+    s(t, "pointerdown", (n) => {
+      this.track(n), !pt.ignorePress?.(n) && (this.buttons |= U(n.button));
+    }), s(window, "pointermove", (n) => {
+      this.track(n), n.button >= 0 && (this.buttons = (n.buttons & U(n.button)) !== 0 ? this.buttons | U(n.button) : this.buttons & ~U(n.button));
+    }), s(window, "pointerup", (n) => {
+      this.buttons &= ~U(n.button);
+    }), s(window, "blur", () => {
+      this.buttons = 0;
+    }), s(t, "contextmenu", (n) => n.preventDefault());
+  }
+  canvas;
+  /**
+   * A press this returns true for is not counted as a held button (e.g. Shift + right-click opening a context menu
+   * instead of firing what the right button is bound to). Unset, every press counts.
+   */
+  static ignorePress = null;
+  /** Screen position relative to the canvas, in CSS pixels. */
+  x = 0;
+  y = 0;
+  worldX = 0;
+  worldY = 0;
+  buttons = 0;
+  cleanup = [];
+  leftButtonDown() {
+    return (this.buttons & 1) !== 0;
+  }
+  rightButtonDown() {
+    return (this.buttons & 2) !== 0;
+  }
+  updateWorldPoint(t) {
+    this.worldX = t.scrollX + this.x / t.zoom, this.worldY = t.scrollY + this.y / t.zoom;
+  }
+  destroy() {
+    for (const t of this.cleanup) t();
+    this.cleanup.length = 0;
+  }
+  track(t) {
+    const e = this.canvas.getBoundingClientRect();
+    this.x = t.clientX - e.left, this.y = t.clientY - e.top;
+  }
+}
+const _t = (i) => i, wt = {
+  Linear: _t,
+  "Quad.In": (i) => i * i,
+  "Quad.Out": (i) => i * (2 - i),
+  "Cubic.Out": (i) => 1 - Math.pow(1 - i, 3),
+  "Sine.In": (i) => 1 - Math.cos(i * Math.PI / 2),
+  "Sine.InOut": (i) => -(Math.cos(Math.PI * i) - 1) / 2,
+  "Back.Out": (i) => {
+    const e = i - 1;
+    return e * e * ((1.70158 + 1) * e + 1.70158) + 1;
+  }
+};
+function Se(i) {
+  if (!i) return wt["Quad.Out"];
+  const t = wt[i];
+  return t || console.warn(`[tween] unknown ease ${i}`), t ?? _t;
+}
+const Ee = /* @__PURE__ */ new Set([
+  "targets",
+  "duration",
+  "delay",
+  "hold",
+  "yoyo",
+  "repeat",
+  "ease",
+  "props",
+  "onStart",
+  "onUpdate",
+  "onComplete"
+]);
+class Fe {
+  constructor(t, e) {
+    this.cfg = t, this.ends = e;
+    const s = t.targets;
+    this.targets = Array.isArray(s) ? s : [s];
+  }
+  cfg;
+  ends;
+  tracks = null;
+  elapsed = 0;
+  plays = 0;
+  removed = !1;
+  targets;
+  /**
+   * Every target is a destroyed display object: nothing is left to move. A forever tween (`repeat: -1`) on a sprite
+   * its owner freed used to stay in the list for good, holding the sprite, and the list grew with every map loaded.
+   * A plain object (a clock a callback reads) has no `destroyed` and is never taken for one. Only a forever tween is
+   * dropped this way: a finite one still runs out and calls its `onComplete`, which may clean up more than the sprite.
+   */
+  orphaned() {
+    if (this.cfg.repeat !== -1) return !1;
+    const t = this.targets;
+    if (t.length === 0) return !1;
+    for (const e of t) if (e.destroyed !== !0) return !1;
+    return !0;
+  }
+  remove() {
+    this.removed = !0;
+  }
+  stop() {
+    this.removed = !0;
+  }
+  /** Advances by `dt` ms; returns false once the tween is finished. */
+  step(t) {
+    if (this.removed) return !1;
+    if (this.orphaned())
+      return this.removed = !0, !1;
+    const e = this.cfg, s = e.delay ?? 0;
+    if (this.elapsed += t, this.elapsed < s) return !0;
+    if (!this.tracks) {
+      this.tracks = [];
+      for (const d of this.targets)
+        for (const [m, f] of Object.entries(this.ends)) this.tracks.push({ target: d, prop: m, from: Be(d, m), to: f });
+      e.onStart?.();
+    }
+    const n = Math.max(1, e.duration ?? 1e3), r = e.yoyo ? e.hold ?? 0 : 0, o = e.yoyo ? n * 2 + r : n;
+    let a = this.elapsed - s - this.plays * o;
+    const h = e.repeat ?? 0;
+    let l = !1;
+    a >= o && (h === -1 || this.plays < h ? (this.plays++, a -= o) : (a = o, l = !0));
+    let c;
+    e.yoyo ? a <= n ? c = a / n : a <= n + r ? c = 1 : c = 1 - (a - n - r) / n : c = a / n;
+    const u = Se(e.ease)(Math.min(1, Math.max(0, c)));
+    for (const d of this.tracks) d.target.destroyed || De(d.target, d.prop, d.from + (d.to - d.from) * u);
+    return e.onUpdate?.(), l ? (this.removed = !0, e.onComplete?.(), !1) : !0;
+  }
+}
+function Be(i, t) {
+  const e = t === "scale" ? i.scaleX : i[t];
+  return typeof e == "number" ? e : 0;
+}
+function De(i, t, e) {
+  t === "scale" ? (i.scaleX = e, i.scaleY = e) : i[t] = e;
+}
+class Te {
+  /** Global speed factor; hit-stop slows every tween at once. */
+  timeScale = 1;
+  tweens = [];
+  add(t) {
+    const e = { ...t.props ?? {} }, s = {};
+    for (const [o, a] of Object.entries(t))
+      if (!Ee.has(o)) {
+        if (typeof a == "number") e[o] = a;
+        else if (a && typeof a == "object" && "to" in a) {
+          const h = a;
+          e[o] = h.to, h.from !== void 0 && (s[o] = h.from);
+        }
+      }
+    const n = Array.isArray(t.targets) ? t.targets : [t.targets];
+    for (const o of n) for (const [a, h] of Object.entries(s)) o[a] = h;
+    const r = new Fe(t, e);
+    return this.tweens.push(r), r;
+  }
+  killTweensOf(t) {
+    const e = new Set(Array.isArray(t) ? t : [t]);
+    for (const s of this.tweens) s.targets.some((n) => e.has(n)) && s.remove();
+  }
+  update(t) {
+    const e = t * this.timeScale, s = this.tweens, n = s.length;
+    let r = 0;
+    for (let o = 0; o < n; o++) {
+      const a = s[o];
+      Re(a, e) && (s[r++] = a);
+    }
+    if (this.tweens === s) {
+      for (let o = n; o < s.length; o++) s[r++] = s[o];
+      s.length = r;
+    }
+  }
+  clear() {
+    for (const t of this.tweens) t.remove();
+    this.tweens = [];
+  }
+}
+function Re(i, t) {
+  try {
+    return i.step(t);
+  } catch (e) {
+    return console.error("[tween] dropped after an error", e), !1;
+  }
+}
+class H {
+  constructor(t, e) {
+    this.app = t, this.textures = e, t.stage.addChild(this.world, this.screen), this.cameras = { main: new ge(this.world, this.screen) }, this.input = { activePointer: new pt(t.canvas) }, this.syncSize();
+  }
+  app;
+  textures;
+  /** Told of every fault a guarded step caught (error telemetry, if the game sets one). */
+  static onCaught = null;
+  world = new M({ sortableChildren: !0 });
+  screen = new M();
+  add = new ke(this);
+  tweens = new Te();
+  time = new ye();
+  cameras;
+  input;
+  resizeListeners = [];
+  lastWidth = 0;
+  lastHeight = 0;
+  get width() {
+    return this.app.screen.width;
+  }
+  get height() {
+    return this.app.screen.height;
+  }
+  get fps() {
+    return this.app.ticker.FPS;
+  }
+  /** Calls `fn` whenever the window changes size; the returned function stops it (a per-map listener must). */
+  onResize(t) {
+    return this.resizeListeners.push(t), () => {
+      const e = this.resizeListeners.indexOf(t);
+      e >= 0 && this.resizeListeners.splice(e, 1);
+    };
+  }
+  /**
+   * One frame: game logic, then tweens and timers, then the camera. Pixi renders after. Each step is guarded: a
+   * ticker listener that throws never asks for the next animation frame, so one bad frame used to stop the world for
+   * good — the canvas frozen and no input reaching the server (seen on Android).
+   */
+  frame(t) {
+    const e = performance.now();
+    this.guard("resize", () => this.syncSize()), this.guard("update", () => this.update(e, t)), this.guard("tweens", () => this.tweens.update(t)), this.guard("timers", () => this.time.update(e)), this.guard("camera", () => this.cameras.main.apply(e));
+  }
+  reported = /* @__PURE__ */ new Set();
+  /**
+   * Runs one step of a frame and swallows what it throws, so the steps after it still run. Subclasses guard the parts
+   * of their own `update` too: a fault before the camera follows the player used to leave the view standing on one
+   * spot while the world went on.
+   */
+  guard(t, e) {
+    this.guarded(t, e, void 0);
+  }
+  /** `guard` for a step that answers something: `fallback` when it threw. */
+  guarded(t, e, s) {
+    try {
+      return e();
+    } catch (n) {
+      return this.caught(t, n), s;
+    }
+  }
+  /** What a guarded step threw: logged once per distinct error, or a fault repeating every frame floods the log at 60 a second. */
+  caught(t, e) {
+    const s = `${t}|${e instanceof Error ? e.message : String(e)}`;
+    this.reported.has(s) || (this.reported.add(s), console.error(`[frame] ${t} failed`, e), H.onCaught?.(`[frame] ${t}`, e));
+  }
+  destroy() {
+    this.tweens.clear(), this.time.clear(), this.input.activePointer.destroy(), this.world.destroy({ children: !0, context: !0 }), this.screen.destroy({ children: !0, context: !0 });
+  }
+  syncSize() {
+    const { width: t, height: e } = this.app.screen, s = this.cameras.main;
+    if (s.width = t, s.height = e, !(t === this.lastWidth && e === this.lastHeight)) {
+      this.lastWidth = t, this.lastHeight = e;
+      for (const n of [...this.resizeListeners]) n();
+    }
+  }
+}
+class Oe {
+  constructor(t, e) {
+    this.key = t, this.canvas = e, this.source = new re({ resource: e, scaleMode: "nearest" }), this.whole = new C({ source: this.source });
+  }
+  key;
+  canvas;
+  frames = /* @__PURE__ */ new Map();
+  source;
+  whole;
+  get width() {
+    return this.canvas.width;
+  }
+  get height() {
+    return this.canvas.height;
+  }
+  get context() {
+    return this.canvas.getContext("2d");
+  }
+  /** Adds a frame cut from the canvas (`_source` kept for the old call shape). */
+  add(t, e, s, n, r, o) {
+    this.frames.get(t)?.destroy(), this.frames.set(t, new C({ source: this.source, frame: new oe(s, n, r, o) }));
+  }
+  /**
+   * Registers under this texture a frame that lives on another one (an atlas page after the first), so the frame is
+   * found by this texture's key. A texture of its own over the other page's source: each side frees its own.
+   */
+  adopt(t, e) {
+    const s = e.frames.get(t);
+    s && (this.frames.get(t)?.destroy(), this.frames.set(t, new C({ source: e.source, frame: s.frame.clone() })));
+  }
+  refresh() {
+    this.source.update();
+  }
+  destroy() {
+    for (const t of this.frames.values()) t.destroy();
+    this.frames.clear(), this.whole.destroy(), this.source.destroy();
+  }
+}
+class Ce {
+  textures = /* @__PURE__ */ new Map();
+  /** Textures repainted or freed while in use (a rig body, its hand): a copy of one must snapshot it first. */
+  live = /* @__PURE__ */ new Set();
+  missing = /* @__PURE__ */ new Set();
+  snapshots = 0;
+  markLive(t) {
+    this.live.add(t);
+  }
+  isLive(t) {
+    return this.live.has(t);
+  }
+  /** A new texture holding frame `frame` of `key` as it is painted right now; returns its key (one frame, '0'). */
+  snapshot(t, e) {
+    const s = this.get(t, e), { x: n, y: r, width: o, height: a } = s.frame, h = document.createElement("canvas");
+    h.width = o, h.height = a;
+    const l = this.textures.get(t)?.canvas;
+    l && h.getContext("2d").drawImage(l, n, r, o, a, 0, 0, o, a);
+    const c = `${t}#still${++this.snapshots}`;
+    return this.addCanvas(c, h).add("0", 0, 0, 0, o, a), c;
+  }
+  /**
+   * `snapshot` into a texture kept for reuse (`into`): its canvas is repainted in place and uploaded again, and only
+   * made anew when the frame's size changes. Frame '0' is the copy.
+   */
+  snapshotInto(t, e, s) {
+    const n = this.get(t, e), { x: r, y: o, width: a, height: h } = n.frame;
+    let l = this.textures.get(s);
+    if (!l || l.width !== a || l.height !== h) {
+      const d = document.createElement("canvas");
+      d.width = a, d.height = h, l = this.addCanvas(s, d), l.add("0", 0, 0, 0, a, h);
+    }
+    const c = l.context;
+    c.clearRect(0, 0, a, h);
+    const u = this.textures.get(t)?.canvas;
+    u && c.drawImage(u, r, o, a, h, 0, 0, a, h), l.refresh();
+  }
+  exists(t) {
+    return this.textures.has(t);
+  }
+  addCanvas(t, e) {
+    this.remove(t);
+    const s = new Oe(t, e);
+    return this.textures.set(t, s), s;
+  }
+  /** A canvas cut into equal frames named 0, 1, 2... left to right, then row by row. */
+  addSpriteSheet(t, e, s) {
+    const n = this.addCanvas(t, e), r = Math.floor(e.width / s.frameWidth), o = Math.floor(e.height / s.frameHeight);
+    for (let a = 0; a < r * o; a++)
+      n.add(String(a), 0, a % r * s.frameWidth, Math.floor(a / r) * s.frameHeight, s.frameWidth, s.frameHeight);
+    return n;
+  }
+  createCanvas(t, e, s) {
+    const n = document.createElement("canvas");
+    return n.width = e, n.height = s, this.addCanvas(t, n);
+  }
+  remove(t) {
+    this.textures.get(t)?.destroy(), this.textures.delete(t), this.live.delete(t);
+  }
+  get(t, e) {
+    const s = this.textures.get(t);
+    return s ? e === void 0 || e === "" ? s.whole : s.frames.get(String(e)) ?? this.warn(`${t}/${e}`) : this.warn(t);
+  }
+  warn(t) {
+    return this.missing.has(t) || (this.missing.add(t), console.warn(`[textures] missing ${t}`)), C.EMPTY;
+  }
+}
+class Pt {
+  constructor(t = (e, s) => console.error(`[events] ${String(e)} listener failed`, s)) {
+    this.onError = t;
+  }
+  onError;
+  listeners = /* @__PURE__ */ new Map();
+  /** Subscribes to `type`; returns the unsubscribe function. */
+  on(t, e) {
+    return this.listeners.set(t, [...this.listeners.get(t) ?? [], e]), () => this.off(t, e);
+  }
+  /** Subscribes for the next `type` only. */
+  once(t, e) {
+    const s = this.on(t, (n) => {
+      s(), e(n);
+    });
+    return s;
+  }
+  off(t, e) {
+    const s = this.listeners.get(t);
+    if (!s) return;
+    const n = s.filter((r) => r !== e);
+    n.length ? this.listeners.set(t, n) : this.listeners.delete(t);
+  }
+  emit(t, e) {
+    for (const s of this.listeners.get(t) ?? [])
+      try {
+        s(e);
+      } catch (n) {
+        this.onError(t, n);
+      }
+  }
+  listenerCount(t) {
+    return this.listeners.get(t)?.length ?? 0;
+  }
+  clear() {
+    this.listeners.clear();
+  }
+}
+class Le {
+  stepMs;
+  stepSeconds;
+  maxSteps;
+  carry = 0;
+  /** Steps taken since the loop started. */
+  tick = 0;
+  constructor(t = {}) {
+    const e = t.hz ?? 60;
+    if (!(e > 0)) throw new Error(`FixedLoop: hz must be positive, got ${e}`);
+    this.stepMs = 1e3 / e, this.stepSeconds = 1 / e, this.maxSteps = Math.max(1, t.maxStepsPerFrame ?? 8);
+  }
+  /**
+   * Feeds one frame of `deltaMs` and runs `step` as many times as it owes. Returns the share of a step left over
+   * (0–1), for interpolating what is drawn between the last two steps.
+   */
+  advance(t, e) {
+    t > 0 && Number.isFinite(t) && (this.carry += t);
+    let s = 0;
+    for (; this.carry >= this.stepMs; ) {
+      if (s === this.maxSteps) {
+        this.carry %= this.stepMs;
+        break;
+      }
+      this.carry -= this.stepMs, s++, e(this.tick++);
+    }
+    return this.carry / this.stepMs;
+  }
+  /** Forgets any debt, e.g. after a scene change or a long load. */
+  reset() {
+    this.carry = 0;
+  }
+}
+class He {
+  constructor(t) {
+    this.engine = t;
+  }
+  engine;
+  stack = [];
+  queue = Promise.resolve();
+  /** True while an async `onEnter` is running: nothing updates until it is done. */
+  entering = !1;
+  /** The scene that updates, if any. */
+  get current() {
+    return this.entering ? void 0 : this.stack[this.stack.length - 1];
+  }
+  /** Every scene on the stack, bottom first. */
+  get all() {
+    return this.stack;
+  }
+  /** Removes every scene and enters `scene`. */
+  replace(t) {
+    return this.enqueue(async () => {
+      for (; this.stack.length; ) this.exitTop();
+      await this.enter(t);
+    });
+  }
+  /** Pauses the current scene and enters `scene` over it. */
+  push(t) {
+    return this.enqueue(async () => {
+      this.stack[this.stack.length - 1]?.onPause(), await this.enter(t);
+    });
+  }
+  /** Leaves the current scene and resumes the one under it. */
+  pop() {
+    return this.enqueue(async () => {
+      this.stack.length && (this.exitTop(), this.stack[this.stack.length - 1]?.onResume());
+    });
+  }
+  /** Leaves every scene (the engine is shutting down). */
+  clear() {
+    return this.enqueue(async () => {
+      for (; this.stack.length; ) this.exitTop();
+    });
+  }
+  async enter(t) {
+    if (this.stack.includes(t)) throw new Error(`${t.constructor.name} is already on the scene stack`);
+    t.attach(this.engine), this.stack.push(t), this.entering = !0;
+    try {
+      await t.onEnter();
+    } finally {
+      this.entering = !1;
+    }
+    this.engine.loop.reset();
+  }
+  exitTop() {
+    const t = this.stack.pop();
+    if (t)
+      try {
+        t.onExit();
+      } finally {
+        t.detach();
+      }
+  }
+  enqueue(t) {
+    const e = this.queue.then(t);
+    return this.queue = e.catch((s) => this.engine.reportError("scene", s)), e;
+  }
+}
+class Ie extends H {
+  constructor(t, e, s) {
+    super(t, e), this.tick = s;
+  }
+  tick;
+  update(t, e) {
+    this.tick(t, e);
+  }
+}
+class Wt {
+  constructor(t, e, s) {
+    this.app = t, this.loop = new Le(s.hz === void 0 ? {} : { hz: s.hz }), this.stage = new Ie(t, e, (r, o) => this.tick(r, o));
+    const n = this.stage.cameras.main;
+    n.setZoom(s.zoom ?? 1), n.roundPixels = s.pixelPerfect === !0, n.resolution = t.renderer.resolution, this.scenes = new He(this), H.onCaught = (r, o) => this.events.emit("error", { where: r, error: o }), t.ticker.add(this.onTick);
+  }
+  app;
+  stage;
+  loop;
+  scenes;
+  events = new Pt();
+  running = !0;
+  destroyed = !1;
+  onTick = (t) => this.stage.frame(t.deltaMS);
+  static async create(t) {
+    const e = t.pixelPerfect === !0;
+    ae.defaultOptions.scaleMode = e ? "nearest" : "linear";
+    const s = e ? 1 : t.resolution ?? Math.min(2, typeof devicePixelRatio == "number" ? devicePixelRatio : 1);
+    de();
+    const n = new he(), r = t.width === void 0 && t.height === void 0;
+    return await n.init({
+      ...r ? { resizeTo: t.parent } : { width: t.width ?? 800, height: t.height ?? 600 },
+      background: t.background ?? "#000000",
+      antialias: !e,
+      resolution: s,
+      autoDensity: !0,
+      preference: t.preference ?? "webgl"
+    }), t.parent.appendChild(n.canvas), new Wt(n, t.textures ?? new Ce(), t);
+  }
+  /** The scene that updates now, if any. */
+  get scene() {
+    return this.scenes.current;
+  }
+  /** Stops simulating and drawing; the canvas keeps its last frame. */
+  pause() {
+    this.running && (this.running = !1, this.app.ticker.stop());
+  }
+  resume() {
+    this.running || this.destroyed || (this.running = !0, this.loop.reset(), this.app.ticker.start());
+  }
+  get paused() {
+    return !this.running;
+  }
+  /** Reports a fault to `events.error` (and the console when nobody listens). */
+  reportError(t, e) {
+    this.events.listenerCount("error") === 0 && console.error(`[engine] ${t}`, e), this.events.emit("error", { where: t, error: e });
+  }
+  /** Leaves every scene, removes the canvas and frees the renderer. */
+  async destroy() {
+    this.destroyed || (this.destroyed = !0, await this.scenes.clear(), this.app.ticker.remove(this.onTick), H.onCaught && (H.onCaught = null), this.stage.destroy(), this.events.clear(), this.app.destroy({ removeView: !0 }, { children: !0 }));
+  }
+  tick(t, e) {
+    const s = this.scenes.current;
+    if (s) {
+      const n = (h, l) => this.reportError(`system ${h.name}`, l), r = this.loop.stepSeconds, o = this.loop.advance(e, () => {
+        s.world.run("fixed", { dt: r, now: t, alpha: 0 }, n), s.fixedUpdate(r);
+      }), a = e / 1e3;
+      s.world.run("frame", { dt: a, now: t, alpha: o }, n), s.update(a, o);
+    }
+    this.events.emit("frame", { now: t, dt: e / 1e3 });
+  }
+}
+class _e {
+  sparse = new Int32Array(64).fill(-1);
+  /** Packed entity ids, in the same order as `values`. */
+  entities = [];
+  values = [];
+  /** Bumped whenever an entity joins or leaves the set (not when a value changes): query caches key on it. */
+  version = 0;
+  get size() {
+    return this.entities.length;
+  }
+  has(t) {
+    return t < this.sparse.length && this.sparse[t] >= 0;
+  }
+  /** The value at slot `index`, or undefined. */
+  get(t) {
+    if (t >= this.sparse.length) return;
+    const e = this.sparse[t];
+    return e >= 0 ? this.values[e] : void 0;
+  }
+  set(t, e, s) {
+    this.grow(t);
+    const n = this.sparse[t];
+    if (n >= 0) {
+      this.values[n] = s, this.entities[n] = e;
+      return;
+    }
+    this.sparse[t] = this.entities.length, this.version++, this.entities.push(e), this.values.push(s);
+  }
+  /** Removes slot `index`; true if it was there. */
+  delete(t, e) {
+    if (t >= this.sparse.length) return !1;
+    const s = this.sparse[t];
+    if (s < 0) return !1;
+    const n = this.entities.length - 1;
+    if (s !== n) {
+      const r = this.entities[n];
+      this.entities[s] = r, this.values[s] = this.values[n], this.sparse[e(r)] = s;
+    }
+    return this.entities.pop(), this.values.pop(), this.sparse[t] = -1, this.version++, !0;
+  }
+  clear() {
+    this.version++, this.sparse.fill(-1), this.entities.length = 0, this.values.length = 0;
+  }
+  grow(t) {
+    if (t < this.sparse.length) return;
+    let e = this.sparse.length;
+    for (; e <= t; ) e *= 2;
+    const s = new Int32Array(e).fill(-1);
+    s.set(this.sparse), this.sparse = s;
+  }
+}
+const Pe = {
+  f32: Float32Array,
+  f64: Float64Array,
+  i8: Int8Array,
+  i16: Int16Array,
+  i32: Int32Array,
+  u8: Uint8Array,
+  u16: Uint16Array,
+  u32: Uint32Array
+};
+function We(i) {
+  return i.fields !== void 0;
+}
+function Ue(i, t, e) {
+  const s = {};
+  for (const [n, r] of Object.entries(i)) {
+    const o = new Pe[r](t), a = e?.[n];
+    a && o.set(a), s[n] = o;
+  }
+  return s;
+}
+let Ut = 0;
+function Nt(i) {
+  return { id: Ut++, name: i };
+}
+function In(i, t) {
+  return { id: Ut++, name: i, fields: t };
+}
+function Ne(i, t, e) {
+  return { name: i, phase: t, run: e };
+}
+const $e = 22, Q = (1 << $e) - 1, xt = 2 ** 31, b = (i) => i & Q;
+class ze {
+  /** Current generation per slot; an id is alive when its generation matches and the slot is in use. */
+  generations = [];
+  inUse = [];
+  free = [];
+  live = 0;
+  stores = [];
+  /** Typed-array columns of the field components, by component id. */
+  cols = [];
+  systems = [];
+  pending = [];
+  /** `slots` results by the component ids asked for, rebuilt only when one of those sets changed membership. */
+  slotCache = /* @__PURE__ */ new Map();
+  /** Walks (`query`, `each`, system runs) in progress: structure changes wait until it is 0. */
+  walking = 0;
+  /** A new entity with no components. */
+  create() {
+    let t;
+    if (this.free.length)
+      t = this.free.pop();
+    else {
+      if (t = this.generations.length, t > Q) throw new Error("World: too many live entities");
+      this.generations.push(0), this.inUse.push(!1);
+    }
+    return this.inUse[t] = !0, this.live++, this.generations[t] * (Q + 1) + t;
+  }
+  /** A new entity with these components. */
+  spawn(...t) {
+    const e = this.create();
+    for (const [s, n] of t) this.add(e, s, n);
+    return e;
+  }
+  isAlive(t) {
+    const e = b(t);
+    return this.inUse[e] === !0 && this.generations[e] === Math.floor(t / (Q + 1));
+  }
+  /** Live entities. */
+  get size() {
+    return this.live;
+  }
+  /** Removes an entity and every component it had (deferred while a walk is in progress). */
+  destroy(t) {
+    if (!this.isAlive(t)) return;
+    if (this.walking > 0) {
+      this.pending.push({ kind: "destroy", e: t });
+      return;
+    }
+    const e = b(t);
+    for (const s of this.stores) s?.delete(e, b);
+    this.inUse[e] = !1, this.generations[e] = (this.generations[e] + 1) % xt, this.free.push(e), this.live--;
+  }
+  add(t, e, s) {
+    if (!this.isAlive(t)) throw new Error(`World.add: entity ${t} is not alive`);
+    const n = b(t);
+    if (We(e)) {
+      const r = this.columnsOf(e, n + 1), o = s ?? {};
+      for (const a of Object.keys(e.fields)) r[a][n] = o[a] ?? 0;
+      return this.store(e).set(n, t, n), n;
+    }
+    return this.store(e).set(n, t, s), s;
+  }
+  /**
+   * The typed-array columns of a field component, indexed by slot. Fetch them per system run: adding entities may
+   * grow them into new arrays.
+   */
+  columns(t) {
+    return this.columnsOf(t, this.generations.length);
+  }
+  get(t, e) {
+    if (this.isAlive(t))
+      return this.stores[e.id]?.get(b(t));
+  }
+  /** The component, or an error naming what is missing: for code that knows the entity has it. */
+  require(t, e) {
+    const s = this.stores[e.id];
+    if (!this.isAlive(t) || !s?.has(b(t))) throw new Error(`World.require: entity ${t} has no ${e.name}`);
+    return s.get(b(t));
+  }
+  has(t, e) {
+    return this.isAlive(t) && (this.stores[e.id]?.has(b(t)) ?? !1);
+  }
+  /** Takes one component off an entity (deferred while a walk is in progress). */
+  remove(t, e) {
+    if (this.isAlive(t)) {
+      if (this.walking > 0) {
+        this.pending.push({ kind: "remove", e: t, type: e });
+        return;
+      }
+      this.stores[e.id]?.delete(b(t), b);
+    }
+  }
+  /** How many entities hold `type`. */
+  count(t) {
+    return this.stores[t.id]?.size ?? 0;
+  }
+  /**
+   * Calls `fn(entity, ...components)` for every live entity holding all of `types`. Allocates nothing per entity:
+   * the form for systems that walk thousands of bodies every step.
+   */
+  each(...t) {
+    const e = t[t.length - 1], s = t.slice(0, -1), n = this.setsFor(s);
+    if (!n) return;
+    const r = nt(n), o = r.entities.length;
+    this.walking++;
+    try {
+      if (n.length === 1)
+        for (let a = o - 1; a >= 0; a--) e(r.entities[a], r.values[a]);
+      else if (n.length === 2) {
+        const [a, h] = n;
+        for (let l = o - 1; l >= 0; l--) {
+          const c = r.entities[l], u = b(c);
+          !a.has(u) || !h.has(u) || e(c, a.get(u), h.get(u));
+        }
+      } else {
+        const a = new Array(n.length);
+        for (let h = o - 1; h >= 0; h--) {
+          const l = r.entities[h], c = b(l);
+          let u = !0;
+          for (let d = 0; d < n.length; d++) {
+            const m = n[d];
+            if (!m.has(c)) {
+              u = !1;
+              break;
+            }
+            a[d] = m.get(c);
+          }
+          u && e(l, ...a);
+        }
+      }
+    } finally {
+      this.endWalk();
+    }
+  }
+  /**
+   * The slot index of every entity holding all of `types`, as a typed array: the fastest walk there is, made for
+   * field components (`defineFields`), whose columns are indexed by slot.
+   *
+   * ```ts
+   * const p = world.columns(Position), v = world.columns(Velocity);
+   * const slots = world.slots(Position, Velocity);
+   * for (let k = 0; k < slots.length; k++) { const i = slots[k]!; p.x[i]! += v.x[i]! * dt; }
+   * ```
+   *
+   * The result is cached and rebuilt only when an entity joins or leaves one of those components, so asking every
+   * step is cheap. It is a view the world owns: read it, don't keep it past the step, and fetch it again after
+   * adding or removing components.
+   */
+  slots(...t) {
+    const e = t.map((h) => h.id).join(","), s = this.setsFor(t);
+    if (!s) return Ge;
+    let n = this.slotCache.get(e);
+    if (n && n.versions.every((h, l) => h === s[l].version)) return n.view;
+    const r = nt(s), o = n && n.slots.length >= r.size ? n.slots : new Int32Array(Math.max(16, r.size));
+    let a = 0;
+    for (let h = 0; h < r.entities.length; h++) {
+      const l = b(r.entities[h]);
+      let c = !0;
+      for (const u of s)
+        if (u !== r && !u.has(l)) {
+          c = !1;
+          break;
+        }
+      c && (o[a++] = l);
+    }
+    return n = { versions: s.map((h) => h.version), slots: o, view: o.subarray(0, a) }, this.slotCache.set(e, n), n.view;
+  }
+  /**
+   * Every live entity holding all of `types`, with those components in the same order. Yields a fresh row per
+   * entity: convenient, but `each` is the form for hot loops.
+   */
+  *query(...t) {
+    const e = this.setsFor(t);
+    if (!e) return;
+    const s = nt(e);
+    this.walking++;
+    try {
+      for (let n = s.entities.length - 1; n >= 0; n--) {
+        const r = s.entities[n], o = b(r), a = [r];
+        let h = !0;
+        for (const l of e) {
+          if (!l.has(o)) {
+            h = !1;
+            break;
+          }
+          a.push(l.get(o));
+        }
+        h && (yield a);
+      }
+    } finally {
+      this.endWalk();
+    }
+  }
+  /** The first entity matching the query, or undefined: for singletons (the player, the camera target). */
+  first(...t) {
+    for (const e of this.query(...t)) return e;
+  }
+  addSystem(t) {
+    if (this.systems.some((e) => e.name === t.name)) throw new Error(`World.addSystem: a system named "${t.name}" is already added`);
+    return this.systems.push(t), this;
+  }
+  removeSystem(t) {
+    const e = this.systems.findIndex((n) => n.name === t);
+    if (e < 0) return;
+    const [s] = this.systems.splice(e, 1);
+    s.dispose?.();
+  }
+  /** Runs every system of `phase` in the order added. A system that throws is reported and the rest still run. */
+  run(t, e, s) {
+    const n = { dt: e.dt, now: e.now, alpha: e.alpha, world: this };
+    this.walking++;
+    try {
+      for (const r of this.systems)
+        if (r.phase === t)
+          try {
+            r.run(n);
+          } catch (o) {
+            if (s) s(r, o);
+            else throw o;
+          }
+    } finally {
+      this.endWalk();
+    }
+  }
+  /** Every entity, component and system gone. */
+  clear() {
+    for (const t of this.systems.splice(0)) t.dispose?.();
+    for (const t of this.stores) t?.clear();
+    this.generations = this.generations.map((t) => (t + 1) % xt), this.inUse.fill(!1), this.free.length = 0;
+    for (let t = this.generations.length - 1; t >= 0; t--) this.free.push(t);
+    this.live = 0, this.pending.length = 0, this.slotCache.clear();
+  }
+  columnsOf(t, e) {
+    let s = this.cols[t.id];
+    const n = s ? Object.values(s)[0]?.length ?? 0 : 0;
+    if (!s || n < e) {
+      let r = Math.max(64, n);
+      for (; r < e; ) r *= 2;
+      s = Ue(t.fields, r, s), this.cols[t.id] = s;
+    }
+    return s;
+  }
+  store(t) {
+    let e = this.stores[t.id];
+    return e || (e = new _e(), this.stores[t.id] = e), e;
+  }
+  /** The stores for `types`, or null when one has never been used (so nothing can match). */
+  setsFor(t) {
+    if (t.length === 0) return null;
+    const e = [];
+    for (const s of t) {
+      const n = this.stores[s.id];
+      if (!n || n.size === 0) return null;
+      e.push(n);
+    }
+    return e;
+  }
+  endWalk() {
+    if (this.walking--, this.walking > 0 || this.pending.length === 0) return;
+    const t = this.pending.splice(0);
+    for (const e of t)
+      e.kind === "destroy" ? this.destroy(e.e) : this.remove(e.e, e.type);
+  }
+}
+const Ge = new Int32Array(0);
+function nt(i) {
+  let t = i[0];
+  for (const e of i) e.size < t.size && (t = e);
+  return t;
+}
+class _n {
+  world = new ze();
+  /** Everything the scene draws in the world goes under this (the camera moves it). */
+  root = new M({ sortableChildren: !0 });
+  /** Everything the scene draws on the screen (HUD) goes under this. */
+  hud = new M();
+  bound = null;
+  /** The engine running this scene; only valid between `enter` and `exit`. */
+  get engine() {
+    if (!this.bound) throw new Error(`${this.constructor.name}: not running in an engine`);
+    return this.bound;
+  }
+  /** Called once when the scene becomes active. May be async: the scene starts updating when it resolves. */
+  onEnter() {
+  }
+  /** Called when the scene is removed. The world and containers are cleared after it returns. */
+  onExit() {
+  }
+  /** Called when another scene is pushed over this one. */
+  onPause() {
+  }
+  /** Called when the scene over this one is popped. */
+  onResume() {
+  }
+  /** Once per simulation step, `dt` in seconds. */
+  fixedUpdate(t) {
+  }
+  /** Once per rendered frame, `dt` in seconds; `alpha` is the share of a step since the last one (0–1). */
+  update(t, e) {
+  }
+  /** @internal Engine-side wiring; games call `engine.scenes`. */
+  attach(t) {
+    this.bound = t, t.stage.world.addChild(this.root), t.stage.screen.addChild(this.hud);
+  }
+  /** @internal Clears what the scene made but keeps its containers, so the same scene may be entered again. */
+  detach() {
+    this.world.clear();
+    for (const t of [this.root, this.hud]) {
+      for (const e of t.removeChildren()) e.destroy({ children: !0 });
+      t.removeFromParent();
+    }
+    this.bound = null;
+  }
+}
+const N = 2, qe = 1024, lt = 8192, Ye = 4096;
+function Pn(i) {
+  return i === null || i >= lt ? lt : Math.min(Ye, 2 ** Math.floor(Math.log2(Math.max(1, i))));
+}
+function je(i, t) {
+  const e = i.map((f, p) => p).sort((f, p) => i[p].h - i[f].h), s = i.reduce((f, p) => f + (p.w + N) * (p.h + N), 0), n = Math.max(1, ...i.map((f) => f.w + N)), r = Math.min(t, Math.max(qe, 2 ** Math.ceil(Math.log2(Math.max(n, Math.sqrt(s)))))), o = new Array(i.length), a = [];
+  let h = 0, l = 0, c = 0, u = 0, d = r;
+  const m = () => a.push({ width: d, height: c + u });
+  for (const f of e) {
+    const p = i[f].w + N, g = i[f].h + N;
+    l > 0 && l + p > d && (l = 0, c += u, u = 0), c > 0 && c + g > t && (m(), h++, l = 0, c = 0, u = 0, d = r), p > d && (d = p), o[f] = { page: h, x: l, y: c }, l += p, u = Math.max(u, g);
+  }
+  return i.length > 0 && m(), { pages: a, places: o };
+}
+class Wn {
+  items = [];
+  add(t, e) {
+    this.items.push({ name: t, canvas: e });
+  }
+  addSheet(t, e, s, n) {
+    this.items.push({ name: t, canvas: e, frameWidth: s, frameHeight: n });
+  }
+  build(t, e, s = lt) {
+    const n = this.items, r = je(n.map((c) => ({ w: c.canvas.width, h: c.canvas.height })), s), o = r.pages.map((c, u) => {
+      const d = document.createElement("canvas");
+      return d.width = c.width, d.height = c.height, { canvas: d, ctx: d.getContext("2d", { willReadFrequently: !0 }), key: u === 0 ? e : `${e}~${u}` };
+    });
+    n.forEach((c, u) => {
+      const d = r.places[u];
+      o[d.page].ctx.drawImage(c.canvas, d.x, d.y);
+    });
+    const a = t.addCanvas(e, o[0].canvas), h = o.map((c, u) => u === 0 ? a : t.addCanvas(c.key, c.canvas));
+    n.forEach((c, u) => {
+      const d = r.places[u], m = h[d.page], f = (p, g, y, w, v) => {
+        m.add(p, 0, g, y, w, v), d.page > 0 && a.adopt(p, m);
+      };
+      if (c.frameWidth && c.frameHeight) {
+        const p = Math.floor(c.canvas.width / c.frameWidth), g = Math.max(1, Math.floor(c.canvas.height / c.frameHeight));
+        for (let y = 0; y < p * g; y++)
+          f(`${c.name}#${y}`, d.x + y % p * c.frameWidth, d.y + Math.floor(y / p) * c.frameHeight, c.frameWidth, c.frameHeight);
+      } else
+        f(c.name, d.x, d.y, c.canvas.width, c.canvas.height);
+    });
+    const l = r.pages.map((c) => `${c.width}x${c.height}`).join(" + ");
+    console.info(`[atlas] ${e}: ${n.length} images packed into ${l}${r.pages.length > 1 ? ` (pages of ${s})` : ""}`);
+  }
+}
+const Ve = 2147483648, Xe = 1073741824, Je = 536870912, Ke = 536870911, $t = (i) => i & Ke;
+function zt(i, t) {
+  const e = $t(t);
+  if (e === 0) return null;
+  let s = null;
+  for (const n of i.tilesets) n.firstGid <= e && (!s || n.firstGid > s.firstGid) && (s = n);
+  return !s || e - s.firstGid >= s.tileCount ? null : { tileset: s, local: e - s.firstGid };
+}
+function Ze(i, t) {
+  const e = t % i.columns, s = Math.floor(t / i.columns);
+  return { x: i.margin + e * (i.tileWidth + i.spacing), y: i.margin + s * (i.tileHeight + i.spacing), w: i.tileWidth, h: i.tileHeight };
+}
+function Un(i, t) {
+  return i.layers.find((e) => e.name === t);
+}
+function Nn(i, t) {
+  const e = [];
+  for (const s of i.layers) if (s.kind === "objects")
+    for (const n of s.objects) (t === void 0 || n.type === t) && e.push(n);
+  return e;
+}
+class F extends Error {
+  constructor(t) {
+    super(`Tiled map: ${t}`);
+  }
+}
+function _(i) {
+  const t = {};
+  if (!Array.isArray(i)) return t;
+  for (const e of i) e && typeof e.name == "string" && ["string", "number", "boolean"].includes(typeof e.value) && (t[e.name] = e.value);
+  return t;
+}
+function x(i, t) {
+  if (typeof i != "number" || !Number.isFinite(i)) throw new F(`${t} must be a number`);
+  return i;
+}
+function Qe(i) {
+  if (typeof atob == "function") {
+    const t = atob(i.trim()), e = new Uint8Array(t.length);
+    for (let s = 0; s < t.length; s++) e[s] = t.charCodeAt(s);
+    return e;
+  }
+  return new Uint8Array(globalThis.Buffer.from(i, "base64"));
+}
+function ts(i, t) {
+  if (i.compression) throw new F(`layer "${i.name}" is ${i.compression}-compressed; save it as CSV or uncompressed base64`);
+  let e;
+  if (i.encoding === "base64") {
+    const s = Qe(String(i.data));
+    if (s.length !== t * 4) throw new F(`layer "${i.name}" holds ${s.length / 4} cells, not ${t}`);
+    const n = new DataView(s.buffer, s.byteOffset, s.byteLength);
+    e = new Uint32Array(t);
+    for (let r = 0; r < t; r++) e[r] = n.getUint32(r * 4, !0);
+  } else {
+    if (!Array.isArray(i.data) || i.data.length !== t) throw new F(`layer "${i.name}" must hold ${t} cells`);
+    e = Uint32Array.from(i.data);
+  }
+  return e;
+}
+function es(i) {
+  const t = {
+    id: x(i.id, "object id"),
+    name: String(i.name ?? ""),
+    type: String(i.type ?? i.class ?? ""),
+    x: x(i.x, "object x"),
+    y: x(i.y, "object y"),
+    width: Number(i.width ?? 0),
+    height: Number(i.height ?? 0),
+    rotation: Number(i.rotation ?? 0),
+    point: i.point === !0,
+    ellipse: i.ellipse === !0,
+    properties: _(i.properties)
+  };
+  return typeof i.gid == "number" && (t.gid = i.gid), Array.isArray(i.polygon) && (t.polygon = i.polygon.map((e) => ({ x: x(e.x, "polygon x"), y: x(e.y, "polygon y") }))), t;
+}
+function Gt(i, t, e, s = { visible: !0, opacity: 1, x: 0, y: 0 }) {
+  if (Array.isArray(i))
+    for (const n of i) {
+      const r = s.visible && n.visible !== !1, o = s.opacity * (typeof n.opacity == "number" ? n.opacity : 1), a = s.x + Number(n.offsetx ?? 0), h = s.y + Number(n.offsety ?? 0);
+      n.type === "tilelayer" ? e.push({ kind: "tiles", name: String(n.name ?? ""), data: ts(n, t.width * t.height), visible: r, opacity: o, offsetX: a, offsetY: h, properties: _(n.properties) }) : n.type === "objectgroup" ? e.push({ kind: "objects", name: String(n.name ?? ""), objects: (n.objects ?? []).map(es), visible: r, properties: _(n.properties) }) : n.type === "group" && Gt(n.layers, t, e, { visible: r, opacity: o, x: a, y: h });
+    }
+}
+function ss(i) {
+  if (typeof i.source == "string") throw new F(`tileset "${i.source}" is external; embed it in the map (Map → Embed Tilesets)`);
+  if (typeof i.image != "string") throw new F(`tileset "${i.name}" is a collection of images; use a single-image tileset`);
+  const t = /* @__PURE__ */ new Map(), e = /* @__PURE__ */ new Map();
+  for (const s of i.tiles ?? []) {
+    const n = x(s.id, "tile id");
+    s.properties && t.set(n, _(s.properties)), Array.isArray(s.animation) && e.set(n, s.animation.map((r) => ({ tileId: x(r.tileid, "animation tileid"), duration: x(r.duration, "animation duration") })));
+  }
+  return {
+    name: String(i.name ?? ""),
+    firstGid: x(i.firstgid, "tileset firstgid"),
+    image: i.image,
+    imageWidth: x(i.imagewidth, "tileset imagewidth"),
+    imageHeight: x(i.imageheight, "tileset imageheight"),
+    tileWidth: x(i.tilewidth, "tileset tilewidth"),
+    tileHeight: x(i.tileheight, "tileset tileheight"),
+    columns: x(i.columns, "tileset columns"),
+    tileCount: x(i.tilecount, "tileset tilecount"),
+    margin: Number(i.margin ?? 0),
+    spacing: Number(i.spacing ?? 0),
+    tileProperties: t,
+    animations: e,
+    properties: _(i.properties)
+  };
+}
+function is(i) {
+  const t = i;
+  if (!t || typeof t != "object") throw new F("not a JSON object");
+  if (t.infinite) throw new F("infinite maps are not supported; uncheck Map → Map Properties → Infinite");
+  if (t.orientation && t.orientation !== "orthogonal") throw new F(`${t.orientation} maps are not supported, only orthogonal`);
+  const e = x(t.width, "width"), s = x(t.height, "height"), n = [];
+  Gt(t.layers, { width: e, height: s }, n);
+  const r = {
+    width: e,
+    height: s,
+    tileWidth: x(t.tilewidth, "tilewidth"),
+    tileHeight: x(t.tileheight, "tileheight"),
+    layers: n,
+    tilesets: (t.tilesets ?? []).map(ss),
+    properties: _(t.properties)
+  };
+  return typeof t.backgroundcolor == "string" && (r.backgroundColor = t.backgroundcolor), r;
+}
+function bt(i, t) {
+  if (/^[a-z][a-z0-9+.-]*:/i.test(i) || i.startsWith("/")) return i;
+  const s = (t.slice(0, t.lastIndexOf("/") + 1) + i).split("/"), n = [];
+  for (const r of s)
+    r === ".." && n.length && n[n.length - 1] !== ".." && n[n.length - 1] !== "" ? n.pop() : r !== "." && n.push(r);
+  return n.join("/");
+}
+async function ns(i) {
+  const t = await createImageBitmap(i), e = document.createElement("canvas");
+  e.width = t.width, e.height = t.height;
+  const s = e.getContext("2d");
+  if (!s) throw new Error("AssetLoader: no 2D context (out of canvas memory?)");
+  return s.drawImage(t, 0, 0), t.close(), e;
+}
+class $n {
+  constructor(t, e = {}) {
+    this.textures = t, this.options = e, this.fetcher = e.fetch ?? ((s) => fetch(s)), this.toCanvas = e.toCanvas ?? ns;
+  }
+  textures;
+  options;
+  queue = [];
+  data = /* @__PURE__ */ new Map();
+  maps = /* @__PURE__ */ new Map();
+  fetcher;
+  toCanvas;
+  total = 0;
+  done = 0;
+  image(t, e) {
+    return this.add(t, async () => {
+      this.textures.addCanvas(t, await this.toCanvas(await this.blob(e)));
+    });
+  }
+  /** An image cut into equal frames named 0, 1, 2…, left to right, then row by row. */
+  spritesheet(t, e, s) {
+    return this.add(t, async () => {
+      this.textures.addSpriteSheet(t, await this.toCanvas(await this.blob(e)), s);
+    });
+  }
+  json(t, e) {
+    return this.add(t, async () => {
+      this.data.set(t, await (await this.request(e)).json());
+    });
+  }
+  text(t, e) {
+    return this.add(t, async () => {
+      this.data.set(t, await (await this.request(e)).text());
+    });
+  }
+  /** A Tiled JSON map, then every tileset image it names (resolved beside the map file). */
+  tilemap(t, e, s = {}) {
+    return this.add(t, async () => {
+      const n = is(await (await this.request(e)).json());
+      this.maps.set(t, n);
+      const r = s.textureKey ?? ((o) => o.name);
+      for (const o of n.tilesets) this.image(r(o), bt(o.image, e));
+    });
+  }
+  /** Runs everything queued; `onProgress` after each asset. Safe to call again after queueing more. */
+  async load(t) {
+    const e = Math.max(1, this.options.concurrency ?? 6), s = async () => {
+      for (let n = this.queue.shift(); n; n = this.queue.shift())
+        await n.run(), this.done++, t?.({ done: this.done, total: this.total, key: n.key });
+    };
+    for (; this.queue.length; ) await Promise.all(Array.from({ length: e }, s));
+  }
+  /** A loaded JSON value. */
+  getJson(t) {
+    if (!this.data.has(t)) throw new Error(`AssetLoader: no JSON or text loaded as "${t}"`);
+    return this.data.get(t);
+  }
+  /** A loaded text file. */
+  getText(t) {
+    return this.getJson(t);
+  }
+  /** A loaded Tiled map. */
+  map(t) {
+    const e = this.maps.get(t);
+    if (!e) throw new Error(`AssetLoader: no tilemap loaded as "${t}"`);
+    return e;
+  }
+  add(t, e) {
+    return this.queue.push({ key: t, run: e }), this.total++, this;
+  }
+  async request(t) {
+    const e = bt(t, this.options.baseUrl ?? "");
+    let s;
+    try {
+      s = await this.fetcher(e);
+    } catch (n) {
+      throw new Error(`AssetLoader: could not fetch ${e}: ${n instanceof Error ? n.message : String(n)}`);
+    }
+    if (!s.ok) throw new Error(`AssetLoader: ${e} answered ${s.status}`);
+    return s;
+  }
+  async blob(t) {
+    return (await this.request(t)).blob();
+  }
+}
+class zn {
+  constructor(t, e) {
+    this.clips = t;
+    const s = t[e];
+    if (!s) throw new Error(`Animator: no clip "${e}"`);
+    if (s.frames.length === 0) throw new Error(`Animator: clip "${e}" has no frames`);
+    this.clip = s, this.name = e;
+  }
+  clips;
+  clip;
+  index = 0;
+  elapsed = 0;
+  ended = !1;
+  name;
+  /** Called when a clip that does not loop reaches its last frame. */
+  onComplete = null;
+  /** Playback speed multiplier (1 normal, 0 paused). */
+  speed = 1;
+  /** The clip playing. */
+  get current() {
+    return this.name;
+  }
+  /** The frame to show now. */
+  get frame() {
+    return this.clip.frames[this.index];
+  }
+  /** Which frame of the clip (0-based). */
+  get frameIndex() {
+    return this.index;
+  }
+  /** A non-looping clip has reached its last frame. */
+  get finished() {
+    return this.ended;
+  }
+  /** Plays `name`. The clip already playing keeps its place unless `restart`. */
+  play(t, e = !1) {
+    if (t === this.name && !e) return this;
+    const s = this.clips[t];
+    if (!s) throw new Error(`Animator: no clip "${t}"`);
+    if (s.frames.length === 0) throw new Error(`Animator: clip "${t}" has no frames`);
+    return this.clip = s, this.name = t, this.index = 0, this.elapsed = 0, this.ended = !1, this;
+  }
+  /** Advances by `dt` seconds; returns true when the frame changed. */
+  update(t) {
+    if (this.ended || !(t > 0) || this.speed <= 0) return !1;
+    this.elapsed += t * 1e3 * this.speed;
+    const e = this.index, s = this.clip.frames.length;
+    for (let n = this.lengthOf(this.index); this.elapsed >= n; n = this.lengthOf(this.index))
+      if (this.elapsed -= n, this.index < s - 1)
+        this.index++;
+      else if (this.clip.loop !== !1)
+        this.index = 0;
+      else {
+        this.ended = !0, this.elapsed = 0, this.onComplete?.(this.name);
+        break;
+      }
+    return this.index !== e;
+  }
+  lengthOf(t) {
+    const e = this.clip.durations?.[t] ?? 1e3 / (this.clip.fps ?? 10);
+    return Math.max(1, e);
+  }
+}
+const rs = Nt("Sprite"), os = Nt("Animation");
+function Gn(i = "animation") {
+  return Ne(i, "frame", ({ world: t, dt: e }) => {
+    t.each(rs, os, (s, n, r) => {
+      (r.update(e) || n.frameName !== String(r.frame)) && n.setFrame(r.frame);
+    });
+  });
+}
+const vt = 0.7071067811865476;
+function as(i, t, e, s, n = {}) {
+  if (s.length !== i * t)
+    throw new Error(`collision string length ${s.length} != ${i}x${t}`);
+  const r = new Uint8Array(i * t);
+  for (let u = 0; u < r.length; u++) r[u] = s.charCodeAt(u) === 49 ? 1 : 0;
+  const { ground: o } = n, a = new Set(n.shotOverTiles ?? []);
+  let h;
+  if (o && o.length === r.length && a.size) {
+    h = new Uint8Array(r.length);
+    for (let u = 0; u < r.length; u++) h[u] = r[u] && a.has(o[u]) ? 1 : 0;
+  }
+  const l = n.bodyHalfWidth ?? fe, c = n.bodyHalfHeight ?? pe;
+  return h ? { width: i, height: t, tileSize: e, solid: r, shotOver: h, bodyHalfWidth: l, bodyHalfHeight: c } : { width: i, height: t, tileSize: e, solid: r, bodyHalfWidth: l, bodyHalfHeight: c };
+}
+function qn(i, t, e) {
+  return P(i, t, e) ? i.shotOver?.[e * i.width + t] !== 1 : !1;
+}
+function qt(i, t) {
+  return { x: i, y: t, lastDx: 1, lastDy: 0, dashLeft: 0, dashCd: 0, dashDx: 1, dashDy: 0 };
+}
+function P(i, t, e) {
+  return t < 0 || e < 0 || t >= i.width || e >= i.height ? !0 : i.solid[e * i.width + t] === 1;
+}
+function Yn(i, t, e) {
+  const s = i.tileSize, n = Math.floor((t - i.bodyHalfWidth) / s), r = Math.floor((t + i.bodyHalfWidth) / s), o = Math.floor((e - i.bodyHalfHeight) / s), a = Math.floor((e + i.bodyHalfHeight) / s);
+  for (let h = o; h <= a; h++)
+    for (let l = n; l <= r; l++)
+      if (P(i, l, h)) return !0;
+  return !1;
+}
+function hs(i, t, e, s) {
+  if (s === 0) return t;
+  const n = i.tileSize, r = t + s, o = Math.floor((e - i.bodyHalfHeight) / n), a = Math.floor((e + i.bodyHalfHeight) / n);
+  if (s > 0) {
+    const h = Math.floor((r + i.bodyHalfWidth) / n);
+    for (let l = o; l <= a; l++)
+      if (P(i, h, l)) return h * n - i.bodyHalfWidth - tt;
+  } else {
+    const h = Math.floor((r - i.bodyHalfWidth) / n);
+    for (let l = o; l <= a; l++)
+      if (P(i, h, l)) return (h + 1) * n + i.bodyHalfWidth + tt;
+  }
+  return r;
+}
+function ls(i, t, e, s) {
+  if (s === 0) return e;
+  const n = i.tileSize, r = e + s, o = Math.floor((t - i.bodyHalfWidth) / n), a = Math.floor((t + i.bodyHalfWidth) / n);
+  if (s > 0) {
+    const h = Math.floor((r + i.bodyHalfHeight) / n);
+    for (let l = o; l <= a; l++)
+      if (P(i, l, h)) return h * n - i.bodyHalfHeight - tt;
+  } else {
+    const h = Math.floor((r - i.bodyHalfHeight) / n);
+    for (let l = o; l <= a; l++)
+      if (P(i, l, h)) return (h + 1) * n + i.bodyHalfHeight + tt;
+  }
+  return r;
+}
+function Mt(i) {
+  return i > 0 ? 1 : i < 0 ? -1 : 0;
+}
+function ct(i, t, e, s) {
+  i.dashCd > 0 && i.dashCd--;
+  const n = i.dashLeft > 0;
+  let r = e.canMove && !n ? Mt(t[0]) : 0, o = e.canMove && !n ? Mt(t[1]) : 0;
+  r !== 0 && o !== 0 && (r = r * vt, o = o * vt), (r !== 0 || o !== 0) && (i.lastDx = r, i.lastDy = o), (t[2] & me) !== 0 && e.canDash && e.canMove && i.dashLeft === 0 && i.dashCd === 0 && (i.dashLeft = e.dashSteps, i.dashCd = e.dashCooldownSteps, i.dashDx = i.lastDx, i.dashDy = i.lastDy);
+  let a, h;
+  i.dashLeft > 0 ? (a = i.dashDx * e.dashSpeed, h = i.dashDy * e.dashSpeed, i.dashLeft--) : (a = r * e.speed, h = o * e.speed), i.x = hs(s, i.x, i.y, a * gt), i.y = ls(s, i.x, i.y, h * gt);
+}
+function jn(i, t = {}) {
+  if (i.tileWidth !== i.tileHeight) throw new Error(`Tiled map: collision needs square tiles, not ${i.tileWidth}x${i.tileHeight}`);
+  const e = t.solid ?? (i.layers.some((h) => h.kind === "tiles" && h.name === "collision") ? "collision" : { property: "solid" }), s = i.width * i.height, n = new Uint8Array(s);
+  if (typeof e == "string") {
+    const h = i.layers.find((l) => l.kind === "tiles" && l.name === e);
+    if (!h || h.kind !== "tiles") throw new Error(`Tiled map: no tile layer named "${e}"`);
+    for (let l = 0; l < s; l++) $t(h.data[l]) !== 0 && (n[l] = 1);
+  } else
+    for (const h of i.layers)
+      if (h.kind === "tiles")
+        for (let l = 0; l < s; l++) {
+          const c = zt(i, h.data[l]);
+          c && c.tileset.tileProperties.get(c.local)?.[e.property] === !0 && (n[l] = 1);
+        }
+  let r = "";
+  for (let h = 0; h < s; h++) r += n[h] ? "1" : "0";
+  const { solid: o, ...a } = t;
+  return as(i.width, i.height, i.tileWidth, r, a);
+}
+let cs = 0;
+class Vn {
+  constructor(t, e, s = {}) {
+    this.stage = t, this.map = e;
+    const n = s.textureFor ?? ((c) => c.name), r = Math.max(1, s.chunkTiles ?? 32), o = s.baseDepth ?? -1e6, a = s.layers ? new Set(s.layers) : null, h = e.layers.filter((c) => c.kind === "tiles" && (a ? a.has(c.name) : c.visible)), l = s.parent ?? t.world;
+    h.forEach((c, u) => {
+      const d = typeof c.properties.depth == "number" ? c.properties.depth : o + u, m = new M();
+      m.zIndex = d, m.alpha = c.opacity, m.position.set(c.offsetX, c.offsetY), this.layers.set(c.name, m), l.addChild(m);
+      for (let f = 0; f < e.height; f += r)
+        for (let p = 0; p < e.width; p += r) {
+          const g = Math.min(r, e.width - p), y = Math.min(r, e.height - f);
+          this.paintChunk(c, m, p, f, g, y, n);
+        }
+    });
+  }
+  stage;
+  map;
+  /** One container per drawn tile layer, by name, each at its own depth among the bodies. */
+  layers = /* @__PURE__ */ new Map();
+  chunks = [];
+  id = cs++;
+  /** Shows only the chunks in the camera's view (plus a margin in world px). Call once a frame. */
+  update(t = 32) {
+    const e = this.stage.cameras.main.worldView;
+    for (const s of this.chunks)
+      s.sprite.visible = s.x < e.right + t && s.x + s.w > e.x - t && s.y < e.bottom + t && s.y + s.h > e.y - t;
+  }
+  /** World size of the map in px. */
+  get widthPx() {
+    return this.map.width * this.map.tileWidth;
+  }
+  get heightPx() {
+    return this.map.height * this.map.tileHeight;
+  }
+  destroy() {
+    for (const t of this.chunks) this.stage.textures.remove(t.key);
+    this.chunks.length = 0;
+    for (const t of this.layers.values()) t.destroy({ children: !0 });
+    this.layers.clear();
+  }
+  paintChunk(t, e, s, n, r, o, a) {
+    const { map: h } = this, l = h.tileWidth, c = h.tileHeight;
+    let u = !1;
+    const d = `tilemap:${this.id}:${t.name}:${s},${n}`, f = Math.max(c, ...h.tilesets.map((w) => w.tileHeight)) - c, p = this.stage.textures.createCanvas(d, r * l, o * c + f), g = p.context;
+    g.imageSmoothingEnabled = !1;
+    for (let w = 0; w < o; w++)
+      for (let v = 0; v < r; v++) {
+        const L = t.data[(n + w) * h.width + (s + v)], D = zt(h, L);
+        if (!D) continue;
+        const mt = this.stage.textures.exists(a(D.tileset)) ? this.stage.textures.get(a(D.tileset)).source.resource : null;
+        if (!mt) continue;
+        const A = Ze(D.tileset, D.local), Qt = v * l, te = f + (w + 1) * c - A.h;
+        g.save(), g.translate(Qt + A.w / 2, te + A.h / 2), L & Je && g.transform(0, 1, 1, 0, 0, 0), g.scale(L & Ve ? -1 : 1, L & Xe ? -1 : 1), g.drawImage(mt, A.x, A.y, A.w, A.h, -A.w / 2, -A.h / 2, A.w, A.h), g.restore(), u = !0;
+      }
+    if (!u) {
+      this.stage.textures.remove(d);
+      return;
+    }
+    p.refresh();
+    const y = new R(p.whole);
+    y.position.set(s * l, n * c - f), e.addChild(y), this.chunks.push({ sprite: y, x: y.x + t.offsetX, y: y.y + t.offsetY, w: r * l, h: o * c + f, key: d });
+  }
+}
+const At = Math.PI / 180, X = [90, 2, 0, 2];
+function T(i, t, e) {
+  return { x: i.x + t, y: i.y + e };
+}
+function J(i, t) {
+  const [e, s, n, r] = t, o = e * At, a = (e + n) * At, h = T(i, Math.cos(o) * s, Math.sin(o) * s);
+  return [h, T(h, Math.cos(a) * r, Math.sin(a) * r), a];
+}
+class us {
+  def;
+  constructor(t) {
+    this.def = t;
+  }
+  solve(t, e = !1) {
+    const s = this.def, n = e ? s.bulkyShoulder : 0, r = { x: s.chest[0], y: s.chest[1] + (t.by ?? 0) }, o = T(r, s.shoulderF[0] + n, s.shoulderF[1]), a = T(r, s.shoulderB[0] - n, s.shoulderB[1]), h = t.hipDx ?? 0, l = t.hipDy ?? 0, c = { x: s.hipF[0] + h, y: s.hipF[1] + l }, u = { x: s.hipB[0] + h, y: s.hipB[1] + l }, [d, m, f] = this.frontArm(o, t.armF ?? X), [p, g] = J(a, t.armB ?? X), [y, w] = J(c, t.legF ?? X), [v, L] = J(u, t.legB ?? X), D = T(r, t.headDx ?? 0, t.headDy ?? 0);
+    return { chest: r, head: D, shoulderF: o, elbowF: d, wristF: m, shoulderB: a, elbowB: p, wristB: g, hipF: c, kneeF: y, ankleF: w, hipB: u, kneeB: v, ankleB: L, forearm: f };
+  }
+  /**
+   * Elbow, wrist and forearm direction of the front arm (or of its motion smear) hung from `shoulder`. The fist keeps
+   * the frame's last column for its outline: an arm reaching past that (a swing, a thrust, a draw on a bulky body) is
+   * pulled back whole, so the forearm — and the weapon laid along it — keeps its angle.
+   */
+  frontArm(t, e) {
+    const s = this.def, [n, r, o] = J(t, e), a = Math.max(0, r.x - (s.width - s.limbWidth - 1));
+    return [T(n, -a, 0), T(r, -a, 0), o];
+  }
+}
+const ds = 1, fs = 20, ps = 24, ms = [10, 13], gs = [3, 1], ys = [-4, 1], ws = 1, xs = [11, 19], bs = [9, 19], vs = 2, Ms = 0.75, As = 0.72, ks = {
+  scale: ds,
+  width: fs,
+  height: ps,
+  chest: ms,
+  shoulderF: gs,
+  shoulderB: ys,
+  bulkyShoulder: ws,
+  hipF: xs,
+  hipB: bs,
+  limbWidth: vs,
+  backShade: Ms,
+  backArmShade: As
+}, Xn = ks;
+function Y(i, t, e) {
+  return i + (t - i) * e;
+}
+function kt(i, t, e) {
+  let s = (t - i) % 360;
+  return s > 180 && (s -= 360), s < -180 && (s += 360), i + s * e;
+}
+function K(i, t, e) {
+  return !i || !t ? e < 1 ? i ?? t : t ?? i : [kt(i[0], t[0], e), Y(i[1], t[1], e), kt(i[2], t[2], e), Y(i[3], t[3], e)];
+}
+function $(i, t, e) {
+  if (!(i === void 0 && t === void 0))
+    return Y(i ?? 0, t ?? 0, e);
+}
+function St(i, t, e) {
+  return e <= 0 ? i : e >= 1 ? t : {
+    ...i,
+    by: $(i.by, t.by, e),
+    armF: K(i.armF, t.armF, e),
+    armB: K(i.armB, t.armB, e),
+    legF: K(i.legF, t.legF, e),
+    legB: K(i.legB, t.legB, e),
+    hipDx: $(i.hipDx, t.hipDx, e),
+    hipDy: $(i.hipDy, t.hipDy, e),
+    headDx: $(i.headDx, t.headDx, e),
+    headDy: $(i.headDy, t.headDy, e),
+    smearArm: i.smearArm,
+    curl: i.curl && t.curl ? [Y(i.curl[0], t.curl[0], e), Y(i.curl[1], t.curl[1], e)] : i.curl
+  };
+}
+function Jn(i, t) {
+  const e = { ...i };
+  for (const [s, n] of Object.entries(t)) n !== void 0 && (e[s] = n);
+  return e;
+}
+function Kn(i, t) {
+  return {
+    ...i,
+    by: Math.max(-1, (i.by ?? 0) + (t.by ?? 0)),
+    legF: t.legF,
+    legB: t.legB,
+    hipDx: t.hipDx,
+    hipDy: t.hipDy,
+    // the far arm swings with the run, unless it holds the bow the action draws
+    armB: i.armBFront ? i.armB : t.armB,
+    trail: t.trail ?? i.trail
+  };
+}
+const Ss = { by: 0, armF: [45, 1.2, 45, 1.7], armB: [90, 2, 0, 1], legB: [135, 1.41, -45, 2], legF: [90, 1, 0, 2] }, Es = { by: 0, armF: [45, 2.41, 45, 1.7], armB: [90, 2, 0, 1], legB: [135, 1.41, -45, 2], legF: [90, 1, 0, 2], breathe: !0, sway: 1 }, Fs = { by: -1, armF: [45, 2.41, 45, 1.7], armB: [90, 2, 0, 1], legB: [135, 1.41, -45, 2], legF: [90, 1, 0, 2], breathe: !0, sway: 1 }, Bs = { by: 0, armF: [45, 1.2, 45, 1.7], armB: [90, 2, 0, 1], legB: [135, 1.41, -45, 2], legF: [90, 1, 0, 2], sway: -1 }, Ds = { by: -1, armF: [45, 2.41, 45, 1.7], armB: [90, 2, 0, 1], legB: [135, 1.41, -45, 2], legF: [90, 1, 0, 2], breathe: !0, sway: 2 }, Ts = { by: 1, armF: [45, 1.2, 45, 1.7], armB: [90, 2, 0, 1], legB: [135, 1.41, -45, 2], legF: [90, 1, 0, 2], sway: -1 }, Rs = { by: 0, armF: [45, 1.2, 45, 1.7], armB: [90, 2, 0, 1], legB: [135, 1.41, -45, 2], legF: [90, 1, 0, 2] }, Os = { by: 1, armF: [45, 1.2, 45, 1.7], armB: [90, 2, 0, 1], legB: [135, 1.41, -45, 2], legF: [90, 1, 0, 2] }, Cs = { by: 0, armF: [90, 1.7, 0, 0.85], armB: [90, 2, 0, 1], legB: [153.4, 2.24, -63.4, 1], legF: [45, 1.41, 45, 2], trail: 1 }, Ls = { by: -1, armF: [90, 1.7, 0, 0.85], armB: [90, 2, 0, 1], legB: [90, 1, 0, 1], legF: [90, 1, 0, 2], trail: 2 }, Hs = { by: 0, armF: [45, 1.2, 45, 1.7], armB: [90, 2, 0, 1], legB: [26.6, 2.24, 63.4, 1], legF: [153.4, 2.24, -63.4, 2], trail: 1 }, Is = { by: 0, armF: [45, 1.2, 0, 1.2], armB: [90, 1, 45, 1.41], legB: [18.4, 3.16, 71.6, 2], legF: [166, 4.12, -76, 1], trail: 1 }, _s = { by: -1, armF: [45, 1.2, 0, 1.2], armB: [90, 1, 45, 1.41], legB: [26.6, 2.24, 63.4, 2], legF: [153.4, 2.24, -63.4, 1], trail: 2 }, Ps = { by: 0, armF: [45, 1.2, 45, 1.7], armB: [90, 2, 0, 1], legB: [90, 1, 0, 2], legF: [90, 1, 0, 1], trail: 1 }, Ws = { by: 0, armF: [135, 2.41, 71.6, 1.9], armB: [21.8, 2.69, -55.5, 1.8], legB: [116.6, 2.24, 45, 3.16], legF: [90, 2, -71.6, 3.16], trail: 1 }, Us = { by: 1, armF: [135, 2.41, 71.6, 1.9], armB: [21.8, 2.69, -55.5, 1.8], legB: [153.4, 2.24, 26.6, 2], legF: [63.4, 2.24, -18.4, 1.41], trail: 1 }, Ns = { by: 0, armF: [63.4, 1.9, -108.4, 1.2], armB: [21.8, 2.69, -55.5, 1.8], legB: [90, 0, 45, 1.41], legF: [90, 2, 45, 1.41], trail: 2 }, $s = { by: -1, armF: [18.4, 2.69, -90, 2.69], armB: [21.8, 2.69, -55.5, 1.8], legB: [18.4, 3.16, -18.4, 1], legF: [153.4, 2.24, 0, 2.24], trail: 2 }, zs = { by: 0, armF: [18.4, 2.69, -90, 2.69], armB: [116.6, 1.12, 63.4, 1.5], legB: [45, 2.83, -26.6, 3.16], legF: [146.3, 3.61, 15.3, 3.16], trail: 1 }, Gs = { by: 1, armF: [18.4, 2.69, -90, 2.69], armB: [116.6, 1.12, 63.4, 1.5], legB: [33.7, 3.61, 11.3, 1.41], legF: [166, 4.12, 14, 2], trail: 1 }, qs = { by: 0, armF: [63.4, 1.9, -108.4, 1.2], armB: [116.6, 1.12, 63.4, 1.5], legB: [45, 2.83, 90, 1.41], legF: [180, 2, -45, 1.41], trail: 2 }, Ys = { by: -1, armF: [135, 2.41, 71.6, 1.9], armB: [116.6, 1.12, 63.4, 1.5], legB: [90, 1, 63.4, 2.24], legF: [45, 1.41, -45, 1], trail: 2 }, js = { by: 0, curl: [10, 18], hipDx: -1, hipDy: -1, headDx: 0, headDy: 5, legB: [14, 4.12, 57.5, 3.16], legF: [14, 4.12, 57.5, 3.16], armF: [94.4, 2.77, -17.4, 2.84], armB: [90, 2, 0, 1] }, Vs = { by: 0, curl: [10, 17], hipDx: -1, hipDy: -2, headDx: 3, headDy: 8, legB: [-9.5, 6.08, -80.5, 4], legF: [-9.5, 6.08, -80.5, 4], armF: [-45, 0.6, 63.4, 1.34], armB: [90, 2, 0, 1] }, Xs = { by: 0, curl: [9, 16], hipDx: -2, hipDy: -3, headDx: 3, headDy: 10, legB: [-39.8, 7.81, -103.3, 5], legF: [-39.8, 7.81, -103.3, 5], armF: [-114.8, 3.04, 46.6, 1.15], armB: [90, 2, 0, 1] }, Js = { by: 0, curl: [8, 16], hipDx: -3, hipDy: -3, headDx: 1, headDy: 10, legB: [-74.1, 7.28, -117.3, 5.1], legF: [-74.1, 7.28, -117.3, 5.1], armF: [-145.6, 4.9, 1.2, 1.83], armB: [90, 2, 0, 1] }, Ks = { by: 0, curl: [9, 17], hipDx: -2, hipDy: -2, headDx: 0, headDy: 8, legB: [-135, 4.24, -135, 5], legF: [-135, 4.24, -135, 5], armF: [171.5, 4.3, -21.7, 2.95], armB: [90, 2, 0, 1] }, Zs = { by: 0, curl: [10, 18], hipDx: -1, hipDy: -1, headDx: 0, headDy: 5, legB: [90, 1, 18.4, 3.16], legF: [90, 1, 18.4, 3.16], armF: [130.2, 3.62, -11.9, 3.14], armB: [90, 2, 0, 1] }, Qs = { by: 0, curl: [10, 18], hipDx: -1, hipDy: -1, headDx: 2, headDy: 7, legB: [0, 5, -45, 1.41], legF: [0, 5, -45, 1.41], armF: [81.9, 1.5, -27.4, 1.83], armB: [90, 2, 0, 1] }, ti = { by: 0, curl: [10, 17], hipDx: -1, hipDy: -2, headDx: 3, headDy: 9, legB: [-26.6, 6.71, -90, 4.47], legF: [-26.6, 6.71, -90, 4.47], armF: [-90, 1.27, 63.4, 0.95], armB: [90, 2, 0, 1] }, ei = { by: 0, curl: [9, 16], hipDx: -2, hipDy: -3, headDx: 2, headDy: 10, legB: [-56.3, 7.21, -112.4, 5.1], legF: [-56.3, 7.21, -112.4, 5.1], armF: [-130.2, 3.62, 9.3, 1.24], armB: [90, 2, 0, 1] }, si = { by: 0, curl: [9, 17], hipDx: -2, hipDy: -2, headDx: 1, headDy: 9, legB: [-101.3, 5.1, -135, 3.61], legF: [-101.3, 5.1, -135, 3.61], armF: [-170.5, 3.88, -15.2, 2.13], armB: [90, 2, 0, 1] }, ii = { by: 0, curl: [10, 18], hipDx: -1, hipDy: -1, headDx: 0, headDy: 7, legB: [-153.4, 2.24, -116.6, 4], legF: [-153.4, 2.24, -116.6, 4], armF: [144.5, 3.66, -9.5, 3.01], armB: [90, 2, 0, 1] }, ni = { by: 0, curl: [10, 18], hipDx: -1, hipDy: -1, headDx: 0, headDy: 3, legB: [45, 2.83, 45, 2], legF: [45, 2.83, 45, 2], armF: [113.2, 3.24, -15.1, 3.01], armB: [90, 2, 0, 1] }, ri = { by: 1, armF: [90, 1.7, 0, 0.85], armB: [90, 2, 0, 1], legB: [153.4, 2.24, -63.4, 1], legF: [45, 1.41, 45, 2] }, oi = { by: 0, armF: [45, 1.2, 45, 1.7], armB: [90, 2, 0, 1], legB: [135, 1.41, -45, 2], legF: [90, 1, 0, 2], face: "blink", headDx: -1 }, ai = { by: 1, armF: [45, 1.2, 45, 1.7], armB: [90, 2, 0, 1], legB: [135, 1.41, -45, 2], legF: [90, 1, 0, 2], face: "dizzy" }, hi = { by: 2, armF: [45, 1.2, 45, 1.7], armB: [90, 2, 0, 1], legB: [153.4, 2.24, -63.4, 2], legF: [45, 1.41, 45, 2] }, li = { by: 2, armF: [45, 1.2, 0, 1.2], armB: [90, 1, 45, 1.41], legB: [116.6, 2.24, 45, 3.16], legF: [26.6, 2.24, 63.4, 2] }, ci = { by: 0, armF: [45, 1.2, 45, 1.7], armB: [90, 2, 0, 1], legB: [0, 2, 63.4, 2.24], legF: [0, 1, 63.4, 2.24] }, ui = { by: 5, armF: [45, 1.2, 45, 1.7], armB: [90, 2, 0, 1], hipDy: 3, legB: [0, 2, -26.6, 2.24], legF: [0, 3, -26.6, 2.24] }, di = { by: 2, armF: [63.4, 1.9, 8.1, 2.69], armB: [90, 2, 0, 1], legB: [116.6, 2.24, 45, 3.16], legF: [26.6, 2.24, 63.4, 2] }, fi = { by: 0, armF: [45, 1.2, 45, 1.7], armB: [90, 2, 0, 1], legB: [135, 1.41, -45, 2], legF: [90, 1, 0, 2], lookBack: !0 }, pi = { by: -1, armF: [-63.4, 1.9, -26.6, 1.7], armB: [-90, 2, 0, 2], legB: [135, 1.41, -45, 2], legF: [90, 1, 0, 2], face: "blink" }, mi = { by: -1, armF: [-63.4, 1.9, -26.6, 1.7], armB: [-90, 2, 0, 2], legB: [135, 1.41, -45, 1], legF: [90, 1, 0, 1], face: "happy" }, gi = { by: 0, armF: [-45, 2.41, -18.4, 3.8], armB: [90, 2, 0, 1], legB: [135, 1.41, -45, 2], legF: [90, 1, 0, 2], face: "happy" }, yi = { by: 0, armF: [-45, 2.41, -56.3, 4.34], armB: [90, 2, 0, 1], legB: [135, 1.41, -45, 2], legF: [90, 1, 0, 2], face: "happy" }, wi = { by: -1, armF: [-63.4, 1.9, -26.6, 1.7], armB: [-90, 2, 0, 2], legB: [153.4, 2.24, -63.4, 1], legF: [45, 1.41, 45, 2], face: "happy" }, xi = { by: 0, armF: [-45, 2.41, -18.4, 3.8], armB: [90, 2, 0, 1], legB: [18.4, 3.16, 71.6, 2], legF: [161.6, 3.16, -71.6, 1], face: "happy" }, bi = { by: 1, armF: [-110, 1.9, 63, 3.06], armB: [90, 2, 0, 1], legB: [153.4, 2.24, -63.4, 2], legF: [45, 1.41, 45, 2] }, vi = { by: 1, armF: [-90, 1.7, 11.3, 4.34], armB: [90, 2, 0, 1], legB: [153.4, 2.24, -63.4, 2], legF: [45, 1.41, 45, 2], smearArm: [-110, 1.9, 63, 3.06] }, Mi = { by: 0, armF: [-33.7, 3.07, 15.3, 2.69], armB: [90, 2, 0, 1], legB: [153.4, 2.24, -63.4, 2], legF: [45, 1.41, 45, 2] }, Ai = { by: 1, armF: [33.7, 3.07, 22.6, 3.07], armB: [90, 2, 0, 1], legB: [153.4, 2.24, -63.4, 2], legF: [45, 1.41, 45, 2], smearArm: [33.7, 3.07, 11.3, 2.41] }, ki = { by: 1, armF: [33.7, 3.07, 11.3, 2.41], armB: [90, 2, 0, 1], legB: [153.4, 2.24, -63.4, 2], legF: [45, 1.41, 45, 2] }, Si = { by: 0, armF: [45, 2.41, 18.4, 1.9], armB: [90, 2, 0, 1], legB: [153.4, 2.24, -63.4, 2], legF: [45, 1.41, 45, 2] }, Ei = { by: 1, armF: [116.6, 1.9, -180, 1.9], armB: [90, 2, 0, 1], legB: [153.4, 2.24, -63.4, 2], legF: [45, 1.41, 45, 2] }, Fi = { by: 1, armF: [0, 2.55, 0, 2.55], armB: [90, 2, 0, 1], legB: [153.4, 2.24, -63.4, 2], legF: [45, 1.41, 45, 2], smearArm: [0, 1.7, 0, 1.7] }, Bi = { by: 0, armF: [45, 1.2, -90, 1.2], armB: [90, 2, 0, 1], legB: [153.4, 2.24, -63.4, 2], legF: [45, 1.41, 45, 2], smearArm: [116.6, 1.9, -180, 1.9] }, Di = { by: 0, armF: [0, 1.7, 0, 1.7], armB: [90, 2, 0, 1], legB: [153.4, 2.24, -63.4, 2], legF: [45, 1.41, 45, 2] }, Ti = { by: 0, armF: [45, 1.2, 0, 1.2], armB: [90, 2, 0, 1], legB: [153.4, 2.24, -63.4, 2], legF: [45, 1.41, 45, 2] }, Ri = { by: 1, armF: [-71.6, 2.69, -45, 1.9], armB: [90, 2, 0, 1], legB: [153.4, 2.24, -63.4, 2], legF: [45, 1.41, 45, 2] }, Oi = { by: 0, armF: [-59, 4.96, -40.4, 5.17], armB: [90, 2, 0, 1], legB: [153.4, 2.24, -63.4, 2], legF: [45, 1.41, 45, 2] }, Ci = { by: 0, armF: [-36.9, 4.25, 10.3, 1.9], armB: [90, 2, 0, 1], legB: [153.4, 2.24, -63.4, 2], legF: [45, 1.41, 45, 2], smearArm: [-59, 4.96, -40.4, 5.17] }, Li = { by: 0, armF: [-26.6, 3.8, 53.1, 1.9], armB: [90, 2, 0, 1], legB: [153.4, 2.24, -63.4, 2], legF: [45, 1.41, 45, 2], smearArm: [-36.9, 4.25, 10.3, 1.9] }, Hi = { by: 1, armF: [45, 1.2, 0, 1.2], armB: [90, 1, 45, 1.41], legB: [135, 1.41, -45, 2], legF: [90, 1, 0, 2] }, Ii = { by: 0, armF: [-63.4, 1.9, -26.6, 1.7], armB: [-90, 2, 0, 2], legB: [135, 1.41, -45, 2], legF: [90, 1, 0, 2] }, _i = { by: -1, armF: [-63.4, 1.9, -26.6, 1.7], armB: [-90, 2, 0, 2], legB: [135, 1.41, -45, 2], legF: [90, 1, 0, 2] }, Pi = { by: 1, armF: [-130, 2.41, 26.6, 2.69], armB: [90, 2, 0, 1], legB: [153.4, 2.24, -63.4, 2], legF: [45, 1.41, 45, 2] }, Wi = { by: 1, armF: [-123.7, 3.07, 0, 3.07], armB: [90, 2, 0, 1], legB: [153.4, 2.24, -63.4, 2], legF: [45, 1.41, 45, 2] }, Ui = { by: 0, armF: [-45, 2.41, 45, 1.7], armB: [90, 2, 0, 1], legB: [153.4, 2.24, -63.4, 2], legF: [45, 1.41, 45, 2] }, Ni = { by: 1, armF: [-90, 3.4, 18.4, 2.69], armB: [90, 2, 0, 1], legB: [153.4, 2.24, -63.4, 2], legF: [45, 1.41, 45, 2], smearArm: [-135, 2.41, 26.6, 2.69] }, $i = { by: 0, armF: [26.6, 1.9, 63.4, 1.7], armB: [90, 2, 0, 1], legB: [153.4, 2.24, -63.4, 2], legF: [45, 1.41, 45, 2] }, zi = {
+  BREATHE0: Ss,
+  BREATHE1: Es,
+  BREATHE2: Fs,
+  BREATHE3: Bs,
+  BREATHE4: Ds,
+  BREATHE5: Ts,
+  IDLE0: Rs,
+  IDLE1: Os,
+  STRIDE0: Cs,
+  STRIDE1: Ls,
+  STRIDE2: Hs,
+  STRIDE3: Is,
+  STRIDE4: _s,
+  STRIDE5: Ps,
+  JOG0: Ws,
+  JOG1: Us,
+  JOG2: Ns,
+  JOG3: $s,
+  JOG4: zs,
+  JOG5: Gs,
+  JOG6: qs,
+  JOG7: Ys,
+  ROLL0: js,
+  ROLL1: Vs,
+  ROLL2: Xs,
+  ROLL3: Js,
+  ROLL4: Ks,
+  ROLL5: Zs,
+  ROLL6: Qs,
+  ROLL7: ti,
+  ROLL8: ei,
+  ROLL9: si,
+  ROLL10: ii,
+  ROLL11: ni,
+  DASH: ri,
+  HURT: oi,
+  DIZZY: ai,
+  CROUCH: hi,
+  KNEEL: li,
+  SIT: ci,
+  SIT_GROUND: ui,
+  PICK: di,
+  LOOK_BACK: fi,
+  STRETCH: pi,
+  CHEER: mi,
+  WAVE_A: gi,
+  WAVE_B: yi,
+  DANCE_A: wi,
+  DANCE_B: xi,
+  SLASH_READY: bi,
+  SLASH_WIND: vi,
+  SLASH_SWEEP: Mi,
+  SLASH_FOLLOW: Ai,
+  SLASH_END: ki,
+  SLASH_RECOVER: Si,
+  THRUST_READY: Ei,
+  THRUST_LUNGE: Fi,
+  THRUST_MID: Bi,
+  THRUST_END: Di,
+  THRUST_RECOVER: Ti,
+  OVERHEAD_READY: Ri,
+  OVERHEAD: Oi,
+  OVERHEAD_MID: Ci,
+  OVERHEAD_FALL: Li,
+  CAST_CHARGE: Hi,
+  CAST: Ii,
+  CAST_RELEASE: _i,
+  THROW_READY: Pi,
+  THROW_WIND: Wi,
+  THROW_RELEASE: Ui,
+  THROW_MID: Ni,
+  THROW_RECOVER: $i
+}, Zn = zi, Z = (i, t) => Array.from({ length: t }, (e, s) => `${i}${s}`), Qn = {
+  idle: { poses: Z("BREATHE", 6), fps: 6 },
+  walk: { poses: Z("STRIDE", 6), fps: 10 },
+  run: { poses: Z("JOG", 8), fps: 14 },
+  roll: { poses: Z("ROLL", 12), fps: 30, loop: !1, blend: !1 },
+  dash: { poses: ["DASH"], fps: 1, loop: !1 },
+  hurt: { poses: ["HURT", "BREATHE0"], fps: 5, loop: !1 },
+  dizzy: { poses: ["DIZZY", "BREATHE0"], fps: 2 },
+  crouch: { poses: ["CROUCH"], fps: 1, loop: !1 },
+  kneel: { poses: ["KNEEL"], fps: 1, loop: !1 },
+  sit: { poses: ["SIT"], fps: 1, loop: !1 },
+  sitGround: { poses: ["SIT_GROUND"], fps: 1, loop: !1 },
+  pick: { poses: ["CROUCH", "PICK", "CROUCH"], fps: 6, loop: !1 },
+  lookBack: { poses: ["LOOK_BACK"], fps: 1, loop: !1 },
+  stretch: { poses: ["BREATHE0", "STRETCH", "STRETCH", "BREATHE0"], fps: 3, loop: !1 },
+  cheer: { poses: ["BREATHE0", "CHEER", "CHEER"], fps: 6, loop: !1 },
+  wave: { poses: ["WAVE_A", "WAVE_B"], fps: 4 },
+  dance: { poses: ["DANCE_A", "DANCE_B"], fps: 3 },
+  slash: { poses: ["SLASH_READY", "SLASH_WIND", "SLASH_SWEEP", "SLASH_FOLLOW", "SLASH_END", "SLASH_RECOVER"], durations: [60, 90, 40, 60, 90, 120], loop: !1 },
+  thrust: { poses: ["THRUST_READY", "THRUST_LUNGE", "THRUST_MID", "THRUST_END", "THRUST_RECOVER"], durations: [80, 50, 60, 100, 120], loop: !1 },
+  overhead: { poses: ["OVERHEAD_READY", "OVERHEAD", "OVERHEAD_MID", "OVERHEAD_FALL"], durations: [90, 140, 50, 160], loop: !1 },
+  cast: { poses: ["CAST_CHARGE", "CAST", "CAST_RELEASE"], durations: [220, 120, 200], loop: !1 },
+  throw: { poses: ["THROW_READY", "THROW_WIND", "THROW_RELEASE", "THROW_MID", "THROW_RECOVER"], durations: [70, 110, 40, 70, 120], loop: !1 }
+};
+class tr {
+  constructor(t, e, s) {
+    this.library = t, this.clips = e, this.clip = this.clipOf(s), this.name = s;
+  }
+  library;
+  clips;
+  clip;
+  name;
+  elapsed = 0;
+  ended = !1;
+  /** The pose being faded out of, and how long the fade lasts and has run. */
+  from = null;
+  fadeMs = 0;
+  fadeAt = 0;
+  cached = null;
+  speed = 1;
+  /** Called when a clip that does not loop reaches its end. */
+  onComplete = null;
+  get current() {
+    return this.name;
+  }
+  get finished() {
+    return this.ended;
+  }
+  /** Time into the current clip, ms. */
+  get time() {
+    return this.elapsed;
+  }
+  /** Plays `name`, fading from the pose shown now over `fadeMs`. The clip already playing keeps going unless `restart`. */
+  play(t, e = {}) {
+    if (t === this.name && !e.restart) return this;
+    const s = e.fadeMs ?? 0;
+    return this.from = s > 0 ? this.pose : null, this.fadeMs = s, this.fadeAt = 0, this.clip = this.clipOf(t), this.name = t, this.elapsed = 0, this.ended = !1, this.cached = null, this;
+  }
+  /** Advances by `dt` seconds. */
+  update(t) {
+    if (!(t > 0) || this.speed <= 0) return;
+    const e = t * 1e3 * this.speed;
+    if (this.cached = null, this.from && (this.fadeAt += e, this.fadeAt >= this.fadeMs && (this.from = null)), this.ended) return;
+    this.elapsed += e;
+    const s = this.totalMs();
+    this.elapsed >= s && (this.clip.loop !== !1 ? this.elapsed %= s : (this.elapsed = s, this.ended = !0, this.onComplete?.(this.name)));
+  }
+  /** The pose to show now. */
+  get pose() {
+    if (this.cached) return this.cached;
+    let t = this.sample(this.elapsed);
+    return this.from && (t = St(this.from, t, Math.min(1, this.fadeAt / this.fadeMs))), this.cached = t, t;
+  }
+  /** The current clip's pose at `ms` into it. */
+  sample(t) {
+    const e = this.clip.poses, s = e.length;
+    let n = Math.max(0, t);
+    for (let r = 0; r < s; r++) {
+      const o = this.lengthOf(r);
+      if (n < o || r === s - 1) {
+        const a = this.resolve(e[r]), h = r === s - 1;
+        if (this.clip.blend === !1 || s === 1 || h && this.clip.loop === !1) return a;
+        const l = this.resolve(e[h ? 0 : r + 1]);
+        return St(a, l, Math.min(1, n / o));
+      }
+      n -= o;
+    }
+    return this.resolve(e[s - 1]);
+  }
+  totalMs() {
+    let t = 0;
+    for (let e = 0; e < this.clip.poses.length; e++) t += this.lengthOf(e);
+    return t;
+  }
+  lengthOf(t) {
+    return Math.max(1, this.clip.durations?.[t] ?? 1e3 / (this.clip.fps ?? 8));
+  }
+  resolve(t) {
+    if (typeof t != "string") return t;
+    const e = this.library[t];
+    if (!e) throw new Error(`PosePlayer: no pose "${t}" in the library`);
+    return e;
+  }
+  clipOf(t) {
+    const e = this.clips[t];
+    if (!e) throw new Error(`PosePlayer: no clip "${t}"`);
+    if (e.poses.length === 0) throw new Error(`PosePlayer: clip "${t}" has no poses`);
+    for (const s of e.poses) this.resolve(s);
+    return e;
+  }
+}
+const Et = ["upperArmB", "forearmB", "thighB", "shinB", "torso", "thighF", "shinF", "head", "upperArmF", "forearmF"], Gi = {
+  upperArmB: 6983888,
+  forearmB: 1578e4,
+  thighB: 3813448,
+  shinB: 3813448,
+  torso: 4878256,
+  thighF: 3813448,
+  shinF: 3813448,
+  head: 1578e4,
+  upperArmF: 6983888,
+  forearmF: 1578e4
+}, qi = /* @__PURE__ */ new Set(["upperArmB", "forearmB", "thighB", "shinB"]), Yi = {
+  upperArmB: ["shoulderB", "elbowB"],
+  forearmB: ["elbowB", "wristB"],
+  thighB: ["hipB", "kneeB"],
+  shinB: ["kneeB", "ankleB"],
+  thighF: ["hipF", "kneeF"],
+  shinF: ["kneeF", "ankleF"],
+  upperArmF: ["shoulderF", "elbowF"],
+  forearmF: ["elbowF", "wristF"]
+};
+function ji(i, t) {
+  const e = Math.round((i >> 16 & 255) * t), s = Math.round((i >> 8 & 255) * t), n = Math.round((i & 255) * t);
+  return e << 16 | s << 8 | n;
+}
+class er extends M {
+  constructor(t, e = {}, s, n = {}) {
+    super(), this.def = t, this.skin = e, this.skeleton = new us(t), this.scaleGrid = n.scale ?? 1, this.headRadius = n.headRadius ?? 5, this.headRise = n.headRise ?? 5.5, this.bulky = n.bulky === !0;
+    const r = new M();
+    r.position.set(-t.width / 2, -t.height), this.addChild(r);
+    for (const o of Et) {
+      const a = new M();
+      this.layers.set(o, a), r.addChild(a);
+      const h = e[o];
+      if (h?.texture && s) {
+        const l = new R(s.get(h.texture, h.frame));
+        l.anchor.set(h.anchorX ?? 0.5, h.anchorY ?? 0), l.scale.set(1 / this.scaleGrid), this.sprites.set(o, l), a.addChild(l);
+      }
+    }
+    this.scale.set(this.scaleGrid);
+  }
+  def;
+  skin;
+  skeleton;
+  sprites = /* @__PURE__ */ new Map();
+  layers = /* @__PURE__ */ new Map();
+  joints = null;
+  curl;
+  scaleGrid;
+  headRadius;
+  headRise;
+  bulky;
+  /** 1 faces right, -1 faces left. */
+  set facing(t) {
+    this.scale.x = this.scaleGrid * t;
+  }
+  get facing() {
+    return this.scale.x < 0 ? -1 : 1;
+  }
+  /** The joints of the last pose, in grid px of the rig's frame (for attaching a held item, an effect). */
+  get lastJoints() {
+    return this.joints;
+  }
+  /** Where a joint of the last pose is in this view's parent, in world px. */
+  jointInParent(t) {
+    if (!this.joints) return null;
+    const e = this.joints[t];
+    return { x: this.x + (e.x - this.def.width / 2) * this.scale.x, y: this.y + (e.y - this.def.height) * this.scale.y };
+  }
+  setPose(t) {
+    const e = this.skeleton.solve(t, this.bulky);
+    this.joints = e, this.curl = t.curl;
+    for (const s of Et) this.place(s, e);
+    return this;
+  }
+  destroy(t) {
+    super.destroy(t ?? { children: !0 });
+  }
+  place(t, e) {
+    const s = this.layers.get(t), n = this.skin[t] ?? {}, r = this.sprites.get(t), [o, a] = this.ends(t, e), h = Math.atan2(a.y - o.y, a.x - o.x);
+    if (r) {
+      r.position.set(o.x, o.y), r.rotation = h - Math.PI / 2, n.stretch && r.texture.height > 0 && (r.scale.y = Math.hypot(a.x - o.x, a.y - o.y) / r.texture.height);
+      return;
+    }
+    let l = s.children[0];
+    l || (l = new Lt(), s.addChild(l)), l.clear();
+    const c = n.color ?? Gi[t], u = qi.has(t) ? ji(c, t.endsWith("ArmB") || t === "forearmB" ? this.def.backArmShade : this.def.backShade) : c, d = n.outline === void 0 ? 1709092 : n.outline, m = d === null ? null : { color: d, width: 0.6 };
+    if (t === "head") {
+      const p = n.width !== void 0 ? n.width / 2 : this.headRadius;
+      l.circle(o.x, o.y, p).fill(u), m && l.stroke(m);
+      return;
+    }
+    if (t === "torso") {
+      const p = n.width ?? Math.abs(this.def.shoulderF[0] - this.def.shoulderB[0]) + 1;
+      if (this.curl)
+        l.circle(this.curl[0], this.curl[1], p / 2 + 1).fill(u);
+      else {
+        const g = Math.hypot(a.x - o.x, a.y - o.y);
+        l.roundRect(-p / 2, -0.5, p, g + 1, Math.min(2, p / 3)).fill(u), l.position.set(o.x, o.y), l.rotation = h - Math.PI / 2, m && l.stroke(m);
+        return;
+      }
+      l.position.set(0, 0), l.rotation = 0, m && l.stroke(m);
+      return;
+    }
+    const f = n.width ?? this.def.limbWidth;
+    l.position.set(0, 0), l.rotation = 0, m && l.moveTo(o.x, o.y).lineTo(a.x, a.y).stroke({ color: m.color, width: f + m.width * 2, cap: "round" }), l.moveTo(o.x, o.y).lineTo(a.x, a.y).stroke({ color: u, width: f, cap: "round" });
+  }
+  /** The two points a part spans: a limb's joints, the torso from chest to hips, the head's centre (twice). */
+  ends(t, e) {
+    if (t === "head") {
+      const r = { x: e.head.x, y: e.head.y - this.headRise };
+      return [r, { x: r.x, y: r.y + 1 }];
+    }
+    if (t === "torso") return [e.chest, { x: (e.hipF.x + e.hipB.x) / 2, y: (e.hipF.y + e.hipB.y) / 2 }];
+    const [s, n] = Yi[t];
+    return [e[s], e[n]];
+  }
+}
+let z = null;
+function Ft() {
+  if (z) return z;
+  const i = 256, t = document.createElement("canvas");
+  t.width = t.height = i;
+  const e = t.getContext("2d");
+  if (!e) return C.EMPTY;
+  const s = e.createRadialGradient(i / 2, i / 2, 0, i / 2, i / 2, i / 2);
+  return s.addColorStop(0, "rgba(255,255,255,1)"), s.addColorStop(0.35, "rgba(255,255,255,0.75)"), s.addColorStop(0.7, "rgba(255,255,255,0.25)"), s.addColorStop(1, "rgba(255,255,255,0)"), e.fillStyle = s, e.fillRect(0, 0, i, i), z = C.from(t), z.source.scaleMode = "linear", z;
+}
+class sr {
+  constructor(t, e = {}) {
+    this.stage = t, this.ambient = e.ambient ?? 658468, this.darkness = e.darkness ?? 0.85, this.tint = e.tint ?? 0.35, this.squash = e.squash ?? 1, this.scratch.addChild(this.sheet, this.holes), this.rt = le.create({ width: 1, height: 1 }), this.view = new R(this.rt), this.washes.blendMode = "add", t.screen.addChild(this.view, this.washes), this.unsubscribe = t.onResize(() => this.fit()), this.fit();
+  }
+  stage;
+  lights = /* @__PURE__ */ new Set();
+  scratch = new M();
+  sheet = new R(C.WHITE);
+  holes = new M();
+  washes = new M();
+  view;
+  rt;
+  pool = [];
+  ambient;
+  darkness;
+  tint;
+  squash;
+  unsubscribe;
+  add(t) {
+    return this.lights.add(t), t;
+  }
+  remove(t) {
+    this.lights.delete(t);
+  }
+  clear() {
+    this.lights.clear();
+  }
+  /** Changes the dark: its colour and how dark (a day/night cycle eases these). */
+  setAmbient(t, e) {
+    this.ambient = t, this.darkness = Math.min(1, Math.max(0, e));
+  }
+  /** Redraws the dark with this frame's lights. Call once a frame, after the camera moved. */
+  update(t = performance.now()) {
+    const e = this.darkness > 4e-3;
+    if (this.view.visible = e, this.washes.visible = e, !e) return;
+    const s = this.stage.cameras.main, n = s.zoom;
+    this.sheet.tint = this.ambient, this.sheet.alpha = this.darkness;
+    let r = 0;
+    for (const o of this.lights) {
+      if (o.on === !1 || o.radius <= 0) continue;
+      const a = (o.x - s.scrollX) * n, h = (o.y - s.scrollY) * n, l = o.flicker ? 1 + Math.sin(t / 97 + o.x) * Math.sin(t / 53 + o.y) * o.flicker : 1, c = o.radius * n * l;
+      if (a < -c || h < -c || a > s.width + c || h > s.height + c) continue;
+      const u = this.sprites(r++), d = Math.min(1, Math.max(0, o.intensity ?? 1));
+      for (const m of [u.hole, u.wash])
+        m.visible = !0, m.position.set(a, h), m.width = c * 2, m.height = c * 2 * this.squash;
+      u.hole.alpha = d, u.wash.tint = o.color ?? 16773340, u.wash.alpha = d * this.tint;
+    }
+    for (let o = r; o < this.pool.length; o++)
+      this.pool[o].hole.visible = !1, this.pool[o].wash.visible = !1;
+    this.stage.app.renderer.render({ container: this.scratch, target: this.rt, clear: !0 });
+  }
+  destroy() {
+    this.unsubscribe(), this.view.destroy(), this.washes.destroy({ children: !0 }), this.scratch.destroy({ children: !0 }), this.rt.destroy(!0), this.lights.clear();
+  }
+  sprites(t) {
+    let e = this.pool[t];
+    if (!e) {
+      const s = new R(Ft());
+      s.anchor.set(0.5), s.blendMode = "erase";
+      const n = new R(Ft());
+      n.anchor.set(0.5), this.holes.addChild(s), this.washes.addChild(n), e = { hole: s, wash: n }, this.pool.push(e);
+    }
+    return e;
+  }
+  fit() {
+    const t = Math.max(1, Math.ceil(this.stage.width)), e = Math.max(1, Math.ceil(this.stage.height));
+    this.rt.resize(t, e), this.sheet.width = t, this.sheet.height = e;
+  }
+}
+function ir(i, t) {
+  const e = Math.min(140, 40 + Math.max(0, i) * 400);
+  return Math.round(e + (t ? 40 : 0));
+}
+function nr(i, t, e) {
+  return i ? e ? 2 : 1 : Math.min(3, 2 + (t > 0.2 ? 1 : 0) + (e ? 1 : 0));
+}
+const rr = 120;
+function or(i, t) {
+  return t >= 1 || i <= 0 ? 0 : Math.round(i * (1 - t) * (1 - t));
+}
+const Vi = 400;
+function ar(i, t, e) {
+  return e ? 0 : i ? t ? 60 : 0 : t ? 140 : 70;
+}
+function hr(i) {
+  return i ? Vi : 0;
+}
+function lr(i, t, e, s) {
+  const n = i.width, r = i.height;
+  if (!n || !r || !(i.zoom > 0)) return !0;
+  const o = i.scrollX ?? 0, a = i.scrollY ?? 0;
+  return t >= o - s && e >= a - s && t <= o + n / i.zoom + s && e <= a + r / i.zoom + s;
+}
+const Xi = 0.01, Ji = 5e-3, Ki = 0.16, Zi = 0.95, Qi = 2e-3, tn = 0.01;
+function en(i, t) {
+  const e = i[0]?.length ?? 0, s = 1 / Math.max(1, i.length), n = new Float32Array(e);
+  for (const f of i) for (let p = 0; p < e; p++) n[p] += f[p] * s;
+  let r = 0;
+  for (let f = 0; f < e; f++) {
+    const p = Math.abs(n[f]);
+    p > r && (r = p);
+  }
+  if (r < Ji) return null;
+  const o = r * Xi;
+  let a = 0;
+  for (; a < e && Math.abs(n[a]) < o; ) a++;
+  let h = e;
+  for (; h > a && Math.abs(n[h - 1]) < o; ) h--;
+  if (h <= a) return null;
+  a = Math.max(0, a - Math.round(Qi * t));
+  const l = n.slice(a, h);
+  let c = 0;
+  for (let f = 0; f < l.length; f++) c += l[f] * l[f];
+  const u = Math.sqrt(c / l.length), d = Math.min(Ki / Math.max(u, 1e-6), Zi / r), m = Math.min(l.length, Math.round(tn * t));
+  for (let f = 0; f < l.length; f++) {
+    const p = l.length - f;
+    l[f] *= d * (p < m ? p / m : 1);
+  }
+  return l;
+}
+const et = {};
+function cr(i) {
+  for (const [t, e] of Object.entries(i)) {
+    const s = /(?:^|\/)([a-z_]+?)(?:_\d+)?\.mp3$/.exec(t);
+    s && (et[s[1]] ??= []).push(e);
+  }
+}
+const Bt = (i) => !!et[i];
+class sn {
+  decoded = /* @__PURE__ */ new Map();
+  loading = /* @__PURE__ */ new Set();
+  last = /* @__PURE__ */ new Map();
+  names() {
+    return Object.keys(et);
+  }
+  /** A decoded take, or null while none is ready (the caller then synthesises); starts loading on first ask. */
+  take(t, e) {
+    const s = this.decoded.get(e);
+    if (!s?.length)
+      return this.load(t, e), null;
+    let n = Math.floor(Math.random() * s.length);
+    return s.length > 1 && n === this.last.get(e) && (n = (n + 1) % s.length), this.last.set(e, n), s[n];
+  }
+  load(t, e) {
+    const s = et[e];
+    if (!s || this.loading.has(e)) return;
+    this.loading.add(e);
+    const n = [];
+    this.decoded.set(e, n);
+    for (const r of s)
+      fetch(r).then((o) => o.arrayBuffer()).then((o) => t.decodeAudioData(o)).then((o) => on(o)).then((o) => {
+        if (!o) return;
+        const a = t.createBuffer(1, o.length, t.sampleRate);
+        a.copyToChannel(o, 0), n.push(a);
+      }).catch(() => {
+      });
+  }
+}
+let k, nn = 0;
+const G = /* @__PURE__ */ new Map();
+function rn() {
+  if (k !== void 0) return k;
+  try {
+    k = new Worker(new URL(
+      /* @vite-ignore */
+      "/assets/takeCleanerWorker-DTcI_Jqr.js",
+      import.meta.url
+    ), { type: "module" }), k.onmessage = (i) => {
+      G.get(i.data.id)?.(i.data.data), G.delete(i.data.id);
+    }, k.onerror = () => {
+      k?.terminate(), k = null;
+      for (const i of G.values()) i(null);
+      G.clear();
+    };
+  } catch {
+    k = null;
+  }
+  return k;
+}
+let Dt = Promise.resolve();
+function on(i) {
+  return new Promise((t) => {
+    Dt = Dt.then(() => new Promise((e) => setTimeout(e, 0))).then(() => {
+      an(i).then(t, () => t(null));
+    });
+  });
+}
+function an(i) {
+  const t = Array.from({ length: i.numberOfChannels }, (n, r) => i.getChannelData(r).slice()), e = rn();
+  if (!e) return Promise.resolve(en(t, i.sampleRate));
+  const s = nn++;
+  return new Promise((n) => {
+    G.set(s, n), e.postMessage({ id: s, channels: t, sampleRate: i.sampleRate }, { transfer: t.map((r) => r.buffer) });
+  });
+}
+const B = { master: 1, recipes: {} };
+function ur(i) {
+  i.master !== void 0 && (B.master = i.master), i.recipes && Object.assign(B.recipes, i.recipes);
+}
+const S = 22050, hn = {
+  sine: (i) => Math.sin(i * Math.PI * 2),
+  square: (i, t) => i < t ? 1 : -1,
+  tri: (i) => 1 - 4 * Math.abs(i - 0.5),
+  saw: (i) => 2 * i - 1
+}, rt = (i, t, e) => i > 0 && t > 0 ? i * Math.pow(t / i, e) : i + (t - i) * e;
+function Tt(i) {
+  return 1 - Math.exp(-2 * Math.PI * Math.min(i, S * 0.45) / S);
+}
+function ln(i) {
+  const t = Math.max(...i.layers.map((o) => (o.d ?? 0) + o.t)), e = new Float32Array(Math.ceil(t * S) + 1);
+  let s = 2654435769;
+  const n = () => (s ^= s << 13, s ^= s >>> 17, s ^= s << 5, (s >>> 0) / 4294967295 * 2 - 1);
+  for (const o of i.layers) {
+    const a = Math.round((o.d ?? 0) * S), h = Math.round(o.t * S), l = Math.max(1, Math.round((o.at ?? 4e-3) * S));
+    let c = 0, u = 0, d = 0, m = 0;
+    for (let f = 0; f < h && a + f < e.length; f++) {
+      const p = f / h, g = o.f ? rt(o.f[0], o.f[1], p) : 0;
+      c += g / S;
+      const y = c - Math.floor(c);
+      let w;
+      o.w === "noise" ? ((!o.f || y < g / S || f === 0) && (u = n()), w = o.f ? u : n()) : w = hn[o.w](y, o.duty ?? 0.5), o.lp && (d += (w - d) * Tt(rt(o.lp[0], o.lp[1], p)), w = d), o.hp && (m += (w - m) * Tt(rt(o.hp[0], o.hp[1], p)), w -= m);
+      const v = f < l ? f / l : Math.pow(1 - (f - l) / Math.max(1, h - l), o.c ?? 2);
+      e[a + f] += w * v * o.g;
+    }
+  }
+  let r = 0;
+  for (const o of e) r = Math.max(r, Math.abs(o));
+  if (r > 0.95) for (let o = 0; o < e.length; o++) e[o] *= 0.95 / r;
+  return e;
+}
+const ot = 480, cn = 10, un = 6, dn = 60, fn = 0.45, pn = 0.05, Rt = 80, at = [18e3, 1800], Ot = { freq: 3500, gainDb: -7 }, mn = 11e3;
+class gn {
+  ctx = null;
+  master = null;
+  buffers = /* @__PURE__ */ new Map();
+  samples = new sn();
+  lastAt = /* @__PURE__ */ new Map();
+  voices = 0;
+  /** Where the local player stands, set by the world scene; null off the world screens. */
+  listener = () => null;
+  onRunning = () => {
+  };
+  constructor() {
+    if (typeof window > "u") return;
+    const t = () => {
+      const r = this.context();
+      if (!r || r.state === "running") return;
+      r.resume();
+      const o = r.createBufferSource();
+      o.buffer = r.createBuffer(1, 1, 22050), o.connect(r.destination), o.start();
+    }, e = ["pointerdown", "pointerup", "touchend", "keydown"], s = (r) => {
+      for (const o of e)
+        r ? window.addEventListener(o, t, { capture: !0 }) : window.removeEventListener(o, t, { capture: !0 });
+    };
+    this.onRunning = (r) => s(!r), s(!0);
+    const n = navigator.audioSession;
+    n && (n.type = "ambient"), q.subscribe((r) => {
+      this.ctx && this.master && this.master.gain.setTargetAtTime(this.level(r.sfxVolume), this.ctx.currentTime, 0.02);
+    });
+  }
+  play(t, e = {}) {
+    if (!t || !B.recipes[t] && !Bt(t) || q.getState().sfxVolume <= 0) return;
+    const s = this.ctx;
+    if (!s || s.state !== "running" || this.voices >= (e.minor ? un : cn)) return;
+    let n = (e.gain ?? 1) * (e.local ? 1 : fn), r = 0, o = 0;
+    if (e.x !== void 0 && e.y !== void 0) {
+      const g = this.listener();
+      if (g) {
+        const y = e.x - g.x, w = Math.hypot(y, e.y - g.y), v = Math.min(ot, e.range ?? ot);
+        if (w >= v) return;
+        n *= Math.pow(1 - w / v, 1.5), o = w / ot, r = Math.max(-0.7, Math.min(0.7, y / 320));
+      }
+    }
+    if (n < 0.03) return;
+    const a = performance.now();
+    if (a - (this.lastAt.get(t) ?? -1e9) < dn) return;
+    const h = this.samples.take(s, t), l = h ?? this.buffer(s, t);
+    if (!l) return;
+    h && (n *= B.recipes[t]?.fileGain ?? 1), this.lastAt.set(t, a);
+    const c = s.createBufferSource();
+    c.buffer = l;
+    const u = B.recipes[t]?.jitter ?? pn;
+    c.playbackRate.value = 1 + (Math.random() * 2 - 1) * u;
+    const d = s.createGain();
+    d.gain.value = Math.min(1, n);
+    const m = s.createStereoPanner();
+    m.pan.value = r;
+    const f = s.createBiquadFilter();
+    f.type = "lowpass", f.frequency.value = at[0] * Math.pow(at[1] / at[0], o), c.connect(f).connect(d).connect(m).connect(this.master), this.voices++, c.onended = () => {
+      this.voices--, c.disconnect(), f.disconnect(), d.disconnect(), m.disconnect();
+    }, c.start();
+    const p = l.duration / c.playbackRate.value * 1e3;
+    if (e.maxMs !== void 0 && p > e.maxMs) {
+      const g = s.currentTime + Math.max(Rt, e.maxMs) / 1e3;
+      d.gain.setValueAtTime(d.gain.value, g - Rt / 1e3), d.gain.linearRampToValueAtTime(0, g), c.stop(g);
+    }
+  }
+  level(t) {
+    return Math.max(0, Math.min(1, t)) * B.master;
+  }
+  context() {
+    if (this.ctx) return this.ctx;
+    if (typeof AudioContext > "u") return null;
+    this.ctx = new AudioContext(), this.master = this.ctx.createGain(), this.master.gain.value = this.level(q.getState().sfxVolume);
+    const t = this.ctx.createBiquadFilter();
+    t.type = "highshelf", t.frequency.value = Ot.freq, t.gain.value = Ot.gainDb;
+    const e = this.ctx.createBiquadFilter();
+    e.type = "lowpass", e.frequency.value = mn, this.master.connect(t).connect(e).connect(this.ctx.destination);
+    const s = this.ctx, n = () => {
+      const r = s.state === "running";
+      this.onRunning(r), r && this.prerender(s);
+    };
+    return s.addEventListener("statechange", n), s.state === "running" && queueMicrotask(n), s;
+  }
+  /**
+   * Starts decoding every recorded take and renders every recipe not rendered yet, one per task, once the context
+   * first runs — so the first swing of a fight does not pay for its sound in that frame.
+   */
+  prerender(t) {
+    for (const n of this.samples.names()) this.samples.load(t, n);
+    const e = Object.keys(B.recipes).filter((n) => !this.buffers.has(n) && !Bt(n)), s = () => {
+      const n = e.shift();
+      n !== void 0 && (this.buffer(t, n), setTimeout(s, 0));
+    };
+    s();
+  }
+  /** Rendered on first use or by `prerender` (a few ms each), then kept. */
+  buffer(t, e) {
+    const s = this.buffers.get(e);
+    if (s !== void 0) return s;
+    const n = B.recipes[e];
+    let r = null;
+    if (n) {
+      const o = ln(n);
+      r = t.createBuffer(1, o.length, S), r.getChannelData(0).set(o);
+    }
+    return this.buffers.set(e, r), r;
+  }
+}
+const dr = new gn();
+class yn {
+  ctx = null;
+  master = null;
+  tracks = [];
+  raf = 0;
+  unlocked = !1;
+  cleanup = [];
+  constructor() {
+    if (typeof window > "u") return;
+    const t = () => {
+      this.unlocked = !0, this.ctx?.resume();
+      for (const e of this.tracks) !e.dying && e.el.paused && e.el.play().catch(() => {
+      });
+    };
+    for (const e of ["pointerdown", "keydown", "touchend"])
+      window.addEventListener(e, t, { passive: !0 }), this.cleanup.push(() => window.removeEventListener(e, t));
+    this.cleanup.push(q.subscribe(() => this.applyVolume()));
+  }
+  /** The url of the track playing (or fading in), if any. */
+  get current() {
+    for (let t = this.tracks.length - 1; t >= 0; t--) if (!this.tracks[t].dying) return this.tracks[t].url;
+    return null;
+  }
+  /** Plays `url`, crossfading from what plays now. The track already playing is left alone. */
+  play(t, e = {}) {
+    if (typeof Audio > "u" || this.current === t) return;
+    const s = Math.max(0, e.fadeMs ?? 1200);
+    this.fadeOutAll(s);
+    const n = new Audio(t);
+    n.loop = e.loop !== !1, n.preload = "auto", n.crossOrigin = "anonymous";
+    const r = { url: t, el: n, gain: null, level: Math.min(1, Math.max(0, e.volume ?? 1)), fade: { from: 0, to: 1, start: performance.now(), ms: s }, dying: !1 }, o = this.context();
+    if (o && this.master) {
+      const a = o.createGain();
+      a.gain.value = 0, o.createMediaElementSource(n).connect(a).connect(this.master), r.gain = a;
+    } else
+      n.volume = 0;
+    this.tracks.push(r), (this.unlocked || !this.needsGesture()) && n.play().catch(() => {
+    }), this.tick();
+  }
+  /** Fades the music out and stops it. */
+  stop(t = 1200) {
+    this.fadeOutAll(Math.max(0, t)), this.tick();
+  }
+  pause() {
+    for (const t of this.tracks) t.el.pause();
+  }
+  resume() {
+    for (const t of this.tracks) t.dying || t.el.play().catch(() => {
+    });
+  }
+  destroy() {
+    cancelAnimationFrame(this.raf);
+    for (const t of this.cleanup.splice(0)) t();
+    for (const t of this.tracks.splice(0)) this.release(t);
+    this.ctx?.close(), this.ctx = null;
+  }
+  fadeOutAll(t) {
+    const e = performance.now();
+    for (const s of this.tracks)
+      s.dying || (s.fade = { from: ht(s.fade, e), to: 0, start: e, ms: t }, s.dying = !0);
+  }
+  /** Runs the fades a frame at a time until none is left. */
+  tick = () => {
+    cancelAnimationFrame(this.raf);
+    const t = performance.now();
+    let e = !1;
+    for (let s = this.tracks.length - 1; s >= 0; s--) {
+      const n = this.tracks[s], r = ht(n.fade, t);
+      if (n.dying && r <= 0) {
+        this.release(n), this.tracks.splice(s, 1);
+        continue;
+      }
+      this.setLevel(n, r), t < n.fade.start + n.fade.ms && (e = !0);
+    }
+    e && (this.raf = requestAnimationFrame(this.tick));
+  };
+  applyVolume() {
+    const t = performance.now();
+    for (const e of this.tracks) this.setLevel(e, ht(e.fade, t));
+  }
+  setLevel(t, e) {
+    const s = Math.min(1, Math.max(0, e * t.level * q.getState().musicVolume));
+    t.gain ? t.gain.gain.value = s : t.el.volume = s;
+  }
+  release(t) {
+    t.el.pause(), t.el.removeAttribute("src"), t.el.load(), t.gain?.disconnect();
+  }
+  needsGesture() {
+    return this.ctx?.state === "suspended";
+  }
+  context() {
+    if (this.ctx) return this.ctx;
+    const t = globalThis.AudioContext;
+    return t ? (this.ctx = new t(), this.master = this.ctx.createGain(), this.master.connect(this.ctx.destination), this.ctx) : null;
+  }
+}
+function ht(i, t) {
+  return i.ms <= 0 || t >= i.start + i.ms ? i.to : t <= i.start ? i.from : i.from + (i.to - i.from) * (t - i.start) / i.ms;
+}
+const fr = new yn();
+class pr {
+  held = /* @__PURE__ */ new Set();
+  down = /* @__PURE__ */ new Set();
+  up = /* @__PURE__ */ new Set();
+  cleanup = [];
+  constructor(t = window) {
+    const e = (r) => {
+      const o = r.code;
+      r.repeat || this.held.has(o) || (this.held.add(o), this.down.add(o));
+    }, s = (r) => {
+      const o = r.code;
+      this.held.delete(o) && this.up.add(o);
+    }, n = () => {
+      for (const r of this.held) this.up.add(r);
+      this.held.clear();
+    };
+    t.addEventListener("keydown", e), t.addEventListener("keyup", s), window.addEventListener("blur", n), this.cleanup.push(
+      () => t.removeEventListener("keydown", e),
+      () => t.removeEventListener("keyup", s),
+      () => window.removeEventListener("blur", n)
+    );
+  }
+  isDown(t) {
+    return this.held.has(t);
+  }
+  /** Any of these keys is held. */
+  anyDown(...t) {
+    return t.some((e) => this.held.has(e));
+  }
+  /** Went down since the last `endStep`. */
+  pressed(t) {
+    return this.down.has(t);
+  }
+  /** Came up since the last `endStep`. */
+  released(t) {
+    return this.up.has(t);
+  }
+  /** -1, 0 or 1 from two sets of keys: `axis(['KeyA', 'ArrowLeft'], ['KeyD', 'ArrowRight'])`. */
+  axis(t, e) {
+    return (this.anyDown(...e) ? 1 : 0) - (this.anyDown(...t) ? 1 : 0);
+  }
+  /** Forgets this step's edges; held keys stay held. */
+  endStep() {
+    this.down.clear(), this.up.clear();
+  }
+  destroy() {
+    for (const t of this.cleanup.splice(0)) t();
+    this.held.clear(), this.endStep();
+  }
+}
+const wn = ["a", "b", "x", "y", "lb", "rb", "lt", "rt", "select", "start", "ls", "rs", "up", "down", "left", "right", "home"], xn = ["lx", "ly", "rx", "ry"];
+class mr {
+  constructor(t, e, s = {}) {
+    this.keyboard = t, this.bindings = new Map(Object.entries(e)), this.deadZone = s.deadZone ?? 0.25, this.gamepads = s.gamepads ?? (() => typeof navigator < "u" && typeof navigator.getGamepads == "function" ? navigator.getGamepads() : []);
+  }
+  keyboard;
+  bindings;
+  virtual = /* @__PURE__ */ new Set();
+  virtualDown = /* @__PURE__ */ new Set();
+  /** Analog value of each action this step (0–1), and last step's, for edges. */
+  now = /* @__PURE__ */ new Map();
+  before = /* @__PURE__ */ new Map();
+  deadZone;
+  gamepads;
+  /** Replaces one action's bindings (a player's rebinding). */
+  bind(t, e) {
+    this.bindings.set(t, [...e]);
+  }
+  bindingsOf(t) {
+    return this.bindings.get(t) ?? [];
+  }
+  /** A touch UI's virtual button went down: `touch:<name>` bindings read it. */
+  press(t) {
+    this.virtual.add(t), this.virtualDown.add(t);
+  }
+  release(t) {
+    this.virtual.delete(t);
+  }
+  /** Reads every device once; call at the start of each simulation step. */
+  poll() {
+    [this.before, this.now] = [this.now, this.before], this.now.clear();
+    const t = this.gamepads().filter((e) => e !== null);
+    for (const [e, s] of this.bindings) {
+      let n = 0;
+      for (const r of s) n = Math.max(n, this.read(r, t));
+      n > 0 && this.now.set(e, n);
+    }
+  }
+  /** Held this step. */
+  down(t) {
+    return (this.now.get(t) ?? 0) > 0;
+  }
+  /** How far it is held (0–1): 1 for a key, the trigger or stick amount for analog input. */
+  value(t) {
+    return this.now.get(t) ?? 0;
+  }
+  /** Went down this step. */
+  pressed(t) {
+    return this.down(t) && !((this.before.get(t) ?? 0) > 0);
+  }
+  /** Came up this step. */
+  released(t) {
+    return !this.down(t) && (this.before.get(t) ?? 0) > 0;
+  }
+  /** `value(positive) - value(negative)`, in −1…1. */
+  axis(t, e) {
+    return this.value(e) - this.value(t);
+  }
+  /** A 2D direction from four actions, never longer than 1 (a diagonal is not faster). */
+  vector(t, e, s, n) {
+    const r = this.axis(t, e), o = this.axis(s, n), a = Math.hypot(r, o);
+    return a > 1 ? [r / a, o / a] : [r, o];
+  }
+  /** Ends the step: the keyboard forgets its edges; virtual taps shorter than a step have now been seen. */
+  endStep() {
+    this.keyboard?.endStep(), this.virtualDown.clear();
+  }
+  read(t, e) {
+    if (t.startsWith("touch:")) {
+      const s = t.slice(6);
+      return this.virtual.has(s) || this.virtualDown.has(s) ? 1 : 0;
+    }
+    if (t.startsWith("pad:")) {
+      const s = t.slice(4);
+      let n = 0;
+      const r = s.endsWith("+") ? 1 : s.endsWith("-") ? -1 : 0;
+      if (r !== 0) {
+        const a = xn.indexOf(s.slice(0, -1));
+        if (a < 0) return 0;
+        for (const h of e) {
+          const l = (h.axes[a] ?? 0) * r;
+          l > this.deadZone && (n = Math.max(n, (l - this.deadZone) / (1 - this.deadZone)));
+        }
+        return Math.min(1, n);
+      }
+      const o = wn.indexOf(s);
+      if (o < 0) return 0;
+      for (const a of e) {
+        const h = a.buttons[o];
+        h?.pressed && (n = Math.max(n, h.value > 0 ? h.value : 1));
+      }
+      return Math.min(1, n);
+    }
+    return this.keyboard?.isDown(t) || this.keyboard?.pressed(t) ? 1 : 0;
+  }
+}
+function gr(i) {
+  const t = Math.cos(i), e = Math.sin(i), s = Math.sin(Math.PI / 8);
+  return { dx: Math.abs(t) > s ? Math.sign(t) : 0, dy: Math.abs(e) > s ? Math.sign(e) : 0 };
+}
+const Yt = 0.28;
+function yr(i, t, e) {
+  if (e <= 0) return { x: 0, y: 0 };
+  const s = Math.hypot(i, t);
+  if (s === 0) return { x: 0, y: 0 };
+  const n = s > e ? 1 / s : 1 / e;
+  return { x: i * n, y: t * n };
+}
+function bn(i, t = Yt) {
+  return Math.hypot(i.x, i.y) >= t;
+}
+function wr(i, t = Yt) {
+  if (!bn(i, t)) return { dx: 0, dy: 0 };
+  const s = Math.round(Math.atan2(i.y, i.x) / (Math.PI / 4)) * (Math.PI / 4), n = (r) => Math.abs(r) < 1e-9 ? 0 : Math.sign(r);
+  return { dx: n(Math.cos(s)), dy: n(Math.sin(s)) };
+}
+class xr {
+  constructor(t = 480, e = 10) {
+    this.ms = t, this.slop = e;
+  }
+  ms;
+  slop;
+  finger = null;
+  done = !1;
+  down(t, e, s, n) {
+    if (this.finger) {
+      this.finger = null, this.done = !0;
+      return;
+    }
+    this.finger = { id: t, x: e, y: s, at: n }, this.done = !1;
+  }
+  move(t, e, s) {
+    const n = this.finger;
+    n && n.id === t && Math.hypot(e - n.x, s - n.y) > this.slop && (this.finger = null);
+  }
+  up(t) {
+    this.finger?.id === t && (this.finger = null), this.finger || (this.done = !1);
+  }
+  /** Where the press is, the first time this is asked at or after `ms`; null otherwise. */
+  fire(t) {
+    const e = this.finger;
+    return !e || this.done || t - e.at < this.ms ? null : (this.done = !0, { x: e.x, y: e.y });
+  }
+}
+const jt = 1, I = 5, W = 16, j = 8, O = 256, Vt = Math.PI * 2;
+function E(i, t, e) {
+  if (!Number.isFinite(i)) return Number.isNaN(i) ? 0 : i > 0 ? e : t;
+  const s = Math.round(i);
+  return s < t ? t : s > e ? e : s;
+}
+function st(i) {
+  return E(i * j, -32768, 32767);
+}
+function Xt(i) {
+  return Number.isFinite(i) ? (Math.round(i * O / Vt) % O + O) % O : 0;
+}
+function Jt(i) {
+  return (i >= O / 2 ? i - O : i) * Vt / O;
+}
+function Kt(i, t, e) {
+  i.setInt32(t, E(e[0], -2147483648, 2147483647)), i.setInt16(t + 4, st(e[1])), i.setInt16(t + 6, st(e[2])), i.setUint8(t + 8, Xt(e[3])), i.setUint8(t + 9, E(e[4], 0, 255)), i.setInt32(t + 10, E(e[5], -2147483648, 2147483647)), i.setUint16(t + 14, E(e[6], 0, 65535));
+}
+function vn(i, t) {
+  return [
+    i.getInt32(t),
+    i.getInt16(t + 4) / j,
+    i.getInt16(t + 6) / j,
+    Jt(i.getUint8(t + 8)),
+    i.getUint8(t + 9),
+    i.getInt32(t + 10),
+    i.getUint16(t + 14)
+  ];
+}
+function br(i) {
+  const t = new Uint8Array(i.length * W), e = new DataView(t.buffer);
+  for (let s = 0; s < i.length; s++) Kt(e, s * W, i[s]);
+  return t;
+}
+function Mn(i) {
+  if (i.byteLength % W !== 0) throw new Error(`update block of ${i.byteLength} bytes`);
+  const t = new DataView(i.buffer, i.byteOffset, i.byteLength), e = [];
+  for (let s = 0; s < i.byteLength; s += W) e.push(vn(t, s));
+  return e;
+}
+function vr(i) {
+  const t = new Array(i.length);
+  for (let e = 0; e < i.length; e++) {
+    const s = i[e];
+    t[e] = [
+      E(s[0], -2147483648, 2147483647) + 0,
+      st(s[1]) / j + 0,
+      st(s[2]) / j + 0,
+      Jt(Xt(s[3])),
+      E(s[4], 0, 255) + 0,
+      E(s[5], -2147483648, 2147483647) + 0,
+      E(s[6], 0, 65535) + 0
+    ];
+  }
+  return t;
+}
+const Zt = globalThis, An = new Zt.TextEncoder(), kn = new Zt.TextDecoder();
+function Sn(i) {
+  const { up: t, ...e } = i, s = An.encode(JSON.stringify(e)), n = t?.length ? t.length : 0, r = new Uint8Array(I + s.byteLength + n * W), o = new DataView(r.buffer);
+  o.setUint8(0, jt), o.setUint32(1, s.byteLength), r.set(s, I);
+  const a = I + s.byteLength;
+  for (let h = 0; h < n; h++) Kt(o, a + h * W, t[h]);
+  return r;
+}
+function En(i) {
+  const t = i instanceof Uint8Array ? i : new Uint8Array(i);
+  if (t.byteLength < I) throw new Error("short snapshot frame");
+  const e = new DataView(t.buffer, t.byteOffset, t.byteLength), s = e.getUint8(0);
+  if (s !== jt) throw new Error(`unknown binary frame tag ${s}`);
+  const n = e.getUint32(1), r = I + n;
+  if (r > t.byteLength) throw new Error("snapshot frame JSON overruns the frame");
+  const o = JSON.parse(kn.decode(t.subarray(I, r)));
+  return r < t.byteLength && (o.up = Mn(t.subarray(r))), o;
+}
+const Mr = {
+  /** A basic attack may arrive this share of its interval early. */
+  attackEarlyShare: 0.2,
+  /** The cast lock and the attack lock a cast leaves may be cut this short. */
+  lockSlackMs: 60,
+  /** A skill may be cast this long before its cooldown ends. */
+  cooldownSlackMs: 40,
+  /** A potion may be drunk this long before its kind's cooldown ends. */
+  potionSlackMs: 150
+};
+function Ar(i, t, e) {
+  return t !== void 0 && i < t - e;
+}
+function kr(i, t, e) {
+  return Math.max(i, t ?? i) + e;
+}
+const Fn = 6e4, Bn = 2e3;
+let it = 0, ut = 1 / 0, dt = 0, ft = !1;
+function Sr() {
+  return Date.now() + it;
+}
+function Er() {
+  return it;
+}
+function Dn(i, t, e = Date.now()) {
+  !Number.isFinite(i) || !Number.isFinite(t) || t < 0 || t > Bn || ft && t > ut && e - dt < Fn || (it = i + t / 2 - e, ut = t, dt = e, ft = !0);
+}
+function Fr() {
+  it = 0, ut = 1 / 0, dt = 0, ft = !1;
+}
+function Tn(i) {
+  return [i.x, i.y, i.lastDx, i.lastDy, i.dashLeft, i.dashCd, i.dashDx, i.dashDy];
+}
+function Rn(i, t) {
+  return [t.x, t.y, t.lastDx, t.lastDy, t.dashLeft, t.dashCd, t.dashDx, t.dashDy] = i, t;
+}
+class Br {
+  constructor(t, e, s, n) {
+    this.params = s, this.grid = n, this.mover = qt(t, e);
+  }
+  params;
+  grid;
+  mover;
+  pending = [];
+  nextSeq = 0;
+  /** The jump the last reconciliation made, still being eased out (world px). */
+  offsetX = 0;
+  offsetY = 0;
+  /** How big the last correction was (0 when the prediction was right). */
+  correction = 0;
+  /** Share of a visual correction left after each 60th of a second (default 0.8). */
+  smoothing = 0.8;
+  /** Applies one input step now and keeps it for replay; returns its sequence number (send it with the step). */
+  step(t) {
+    const e = this.nextSeq++;
+    return this.pending.push({ seq: e, step: [t[0], t[1], t[2]] }), ct(this.mover, t, this.params, this.grid), e;
+  }
+  /** Steps sent but not yet acknowledged. */
+  get unacknowledged() {
+    return this.pending.length;
+  }
+  /** The server's word: the body as of step `ack`. Rewinds there and replays the rest. */
+  reconcile(t, e) {
+    const s = this.mover.x, n = this.mover.y;
+    let r = 0;
+    for (; r < this.pending.length && this.pending[r].seq <= t; ) r++;
+    r && (this.pending = this.pending.slice(r)), Rn(e, this.mover);
+    for (const h of this.pending) ct(this.mover, h.step, this.params, this.grid);
+    const o = s - this.mover.x, a = n - this.mover.y;
+    this.correction = Math.hypot(o, a), this.correction > 0.01 && this.correction < 64 ? (this.offsetX += o, this.offsetY += a) : this.correction >= 64 && (this.offsetX = this.offsetY = 0);
+  }
+  /** Eases the visual correction out; call once a frame with its length in seconds. */
+  smooth(t) {
+    const e = Math.pow(this.smoothing, t * 60);
+    this.offsetX *= e, this.offsetY *= e, Math.abs(this.offsetX) < 0.01 && (this.offsetX = 0), Math.abs(this.offsetY) < 0.01 && (this.offsetY = 0);
+  }
+  /** Where to draw the body: the predicted place plus the correction still being eased out. */
+  get drawX() {
+    return this.mover.x + this.offsetX;
+  }
+  get drawY() {
+    return this.mover.y + this.offsetY;
+  }
+  /** New movement rules (a buff, a slow): applied to future steps and to replays. */
+  setParams(t) {
+    this.params = t;
+  }
+  setGrid(t) {
+    this.grid = t;
+  }
+}
+class Dr {
+  constructor(t = 100, e = 120, s = 30) {
+    this.delayMs = t, this.maxExtrapolateMs = e, this.keep = s;
+  }
+  delayMs;
+  maxExtrapolateMs;
+  keep;
+  samples = /* @__PURE__ */ new Map();
+  /** Records every body of a snapshot taken at `time`. */
+  push(t, e) {
+    for (const [s, n, r, o, a, h, l] of e) {
+      let c = this.samples.get(s);
+      c || (c = [], this.samples.set(s, c));
+      const u = c[c.length - 1];
+      u && t <= u.time || (c.push({ time: t, x: n, y: r, aim: o, anim: a, hp: h, flags: l }), c.length > this.keep && c.splice(0, c.length - this.keep));
+    }
+  }
+  /** Forgets a body (it left view). */
+  remove(t) {
+    this.samples.delete(t);
+  }
+  has(t) {
+    return this.samples.has(t);
+  }
+  ids() {
+    return this.samples.keys();
+  }
+  /** Where body `id` should be drawn at server time `now`, or null if nothing is known of it. */
+  sample(t, e) {
+    const s = this.samples.get(t);
+    if (!s || s.length === 0) return null;
+    const n = e - this.delayMs, r = s[0];
+    if (n <= r.time || s.length === 1) return On(r);
+    for (let c = s.length - 1; c > 0; c--) {
+      const u = s[c - 1], d = s[c];
+      if (n >= u.time && n <= d.time) {
+        const m = d.time === u.time ? 1 : (n - u.time) / (d.time - u.time);
+        return Ct(u, d, m);
+      }
+    }
+    const o = s[s.length - 2], a = s[s.length - 1], h = Math.min(n - a.time, this.maxExtrapolateMs), l = a.time === o.time ? 1 : 1 + h / (a.time - o.time);
+    return Ct(o, a, l);
+  }
+}
+function On(i) {
+  return { x: i.x, y: i.y, aim: i.aim, anim: i.anim, hp: i.hp, flags: i.flags };
+}
+function Ct(i, t, e) {
+  let s = t.aim - i.aim;
+  s > Math.PI && (s -= Math.PI * 2), s < -Math.PI && (s += Math.PI * 2);
+  const n = e < 1 ? i : t;
+  return { x: i.x + (t.x - i.x) * e, y: i.y + (t.y - i.y) * e, aim: i.aim + s * e, anim: n.anim, hp: n.hp, flags: n.flags };
+}
+class Tr {
+  constructor(t) {
+    this.options = t, this.maxQueue = t.maxQueue ?? 30, this.maxSteps = t.maxStepsPerTick ?? 3, this.backlog = t.backlog ?? 4;
+  }
+  options;
+  players = /* @__PURE__ */ new Map();
+  tick = 0;
+  known = /* @__PURE__ */ new Map();
+  maxQueue;
+  maxSteps;
+  backlog;
+  join(t, e) {
+    if (this.players.has(t)) throw new Error(`Room: player ${t} has already joined`);
+    const s = this.options.spawn(t, e), n = {
+      id: t,
+      mover: qt(s.x, s.y),
+      data: e,
+      params: { ...this.options.params },
+      ack: -1,
+      queue: [],
+      aim: 0,
+      anim: 0,
+      hp: 0,
+      flags: 0,
+      strikes: 0
+    };
+    return this.players.set(t, n), this.known.set(t, /* @__PURE__ */ new Set()), n;
+  }
+  leave(t) {
+    this.players.delete(t), this.known.delete(t);
+  }
+  /**
+   * Input steps `seq`, `seq + 1`, … from a player. Steps already received are skipped (a resend), any step with
+   * numbers no client sends refuses the whole message, and steps past a full queue are dropped. Returns false when
+   * something was refused.
+   */
+  input(t, e, s) {
+    const n = this.players.get(t);
+    if (!n) return !1;
+    if (!Number.isInteger(e) || e < 0 || !Array.isArray(s) || s.length > this.maxQueue)
+      return n.strikes++, !1;
+    for (const h of s)
+      if (!Array.isArray(h) || h.length !== 3 || !h.every((l) => Number.isFinite(l)) || Math.abs(h[0]) > 1 || Math.abs(h[1]) > 1 || !Number.isInteger(h[2]))
+        return n.strikes++, !1;
+    const r = n.ack + 1 + n.queue.length, o = e - r;
+    if (o > this.maxQueue)
+      return n.strikes++, !1;
+    for (let h = 0; h < o; h++) n.queue.push([0, 0, 0]);
+    let a = !0;
+    for (let h = 0; h < s.length; h++)
+      if (!(e + h < r)) {
+        if (n.queue.length >= this.maxQueue) {
+          a = !1, n.strikes++;
+          break;
+        }
+        n.queue.push([s[h][0], s[h][1], s[h][2]]);
+      }
+    return a;
+  }
+  /** One simulation step for everyone. */
+  step() {
+    this.tick++;
+    for (const t of this.players.values()) {
+      const e = t.queue.length;
+      if (e === 0) continue;
+      const s = e > this.backlog ? Math.min(this.maxSteps, e - this.backlog + 1) : 1;
+      for (let n = 0; n < s; n++) {
+        const r = t.queue.shift();
+        ct(t.mover, r, t.params, this.options.grid), t.ack++, this.options.onStep?.(t, r);
+      }
+    }
+  }
+  /** The snapshot player `id` should get now. `time` is the server's wall clock (ms). */
+  snapshotFor(t, e) {
+    const s = this.players.get(t), n = this.known.get(t);
+    if (!s || !n) return null;
+    const r = [], o = [], a = /* @__PURE__ */ new Set();
+    for (const c of this.players.values())
+      a.add(c.id), r.push([c.id, c.mover.x, c.mover.y, c.aim, c.anim, c.hp, c.flags]), n.has(c.id) || (n.add(c.id), o.push({ id: c.id, data: c.data }));
+    const h = [];
+    for (const c of n)
+      a.has(c) || (n.delete(c), h.push(c));
+    const l = { t: "snap", tick: this.tick, time: e, ack: s.ack, me: Tn(s.mover), up: r };
+    return o.length && (l.sp = o), h.length && (l.rm = h), l;
+  }
+}
+class Rr {
+  constructor(t, e = {}) {
+    this.room = t, this.options = e, this.stepMs = 1e3 / (e.stepRate ?? 60), this.snapEvery = Math.max(1, Math.round((e.stepRate ?? 60) / (e.snapRate ?? 20))), this.now = e.now ?? Date.now;
+  }
+  room;
+  options;
+  sockets = /* @__PURE__ */ new Map();
+  joined = /* @__PURE__ */ new Set();
+  nextId = 1;
+  stepTimer = null;
+  lastStepAt = 0;
+  stepsDue = 0;
+  stepMs;
+  snapEvery;
+  now;
+  /** A socket connected; returns the id its messages and its close are reported under. */
+  connect(t) {
+    const e = this.nextId++;
+    return this.sockets.set(e, t), e;
+  }
+  /** A message arrived from socket `id` (text as a string, binary as bytes). */
+  message(t, e) {
+    if (typeof e != "string") return;
+    let s;
+    try {
+      s = JSON.parse(e);
+    } catch {
+      return this.strike(t);
+    }
+    if (!s || typeof s != "object" || typeof s.t != "string") return this.strike(t);
+    switch (s.t) {
+      case "hello": {
+        if (this.joined.has(t)) return;
+        let n;
+        try {
+          n = this.options.admit ? this.options.admit(s.data, t) : s.data;
+        } catch (r) {
+          this.sockets.get(t)?.close(4003, r instanceof Error ? r.message : "refused");
+          return;
+        }
+        this.room.join(t, n), this.joined.add(t), this.sendTo(t, { t: "welcome", id: t, tick: this.room.tick, stepRate: 1e3 / this.stepMs, snapRate: 1e3 / this.stepMs / this.snapEvery }), this.options.onJoin?.(t);
+        return;
+      }
+      case "input": {
+        const n = s;
+        if (!this.joined.has(t)) return;
+        this.room.input(t, n.seq, n.steps) || this.checkStrikes(t);
+        return;
+      }
+      case "ping": {
+        const n = s.c;
+        typeof n == "number" && Number.isFinite(n) && this.sendTo(t, { t: "pong", c: n, st: this.now() });
+        return;
+      }
+      default:
+        this.joined.has(t) && this.options.onMessage?.(t, s);
+    }
+  }
+  /** Socket `id` closed. */
+  disconnect(t) {
+    this.sockets.delete(t), this.joined.delete(t) && (this.room.leave(t), this.options.onLeave?.(t));
+  }
+  /** Sends one of the game's own messages to a player. */
+  sendTo(t, e) {
+    const s = this.sockets.get(t);
+    s && (e.t === "snap" && e.up?.length ? s.send(Sn(e)) : s.send(JSON.stringify(e)));
+  }
+  /** Starts stepping on a timer. Steps are counted by the clock, so a late timer runs the steps it owes. */
+  start() {
+    this.stepTimer || (this.lastStepAt = this.now(), this.stepTimer = setInterval(() => {
+      const t = this.now();
+      for (this.stepsDue += (t - this.lastStepAt) / this.stepMs, this.lastStepAt = t, this.stepsDue = Math.min(this.stepsDue, 60); this.stepsDue >= 1; )
+        this.stepsDue--, this.stepOnce();
+    }, this.stepMs / 2));
+  }
+  stop() {
+    this.stepTimer && clearInterval(this.stepTimer), this.stepTimer = null;
+  }
+  /** One step, and the snapshots when they are due. Exposed for tests and for servers that drive their own loop. */
+  stepOnce() {
+    if (this.room.step(), this.room.tick % this.snapEvery !== 0) return;
+    const t = this.now();
+    for (const e of this.joined) {
+      const s = this.room.snapshotFor(e, t);
+      s && this.sendTo(e, s);
+    }
+  }
+  strike(t) {
+    const e = this.room.players.get(t);
+    e && (e.strikes++, this.checkStrikes(t));
+  }
+  checkStrikes(t) {
+    const e = this.room.players.get(t);
+    e && e.strikes >= (this.options.maxStrikes ?? 20) && (this.sockets.get(t)?.close(4008, "too much invalid input"), this.disconnect(t));
+  }
+}
+class Or {
+  constructor(t, e = {}) {
+    this.url = t, this.options = e;
+  }
+  url;
+  options;
+  events = new Pt();
+  /** The last measured round trip, ms. */
+  rtt = 0;
+  socket = null;
+  batch = null;
+  closedByUs = !1;
+  attempt = 0;
+  pingTimer = null;
+  retryTimer = null;
+  get open() {
+    return this.socket?.readyState === 1;
+  }
+  connect() {
+    this.closedByUs = !1;
+    const t = this.options.WebSocket ?? globalThis.WebSocket;
+    if (!t) throw new Error("Connection: no WebSocket in this environment");
+    const e = new t(this.url);
+    return e.binaryType = "arraybuffer", this.socket = e, e.onopen = () => {
+      this.attempt = 0, this.send({ t: "hello", data: this.options.hello?.() }), this.ping(), this.pingTimer = setInterval(() => this.ping(), this.options.pingMs ?? 1e3), this.events.emit("open", void 0);
+    }, e.onmessage = (s) => this.receive(s.data), e.onclose = (s) => {
+      this.pingTimer && clearInterval(this.pingTimer), this.pingTimer = null, this.socket = null;
+      const n = !this.closedByUs && this.options.reconnect !== !1;
+      if (this.events.emit("close", { code: s.code, reason: s.reason, willRetry: n }), n) {
+        const r = Math.min(this.options.maxBackoffMs ?? 1e4, 250 * 2 ** this.attempt++);
+        this.retryTimer = setTimeout(() => this.connect(), r);
+      }
+    }, this;
+  }
+  /** Sends a message now (dropped while closed: input is resent by the prediction's own state, not by the socket). */
+  send(t) {
+    this.socket?.readyState === 1 && this.socket.send(JSON.stringify(t));
+  }
+  /** Adds one input step to this frame's batch; `flush` sends it. Steps must come in sequence order. */
+  queueInput(t, e) {
+    this.batch || (this.batch = { seq: t, steps: [] }), this.batch.steps.push([e[0], e[1], e[2]]);
+  }
+  /** Sends this frame's input steps as one message. Call once a frame. */
+  flush() {
+    this.batch && (this.send({ t: "input", seq: this.batch.seq, steps: this.batch.steps }), this.batch = null);
+  }
+  close() {
+    this.closedByUs = !0, this.retryTimer && clearTimeout(this.retryTimer), this.pingTimer && clearInterval(this.pingTimer), this.socket?.close(), this.socket = null;
+  }
+  ping() {
+    this.send({ t: "ping", c: Date.now() });
+  }
+  receive(t) {
+    let e;
+    try {
+      e = typeof t == "string" ? JSON.parse(t) : En(t);
+    } catch (s) {
+      console.error("[net] could not read a message", s);
+      return;
+    }
+    switch (e.t) {
+      case "pong": {
+        const s = e;
+        this.rtt = Date.now() - s.c, Dn(s.st, this.rtt);
+        return;
+      }
+      case "welcome":
+        this.events.emit("welcome", e);
+        return;
+      case "snap":
+        this.events.emit("snapshot", e);
+        return;
+      default:
+        this.events.emit("message", e);
+    }
+  }
+}
+export {
+  mr as Actions,
+  os as AnimationComponent,
+  zn as Animator,
+  $n as AssetLoader,
+  Wn as AtlasBuilder,
+  pe as BODY_HALF_HEIGHT,
+  fe as BODY_HALF_WIDTH,
+  be as BitmapLabel,
+  Mr as CADENCE,
+  ge as Camera,
+  Oe as CanvasTexture,
+  ye as Clock,
+  Or as Connection,
+  vt as DIAGONAL,
+  Wt as Engine,
+  Pt as EventBus,
+  Je as FLIP_D,
+  Ve as FLIP_H,
+  Xe as FLIP_V,
+  Le as FixedLoop,
+  ce as Graphics,
+  ve as Group,
+  Vi as HEAVY_FLASH_GAP_MS,
+  Qn as HUMANOID_CLIPS,
+  Zn as HUMANOID_POSES,
+  Xn as HUMANOID_RIG,
+  me as INPUT_FLAG_DASH,
+  gt as INPUT_STEP_DT,
+  Hr as INPUT_STEP_RATE,
+  Me as Image,
+  Dr as InterpolationBuffer,
+  pr as Keyboard,
+  sr as LightLayer,
+  xr as LongPress,
+  yn as MusicPlayer,
+  ke as ObjectFactory,
+  wn as PAD_BUTTONS,
+  pt as Pointer,
+  tr as PosePlayer,
+  Br as PredictedMover,
+  rr as RECOIL_MS,
+  Et as RIG_PARTS,
+  Ht as Rectangle,
+  er as RigView,
+  Tr as Room,
+  Rr as RoomHost,
+  Yt as STICK_DEAD_ZONE,
+  S as SYNTH_RATE,
+  _n as Scene,
+  He as SceneManager,
+  us as Skeleton,
+  gn as SoundEngine,
+  rs as SpriteComponent,
+  H as Stage,
+  Ir as TILE_SIZE,
+  Ae as Text,
+  Ce as TextureRegistry,
+  Vn as TilemapView,
+  Fe as Tween,
+  Te as Tweener,
+  W as UPDATE_RECORD_BYTES,
+  ze as World,
+  Hn as addLabelGlyphs,
+  gr as aimAxis,
+  Gn as animationSystem,
+  Pn as atlasPageLimit,
+  St as blendPose,
+  qn as blocksShot,
+  Yn as bodyCollides,
+  Ar as cadenceEarly,
+  kr as cadenceNext,
+  jn as collisionFromTiled,
+  as as createCollisionGrid,
+  qt as createMover,
+  En as decodeSnapshotFrame,
+  Mn as decodeUpdates,
+  Nt as defineComponent,
+  In as defineFields,
+  Se as easeByName,
+  Sn as encodeSnapshotFrame,
+  br as encodeUpdates,
+  q as engineSettings,
+  b as entityIndex,
+  $t as gidOf,
+  Bt as hasTakes,
+  ir as hitStopMs,
+  hr as hurtFlashGapMs,
+  ar as hurtFlashMs,
+  lr as inView,
+  xe as installLabelFont,
+  P as isSolidTile,
+  ue as isTouchUi,
+  Un as layerByName,
+  hs as moveX,
+  ls as moveY,
+  Rn as moverFromWire,
+  Tn as moverToWire,
+  fr as music,
+  Dn as noteServerTime,
+  Nn as objectsOf,
+  Jn as overlay,
+  is as parseTiled,
+  je as planAtlas,
+  vr as quantizeUpdates,
+  or as recoilAt,
+  nr as recoilPx,
+  ur as registerSounds,
+  cr as registerTakes,
+  ln as renderRecipe,
+  Fr as resetServerClock,
+  bt as resolveUrl,
+  Sr as serverNow,
+  Er as serverOffset,
+  _r as setNativeShell,
+  dr as sound,
+  ct as stepMover,
+  bn as stickActive,
+  wr as stickToAxis,
+  yr as stickVector,
+  Ne as system,
+  zt as tileAt,
+  Ze as tileRect,
+  Kn as upperOver
+};
+//# sourceMappingURL=lantern-engine.js.map