lantern-engine 0.0.0-stage → 0.4.0

package/dist/pixel.js

@@ -0,0 +1,1404 @@
+import { Sprite as K, Texture as W, BufferImageSource as ae, RenderTexture as wt, Container as et } from "pixi.js";
+import { a as re, p as he, e as Tt, T as ce, i as le } from "./constants-CjYVdFid.js";
+he();
+const xt = 1024, fe = [16, 24, 32, 48, 64, 96, 128, 192, 256, 384, 512, 768, 1024], ue = 24, de = 24 * 1024 * 1024, Me = 60, Y = /* @__PURE__ */ new Map();
+let V = 0, Ht = 0;
+const yt = (o) => {
+  for (const t of fe) if (t >= o) return t;
+  return Math.ceil(o / 256) * 256;
+}, Ct = (o, t) => o * 4096 + t;
+function pe(o, t) {
+  let e = Y.get(Ct(o, t));
+  if (!e?.length) {
+    let i = 1 / 0;
+    for (const [r, h] of Y) {
+      if (!h.length) continue;
+      const c = Math.floor(r / 4096), l = r % 4096, d = c * l;
+      c >= o && l >= t && d <= o * t * 2 && d < i && (i = d, e = h);
+    }
+  }
+  const n = e?.pop();
+  if (n)
+    return V -= n.pixels.byteLength, n;
+  Ht++;
+  const s = new Uint8Array(o * t * 4), a = new ae({
+    resource: s,
+    width: o,
+    height: t,
+    format: "rgba8unorm",
+    alphaMode: "premultiplied-alpha",
+    scaleMode: "nearest"
+  });
+  return { pixels: s, words: new Uint32Array(s.buffer), source: a, texture: new W({ source: a }), capW: o, capH: t };
+}
+function ge(o) {
+  const t = Ct(o.capW, o.capH);
+  let e = Y.get(t);
+  if (e || Y.set(t, e = []), e.length >= ue || V + o.pixels.byteLength > de) {
+    o.texture.destroy(!0);
+    return;
+  }
+  e.push(o), V += o.pixels.byteLength;
+}
+function me(o) {
+  return o.add.existing(new J());
+}
+class J extends re {
+  /** This frame's rects: x, y, w, h, colour, alpha — six numbers each. */
+  rects = [];
+  /** Staged solid runs not yet committed: x, y, w, colour — four numbers each; later ones win. */
+  staged = [];
+  ink = 16777215;
+  inkAlpha = 1;
+  sprite = new K(W.EMPTY);
+  surface = null;
+  /** Where the buffer's first pixel sits in the layer, as of the last `present`. */
+  originX = 0;
+  originY = 0;
+  /** The last frame's size, and how many presents in a row it stayed well inside a quarter of the buffer. */
+  lastW = 0;
+  lastH = 0;
+  small = 0;
+  constructor() {
+    super(), this.sprite.visible = !1, this.addChild(this.sprite);
+  }
+  /** Textures made, spent buffers waiting in the pool and their bytes (the leak tools read it). */
+  static stats() {
+    let t = 0;
+    for (const e of Y.values()) t += e.length;
+    return { made: Ht, pooled: t, pooledBytes: V };
+  }
+  /** Lets every pooled buffer go (the world changed map): the next map's effects start a pool of their own. */
+  static drainPool() {
+    for (const t of Y.values()) for (const e of t) e.texture.destroy(!0);
+    Y.clear(), V = 0;
+  }
+  fillStyle(t, e = 1) {
+    return this.ink = t, this.inkAlpha = e, super.fillStyle(t, e);
+  }
+  fillRect(t, e, n, s) {
+    const a = Math.round(t), i = Math.round(e), r = Math.round(t + n) - a, h = Math.round(e + s) - i;
+    return r > 0 && h > 0 && this.inkAlpha > 0 && this.rects.push(a, i, r, h, this.ink, this.inkAlpha), this;
+  }
+  /** `fillStyle` + `fillRect` on whole pixels in one call, leaving the fill style alone (a hot loop's way in). */
+  rect(t, e, n, s, a, i = 1) {
+    n > 0 && s > 0 && i > 0 && Number.isFinite(t) && Number.isFinite(e) && Number.isFinite(n) && Number.isFinite(s) && this.rects.push(t, e, n, s, a, i);
+  }
+  /**
+   * A solid run of `w` whole pixels at (x, y) in `color`, held until `commit` lays every staged run in the order given
+   * (the later winning where they cross), after whatever was drawn before the commit. What `pixelTone`'s batch writes
+   * instead of filing each pixel in a map and sorting it into rects.
+   */
+  stage(t, e, n, s) {
+    Number.isFinite(t) && Number.isFinite(e) && Number.isFinite(n) && this.staged.push(t, e, n, s);
+  }
+  /** Lays the staged runs, as opaque rects, after everything drawn so far. */
+  commit() {
+    const t = this.staged, e = t.length;
+    if (e === 0) return;
+    const n = this.rects;
+    for (let s = 0; s < e; s += 4) n.push(t[s], t[s + 1], t[s + 2], 1, t[s + 3], 1);
+    t.length = 0;
+  }
+  clear() {
+    return this.rects.length = 0, this.staged.length = 0, super.clear();
+  }
+  /** How far the last frame reached from the layer's origin, in world pixels (0 when nothing showed). */
+  reach() {
+    return this.sprite.visible ? Math.max(Math.abs(this.originX), Math.abs(this.originY), Math.abs(this.originX + this.lastW), Math.abs(this.originY + this.lastH)) : 0;
+  }
+  /** Writes this frame's rects into the texture and shows it; call once the frame is painted. */
+  present() {
+    this.commit();
+    const t = this.rects;
+    if (t.length === 0) {
+      this.sprite.visible = !1;
+      return;
+    }
+    let e = 1 / 0, n = 1 / 0, s = -1 / 0, a = -1 / 0;
+    for (let u = 0; u < t.length; u += 6)
+      t[u] < e && (e = t[u]), t[u + 1] < n && (n = t[u + 1]), t[u] + t[u + 2] > s && (s = t[u] + t[u + 2]), t[u + 1] + t[u + 3] > a && (a = t[u + 1] + t[u + 3]);
+    const i = s - e, r = a - n;
+    if (i > xt || r > xt) {
+      this.sprite.visible = !1;
+      const u = t.length;
+      for (let f = 0; f < u; f += 6)
+        super.fillStyle(t[f + 4], t[f + 5]), super.fillRect(t[f], t[f + 1], t[f + 2], t[f + 3]);
+      return;
+    }
+    const h = this.fit(i, r), { words: c, pixels: l, capW: d } = h;
+    c.fill(0);
+    for (let u = 0; u < t.length; u += 6) {
+      const f = t[u] - e, M = t[u + 1] - n, p = t[u + 2], g = t[u + 3], b = t[u + 4], w = t[u + 5], x = b >> 16 & 255, y = b >> 8 & 255, A = b & 255;
+      if (w >= 1) {
+        const F = (4278190080 | A << 16 | y << 8 | x) >>> 0;
+        if (p === 1 && g === 1) {
+          c[M * d + f] = F;
+          continue;
+        }
+        for (let k = M; k < M + g; k++) {
+          const X = k * d + f;
+          if (p < 8) for (let lt = X, ie = X + p; lt < ie; lt++) c[lt] = F;
+          else c.fill(F, X, X + p);
+        }
+        continue;
+      }
+      const S = 1 - w, B = x * w, tt = y * w, se = A * w, oe = 255 * w;
+      for (let F = M; F < M + g; F++)
+        for (let k = (F * d + f) * 4, X = k + p * 4; k < X; k += 4)
+          l[k] = B + l[k] * S, l[k + 1] = tt + l[k + 1] * S, l[k + 2] = se + l[k + 2] * S, l[k + 3] = oe + l[k + 3] * S;
+    }
+    h.source.update(), this.sprite.texture = h.texture, this.sprite.position.set(e, n), this.sprite.visible = !0, this.originX = e, this.originY = n, this.lastW = i, this.lastH = r;
+  }
+  /**
+   * Shows `other`'s last frame instead of painting one: its texture, placed where it placed it. A frame shared by
+   * several bodies (the same aura on two bodies) is painted once and shown by each of their layers.
+   */
+  mirror(t) {
+    const e = t.surface;
+    if (!e || !t.sprite.visible) {
+      this.hideMirror();
+      return;
+    }
+    this.sprite.texture = e.texture, this.sprite.position.set(t.originX, t.originY), this.sprite.visible = !0, this.originX = t.originX, this.originY = t.originY, this.lastW = t.lastW, this.lastH = t.lastH;
+  }
+  /** Shows nothing and lets go of the texture a `mirror` showed. */
+  hideMirror() {
+    this.sprite.visible = !1, this.sprite.texture = this.surface?.texture ?? W.EMPTY;
+  }
+  /** The premultiplied [r, g, b, a] last presented at layer pixel (x, y); zeros where nothing was (tests read it). */
+  pixelAt(t, e) {
+    const n = this.surface, s = n?.capW ?? 0, a = n?.capH ?? 0;
+    if (this.sprite.width !== s || this.sprite.height !== a) throw new Error("PixelLayer sprite is scaled");
+    const i = t - this.originX, r = e - this.originY;
+    if (!n || !this.sprite.visible || i < 0 || r < 0 || i >= s || r >= a) return [0, 0, 0, 0];
+    const h = (r * s + i) * 4;
+    return [n.pixels[h], n.pixels[h + 1], n.pixels[h + 2], n.pixels[h + 3]];
+  }
+  /** The buffer's size (tests read it). */
+  capacity() {
+    return { w: this.surface?.capW ?? 0, h: this.surface?.capH ?? 0 };
+  }
+  /**
+   * A buffer at least `w` × `h`: grown a size class at a time and kept while it fits, traded back to the pool for a
+   * smaller one only once the frames have stayed well inside it for `SHRINK_AFTER` presents (a long-lived layer — an
+   * aura, a status mark — that once swelled would otherwise hold and upload its largest buffer for good).
+   */
+  fit(t, e) {
+    const n = this.surface;
+    if (n && t <= n.capW && e <= n.capH) {
+      const h = n.capW * n.capH >= 16384 && t * 4 <= n.capW && e * 4 <= n.capH;
+      if (this.small = h ? this.small + 1 : 0, this.small < Me) return n;
+    }
+    this.small = 0;
+    const s = !!n && (t > n.capW || e > n.capH), a = yt(Math.max(1, t, s ? n.capW : 0)), i = yt(Math.max(1, e, s ? n.capH : 0));
+    this.dropSurface();
+    const r = pe(a, i);
+    return this.surface = r, this.sprite.texture = r.texture, r;
+  }
+  dropSurface() {
+    this.sprite.texture = W.EMPTY, this.surface && ge(this.surface), this.surface = null;
+  }
+  destroy() {
+    this.destroyed || (this.dropSurface(), super.destroy());
+  }
+}
+const bt = 0;
+function L(o, t, e, n = 255) {
+  const s = Math.max(0, Math.min(255, Math.round(o))), a = Math.max(0, Math.min(255, Math.round(t))), i = Math.max(0, Math.min(255, Math.round(e)));
+  return (Math.max(0, Math.min(255, Math.round(n))) << 24 | i << 16 | a << 8 | s) >>> 0;
+}
+function m(o) {
+  let t = o.startsWith("#") ? o.slice(1) : o;
+  t.length === 3 && (t = [...t].map((i) => i + i).join(""));
+  const e = parseInt(t.slice(0, 2), 16), n = parseInt(t.slice(2, 4), 16), s = parseInt(t.slice(4, 6), 16), a = t.length >= 8 ? parseInt(t.slice(6, 8), 16) : 255;
+  return L(e, n, s, a);
+}
+function R(o) {
+  return [o & 255, o >>> 8 & 255, o >>> 16 & 255, o >>> 24 & 255];
+}
+function $t(o, t) {
+  const [e, n, s, a] = R(o);
+  if (t >= 1) {
+    const i = Math.min(1, t - 1);
+    return L(e + (255 - e) * i, n + (255 - n) * i, s + (255 - s) * i, a);
+  }
+  return L(e * t, n * t, s * t, a);
+}
+function we(o, t, e) {
+  const n = R(o), s = R(t);
+  return L(n[0] + (s[0] - n[0]) * e, n[1] + (s[1] - n[1]) * e, n[2] + (s[2] - n[2]) * e, n[3] + (s[3] - n[3]) * e);
+}
+function un(o, t) {
+  const [e, n, s] = R(o);
+  return L(e, n, s, t);
+}
+function dn(o) {
+  const [t, e, n, s] = R(o);
+  return `rgba(${t},${e},${n},${(s / 255).toFixed(3)})`;
+}
+function nt(o, t, e = 0) {
+  let n = o * 374761393 + t * 668265263 + e * 2147483647 | 0;
+  return n = Math.imul(n ^ n >>> 13, 1274126177), ((n ^ n >>> 16) >>> 0) / 4294967296;
+}
+function Mn(o) {
+  let t = o >>> 0;
+  return () => {
+    t = t + 1831565813 >>> 0;
+    let e = t;
+    return e = Math.imul(e ^ e >>> 15, e | 1), e ^= e + Math.imul(e ^ e >>> 7, e | 61), ((e ^ e >>> 14) >>> 0) / 4294967296;
+  };
+}
+function pn(o, t, e, n) {
+  const s = o / e, a = t / e, i = Math.floor(s), r = Math.floor(a), h = s - i, c = a - r, l = h * h * (3 - 2 * h), d = c * c * (3 - 2 * c), u = nt(i, r, n), f = nt(i + 1, r, n), M = nt(i, r + 1, n), p = nt(i + 1, r + 1, n);
+  return u + (f - u) * l + (M - u) * d + (u - f - M + p) * l * d;
+}
+class G {
+  constructor(t, e) {
+    this.w = t, this.h = e, this.data = new Uint32Array(t * e);
+  }
+  w;
+  h;
+  data;
+  inBounds(t, e) {
+    return t >= 0 && e >= 0 && t < this.w && e < this.h;
+  }
+  px(t, e, n) {
+    t = Math.floor(t), e = Math.floor(e), t >= 0 && e >= 0 && t < this.w && e < this.h && (this.data[e * this.w + t] = n);
+  }
+  get(t, e) {
+    return t < 0 || e < 0 || t >= this.w || e >= this.h ? bt : this.data[e * this.w + t] ?? bt;
+  }
+  alphaAt(t, e) {
+    return this.get(t, e) >>> 24;
+  }
+  rect(t, e, n, s, a) {
+    for (let i = Math.floor(e); i < e + s; i++) for (let r = Math.floor(t); r < t + n; r++) this.px(r, i, a);
+  }
+  hline(t, e, n, s) {
+    for (let a = Math.min(t, e); a <= Math.max(t, e); a++) this.px(a, n, s);
+  }
+  vline(t, e, n, s) {
+    for (let a = Math.min(e, n); a <= Math.max(e, n); a++) this.px(t, a, s);
+  }
+  /** Filled ellipse; a pixel is inside when its center lies inside the ellipse. */
+  ellipse(t, e, n, s, a) {
+    if (!(n <= 0 || s <= 0))
+      for (let i = Math.floor(e - s); i <= Math.ceil(e + s); i++)
+        for (let r = Math.floor(t - n); r <= Math.ceil(t + n); r++) {
+          const h = (r + 0.5 - t) / n, c = (i + 0.5 - e) / s;
+          h * h + c * c <= 1 && this.px(r, i, a);
+        }
+  }
+  circle(t, e, n, s) {
+    this.ellipse(t, e, n, n, s);
+  }
+  ring(t, e, n, s, a) {
+    for (let i = Math.floor(e - n - 1); i <= Math.ceil(e + n + 1); i++)
+      for (let r = Math.floor(t - n - 1); r <= Math.ceil(t + n + 1); r++) {
+        const h = Math.hypot(r + 0.5 - t, i + 0.5 - e);
+        h <= n && h >= n - s && this.px(r, i, a);
+      }
+  }
+  line(t, e, n, s, a, i = 1) {
+    t = Math.round(t), e = Math.round(e), n = Math.round(n), s = Math.round(s);
+    const r = Math.abs(n - t), h = -Math.abs(s - e), c = t < n ? 1 : -1, l = e < s ? 1 : -1;
+    let d = r + h;
+    for (; i <= 1 ? this.px(t, e, a) : this.rect(t - Math.floor((i - 1) / 2), e - Math.floor((i - 1) / 2), i, i, a), !(t === n && e === s); ) {
+      const u = 2 * d;
+      u >= h && (d += h, t += c), u <= r && (d += r, e += l);
+    }
+  }
+  /** Filled polygon (even-odd scanline on pixel centers). */
+  poly(t, e) {
+    if (t.length < 3) return;
+    const n = Math.floor(Math.min(...t.map((a) => a[1]))), s = Math.ceil(Math.max(...t.map((a) => a[1])));
+    for (let a = n; a <= s; a++) {
+      const i = a + 0.5, r = [];
+      for (let h = 0; h < t.length; h++) {
+        const c = t[h], l = t[(h + 1) % t.length];
+        (c[1] <= i && l[1] > i || l[1] <= i && c[1] > i) && r.push(c[0] + (i - c[1]) / (l[1] - c[1]) * (l[0] - c[0]));
+      }
+      r.sort((h, c) => h - c);
+      for (let h = 0; h + 1 < r.length; h += 2)
+        for (let c = Math.ceil(r[h] - 0.5); c <= Math.floor(r[h + 1] - 0.5); c++) this.px(c, a, e);
+    }
+  }
+  /**
+   * Adds `width` pixels of outline around all opaque pixels, one ring at a time — the same result as calling it
+   * `width` times, but each ring only visits the neighbours of the ring before it instead of the whole grid again.
+   * (A pixel next to ring `k` is always filled by ring `k+1`, so nothing further back can still be waiting.)
+   */
+  outline(t, e = !1, n = 1) {
+    const s = this.w, a = this.h, i = new Uint8Array(this.data.length);
+    let r = s, h = a, c = -1, l = -1;
+    for (let f = 0; f < a; f++)
+      for (let M = 0; M < s; M++) {
+        const p = f * s + M;
+        this.data[p] >>> 24 && (i[p] = 1, M < r && (r = M), M > c && (c = M), f < h && (h = f), l = f);
+      }
+    if (c < 0) return;
+    const d = (f, M, p) => f >= 0 && M >= 0 && f < s && M < a && i[p] === 1;
+    let u = [];
+    for (let f = Math.max(0, h - 1); f <= Math.min(a - 1, l + 1); f++)
+      for (let M = Math.max(0, r - 1); M <= Math.min(s - 1, c + 1); M++) {
+        const p = f * s + M;
+        if (i[p]) continue;
+        let g = d(M - 1, f, p - 1) || d(M + 1, f, p + 1) || d(M, f - 1, p - s) || d(M, f + 1, p + s);
+        !g && e && (g = d(M - 1, f - 1, p - s - 1) || d(M + 1, f - 1, p - s + 1) || d(M - 1, f + 1, p + s - 1) || d(M + 1, f + 1, p + s + 1)), g && (this.data[p] = t, u.push(p));
+      }
+    for (const f of u) i[f] = 1;
+    for (let f = 1; f < n && u.length; f++) {
+      const M = [];
+      for (const p of u) {
+        const g = p % s, b = p / s | 0, w = (x, y, A) => {
+          x < 0 || y < 0 || x >= s || y >= a || i[A] || (i[A] = 1, this.data[A] = t, M.push(A));
+        };
+        w(g - 1, b, p - 1), w(g + 1, b, p + 1), w(g, b - 1, p - s), w(g, b + 1, p + s), e && (w(g - 1, b - 1, p - s - 1), w(g + 1, b - 1, p - s + 1), w(g - 1, b + 1, p + s - 1), w(g + 1, b + 1, p + s + 1));
+      }
+      u = M;
+    }
+  }
+  /** Replaces every pixel whose color matches `from`. */
+  recolor(t, e) {
+    for (let n = 0; n < this.data.length; n++) this.data[n] === t && (this.data[n] = e);
+  }
+  /** Multiplies brightness of opaque pixels matching `pred`. */
+  tint(t, e) {
+    for (let n = 0; n < this.h; n++)
+      for (let s = 0; s < this.w; s++) {
+        const a = n * this.w + s, i = this.data[a] ?? 0;
+        i >>> 24 && e(s, n) && (this.data[a] = $t(i, t));
+      }
+  }
+  blit(t, e, n, s = !1) {
+    for (let a = 0; a < t.h; a++)
+      for (let i = 0; i < t.w; i++) {
+        const r = t.data[a * t.w + i] ?? 0;
+        r >>> 24 && this.px(e + (s ? t.w - 1 - i : i), n + a, r);
+      }
+  }
+  /** Alpha-blends a color onto an existing pixel. */
+  blend(t, e, n) {
+    if (!this.inBounds(t, e)) return;
+    const s = e * this.w + t, a = this.data[s] ?? 0, [i, r, h, c] = R(n), l = c / 255, d = R(a);
+    this.data[s] = L(d[0] + (i - d[0]) * l, d[1] + (r - d[1]) * l, d[2] + (h - d[2]) * l, Math.max(d[3], c));
+  }
+  /** Reads a canvas back into a grid (a PNG layer of the paper doll joining the painted ones). */
+  static from(t) {
+    const e = new G(t.width, t.height), n = t.getContext("2d").getImageData(0, 0, t.width, t.height);
+    return e.data.set(new Uint32Array(n.data.buffer, n.data.byteOffset, t.width * t.height)), e;
+  }
+  /** The same picture on a grid `factor` times as fine, each pixel becoming a square block. */
+  upscaled(t) {
+    if (t === 1) return this;
+    const e = new G(this.w * t, this.h * t);
+    for (let n = 0; n < this.h; n++)
+      for (let s = 0; s < this.w; s++) {
+        const a = this.data[n * this.w + s] ?? 0;
+        a >>> 24 && e.rect(s * t, n * t, t, t, a);
+      }
+    return e;
+  }
+  /** Same size and same pixels. */
+  equals(t) {
+    if (t.w !== this.w || t.h !== this.h) return !1;
+    for (let e = 0; e < this.data.length; e++) if (this.data[e] !== t.data[e]) return !1;
+    return !0;
+  }
+  /** Cheap hash of the pixels, for grouping identical frames before comparing them. */
+  key() {
+    let t = 2166136261;
+    for (let e = 0; e < this.data.length; e++)
+      t ^= this.data[e], t = Math.imul(t, 16777619) >>> 0;
+    return t >>> 0;
+  }
+  clone() {
+    const t = new G(this.w, this.h);
+    return t.data.set(this.data), t;
+  }
+  toCanvas() {
+    const t = document.createElement("canvas");
+    t.width = this.w, t.height = this.h;
+    const e = t.getContext("2d");
+    if (!e) throw new Error("2D canvas not supported");
+    const n = new Uint8ClampedArray(this.w * this.h * 4);
+    n.set(new Uint8Array(this.data.buffer, this.data.byteOffset, this.data.byteLength));
+    const s = new ImageData(n, this.w, this.h);
+    return e.putImageData(s, 0, 0), t;
+  }
+}
+class gn extends G {
+  constructor(t, e, n, s) {
+    super(n, s), this.x0 = t, this.y0 = e;
+  }
+  x0;
+  y0;
+  inBounds(t, e) {
+    return super.inBounds(t - this.x0, e - this.y0);
+  }
+  px(t, e, n) {
+    super.px(Math.floor(t) - this.x0, Math.floor(e) - this.y0, n);
+  }
+  get(t, e) {
+    return super.get(t - this.x0, e - this.y0);
+  }
+  blend(t, e, n) {
+    const s = t - this.x0, a = e - this.y0;
+    if (!super.inBounds(s, a)) return;
+    const i = a * this.w + s, r = this.data[i] ?? 0, [h, c, l, d] = R(n), u = d / 255, f = R(r);
+    this.data[i] = L(f[0] + (h - f[0]) * u, f[1] + (c - f[1]) * u, f[2] + (l - f[2]) * u, Math.max(f[3], d));
+  }
+}
+function mn(o, t = 16384) {
+  const e = o[0];
+  if (!e) throw new Error("makeSheet: no frames");
+  const n = Math.max(1, Math.min(o.length, Math.floor(t / e.w))), s = Math.ceil(o.length / n), a = new G(e.w * n, e.h * s);
+  return o.forEach((i, r) => a.blit(i, r % n * e.w, Math.floor(r / n) * e.h)), a.toCanvas();
+}
+function wn(o, t) {
+  const e = document.createElement("canvas");
+  e.width = o.width * t, e.height = o.height * t;
+  const n = e.getContext("2d");
+  if (!n) throw new Error("2D canvas not supported");
+  return n.imageSmoothingEnabled = !1, n.drawImage(o, 0, 0, e.width, e.height), e;
+}
+const Ft = {
+  outline: m("#1a1220"),
+  outlineSoft: m("#2e2233"),
+  black: m("#0e0b12"),
+  white: m("#f4f0e8"),
+  offWhite: m("#e2dccf"),
+  skin: m("#f2c59a"),
+  skinShade: m("#d99d74"),
+  skinTan: m("#cf9468"),
+  skinTanShade: m("#a86c48"),
+  blush: m("#e88c80"),
+  hairBlack: m("#2a2230"),
+  hairBrown: m("#5b3a29"),
+  hairAuburn: m("#7a3b2a"),
+  hairWhite: m("#e8e4dc"),
+  hairGrey: m("#9a96a0"),
+  red: m("#c8373a"),
+  redDark: m("#8e2331"),
+  crimson: m("#a3243b"),
+  orange: m("#e07a36"),
+  gold: m("#f2c84b"),
+  goldDark: m("#b88a2a"),
+  yellow: m("#f5e06a"),
+  green: m("#5aa04a"),
+  greenDark: m("#2f6b3a"),
+  jade: m("#4fbf8f"),
+  jadeDark: m("#2d8466"),
+  teal: m("#3aa6a0"),
+  sky: m("#7ec4f0"),
+  azure: m("#4a8ad4"),
+  blue: m("#3560b0"),
+  navy: m("#27335e"),
+  indigo: m("#3b2f6e"),
+  purple: m("#7a4bb0"),
+  pink: m("#e89aaa"),
+  brown: m("#7a5234"),
+  brownDark: m("#4e3222"),
+  brownLight: m("#a6784a"),
+  tan: m("#c9a26e"),
+  cream: m("#efe2c0"),
+  grey: m("#8a8690"),
+  greyDark: m("#57535e"),
+  greyLight: m("#bdb9c2"),
+  steel: m("#c8d2dc"),
+  steelDark: m("#7f8a98"),
+  iron: m("#9aa0a8"),
+  wood: m("#9a6a3c"),
+  woodDark: m("#6a4426"),
+  woodLight: m("#bd8c56"),
+  straw: m("#d8b060"),
+  strawDark: m("#a8823e")
+}, xn = ["cloth", "leather", "mail", "plate", "dragon", "fur", "skin", "hair", "gold", "gem", "shadow"], xe = {
+  // wool and linen: violet shadows, faintly warm lights
+  cloth: { cool: 255, coolDeg: 14, coolSat: 0.06, warm: 50, warmDeg: 6 },
+  // hide: its shadows go red-brown, never grey
+  leather: { cool: 8, coolDeg: 12, coolSat: 0.08, warm: 45, warmDeg: 8 },
+  // steel: blue shadows, lights close to white
+  mail: { cool: 232, coolDeg: 16, coolSat: 0.07, warm: 52, warmDeg: 4 },
+  plate: { cool: 235, coolDeg: 18, coolSat: 0.08, warm: 50, warmDeg: 6 },
+  // scale: crimson-violet shadows, ember-orange lights
+  dragon: { cool: 330, coolDeg: 16, coolSat: 0.06, warm: 36, warmDeg: 12 },
+  fur: { cool: 262, coolDeg: 10, coolSat: 0.04, warm: 48, warmDeg: 6 },
+  // skin: shadows go to blood-red, never to grey or green
+  skin: { cool: 350, coolDeg: 14, coolSat: 0.09, warm: 42, warmDeg: 5 },
+  hair: { cool: 262, coolDeg: 14, coolSat: 0.05, warm: 46, warmDeg: 10 },
+  gold: { cool: 14, coolDeg: 14, coolSat: 0.05, warm: 58, warmDeg: 8 },
+  gem: { cool: 262, coolDeg: 8, coolSat: 0.02, warm: 50, warmDeg: 2 },
+  // the side turned away from the light, whatever it is made of (the far limbs)
+  shadow: { cool: 255, coolDeg: 12, coolSat: 0.04, warm: 50, warmDeg: 0 }
+}, Ot = {
+  cloth: [0.5, 0.66, 0.82, 1.12, 1.25],
+  leather: [0.46, 0.62, 0.8, 1.16, 1.3],
+  mail: [0.44, 0.6, 0.78, 1.22, 1.42],
+  plate: [0.44, 0.56, 0.72, 1.2, 1.45],
+  dragon: [0.42, 0.56, 0.74, 1.14, 1.32],
+  fur: [0.56, 0.7, 0.84, 1.15, 1.26],
+  skin: [0.6, 0.72, 0.86, 1.12, 1.24],
+  hair: [0.5, 0.66, 0.8, 1.2, 1.36],
+  gold: [0.42, 0.62, 0.8, 1.3, 1.5],
+  gem: [0.32, 0.5, 0.78, 1.45, 1.65],
+  shadow: [0.5, 0.66, 0.82, 1.12, 1.25]
+};
+[...new Set(Object.values(Ot).flat())];
+function dt(o) {
+  const [t, e, n] = R(o), s = Math.max(t, e, n), a = Math.min(t, e, n), i = s - a;
+  let r = 0;
+  return i > 0 && (s === t ? r = ((e - n) / i + 6) % 6 : s === e ? r = (n - t) / i + 2 : r = (t - e) / i + 4), [r * 60, s === 0 ? 0 : i / s, s / 255];
+}
+function j(o, t, e, n) {
+  const s = (o % 360 + 360) % 360 / 60, a = Math.floor(s), i = s - a, r = e * (1 - t), h = e * (1 - t * i), c = e * (1 - t * (1 - i)), [l, d, u] = [[e, c, r], [h, e, r], [r, e, c], [r, h, e], [c, r, e], [e, r, h]][a % 6];
+  return L(l * 255, d * 255, u * 255, n);
+}
+function At(o, t, e) {
+  let n = t - o;
+  return n > 180 && (n -= 360), n < -180 && (n += 360), o + Math.sign(n) * Math.min(Math.abs(n), e);
+}
+const U = (o) => Math.max(0, Math.min(1, o)), St = /* @__PURE__ */ new Map();
+function pt(o, t, e) {
+  if (t === 1) return o;
+  const n = `${o}:${t}:${e}`;
+  let s = St.get(n);
+  if (s !== void 0) return s;
+  const a = xe[e], i = $t(o, t), [r, h, c] = dt(i), l = i >>> 24, d = U(1 - dt(o)[1] / 0.14);
+  let u, f;
+  if (t < 1) {
+    const M = (1 - t) / 0.5;
+    u = j(At(r, a.cool, a.coolDeg * M), U(h + a.coolSat * M), c, l), f = j(a.cool, U(h + a.coolSat * M * 1.2), c, l);
+  } else {
+    const M = Math.min(1.5, (t - 1) / 0.3);
+    u = j(At(r, a.warm, a.warmDeg * M), U(h * 1.08), c, l), f = j(a.warm, U(h + 0.03 * M), c, l);
+  }
+  return s = d > 0 ? we(u, f, d) : u, St.set(n, s), s;
+}
+const kt = /* @__PURE__ */ new Map();
+function ye(o, t) {
+  const e = `${o}:${t}`;
+  let n = kt.get(e);
+  if (!n) {
+    const [s, a, i, r, h] = Ot[t].map((c) => pt(o, c, t));
+    n = { deep: s, dark: a, mid: i, base: o, light: r, glint: h }, kt.set(e, n);
+  }
+  return n;
+}
+function yn(o, t) {
+  const e = ye(o, t);
+  return [e.deep, e.dark, e.mid, e.base, e.light, e.glint];
+}
+const vt = /* @__PURE__ */ new Map();
+function Wt(o) {
+  let t = vt.get(o);
+  if (t === void 0) {
+    const [e, n, s] = dt(pt(o, 0.42, "shadow"));
+    t = j(e, U(n * 1.1 + 0.08), Math.min(s, 0.3), 255), vt.set(o, t);
+  }
+  return t;
+}
+function bn(o, t, e) {
+  return { canvas: o.toCanvas(), anchorX: t, anchorY: e };
+}
+function An(o, t = Ft.outline) {
+  const { w: e, h: n } = o, s = new Uint8Array(e * n);
+  for (let i = 0; i < e * n; i++) s[i] = o.data[i] >>> 24 === 255 ? 1 : 0;
+  const a = (i, r) => i >= 0 && r >= 0 && i < e && r < n && s[r * e + i] === 1;
+  for (let i = 0; i < n; i++)
+    for (let r = 0; r < e; r++) {
+      if (s[i * e + r]) continue;
+      const h = a(r, i - 1), c = a(r - 1, i), l = a(r + 1, i), d = a(r, i + 1);
+      (h || c || l || d) && o.px(r, i, h || c ? t : Wt(o.get(l ? r + 1 : r, l ? i : i + 1)));
+    }
+}
+function Sn(o, t, e, n, s) {
+  for (let a = Math.floor(e - s); a <= Math.ceil(e + s); a++)
+    for (let i = Math.floor(t - n); i <= Math.ceil(t + n); i++) {
+      if (!o.inBounds(i, a) || o.alphaAt(i, a)) continue;
+      const r = (i + 0.5 - t) / n, h = (a + 0.5 - e) / s, c = r * r + h * h;
+      c <= 0.55 ? o.px(i, a, be) : c <= 1 && o.px(i, a, Ae);
+    }
+}
+const be = L(26, 22, 44, 78), Ae = L(26, 22, 44, 40);
+function kn(o, t, e, n, s, a, i) {
+  for (let r = e; r < e + s; r++)
+    for (let h = t; h < t + n; h++) {
+      if (!o.inBounds(h, r)) continue;
+      const c = o.get(h, r);
+      !(c >>> 24) || i && !i(h, r) || o.px(h, r, pt(c, a, "shadow"));
+    }
+}
+function vn(o, t = 1) {
+  const { w: e, h: n, data: s } = o, a = new Uint8Array(s.length);
+  let i = e, r = n, h = -1, c = -1;
+  for (let d = 0; d < n; d++) {
+    const u = d * e;
+    for (let f = 0; f < e; f++)
+      s[u + f] >>> 24 && (a[u + f] = 1, f < i && (i = f), f > h && (h = f), d < r && (r = d), c = d);
+  }
+  if (h < 0) return;
+  let l = [];
+  for (let d = Math.max(0, r - 1); d <= Math.min(n - 1, c + 1); d++)
+    for (let u = Math.max(0, i - 1); u <= Math.min(e - 1, h + 1); u++) {
+      const f = d * e + u;
+      if (a[f]) continue;
+      const M = d > 0 && a[f - e] === 1, p = u + 1 < e && a[f + 1] === 1, g = u > 0 && a[f - 1] === 1, b = d + 1 < n && a[f + e] === 1;
+      (M || p || g || b) && (s[f] = M || p ? Ft.outline : Wt(s[g ? f - 1 : f + e]), l.push(f));
+    }
+  for (const d of l) a[d] = 1;
+  for (let d = 1; d < t && l.length; d++) {
+    const u = [];
+    for (const f of l) {
+      const M = f % e, p = f / e | 0, g = s[f], b = (w, x) => {
+        !w || a[x] || (a[x] = 1, s[x] = g, u.push(x));
+      };
+      b(M > 0, f - 1), b(M + 1 < e, f + 1), b(p > 0, f - e), b(p + 1 < n, f + e);
+    }
+    l = u;
+  }
+}
+const Dt = /* @__PURE__ */ new Map();
+function Yt(o) {
+  const t = (o >> 16 & 255) / 255, e = (o >> 8 & 255) / 255, n = (o & 255) / 255, s = Math.max(t, e, n), a = Math.min(t, e, n), i = (s + a) / 2;
+  if (s === a) return [0, 0, i];
+  const r = s - a, h = i > 0.5 ? r / (2 - s - a) : r / (s + a);
+  return [(s === t ? (e - n) / r + (e < n ? 6 : 0) : s === e ? (n - t) / r + 2 : (t - e) / r + 4) / 6, h, i];
+}
+function z(o, t, e) {
+  const n = (r, h, c) => {
+    const l = (c + 1) % 1;
+    return l < 0.16666666666666666 ? r + (h - r) * 6 * l : l < 0.5 ? h : l < 0.6666666666666666 ? r + (h - r) * (0.6666666666666666 - l) * 6 : r;
+  }, s = e < 0.5 ? e * (1 + t) : e + t - e * t, a = 2 * e - s, i = (r) => Math.round(Math.max(0, Math.min(1, t === 0 ? e : n(a, s, r))) * 255);
+  return i(o + 1 / 3) << 16 | i(o) << 8 | i(o - 1 / 3);
+}
+function st(o, t, e) {
+  let n = t - o;
+  return n > 0.5 && (n -= 1), n < -0.5 && (n += 1), (o + Math.sign(n) * Math.min(Math.abs(n), e) + 1) % 1;
+}
+const Se = /* @__PURE__ */ new Map([
+  // arcane violet
+  [13148415, { hi: 16511231, light: 15126012, deep: 8672968, shade: 4072550 }],
+  // straw and bone (the hunters' arrows)
+  [15259808, { hi: 16776168, light: 16182468, deep: 11573858, shade: 5917232 }],
+  // dusk violet
+  [11563263, { hi: 16049919, light: 13938943, deep: 7356600, shade: 3152474 }],
+  // cold sky steel
+  [10479359, { hi: 16055551, light: 13694207, deep: 5937864, shade: 2375274 }],
+  // bright steel
+  [14737648, { hi: 16777215, light: 15921914, deep: 10132662, shade: 4868708 }],
+  // wind over grass
+  [11071680, { hi: 15794164, light: 13957856, deep: 6205576, shade: 2382406 }],
+  // holy gold
+  [16767370, { hi: 16776166, light: 16772280, deep: 13145662, shade: 6964260 }],
+  // judgement gold
+  [16769162, { hi: 16776162, light: 16773308, deep: 13672516, shade: 7359010 }],
+  // trap amber
+  [16760896, { hi: 16774352, light: 16769168, deep: 12614176, shade: 6961686 }],
+  // hunter's gold
+  [13676656, { hi: 16774876, light: 15521440, deep: 9334848, shade: 4864548 }],
+  // war-cry amber
+  [16757051, { hi: 16773324, light: 16766088, deep: 12611614, shade: 6829076 }],
+  // moonlit silver-blue
+  [10531071, { hi: 15922431, light: 13687039, deep: 6187720, shade: 2764394 }],
+  // blood
+  [16730682, { hi: 16769236, light: 16751238, deep: 11017762, shade: 5114902 }],
+  // pale violet steel
+  [14733567, { hi: 16512767, light: 15788287, deep: 10127048, shade: 4864622 }]
+]), ke = new Map([...Se].map(([o, t]) => [o, { ...t, base: o }]));
+function P(o) {
+  return ke.get(o) ?? Bt(o);
+}
+function Bt(o) {
+  let t = Dt.get(o);
+  if (t) return t;
+  const [e, n, s] = Yt(o), a = st(e, 0.72, 0.06), i = st(e, 0.14, 0.04);
+  return t = {
+    shade: z(a, Math.min(1, n * 0.85), Math.max(0.08, s * 0.38)),
+    deep: z(st(e, 0.72, 0.03), n, Math.max(0.14, s * 0.66)),
+    base: o,
+    light: z(i, n * 0.9, Math.min(0.9, s + (1 - s) * 0.45)),
+    hi: z(i, n * 0.5, Math.min(0.97, s + (1 - s) * 0.8))
+  }, Dt.set(o, t), t;
+}
+const Et = /* @__PURE__ */ new Map();
+function $(o) {
+  let t = Et.get(o);
+  if (t !== void 0) return t;
+  const [e, n, s] = Yt(o), a = s > 0.82 ? 0.82 + (s - 0.82) * 0.55 : s;
+  return t = z(s > 0.82 ? st(e, 0.12, 0.05) : e, n * (s > 0.82 ? 0.55 : 0.74), a * 0.97), Et.set(o, t), t;
+}
+let Q = null;
+const rt = (o, t) => o + 32768 << 16 | t + 32768 & 65535;
+function ht() {
+  return Q;
+}
+const It = [1, 0, -1, 0, 0, 1, 0, -1];
+function Xt() {
+  Q = /* @__PURE__ */ new Map();
+}
+function Nt(o, t) {
+  const e = Q;
+  if (Q = null, !e) return;
+  const n = /* @__PURE__ */ new Set();
+  for (const a of e.keys()) {
+    const i = (a >>> 16) - 32768, r = (a & 65535) - 32768;
+    for (let h = 0; h < 8; h += 2) {
+      const c = rt(i + It[h], r + It[h + 1]);
+      e.has(c) || n.add(c);
+    }
+  }
+  const s = $(t);
+  it(o, new Map([...n].map((a) => [a, s]))), it(o, e);
+}
+function it(o, t) {
+  if (T !== null && o === T) {
+    if (_) for (const [e, n] of t) _.stage((e >>> 16) - 32768, (e & 65535) - 32768, 1, n);
+    else for (const [e, n] of t) I.set(e, n);
+    return;
+  }
+  Gt(o, t);
+}
+let I = null, _ = null, T = null;
+const Ut = [];
+function ve(o) {
+  Ut.push({ batch: I, direct: _, g: T }), o instanceof J ? (I = null, _ = o) : (I = /* @__PURE__ */ new Map(), _ = null), T = o;
+}
+function De() {
+  mt();
+  const o = Ut.pop();
+  I = o?.batch ?? null, _ = o?.direct ?? null, T = o?.g ?? null;
+}
+function ct(o) {
+  return T === null || o !== T ? null : _ ?? I;
+}
+function gt(o, t, e, n, s) {
+  if (o instanceof J) {
+    o.stage(t, e, n, s);
+    return;
+  }
+  for (let a = 0; a < n; a++) o.set(rt(t + a, e), s);
+}
+function mt() {
+  if (_) {
+    _.commit();
+    return;
+  }
+  if (!I || !T || I.size === 0) return;
+  const o = I;
+  I = /* @__PURE__ */ new Map(), Gt(T, o);
+}
+function Gt(o, t) {
+  if (o instanceof J) {
+    for (const [r, h] of t) o.stage((r >>> 16) - 32768, (r & 65535) - 32768, 1, h);
+    o.commit();
+    return;
+  }
+  const e = [...t.keys()].sort((r, h) => (r & 65535) - (h & 65535) || (r >>> 16) - (h >>> 16));
+  let n = 0, s = 0, a = 0, i = -1;
+  for (const r of e) {
+    const h = (r >>> 16) - 32768, c = (r & 65535) - 32768, l = t.get(r);
+    if (a > 0 && c === s && h === n + a && l === i) {
+      a++;
+      continue;
+    }
+    a > 0 && o.fillStyle(i, 1).fillRect(n, s, a, 1), n = h, s = c, a = 1, i = l;
+  }
+  a > 0 && o.fillStyle(i, 1).fillRect(n, s, a, 1);
+}
+function Kt(o, t) {
+  return rt(o, t);
+}
+function jt(o, t, e) {
+  Q?.set(rt(o, t), e);
+}
+const Ee = [0, 8, 2, 10, 12, 4, 14, 6, 3, 11, 1, 9, 15, 7, 13, 5];
+let at = 1;
+function Ie(o) {
+  at = o;
+}
+function zt() {
+  return at;
+}
+function C(o, t) {
+  if (at >= 1) return !1;
+  const e = (Math.round(o) & 3) >>> 0, n = (Math.round(t) & 3) >>> 0;
+  return Ee[n * 4 + e] / 16 >= at;
+}
+const Dn = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  batchFor: ct,
+  beginBatch: ve,
+  beginOutline: Xt,
+  capturing: ht,
+  currentCoverage: zt,
+  derivedRamp: Bt,
+  dithered: C,
+  endBatch: De,
+  endOutline: Nt,
+  fillRuns: it,
+  flushBatch: mt,
+  grade: $,
+  pixelKey: Kt,
+  ramp: P,
+  record: jt,
+  setCoverage: Ie,
+  stageRun: gt
+}, Symbol.toStringTag, { value: "Module" })), qt = 16774358, v = (o) => Math.round(o);
+function E(o, t, e, n, s = 1) {
+  const a = v(t), i = v(e);
+  if (C(a, i)) return;
+  const r = $(n);
+  if (ht()) {
+    for (let c = 0; c < s; c++) for (let l = 0; l < s; l++) jt(a + l, i + c, r);
+    return;
+  }
+  const h = ct(o);
+  if (h) {
+    for (let c = 0; c < s; c++) gt(h, a, i + c, s, r);
+    return;
+  }
+  o.fillStyle(r, 1).fillRect(a, i, s, s);
+}
+class Vt {
+  at = /* @__PURE__ */ new Map();
+  set(t, e, n) {
+    this.at.set(Kt(v(t), v(e)), n);
+  }
+  lay(t) {
+    if (ht()) {
+      for (const [s, a] of this.at) E(t, (s >>> 16) - 32768, (s & 65535) - 32768, a);
+      return;
+    }
+    const e = ct(t);
+    if (e instanceof J) {
+      for (const [s, a] of this.at) {
+        const i = (s >>> 16) - 32768, r = (s & 65535) - 32768;
+        C(i, r) || e.stage(i, r, 1, $(a));
+      }
+      return;
+    }
+    const n = /* @__PURE__ */ new Map();
+    for (const [s, a] of this.at) C((s >>> 16) - 32768, (s & 65535) - 32768) || n.set(s, $(a));
+    it(t, n);
+  }
+}
+function O(o, t, e, n, s) {
+  const a = v(t), i = v(n);
+  if (!(i <= 0)) {
+    if (!ht() && !C(a, e) && !C(a + 1, e) && !C(a + 2, e + 1) && !C(a + 3, e + 1)) {
+      const r = ct(o);
+      if (r) {
+        gt(r, a, v(e), i, $(s));
+        return;
+      }
+      o.fillStyle($(s), 1).fillRect(a, v(e), i, 1);
+      return;
+    }
+    for (let r = 0; r < i; r++) E(o, a + r, e, s);
+  }
+}
+function Le(o, t, e) {
+  Xt();
+  try {
+    e();
+  } finally {
+    Nt(o, t);
+  }
+}
+function Z(o, t, e, n, s = 2) {
+  const a = Math.hypot(e.x - t.x, e.y - t.y), i = Math.max(1, Math.ceil(a)), r = a ? -(e.y - t.y) / a : 0, h = a ? (e.x - t.x) / a : 1, c = P(n), l = Math.max(1, Math.round(s));
+  for (let d = 0; d <= i; d++) {
+    const u = i >= 10 && (d <= 1 || d >= i - 1), f = i >= 16 && Math.abs(d - Math.round(i / 3)) <= 1, M = t.x + (e.x - t.x) * d / i, p = t.y + (e.y - t.y) * d / i;
+    for (let g = 0; g < l; g++) {
+      const b = g - (l - 1) / 2, w = l >= 2 ? g === 0 ? c.light : g === l - 1 ? c.deep : n : n;
+      E(o, M + r * b, p + h * b, u ? c.deep : f && g === 0 ? c.hi : w);
+    }
+  }
+}
+function Re(o, t, e, n = 0, s = 0) {
+  const a = P(e), i = Math.max(32, Math.ceil(t * 5)), r = new Vt();
+  for (let h = 0; h < i; h++) {
+    const c = ((h * 64 / i + n) % 16 + 16) % 16;
+    if (c < 3) continue;
+    const l = h * Math.PI * 2 / i, d = Math.sin(l), u = c < 4 ? a.hi : d > 0.35 ? a.light : d < -0.35 ? a.deep : e, f = Math.cos(l) * t, M = s + d * t * 0.5;
+    r.set(f, M, u), d > 0.5 && r.set(f, M + 1, a.deep);
+  }
+  r.lay(o);
+}
+function Pe(o, t, e, n, s) {
+  const a = P(s);
+  for (let i = -n; i <= n; i++) {
+    const r = Math.max(1, v(n - Math.abs(i))), h = v(t - r / 2);
+    if (i > n * 0.45) {
+      O(o, h, e + i, r, a.deep);
+      continue;
+    }
+    const c = Math.floor(r / 2);
+    n < 3 || c < 1 ? O(o, h, e + i, r, s) : (O(o, h, e + i, c, a.light), O(o, h + c, e + i, r - c, s));
+  }
+  n >= 5 && E(o, t - 1, e - n + 2, a.hi);
+}
+function _e(o, t, e, n, s = !1) {
+  for (let a = 0; a < 12; a++) {
+    const i = a * Math.PI / 6 + (s ? t * 1.8 : 0), r = e * (s ? 1 - t : t);
+    E(o, Math.cos(i) * r, -8 + Math.sin(i) * r * 0.6 - (s ? 0 : Math.sin(t * Math.PI) * 8), a % 3 ? n : qt, a % 3 ? 1 : 2);
+  }
+}
+function Qt(o, t, e, n, s, a = !1) {
+  const i = Math.max(1, Math.round(a ? n * 0.5 : n)), r = P(s);
+  for (let h = -i; h <= i; h++) {
+    const c = v(n * Math.sqrt(Math.max(0, 1 - (h / i) ** 2)));
+    if (c <= 0) continue;
+    const l = (h + i) / (2 * i || 1);
+    O(o, t - c, e + h, c * 2, l > 0.7 && n >= 3 ? r.deep : s), n >= 3 && l < 0.35 && c >= 2 && O(o, t - c + 1, e + h, v(c * 0.6), r.light);
+  }
+  n >= 4 && E(o, t - n * 0.4, e - i * 0.55, r.hi);
+}
+function Zt(o, t, e, n, s, a = t + 8) {
+  const i = s / 1e3, r = t + n * i + 260 * i * i;
+  return r > a && n * i + 260 * i * i > 0 ? null : { x: o + e * i, y: r };
+}
+function Te(o, t, e, n, s) {
+  Z(o, { x: t - n, y: e - n }, { x: t + n, y: e + n }, s), Z(o, { x: t - n, y: e + n }, { x: t + n, y: e - n }, s);
+}
+function He(o, t, e, n, s, a) {
+  const i = { x: t.x + (e.x - t.x) * n, y: t.y + (e.y - t.y) * n };
+  Z(o, i, e, s, 4), Z(o, i, e, a, 2);
+}
+function Ce(o, t, e, n, s, a, i = 0, r = 0.7) {
+  if (n = Math.round(n), n < 2) return;
+  const h = P(s), c = Math.max(2, Math.round(n * 0.85)), l = r * zt();
+  mt();
+  const d = v(t);
+  for (let u = -c; u <= c; u++) {
+    const f = n * Math.sqrt(Math.max(0, 1 - (u / (c + 0.5)) ** 2));
+    let M = 0, p = 0, g = -1, b = 0;
+    const w = Math.ceil(f);
+    for (let x = -w; x <= w; x++) {
+      let y = -1, A = 0;
+      if (x < w) {
+        const S = f - Math.abs(x + 0.5), B = (x * 73856093 ^ u * 19349663 ^ i * 83492791) >>> 0;
+        S < 1 && B % 2 === 0 || (y = u < -c * 0.3 && x < f * 0.2 ? a : u > c * 0.4 ? h.deep : B % 9 === 0 ? h.light : s, A = S < 1 ? l * 0.6 : l);
+      }
+      if (y === g && A === b && y !== -1) {
+        p++;
+        continue;
+      }
+      g !== -1 && o.fillStyle($(g), b).fillRect(d + M, v(e + u), p, 1), M = x, p = 1, g = y, b = A;
+    }
+  }
+}
+function $e(o, t, e, n, s, a, i, r = !0, h = 1) {
+  const c = Math.max(2, Math.ceil(Math.abs(a - s) * n)), l = P(i);
+  h *= 2;
+  const d = new Vt();
+  for (let u = 0; u < h; u++) {
+    const f = n - u, M = u === 0 ? l.light : u === h - 1 ? l.deep : i;
+    for (let p = 0; p <= c; p++) {
+      const g = s + (a - s) * p / c, b = p >= c - 1 ? l.hi : h <= 2 && c >= 12 && p < c * 0.2 ? l.deep : M;
+      d.set(t + Math.cos(g) * f, e + Math.sin(g) * f * (r ? 0.5 : 1), b);
+    }
+  }
+  d.lay(o);
+}
+function Fe(o, t, e, n, s = 10, a = 13154458) {
+  for (let i = 0; i < 4; i++) {
+    const r = i * 1.7 + 0.3, h = Math.round(4 * (1 - n));
+    h >= 1 && Qt(o, t + Math.cos(r) * s * n, e - 2 + Math.sin(r) * s * 0.4 * n - n * 4, h, i % 2 ? a : 14734524);
+  }
+}
+function Oe(o, t, e, n, s, a, i) {
+  for (let r = 0; r < n; r++) {
+    const h = r / n * Math.PI * 2 + 0.3, c = s * (0.6 + r * 7 % 5 * 0.1), l = Zt(t, e, Math.cos(h) * c, -70 - r * 17 % 40, a, e + 6);
+    if (!l) continue;
+    const d = i[r % i.length], u = l.y + Math.sin(h) * c * 0.3 * a / 1e3;
+    r % 3 ? E(o, l.x, u, d) : (E(o, l.x, u, d, 2), E(o, l.x, u + 2, P(d).deep, 2), E(o, l.x, u, P(d).hi));
+  }
+}
+const En = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  WHITE: qt,
+  arc: $e,
+  blob: Qt,
+  dashStreak: He,
+  debris: Oe,
+  diamond: Pe,
+  dot: E,
+  drop: Zt,
+  dust: Fe,
+  hline: O,
+  outlined: Le,
+  puffBlob: Ce,
+  ring: Re,
+  shards: _e,
+  snap: v,
+  stroke: Z,
+  xMark: Te
+}, Symbol.toStringTag, { value: "Module" })), Lt = 1e3 / 12, We = 1400, Ye = 150, Be = 420, Xe = 16, ft = { budget: 500, body: 60, big: 160 };
+class In {
+  constructor(t, e) {
+    this.scene = t, this.track = e;
+  }
+  scene;
+  track;
+  clouds = [];
+  live = 0;
+  play(t, e, n) {
+    const s = Tt.getState(), a = s.reducedFx || s.batterySaver, i = Math.min(t.pixels.length, e ? a ? ft.big : Be : a ? ft.body : Ye), r = Math.min(i, Math.max(Xe, (a ? ft.budget : We) - this.live));
+    if (r <= 0) return;
+    const h = Math.max(1, Math.round(Math.abs(t.scaleY))), c = me(this.scene);
+    this.track(c);
+    const l = {
+      g: c,
+      x: Math.round(t.x),
+      y: Math.round(t.y),
+      born: n,
+      end: n,
+      size: h,
+      n: r,
+      frame: -1,
+      x0: new Float32Array(r),
+      y0: new Float32Array(r),
+      delay: new Float32Array(r),
+      life: new Float32Array(r),
+      vx: new Float32Array(r),
+      vy: new Float32Array(r),
+      phase: new Float32Array(r),
+      color: new Uint32Array(r)
+    };
+    let d = 0, u = -1 / 0, f = 1;
+    const M = t.pixels;
+    for (let y = 0; y < M.length; y++)
+      d = Math.min(d, M.dy[y]), u = Math.max(u, M.dy[y]), f = Math.max(f, Math.abs(M.dx[y] * t.scaleX));
+    const p = Math.max(1, u - d), g = e ? 520 : 260, b = e ? 900 : 620, w = r / M.length;
+    let x = 0;
+    for (let y = 0; y < M.length && x < r; y++) {
+      if (w < 1 && Math.random() > w && M.length - y > r - x) continue;
+      const A = M.dy[y], S = M.dx[y] * t.scaleX, B = A * Math.abs(t.scaleY), tt = (A - d) / p;
+      l.x0[x] = S, l.y0[x] = B, l.delay[x] = tt * g * 0.6 + Math.random() * g * 0.4, l.life[x] = b * (0.6 + Math.random() * 0.6), l.vx[x] = S / f * 5 + (Math.random() - 0.5) * 10, l.vy[x] = -(10 + Math.random() * 16) * (e ? 1.3 : 1), l.phase[x] = Math.random() * Math.PI * 2, l.color[x] = M.color[y], l.end = Math.max(l.end, n + l.delay[x] + l.life[x]), x++;
+    }
+    l.n = x, this.live += l.n, this.clouds.push(l), this.draw(l, n);
+  }
+  update(t) {
+    for (let e = this.clouds.length - 1; e >= 0; e--) {
+      const n = this.clouds[e];
+      if (!n.g.active || t >= n.end) {
+        n.g.active && n.g.destroy(), this.live -= n.n, this.clouds.splice(e, 1);
+        continue;
+      }
+      this.draw(n, t);
+    }
+  }
+  draw(t, e) {
+    const n = Math.floor((e - t.born) / Lt);
+    if (n === t.frame) return;
+    t.frame = n;
+    const s = n * Lt, a = t.g;
+    a.clear(), a.setPosition(t.x, t.y).setDepth(t.y + 2);
+    const i = t.size;
+    for (let r = 0; r < t.n; r++) {
+      const h = s - t.delay[r];
+      let c = t.x0[r], l = t.y0[r], d = t.color[r], u = 1;
+      if (h > 0) {
+        const f = h / t.life[r];
+        if (f >= 1) continue;
+        const M = h / 1e3;
+        c += t.vx[r] * M + Math.sin(t.phase[r] + M * 9) * f * 1.5, l += t.vy[r] * M - 22 * M * M;
+        const p = P(d);
+        d = f < 0.3 ? d : f < 0.6 ? p.light : p.hi, u = f < 0.55 ? 1 : f < 0.8 ? 0.66 : 0.33;
+      }
+      a.rect(Math.round(c), Math.round(l), i, i, d, u);
+    }
+    a.present();
+  }
+}
+class Jt {
+  constructor(t, e, n, s) {
+    this.dx = t, this.dy = e, this.color = n, this.length = s;
+  }
+  dx;
+  dy;
+  color;
+  length;
+  *[Symbol.iterator]() {
+    const t = { dx: 0, dy: 0, color: 0 };
+    for (let e = 0; e < this.length; e++)
+      t.dx = this.dx[e], t.dy = this.dy[e], t.color = this.color[e], yield t;
+  }
+}
+const ot = new Jt(new Float32Array(0), new Float32Array(0), new Uint32Array(0), 0), Ln = ot, Ne = 512 * 512, Ue = 256, Ge = 3e5, H = /* @__PURE__ */ new Map();
+let ut = 0;
+function Ke(o, t) {
+  for (H.set(o, t), ut += t.length; H.size > Ue || ut > Ge; ) {
+    const e = H.keys().next();
+    if (e.done) break;
+    ut -= H.get(e.value).length, H.delete(e.value);
+  }
+}
+function Rn(o, t, e) {
+  const n = `${o.textureKey}|${o.frameName}|${t}`;
+  if (!e) {
+    const y = H.get(n);
+    if (y)
+      return H.delete(n), H.set(n, y), y;
+  }
+  const s = o.texture, a = s.source.resource;
+  if (!(a instanceof HTMLCanvasElement)) return ot;
+  const i = s.frame, r = Math.round(i.width), h = Math.round(i.height);
+  if (r <= 0 || h <= 0 || r * h > Ne) return ot;
+  let c;
+  try {
+    c = a.getContext("2d").getImageData(Math.round(i.x), Math.round(i.y), r, h).data;
+  } catch {
+    return ot;
+  }
+  const l = Math.max(1, Math.round(t)), d = Math.floor(r / l), u = Math.floor(h / l), f = Math.floor(l / 2);
+  let M = 0;
+  for (let y = 0; y < u; y++) for (let A = 0; A < d; A++) c[((y * l + f) * r + A * l + f) * 4 + 3] >= 128 && M++;
+  const p = new Float32Array(M), g = new Float32Array(M), b = new Uint32Array(M);
+  let w = 0;
+  for (let y = 0; y < u; y++)
+    for (let A = 0; A < d; A++) {
+      const S = ((y * l + f) * r + A * l + f) * 4;
+      c[S + 3] < 128 || (p[w] = A - d / 2, g[w] = y - u, b[w] = c[S] << 16 | c[S + 1] << 8 | c[S + 2], w++);
+    }
+  const x = new Jt(p, g, b, M);
+  return e || Ke(n, x), x;
+}
+const te = 16773320, D = [], ee = 48;
+function Pn(o, t, e, n, s = te, a = performance.now()) {
+  D.length >= ee && D.shift(), D.push({ x: o, y: t, r: e, born: a, until: a + n, fades: !0, color: s });
+}
+const je = 2e4;
+function _n(o, t, e = te, n = performance.now()) {
+  const s = o(), a = { x: s.x, y: s.y, r: t, born: n, until: n + je, follow: o, fades: !1, color: e };
+  return D.length >= ee && D.shift(), D.push(a), { end: () => a.until = 0 };
+}
+const ze = [];
+function qe(o) {
+  for (let e = D.length - 1; e >= 0; e--) D[e].until <= o && D.splice(e, 1);
+  const t = Tt.getState();
+  if (t.combatLights === !1 || t.batterySaver) return ze;
+  for (const e of D) {
+    if (!e.follow) continue;
+    let n;
+    try {
+      n = e.follow();
+    } catch {
+      e.until = 0, e.follow = void 0;
+      continue;
+    }
+    e.x = n.x, e.y = n.y;
+  }
+  return D;
+}
+function Ve(o, t) {
+  if (!o.fades) return o.r;
+  const e = Math.min(1, (t - o.born) / Math.max(1, o.until - o.born));
+  return o.r * Math.sqrt(1 - e);
+}
+function Tn() {
+  D.length = 0;
+}
+const Qe = 66, Ze = 33, N = 8, Je = (o) => Math.min(1, Math.pow(Math.max(0, 1 - o * o), 1.5) * 1.15), tn = (o) => Math.pow(Math.max(0, 1 - o), 2), en = 4, nn = 3, sn = 0.3, Mt = 0.85, Rt = 16761466, on = [0, 8, 2, 10, 12, 4, 14, 6, 3, 11, 1, 9, 15, 7, 13, 5].map((o) => (o + 0.5) / 16), ne = (o) => o <= 24 ? Math.max(2, Math.round(o / 2) * 2) : Math.round(o / 8) * 8, an = [...new Set(Array.from({ length: 160 }, (o, t) => ne(t + 1)))], rn = 33, Pt = /* @__PURE__ */ new Map();
+let _t = !1;
+function hn() {
+  if (_t) return;
+  _t = !0;
+  const o = an.flatMap((e) => [["hole", e], ["wash", e]]), t = () => {
+    const e = o.shift();
+    e && (q(e[0], e[1]), setTimeout(t, 0));
+  };
+  setTimeout(t, 0);
+}
+function q(o, t) {
+  const e = `${o}${t}`, n = Pt.get(e);
+  if (n) return n;
+  const s = t * 2, a = Math.max(2, Math.round(t * 2 * Mt)), i = o === "hole" ? en : nn, r = o === "hole" ? Je : tn, h = document.createElement("canvas");
+  h.width = s, h.height = a;
+  const c = h.getContext("2d");
+  if (!c) return W.EMPTY;
+  const l = c.createImageData(s, a);
+  for (let u = 0; u < a; u++)
+    for (let f = 0; f < s; f++) {
+      const M = Math.hypot((f + 0.5 - s / 2) / t, (u + 0.5 - a / 2) / (t * Mt));
+      if (M >= 1) continue;
+      const p = Math.min(i, Math.floor(r(M) * i + on[u % 4 * 4 + f % 4])) / i, g = (u * s + f) * 4;
+      l.data[g] = l.data[g + 1] = l.data[g + 2] = 255, l.data[g + 3] = Math.round(p * 255);
+    }
+  c.putImageData(l, 0, 0);
+  const d = W.from(h);
+  return d.source.scaleMode = "nearest", Pt.set(e, d), d;
+}
+class Hn {
+  constructor(t, e, n) {
+    this.stage = t, this.color = e, this.alpha = n, this.sheet = new K({ texture: W.WHITE }), this.scratch.addChild(this.sheet, this.holes, this.washes), this.carried = this.light(16773340), this.rt = wt.create({ width: 1, height: 1 }), this.view = new K({ texture: this.rt }), this.layer.addChild(this.view), t.screen.addChild(this.layer), t.cameras.main.follow(this.layer), this.unsubscribeResize = t.onResize(() => this.dirty = !0), hn();
+  }
+  stage;
+  color;
+  alpha;
+  scratch = new et();
+  sheet;
+  /** Every hole is erased before any colour is laid, or a later hole would wipe an earlier light's colour away. */
+  holes = new et();
+  washes = new et();
+  lamps = [];
+  /** The transient lights (`lights.ts`), reused frame to frame. */
+  flashes = [];
+  rt;
+  /**
+   * On the screen layer, laid over the world with its exact transform by the camera (`Camera.follow`), shake included:
+   * the night is drawn in world pixels round the unshaken camera and only this layer moves with a shake, so a shaking
+   * screen does not redraw the night every frame.
+   */
+  layer = new et();
+  view;
+  /** The light the player carries: the only one that follows them, and the last one they lose. */
+  carried;
+  unsubscribeResize;
+  /** Lamps that flicker: while one does (or the player carries a light) every frame differs. */
+  flickering = 0;
+  /** Something other than the camera changed what the night looks like (a lamp added, dimmed, the window resized). */
+  dirty = !0;
+  /** What the last drawn frame was drawn from: the texture, the camera's texel and the shade. */
+  drawn = "";
+  /** The carried light's place at the last redraw (it follows the body). */
+  carriedAt = "";
+  /** When the sheet was last redrawn. */
+  drawnAt = -1 / 0;
+  /** The world pixel the night's top-left texel stands on. */
+  ox = 0;
+  oy = 0;
+  /** The night texture's size in world pixels, and the zoom it was made for. */
+  rtKey = "";
+  /** The lamps' colour turned down (`setLampsDimmed`). */
+  dimLamps = !1;
+  /** A phone redraws the night at most `PHONE_MS` apart, whatever moves (`isTouchUi`). */
+  phone = le();
+  /** A hole and its colour, added to the night's layers. */
+  light(t) {
+    const e = new K({ texture: q("hole", 8) });
+    e.blendMode = "erase", this.holes.addChild(e);
+    const n = new K({ texture: q("wash", 8) });
+    return n.tint = t, this.washes.addChild(n), { hole: e, wash: n };
+  }
+  /** A lamp fixed in the world: a torch on a wall, the seep in its chamber, a crystal in a seam, in its own colour. */
+  addLamp(t, e, n, s = 0, a = Rt) {
+    this.lamps.push({ sprites: this.light(a), x: t, y: e, r: n, flicker: s }), s && this.flickering++, this.dirty = !0;
+  }
+  /**
+   * Changes how dark and what colour the sheet is (the outdoor night, `NightShade`, deepens and lifts with the
+   * world clock). A sheet with no alpha left is neither drawn nor redrawn, so a map at noon pays nothing for its night.
+   */
+  setShade(t, e) {
+    this.color = t, this.alpha = e, this.layer.visible = e > 4e-3;
+  }
+  /**
+   * Dimmed lamps lay only `LAMP_DIM` of their colour on the dark (a "fewer ambient lights" setting). The holes they
+   * cut stay as wide, so a dark place is still seen by them.
+   */
+  setLampsDimmed(t) {
+    t !== this.dimLamps && (this.dimLamps = t, this.dirty = !0);
+  }
+  /**
+   * The night's own texture, one texel a world pixel and `MARGIN` to spare on each side (a shake, or a camera that
+   * moved while a phone waits for its next redraw, never shows its edge), remade when the window or the zoom changes:
+   * at zoom 2 or 3 it is a quarter or a ninth of the screen's pixels. True when it was remade.
+   */
+  fit(t, e, n) {
+    const s = Math.ceil(t / n) + N * 2, a = Math.ceil(e / n) + N * 2, i = `${s},${a},${n}`;
+    return i === this.rtKey ? !1 : (this.rtKey = i, this.rt.destroy(!0), this.rt = wt.create({ width: s, height: a }), this.rt.source.scaleMode = "nearest", this.view.texture = this.rt, !0);
+  }
+  /** Redraws the night with this frame's holes in it, when anything in it changed. `px`/`py` is where the player stands. */
+  update(t, e, n, s) {
+    if (!this.layer.visible) return;
+    const a = this.stage.cameras.main, i = a.zoom || 1, r = this.fit(this.stage.width, this.stage.height, i), h = Math.floor(a.scrollX) - N, c = Math.floor(a.scrollY) - N, l = `${h},${c},${this.rtKey},${this.color},${this.alpha}`, d = qe(t), u = s > 0 ? `${Math.round(e)},${Math.round(n)},${Math.round(s)}` : "", f = t - this.drawnAt;
+    if (!(this.dirty || l !== this.drawn || u !== this.carriedAt || d.length > 0 && f >= rn || (s > 0 || this.flickering > 0) && f >= Qe)) return;
+    const p = Math.abs(h - this.ox) >= N - 1 || Math.abs(c - this.oy) >= N - 1;
+    if (this.phone && f < Ze && !r && !p) return;
+    this.dirty = !1, this.drawn = l, this.carriedAt = u, this.drawnAt = t, this.ox = h, this.oy = c, this.view.position.set(h, c), this.sheet.width = this.rt.width, this.sheet.height = this.rt.height, this.sheet.position.set(0, 0), this.sheet.tint = this.color, this.sheet.alpha = this.alpha;
+    const g = sn * Math.min(1, this.alpha * 1.4);
+    s <= 0 ? this.hide(this.carried) : this.place(this.carried, e, n - 6, s * (1 + Math.sin(t / 260) * 0.03 + Math.sin(t / 90) * 0.015), g * 0.5);
+    const b = this.dimLamps ? g * cn : g;
+    for (const w of this.lamps) {
+      const x = w.flicker ? 1 + Math.sin(t / 190 + w.flicker) * 0.05 + Math.sin(t / 71 + w.flicker) * 0.03 : 1;
+      this.place(w.sprites, w.x, w.y, w.r * x, b * (w.flicker ? 0.9 + (x - 1) * 2 : 1));
+    }
+    for (; this.flashes.length < d.length; ) this.flashes.push(this.light(Rt));
+    for (let w = 0; w < this.flashes.length; w++) {
+      const x = d[w], y = this.flashes[w];
+      if (!x) {
+        this.hide(y);
+        continue;
+      }
+      y.wash.tint = x.color, this.place(y, x.x, x.y, Ve(x, t), Math.min(0.6, g * 1.6));
+    }
+    this.stage.app.renderer.render({ container: this.scratch, target: this.rt, clear: !0 });
+  }
+  hide(t) {
+    t.hole.visible = !1, t.wash.visible = !1;
+  }
+  /** Lays light `l` at world (wx, wy), `r` px across its radius, in the night's world-pixel grid. */
+  place(t, e, n, s, a) {
+    const i = ne(s), r = Math.round(e) - this.ox, h = Math.round(n) - this.oy;
+    if (s < 1 || r < -i || h < -i || r > this.rt.width + i || h > this.rt.height + i) {
+      this.hide(t);
+      return;
+    }
+    t.hole.texture = q("hole", i), t.wash.texture = q("wash", i);
+    for (const c of [t.hole, t.wash])
+      c.visible = !0, c.position.set(r - i, h - Math.round(i * Mt));
+    t.wash.alpha = a, t.wash.visible = a > 0.01;
+  }
+  destroy() {
+    this.unsubscribeResize(), this.stage.cameras.main.unfollow(this.layer), this.layer.destroy({ children: !0 }), this.rt.destroy(!0), this.scratch.destroy({ children: !0, context: !0 });
+  }
+}
+const cn = 0.35, Cn = ce * 5;
+export {
+  Cn as CARRIED_LIGHT,
+  bt as CLEAR,
+  Hn as Darkness,
+  In as Evaporation,
+  cn as LAMP_DIM,
+  xn as MATERIALS,
+  Ln as NO_PIXELS,
+  Ft as PALETTE,
+  Jt as PackedPixels,
+  G as PixelGrid,
+  J as PixelLayer,
+  gn as PixelWindow,
+  Rt as WARM_LIGHT,
+  me as addPixelLayer,
+  bn as art,
+  _n as carriedLight,
+  R as channels,
+  Tn as clearLights,
+  Pn as flashLight,
+  Sn as groundShadow,
+  nt as hash2,
+  m as hex,
+  pt as hueShade,
+  An as litOutline,
+  qe as liveLights,
+  mn as makeSheet,
+  we as mix,
+  Mn as mulberry32,
+  Wt as outlineOf,
+  En as pixelPaint,
+  Dn as pixelTone,
+  ye as ramp,
+  yn as rampTones,
+  L as rgba,
+  vn as selectiveOutline,
+  $t as shade,
+  kn as shadeBox,
+  Rn as spritePixels,
+  dn as toCss,
+  wn as upscale,
+  pn as valueNoise,
+  un as withAlpha
+};
+//# sourceMappingURL=pixel.js.map