1681-engine 0.0.0-stage → 0.5.8

package/dist/pixel/pixel.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"pixel.js","sources":["../../src/pixel/pixel.ts"],"sourcesContent":["/*\n * Minimal pixel-art canvas. All game art is painted procedurally with these primitives\n * (no external/copyrighted assets). Colors are packed little-endian RGBA (ImageData layout).\n */\n\nexport type Color = number;\n\nexport const CLEAR: Color = 0;\n\nexport function rgba(r: number, g: number, b: number, a = 255): Color {\n  const R = Math.max(0, Math.min(255, Math.round(r)));\n  const G = Math.max(0, Math.min(255, Math.round(g)));\n  const B = Math.max(0, Math.min(255, Math.round(b)));\n  const A = Math.max(0, Math.min(255, Math.round(a)));\n  return ((A << 24) | (B << 16) | (G << 8) | R) >>> 0;\n}\n\nexport function hex(s: string): Color {\n  let h = s.startsWith('#') ? s.slice(1) : s;\n  if (h.length === 3) h = [...h].map((c) => c + c).join('');\n  const r = parseInt(h.slice(0, 2), 16);\n  const g = parseInt(h.slice(2, 4), 16);\n  const b = parseInt(h.slice(4, 6), 16);\n  const a = h.length >= 8 ? parseInt(h.slice(6, 8), 16) : 255;\n  return rgba(r, g, b, a);\n}\n\nexport function channels(c: Color): [number, number, number, number] {\n  return [c & 255, (c >>> 8) & 255, (c >>> 16) & 255, (c >>> 24) & 255];\n}\n\n/** f < 1 darkens, f > 1 lightens toward white. */\nexport function shade(c: Color, f: number): Color {\n  const [r, g, b, a] = channels(c);\n  if (f >= 1) {\n    const t = Math.min(1, f - 1);\n    return rgba(r + (255 - r) * t, g + (255 - g) * t, b + (255 - b) * t, a);\n  }\n  return rgba(r * f, g * f, b * f, a);\n}\n\nexport function mix(c1: Color, c2: Color, t: number): Color {\n  const a = channels(c1);\n  const b = channels(c2);\n  return rgba(a[0] + (b[0] - a[0]) * t, a[1] + (b[1] - a[1]) * t, a[2] + (b[2] - a[2]) * t, a[3] + (b[3] - a[3]) * t);\n}\n\nexport function withAlpha(c: Color, alpha: number): Color {\n  const [r, g, b] = channels(c);\n  return rgba(r, g, b, alpha);\n}\n\nexport function toCss(c: Color): string {\n  const [r, g, b, a] = channels(c);\n  return `rgba(${r},${g},${b},${(a / 255).toFixed(3)})`;\n}\n\nexport function hash2(x: number, y: number, seed = 0): number {\n  let h = (x * 374761393 + y * 668265263 + seed * 2147483647) | 0;\n  h = Math.imul(h ^ (h >>> 13), 1274126177);\n  return ((h ^ (h >>> 16)) >>> 0) / 4294967296;\n}\n\nexport function mulberry32(seed: number): () => number {\n  let a = seed >>> 0;\n  return () => {\n    a = (a + 0x6d2b79f5) >>> 0;\n    let t = a;\n    t = Math.imul(t ^ (t >>> 15), t | 1);\n    t ^= t + Math.imul(t ^ (t >>> 7), t | 61);\n    return ((t ^ (t >>> 14)) >>> 0) / 4294967296;\n  };\n}\n\nexport function valueNoise(x: number, y: number, scale: number, seed: number): number {\n  const fx = x / scale;\n  const fy = y / scale;\n  const x0 = Math.floor(fx);\n  const y0 = Math.floor(fy);\n  const tx = fx - x0;\n  const ty = fy - y0;\n  const sx = tx * tx * (3 - 2 * tx);\n  const sy = ty * ty * (3 - 2 * ty);\n  const a = hash2(x0, y0, seed);\n  const b = hash2(x0 + 1, y0, seed);\n  const c = hash2(x0, y0 + 1, seed);\n  const d = hash2(x0 + 1, y0 + 1, seed);\n  return a + (b - a) * sx + (c - a) * sy + (a - b - c + d) * sx * sy;\n}\n\n\n\n\nexport class PixelGrid {\n  readonly data: Uint32Array;\n\n  constructor(\n    readonly w: number,\n    readonly h: number,\n  ) {\n    this.data = new Uint32Array(w * h);\n  }\n\n  inBounds(x: number, y: number): boolean {\n    return x >= 0 && y >= 0 && x < this.w && y < this.h;\n  }\n\n  px(x: number, y: number, c: Color): void {\n    x = Math.floor(x);\n    y = Math.floor(y);\n    if (x >= 0 && y >= 0 && x < this.w && y < this.h) this.data[y * this.w + x] = c;\n  }\n\n  get(x: number, y: number): Color {\n    if (x < 0 || y < 0 || x >= this.w || y >= this.h) return CLEAR;\n    return this.data[y * this.w + x] ?? CLEAR;\n  }\n\n  alphaAt(x: number, y: number): number {\n    return this.get(x, y) >>> 24;\n  }\n\n  rect(x: number, y: number, w: number, h: number, c: Color): void {\n    for (let yy = Math.floor(y); yy < y + h; yy++) for (let xx = Math.floor(x); xx < x + w; xx++) this.px(xx, yy, c);\n  }\n\n  hline(x0: number, x1: number, y: number, c: Color): void {\n    for (let x = Math.min(x0, x1); x <= Math.max(x0, x1); x++) this.px(x, y, c);\n  }\n\n  vline(x: number, y0: number, y1: number, c: Color): void {\n    for (let y = Math.min(y0, y1); y <= Math.max(y0, y1); y++) this.px(x, y, c);\n  }\n\n  /** Filled ellipse; a pixel is inside when its center lies inside the ellipse. */\n  ellipse(cx: number, cy: number, rx: number, ry: number, c: Color): void {\n    if (rx <= 0 || ry <= 0) return;\n    for (let y = Math.floor(cy - ry); y <= Math.ceil(cy + ry); y++)\n      for (let x = Math.floor(cx - rx); x <= Math.ceil(cx + rx); x++) {\n        const dx = (x + 0.5 - cx) / rx;\n        const dy = (y + 0.5 - cy) / ry;\n        if (dx * dx + dy * dy <= 1) this.px(x, y, c);\n      }\n  }\n\n  circle(cx: number, cy: number, r: number, c: Color): void {\n    this.ellipse(cx, cy, r, r, c);\n  }\n\n  ring(cx: number, cy: number, r: number, thickness: number, c: Color): void {\n    for (let y = Math.floor(cy - r - 1); y <= Math.ceil(cy + r + 1); y++)\n      for (let x = Math.floor(cx - r - 1); x <= Math.ceil(cx + r + 1); x++) {\n        const d = Math.hypot(x + 0.5 - cx, y + 0.5 - cy);\n        if (d <= r && d >= r - thickness) this.px(x, y, c);\n      }\n  }\n\n  line(x0: number, y0: number, x1: number, y1: number, c: Color, thickness = 1): void {\n    x0 = Math.round(x0);\n    y0 = Math.round(y0);\n    x1 = Math.round(x1);\n    y1 = Math.round(y1);\n    const dx = Math.abs(x1 - x0);\n    const dy = -Math.abs(y1 - y0);\n    const sx = x0 < x1 ? 1 : -1;\n    const sy = y0 < y1 ? 1 : -1;\n    let err = dx + dy;\n    for (;;) {\n      if (thickness <= 1) this.px(x0, y0, c);\n      else this.rect(x0 - Math.floor((thickness - 1) / 2), y0 - Math.floor((thickness - 1) / 2), thickness, thickness, c);\n      if (x0 === x1 && y0 === y1) break;\n      const e2 = 2 * err;\n      if (e2 >= dy) {\n        err += dy;\n        x0 += sx;\n      }\n      if (e2 <= dx) {\n        err += dx;\n        y0 += sy;\n      }\n    }\n  }\n\n  /** Filled polygon (even-odd scanline on pixel centers). */\n  poly(points: [number, number][], c: Color): void {\n    if (points.length < 3) return;\n    const minY = Math.floor(Math.min(...points.map((p) => p[1])));\n    const maxY = Math.ceil(Math.max(...points.map((p) => p[1])));\n    for (let y = minY; y <= maxY; y++) {\n      const sy = y + 0.5;\n      const xs: number[] = [];\n      for (let i = 0; i < points.length; i++) {\n        const a = points[i]!;\n        const b = points[(i + 1) % points.length]!;\n        if ((a[1] <= sy && b[1] > sy) || (b[1] <= sy && a[1] > sy)) {\n          xs.push(a[0] + ((sy - a[1]) / (b[1] - a[1])) * (b[0] - a[0]));\n        }\n      }\n      xs.sort((p, q) => p - q);\n      for (let i = 0; i + 1 < xs.length; i += 2) {\n        for (let x = Math.ceil(xs[i]! - 0.5); x <= Math.floor(xs[i + 1]! - 0.5); x++) this.px(x, y, c);\n      }\n    }\n  }\n\n  /**\n   * Adds `width` pixels of outline around all opaque pixels, one ring at a time — the same result as calling it\n   * `width` times, but each ring only visits the neighbours of the ring before it instead of the whole grid again.\n   * (A pixel next to ring `k` is always filled by ring `k+1`, so nothing further back can still be waiting.)\n   */\n  outline(c: Color, diagonal = false, width = 1): void {\n    const w = this.w;\n    const h = this.h;\n    const solid = new Uint8Array(this.data.length);\n    let x0 = w, y0 = h, x1 = -1, y1 = -1;\n    for (let y = 0; y < h; y++)\n      for (let x = 0; x < w; x++) {\n        const i = y * w + x;\n        if ((this.data[i]! >>> 24) === 0) continue;\n        solid[i] = 1;\n        if (x < x0) x0 = x;\n        if (x > x1) x1 = x;\n        if (y < y0) y0 = y;\n        y1 = y;\n      }\n    if (x1 < 0) return;\n    const has = (x: number, y: number, i: number) => x >= 0 && y >= 0 && x < w && y < h && solid[i] === 1;\n    // The first ring is one sweep of the box the body actually fills, so its interior never reaches a frontier list.\n    let frontier: number[] = [];\n    for (let y = Math.max(0, y0 - 1); y <= Math.min(h - 1, y1 + 1); y++)\n      for (let x = Math.max(0, x0 - 1); x <= Math.min(w - 1, x1 + 1); x++) {\n        const i = y * w + x;\n        if (solid[i]) continue;\n        let hit = has(x - 1, y, i - 1) || has(x + 1, y, i + 1) || has(x, y - 1, i - w) || has(x, y + 1, i + w);\n        if (!hit && diagonal)\n          hit = has(x - 1, y - 1, i - w - 1) || has(x + 1, y - 1, i - w + 1) || has(x - 1, y + 1, i + w - 1) || has(x + 1, y + 1, i + w + 1);\n        if (hit) {\n          this.data[i] = c;\n          frontier.push(i);\n        }\n      }\n    for (const i of frontier) solid[i] = 1;\n    // Later rings only visit the neighbours of the ring before them.\n    for (let step = 1; step < width && frontier.length; step++) {\n      const next: number[] = [];\n      for (const i of frontier) {\n        const x = i % w;\n        const y = (i / w) | 0;\n        const grow = (nx: number, ny: number, k: number) => {\n          if (nx < 0 || ny < 0 || nx >= w || ny >= h || solid[k]) return;\n          solid[k] = 1;\n          this.data[k] = c;\n          next.push(k);\n        };\n        grow(x - 1, y, i - 1);\n        grow(x + 1, y, i + 1);\n        grow(x, y - 1, i - w);\n        grow(x, y + 1, i + w);\n        if (diagonal) {\n          grow(x - 1, y - 1, i - w - 1);\n          grow(x + 1, y - 1, i - w + 1);\n          grow(x - 1, y + 1, i + w - 1);\n          grow(x + 1, y + 1, i + w + 1);\n        }\n      }\n      frontier = next;\n    }\n  }\n\n  /** Replaces every pixel whose color matches `from`. */\n  recolor(from: Color, to: Color): void {\n    for (let i = 0; i < this.data.length; i++) if (this.data[i] === from) this.data[i] = to;\n  }\n\n  /** Multiplies brightness of opaque pixels matching `pred`. */\n  tint(f: number, pred: (x: number, y: number) => boolean): void {\n    for (let y = 0; y < this.h; y++)\n      for (let x = 0; x < this.w; x++) {\n        const i = y * this.w + x;\n        const c = this.data[i] ?? 0;\n        if (c >>> 24 && pred(x, y)) this.data[i] = shade(c, f);\n      }\n  }\n\n  blit(src: PixelGrid, dx: number, dy: number, flipX = false): void {\n    for (let y = 0; y < src.h; y++)\n      for (let x = 0; x < src.w; x++) {\n        const c = src.data[y * src.w + x] ?? 0;\n        if (c >>> 24 === 0) continue;\n        this.px(dx + (flipX ? src.w - 1 - x : x), dy + y, c);\n      }\n  }\n\n  /** Alpha-blends a color onto an existing pixel. */\n  blend(x: number, y: number, c: Color): void {\n    if (!this.inBounds(x, y)) return;\n    const i = y * this.w + x;\n    const dst = this.data[i] ?? 0;\n    const [r, g, b, a] = channels(c);\n    const t = a / 255;\n    const d = channels(dst);\n    this.data[i] = rgba(d[0] + (r - d[0]) * t, d[1] + (g - d[1]) * t, d[2] + (b - d[2]) * t, Math.max(d[3], a));\n  }\n\n  /** Reads a canvas back into a grid (a PNG layer of the paper doll joining the painted ones). */\n  static from(canvas: HTMLCanvasElement): PixelGrid {\n    const g = new PixelGrid(canvas.width, canvas.height);\n    const img = canvas.getContext('2d')!.getImageData(0, 0, canvas.width, canvas.height);\n    g.data.set(new Uint32Array(img.data.buffer, img.data.byteOffset, canvas.width * canvas.height));\n    return g;\n  }\n\n  /** The same picture on a grid `factor` times as fine, each pixel becoming a square block. */\n  upscaled(factor: number): PixelGrid {\n    if (factor === 1) return this;\n    const g = new PixelGrid(this.w * factor, this.h * factor);\n    for (let y = 0; y < this.h; y++)\n      for (let x = 0; x < this.w; x++) {\n        const c = this.data[y * this.w + x] ?? 0;\n        if (c >>> 24 === 0) continue;\n        g.rect(x * factor, y * factor, factor, factor, c);\n      }\n    return g;\n  }\n\n  /** Same size and same pixels. */\n  equals(other: PixelGrid): boolean {\n    if (other.w !== this.w || other.h !== this.h) return false;\n    for (let i = 0; i < this.data.length; i++) if (this.data[i] !== other.data[i]) return false;\n    return true;\n  }\n\n  /** Cheap hash of the pixels, for grouping identical frames before comparing them. */\n  key(): number {\n    let h = 2166136261 >>> 0;\n    for (let i = 0; i < this.data.length; i++) {\n      h ^= this.data[i]!;\n      h = Math.imul(h, 16777619) >>> 0;\n    }\n    return h >>> 0;\n  }\n\n  clone(): PixelGrid {\n    const g = new PixelGrid(this.w, this.h);\n    g.data.set(this.data);\n    return g;\n  }\n\n  toCanvas(): HTMLCanvasElement {\n    const canvas = document.createElement('canvas');\n    canvas.width = this.w;\n    canvas.height = this.h;\n    const ctx = canvas.getContext('2d');\n    if (!ctx) throw new Error('2D canvas not supported');\n    const bytes = new Uint8ClampedArray(this.w * this.h * 4);\n    bytes.set(new Uint8Array(this.data.buffer, this.data.byteOffset, this.data.byteLength));\n    const img = new ImageData(bytes, this.w, this.h);\n    ctx.putImageData(img, 0, 0);\n    return canvas;\n  }\n}\n\n/**\n * A grid that stands for one window of a larger picture: it is drawn on in the larger picture's coordinates and\n * keeps only what falls inside `[x0, x0 + w) × [y0, y0 + h)`. A ground painter can paint a crop of a map into one, so the\n * login screen does not paint the whole of two maps to show 17 tiles of each. Every drawing method goes through\n * `px`/`get`/`inBounds`/`blend`; `outline`, `tint` and the whole-grid helpers work in window coordinates.\n */\nexport class PixelWindow extends PixelGrid {\n  constructor(\n    readonly x0: number,\n    readonly y0: number,\n    w: number,\n    h: number,\n  ) {\n    super(w, h);\n  }\n\n  override inBounds(x: number, y: number): boolean {\n    return super.inBounds(x - this.x0, y - this.y0);\n  }\n\n  override px(x: number, y: number, c: Color): void {\n    super.px(Math.floor(x) - this.x0, Math.floor(y) - this.y0, c);\n  }\n\n  override get(x: number, y: number): Color {\n    return super.get(x - this.x0, y - this.y0);\n  }\n\n  override blend(x: number, y: number, c: Color): void {\n    // not through super.blend: it asks `this.inBounds`, which would move the point a second time\n    const lx = x - this.x0;\n    const ly = y - this.y0;\n    if (!super.inBounds(lx, ly)) return;\n    const i = ly * this.w + lx;\n    const dst = this.data[i] ?? 0;\n    const [r, g, b, a] = channels(c);\n    const t = a / 255;\n    const d = channels(dst);\n    this.data[i] = rgba(d[0] + (r - d[0]) * t, d[1] + (g - d[1]) * t, d[2] + (b - d[2]) * t, Math.max(d[3], a));\n  }\n}\n\n/**\n * Packs same-sized frames into rows no wider than `maxWidth`. A browser refuses a canvas past about 16k pixels\n * on a side and hands back a blank one, and a player sheet of six hundred frames at twice the detail is wider\n * than that, so it wraps. Readers work the row out from the canvas width.\n */\nexport function makeSheet(frames: PixelGrid[], maxWidth = 16384): HTMLCanvasElement {\n  const first = frames[0];\n  if (!first) throw new Error('makeSheet: no frames');\n  const cols = Math.max(1, Math.min(frames.length, Math.floor(maxWidth / first.w)));\n  const rows = Math.ceil(frames.length / cols);\n  const sheet = new PixelGrid(first.w * cols, first.h * rows);\n  frames.forEach((f, i) => sheet.blit(f, (i % cols) * first.w, Math.floor(i / cols) * first.h));\n  return sheet.toCanvas();\n}\n\n/** Scales a canvas by an integer factor with nearest-neighbour filtering (for UI icons). */\nexport function upscale(src: HTMLCanvasElement, factor: number): HTMLCanvasElement {\n  const c = document.createElement('canvas');\n  c.width = src.width * factor;\n  c.height = src.height * factor;\n  const ctx = c.getContext('2d');\n  if (!ctx) throw new Error('2D canvas not supported');\n  ctx.imageSmoothingEnabled = false;\n  ctx.drawImage(src, 0, 0, c.width, c.height);\n  return c;\n}\n"],"names":["CLEAR","rgba","g","b","a","R","G","B","hex","s","h","c","r","channels","shade","f","t","mix","c1","c2","withAlpha","alpha","toCss","hash2","x","y","seed","mulberry32","valueNoise","scale","fx","fy","x0","y0","tx","ty","sx","sy","d","PixelGrid","w","yy","xx","x1","y1","cx","cy","rx","ry","dx","dy","thickness","err","e2","points","minY","p","maxY","xs","i","q","diagonal","width","solid","has","frontier","hit","step","next","grow","nx","ny","k","from","to","pred","src","flipX","dst","canvas","img","factor","other","ctx","bytes","PixelWindow","lx","ly","makeSheet","frames","maxWidth","first","cols","rows","sheet","upscale"],"mappings":"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"}

package/dist/pixel/pixelPaint.js

@@ -0,0 +1,194 @@
+import { ramp as P, dithered as R, grade as S, capturing as O, stageRun as v, endOutline as E, pixelKey as F, fillRuns as H, batchFor as T, record as K, beginOutline as L, flushBatch as j, currentCoverage as D } from "./pixelTone.js";
+import { PixelLayer as G } from "./PixelLayer.js";
+const J = 16774358, d = (f) => Math.round(f);
+function y(f, e, o, n, c = 1) {
+  const s = d(e), t = d(o);
+  if (R(s, t)) return;
+  const i = S(n);
+  if (O()) {
+    for (let a = 0; a < c; a++) for (let h = 0; h < c; h++) K(s + h, t + a, i);
+    return;
+  }
+  const l = T(f);
+  if (l) {
+    for (let a = 0; a < c; a++) v(l, s, t + a, c, i);
+    return;
+  }
+  f.fillStyle(i, 1).fillRect(s, t, c, c);
+}
+class C {
+  at = /* @__PURE__ */ new Map();
+  set(e, o, n) {
+    this.at.set(F(d(e), d(o)), n);
+  }
+  lay(e) {
+    if (O()) {
+      for (const [c, s] of this.at) y(e, (c >>> 16) - 32768, (c & 65535) - 32768, s);
+      return;
+    }
+    const o = T(e);
+    if (o instanceof G) {
+      for (const [c, s] of this.at) {
+        const t = (c >>> 16) - 32768, i = (c & 65535) - 32768;
+        R(t, i) || o.stage(t, i, 1, S(s));
+      }
+      return;
+    }
+    const n = /* @__PURE__ */ new Map();
+    for (const [c, s] of this.at) R((c >>> 16) - 32768, (c & 65535) - 32768) || n.set(c, S(s));
+    H(e, n);
+  }
+}
+function k(f, e, o, n, c) {
+  const s = d(e), t = d(n);
+  if (!(t <= 0)) {
+    if (!O() && !R(s, o) && !R(s + 1, o) && !R(s + 2, o + 1) && !R(s + 3, o + 1)) {
+      const i = T(f);
+      if (i) {
+        v(i, s, d(o), t, S(c));
+        return;
+      }
+      f.fillStyle(S(c), 1).fillRect(s, d(o), t, 1);
+      return;
+    }
+    for (let i = 0; i < t; i++) y(f, s + i, o, c);
+  }
+}
+function Y(f, e, o) {
+  L();
+  try {
+    o();
+  } finally {
+    E(f, e);
+  }
+}
+function A(f, e, o, n, c = 2) {
+  const s = Math.hypot(o.x - e.x, o.y - e.y), t = Math.max(1, Math.ceil(s)), i = s ? -(o.y - e.y) / s : 0, l = s ? (o.x - e.x) / s : 1, a = P(n), h = Math.max(1, Math.round(c));
+  for (let r = 0; r <= t; r++) {
+    const u = t >= 10 && (r <= 1 || r >= t - 1), x = t >= 16 && Math.abs(r - Math.round(t / 3)) <= 1, m = e.x + (o.x - e.x) * r / t, p = e.y + (o.y - e.y) * r / t;
+    for (let M = 0; M < h; M++) {
+      const w = M - (h - 1) / 2, g = h >= 2 ? M === 0 ? a.light : M === h - 1 ? a.deep : n : n;
+      y(f, m + i * w, p + l * w, u ? a.deep : x && M === 0 ? a.hi : g);
+    }
+  }
+}
+function Z(f, e, o, n = 0, c = 0) {
+  const s = P(o), t = Math.max(32, Math.ceil(e * 5)), i = new C();
+  for (let l = 0; l < t; l++) {
+    const a = ((l * 64 / t + n) % 16 + 16) % 16;
+    if (a < 3) continue;
+    const h = l * Math.PI * 2 / t, r = Math.sin(h), u = a < 4 ? s.hi : r > 0.35 ? s.light : r < -0.35 ? s.deep : o, x = Math.cos(h) * e, m = c + r * e * 0.5;
+    i.set(x, m, u), r > 0.5 && i.set(x, m + 1, s.deep);
+  }
+  i.lay(f);
+}
+function _(f, e, o, n, c) {
+  const s = P(c);
+  for (let t = -n; t <= n; t++) {
+    const i = Math.max(1, d(n - Math.abs(t))), l = d(e - i / 2);
+    if (t > n * 0.45) {
+      k(f, l, o + t, i, s.deep);
+      continue;
+    }
+    const a = Math.floor(i / 2);
+    n < 3 || a < 1 ? k(f, l, o + t, i, c) : (k(f, l, o + t, a, s.light), k(f, l + a, o + t, i - a, c));
+  }
+  n >= 5 && y(f, e - 1, o - n + 2, s.hi);
+}
+function $(f, e, o, n, c = !1) {
+  for (let s = 0; s < 12; s++) {
+    const t = s * Math.PI / 6 + (c ? e * 1.8 : 0), i = o * (c ? 1 - e : e);
+    y(f, Math.cos(t) * i, -8 + Math.sin(t) * i * 0.6 - (c ? 0 : Math.sin(e * Math.PI) * 8), s % 3 ? n : J, s % 3 ? 1 : 2);
+  }
+}
+function N(f, e, o, n, c, s = !1) {
+  const t = Math.max(1, Math.round(s ? n * 0.5 : n)), i = P(c);
+  for (let l = -t; l <= t; l++) {
+    const a = d(n * Math.sqrt(Math.max(0, 1 - (l / t) ** 2)));
+    if (a <= 0) continue;
+    const h = (l + t) / (2 * t || 1);
+    k(f, e - a, o + l, a * 2, h > 0.7 && n >= 3 ? i.deep : c), n >= 3 && h < 0.35 && a >= 2 && k(f, e - a + 1, o + l, d(a * 0.6), i.light);
+  }
+  n >= 4 && y(f, e - n * 0.4, o - t * 0.55, i.hi);
+}
+function Q(f, e, o, n, c, s = e + 8) {
+  const t = c / 1e3, i = e + n * t + 260 * t * t;
+  return i > s && n * t + 260 * t * t > 0 ? null : { x: f + o * t, y: i };
+}
+function z(f, e, o, n, c) {
+  A(f, { x: e - n, y: o - n }, { x: e + n, y: o + n }, c), A(f, { x: e - n, y: o + n }, { x: e + n, y: o - n }, c);
+}
+function tt(f, e, o, n, c, s) {
+  const t = { x: e.x + (o.x - e.x) * n, y: e.y + (o.y - e.y) * n };
+  A(f, t, o, c, 4), A(f, t, o, s, 2);
+}
+function nt(f, e, o, n, c, s, t = 0, i = 0.7) {
+  if (n = Math.round(n), n < 2) return;
+  const l = P(c), a = Math.max(2, Math.round(n * 0.85)), h = i * D();
+  j();
+  const r = d(e);
+  for (let u = -a; u <= a; u++) {
+    const x = n * Math.sqrt(Math.max(0, 1 - (u / (a + 0.5)) ** 2));
+    let m = 0, p = 0, M = -1, w = 0;
+    const g = Math.ceil(x);
+    for (let I = -g; I <= g; I++) {
+      let q = -1, B = 0;
+      if (I < g) {
+        const W = x - Math.abs(I + 0.5), b = (I * 73856093 ^ u * 19349663 ^ t * 83492791) >>> 0;
+        W < 1 && b % 2 === 0 || (q = u < -a * 0.3 && I < x * 0.2 ? s : u > a * 0.4 ? l.deep : b % 9 === 0 ? l.light : c, B = W < 1 ? h * 0.6 : h);
+      }
+      if (q === M && B === w && q !== -1) {
+        p++;
+        continue;
+      }
+      M !== -1 && f.fillStyle(S(M), w).fillRect(r + m, d(o + u), p, 1), m = I, p = 1, M = q, w = B;
+    }
+  }
+}
+function ot(f, e, o, n, c, s, t, i = !0, l = 1) {
+  const a = Math.max(2, Math.ceil(Math.abs(s - c) * n)), h = P(t);
+  l *= 2;
+  const r = new C();
+  for (let u = 0; u < l; u++) {
+    const x = n - u, m = u === 0 ? h.light : u === l - 1 ? h.deep : t;
+    for (let p = 0; p <= a; p++) {
+      const M = c + (s - c) * p / a, w = p >= a - 1 ? h.hi : l <= 2 && a >= 12 && p < a * 0.2 ? h.deep : m;
+      r.set(e + Math.cos(M) * x, o + Math.sin(M) * x * (i ? 0.5 : 1), w);
+    }
+  }
+  r.lay(f);
+}
+function et(f, e, o, n, c = 10, s = 13154458) {
+  for (let t = 0; t < 4; t++) {
+    const i = t * 1.7 + 0.3, l = Math.round(4 * (1 - n));
+    l >= 1 && N(f, e + Math.cos(i) * c * n, o - 2 + Math.sin(i) * c * 0.4 * n - n * 4, l, t % 2 ? s : 14734524);
+  }
+}
+function st(f, e, o, n, c, s, t) {
+  for (let i = 0; i < n; i++) {
+    const l = i / n * Math.PI * 2 + 0.3, a = c * (0.6 + i * 7 % 5 * 0.1), h = Q(e, o, Math.cos(l) * a, -70 - i * 17 % 40, s, o + 6);
+    if (!h) continue;
+    const r = t[i % t.length], u = h.y + Math.sin(l) * a * 0.3 * s / 1e3;
+    i % 3 ? y(f, h.x, u, r) : (y(f, h.x, u, r, 2), y(f, h.x, u + 2, P(r).deep, 2), y(f, h.x, u, P(r).hi));
+  }
+}
+export {
+  J as WHITE,
+  ot as arc,
+  N as blob,
+  tt as dashStreak,
+  st as debris,
+  _ as diamond,
+  y as dot,
+  Q as drop,
+  et as dust,
+  k as hline,
+  Y as outlined,
+  nt as puffBlob,
+  Z as ring,
+  $ as shards,
+  d as snap,
+  A as stroke,
+  z as xMark
+};
+//# sourceMappingURL=pixelPaint.js.map

package/dist/pixel/pixelPaint.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"pixelPaint.js","sources":["../../src/pixel/pixelPaint.ts"],"sourcesContent":["import { batchFor, beginOutline, capturing, currentCoverage, dithered, endOutline, fillRuns, flushBatch, grade, pixelKey, ramp, record, stageRun } from './pixelTone';\nimport { PixelLayer } from './PixelLayer';\nimport type { Graphics } from '../core/Graphics';\n\n/*\n * Pixel painting shared by every kit's effects: every shape lands on the 1px world grid — the pixel size of the\n * character, prop and tile art, so an effect never looks chunkier than the body it sits on — and is redrawn at 12\n * frames per second. Every colour is pulled into the world's palette on the way out (`grade`). Shapes shade themselves from their colour's ramp (pixelTone.ts): rings are\n * brighter on the near side, thick arcs and discs carry a light edge and a deep underside, and strokes taper. Every\n * layer thins out with an ordered dither in its last frames instead of vanishing.\n */\n\nexport type Point = { x: number; y: number };\nexport const WHITE = 0xfff4d6;\nexport const snap = (n: number) => Math.round(n);\n\n/** A `size`-px square (1 by default: one art pixel) on the world grid, graded into the world palette. */\nexport function dot(g: Graphics, x: number, y: number, color: number, size = 1): void {\n  const px = snap(x);\n  const py = snap(y);\n  if (dithered(px, py)) return;\n  const c = grade(color);\n  if (capturing()) {\n    for (let dy = 0; dy < size; dy++) for (let dx = 0; dx < size; dx++) record(px + dx, py + dy, c);\n    return;\n  }\n  const held = batchFor(g);\n  if (held) {\n    for (let dy = 0; dy < size; dy++) stageRun(held, px, py + dy, size, c);\n    return;\n  }\n  g.fillStyle(c, 1).fillRect(px, py, size, size);\n}\n\n/**\n * Pixels a shape plots, the last plot of a pixel winning as it would on screen, laid when the shape is done as runs of\n * one tone (`fillRuns`) instead of a rect a pixel. A dither fade drops the same pixels `dot` would, and inside an\n * outline capture they are recorded like any `dot`.\n */\nclass Plot {\n  private readonly at = new Map<number, number>();\n\n  set(x: number, y: number, color: number): void {\n    this.at.set(pixelKey(snap(x), snap(y)), color);\n  }\n\n  lay(g: Graphics): void {\n    if (capturing()) {\n      for (const [k, c] of this.at) dot(g, (k >>> 16) - 32768, (k & 0xffff) - 32768, c);\n      return;\n    }\n    const held = batchFor(g);\n    if (held instanceof PixelLayer) {\n      // straight into the layer's staging: the keys are already one a pixel\n      for (const [k, c] of this.at) {\n        const x = (k >>> 16) - 32768;\n        const y = (k & 0xffff) - 32768;\n        if (!dithered(x, y)) held.stage(x, y, 1, grade(c));\n      }\n      return;\n    }\n    const graded = new Map<number, number>();\n    for (const [k, c] of this.at) if (!dithered((k >>> 16) - 32768, (k & 0xffff) - 32768)) graded.set(k, grade(c));\n    fillRuns(g, graded);\n  }\n}\n\n/** A horizontal run of `w` px from (x, y), one pixel tall; drawn pixel by pixel while a dither fade or outline is on. */\nexport function hline(g: Graphics, x: number, y: number, w: number, color: number): void {\n  const x0 = snap(x);\n  const width = snap(w);\n  if (width <= 0) return;\n  if (!capturing() && !dithered(x0, y) && !dithered(x0 + 1, y) && !dithered(x0 + 2, y + 1) && !dithered(x0 + 3, y + 1)) {\n    const held = batchFor(g);\n    if (held) {\n      stageRun(held, x0, snap(y), width, grade(color));\n      return;\n    }\n    g.fillStyle(grade(color), 1).fillRect(x0, snap(y), width, 1);\n    return;\n  }\n  for (let i = 0; i < width; i++) dot(g, x0 + i, y, color);\n}\n\n/** Paints `draw` with a dark 1px outline round everything it drew, like the outline on character and prop sprites. */\nexport function outlined(g: Graphics, outline: number, draw: () => void): void {\n  beginOutline();\n  try {\n    draw();\n  } finally {\n    endOutline(g, outline);\n  }\n}\n\n/**\n * A line `width` px thick built from 1px rows: the row on one side is lit, the far row deep, and a long stroke tapers\n * to the deep tone at both ends and catches a glint a third of the way along.\n */\nexport function stroke(g: Graphics, a: Point, b: Point, color: number, width = 2): void {\n  const len = Math.hypot(b.x - a.x, b.y - a.y);\n  const steps = Math.max(1, Math.ceil(len));\n  const nx = len ? -(b.y - a.y) / len : 0;\n  const ny = len ? (b.x - a.x) / len : 1;\n  const r = ramp(color);\n  const rows = Math.max(1, Math.round(width));\n  for (let i = 0; i <= steps; i++) {\n    const end = steps >= 10 && (i <= 1 || i >= steps - 1);\n    const glint = steps >= 16 && Math.abs(i - Math.round(steps / 3)) <= 1;\n    const x = a.x + ((b.x - a.x) * i) / steps;\n    const y = a.y + ((b.y - a.y) * i) / steps;\n    for (let k = 0; k < rows; k++) {\n      const off = k - (rows - 1) / 2;\n      const edge = rows >= 2 ? (k === 0 ? r.light : k === rows - 1 ? r.deep : color) : color;\n      dot(g, x + nx * off, y + ny * off, end ? r.deep : glint && k === 0 ? r.hi : edge);\n    }\n  }\n}\n\n/** A broken ellipse of radius `r` in the ground's 2:1 perspective, lit on the near side, turning with `phase`. */\nexport function ring(g: Graphics, r: number, color: number, phase = 0, cy = 0): void {\n  const tones = ramp(color);\n  const n = Math.max(32, Math.ceil(r * 5));\n  const plot = new Plot();\n  for (let i = 0; i < n; i++) {\n    const seg = ((((i * 64) / n + phase) % 16) + 16) % 16;\n    if (seg < 3) continue;\n    const a = (i * Math.PI * 2) / n;\n    const near = Math.sin(a);\n    // the near side of the ellipse is lit and a pixel thicker; the far side sinks into the deep tone\n    const tone = seg < 4 ? tones.hi : near > 0.35 ? tones.light : near < -0.35 ? tones.deep : color;\n    const x = Math.cos(a) * r;\n    const y = cy + near * r * 0.5;\n    plot.set(x, y, tone);\n    if (near > 0.5) plot.set(x, y + 1, tones.deep);\n  }\n  plot.lay(g);\n}\n\n/** A faceted gem: light left face, base right face, deep lower tip and a glint on top once it is big enough. */\nexport function diamond(g: Graphics, x: number, y: number, r: number, color: number): void {\n  const tones = ramp(color);\n  for (let row = -r; row <= r; row++) {\n    const width = Math.max(1, snap(r - Math.abs(row)));\n    const left = snap(x - width / 2);\n    if (row > r * 0.45) {\n      hline(g, left, y + row, width, tones.deep);\n      continue;\n    }\n    const half = Math.floor(width / 2);\n    if (r < 3 || half < 1) hline(g, left, y + row, width, color);\n    else {\n      hline(g, left, y + row, half, tones.light);\n      hline(g, left + half, y + row, width - half, color);\n    }\n  }\n  if (r >= 5) dot(g, x - 1, y - r + 2, tones.hi);\n}\n\nexport function shards(g: Graphics, t: number, r: number, color: number, inward = false): void {\n  for (let i = 0; i < 12; i++) {\n    const a = i * Math.PI / 6 + (inward ? t * 1.8 : 0);\n    const d = r * (inward ? 1 - t : t);\n    dot(g, Math.cos(a) * d, -8 + Math.sin(a) * d * 0.6 - (inward ? 0 : Math.sin(t * Math.PI) * 8), i % 3 ? color : WHITE, i % 3 ? 1 : 2);\n  }\n}\n\n/** A filled stepped disc of radius `r` (smoke, gas, puddles), in the ground's 2:1 perspective when `flat`. */\nexport function blob(g: Graphics, x: number, y: number, r: number, color: number, flat = false): void {\n  const ry = Math.max(1, Math.round(flat ? r * 0.5 : r));\n  const tones = ramp(color);\n  for (let row = -ry; row <= ry; row++) {\n    const half = snap(r * Math.sqrt(Math.max(0, 1 - (row / ry) ** 2)));\n    if (half <= 0) continue;\n    const down = (row + ry) / (2 * ry || 1);\n    hline(g, x - half, y + row, half * 2, down > 0.7 && r >= 3 ? tones.deep : color);\n    // a lit cap on the upper left\n    if (r >= 3 && down < 0.35 && half >= 2) hline(g, x - half + 1, y + row, snap(half * 0.6), tones.light);\n  }\n  if (r >= 4) dot(g, x - r * 0.4, y - ry * 0.55, tones.hi);\n}\n\n/** A droplet thrown from (x, y) with velocity (vx, vy) px/s under gravity, `ms` after it left; null once it lands. */\nexport function drop(x: number, y: number, vx: number, vy: number, ms: number, ground = y + 8): Point | null {\n  const t = ms / 1000;\n  const py = y + vy * t + 260 * t * t;\n  return py > ground && vy * t + 260 * t * t > 0 ? null : { x: x + vx * t, y: py };\n}\n\n/** A pixel X, `r` from its centre to a tip. */\nexport function xMark(g: Graphics, x: number, y: number, r: number, color: number): void {\n  stroke(g, { x: x - r, y: y - r }, { x: x + r, y: y + r }, color);\n  stroke(g, { x: x - r, y: y + r }, { x: x + r, y: y - r }, color);\n}\n\n/** A dash streak from `a` to `b`: a dark body with a bright core, eaten away from the start as `t` goes 0 to 1. */\nexport function dashStreak(g: Graphics, a: Point, b: Point, t: number, edge: number, core: number): void {\n  const from = { x: a.x + (b.x - a.x) * t, y: a.y + (b.y - a.y) * t };\n  stroke(g, from, b, edge, 4);\n  stroke(g, from, b, core, 2);\n}\n\n/**\n * A puff of smoke or gas: a small stepped disc whose rim is dithered (every other pixel) so it reads soft, with a\n * lighter cap on its upper left. Solid discs the same size read as boulders or bushes.\n */\nexport function puffBlob(g: Graphics, x: number, y: number, r: number, body: number, light: number, frame = 0, opacity = 0.7): void {\n  r = Math.round(r);\n  if (r < 2) return;\n  const tones = ramp(body);\n  const ry = Math.max(2, Math.round(r * 0.85));\n  // smoke is translucent: overlapping puffs thicken toward the middle of a cloud and the ground shows through its edge\n  const alpha = opacity * currentCoverage();\n  flushBatch();\n  const x0 = snap(x);\n  for (let row = -ry; row <= ry; row++) {\n    const half = r * Math.sqrt(Math.max(0, 1 - (row / (ry + 0.5)) ** 2));\n    // the same pixels as one rect each, laid as runs of one tone and alpha\n    let runAt = 0;\n    let runW = 0;\n    let runTone = -1;\n    let runAlpha = 0;\n    const end = Math.ceil(half);\n    for (let dx = -end; dx <= end; dx++) {\n      let tone = -1;\n      let a = 0;\n      if (dx < end) {\n        const edge = half - Math.abs(dx + 0.5);\n        const noise = ((dx * 73856093) ^ (row * 19349663) ^ (frame * 83492791)) >>> 0;\n        if (!(edge < 1 && noise % 2 === 0)) {\n          const lit = row < -ry * 0.3 && dx < half * 0.2;\n          tone = lit ? light : row > ry * 0.4 ? tones.deep : noise % 9 === 0 ? tones.light : body;\n          a = edge < 1 ? alpha * 0.6 : alpha;\n        }\n      }\n      if (tone === runTone && a === runAlpha && tone !== -1) {\n        runW++;\n        continue;\n      }\n      if (runTone !== -1) g.fillStyle(grade(runTone), runAlpha).fillRect(x0 + runAt, snap(y + row), runW, 1);\n      runAt = dx;\n      runW = 1;\n      runTone = tone;\n      runAlpha = a;\n    }\n  }\n}\n\n/** An arc of dots on an ellipse from angle `a0` to `a1` (flat: in the ground's 2:1 perspective), `thick` rows deep. */\nexport function arc(g: Graphics, x: number, y: number, r: number, a0: number, a1: number, color: number, flat = true, thick = 1): void {\n  const steps = Math.max(2, Math.ceil(Math.abs(a1 - a0) * r));\n  const tones = ramp(color);\n  // `thick` counts the old 2px rows, so an arc keeps its weight; it is built from 1px rows\n  thick *= 2;\n  const plot = new Plot();\n  for (let t = 0; t < thick; t++) {\n    const rr = r - t;\n    // a thick arc is lit on its outer edge and sinks to the deep tone inside; a thin one fades in from its tail\n    const row = t === 0 ? tones.light : t === thick - 1 ? tones.deep : color;\n    for (let i = 0; i <= steps; i++) {\n      const a = a0 + ((a1 - a0) * i) / steps;\n      const tone = i >= steps - 1 ? tones.hi : thick <= 2 && steps >= 12 && i < steps * 0.2 ? tones.deep : row;\n      plot.set(x + Math.cos(a) * rr, y + Math.sin(a) * rr * (flat ? 0.5 : 1), tone);\n    }\n  }\n  plot.lay(g);\n}\n\n/** Pale stepped dust puffs kicked up around (x, y) and settling over `t` 0..1. */\nexport function dust(g: Graphics, x: number, y: number, t: number, spread = 10, color = 0xc8b89a): void {\n  for (let i = 0; i < 4; i++) {\n    const a = i * 1.7 + 0.3;\n    const size = Math.round(4 * (1 - t));\n    if (size >= 1) blob(g, x + Math.cos(a) * spread * t, y - 2 + Math.sin(a) * spread * 0.4 * t - t * 4, size, i % 2 ? color : 0xe0d4bc);\n  }\n}\n\n/** Pixel chunks flung out of (x, y) under gravity (rock, splinters): `ms` after the blow. */\nexport function debris(g: Graphics, x: number, y: number, count: number, speed: number, ms: number, colors: number[]): void {\n  for (let i = 0; i < count; i++) {\n    const a = (i / count) * Math.PI * 2 + 0.3;\n    const v = speed * (0.6 + ((i * 7) % 5) * 0.1);\n    const p = drop(x, y, Math.cos(a) * v, -70 - ((i * 17) % 40), ms, y + 6);\n    if (!p) continue;\n    const c = colors[i % colors.length]!;\n    const py = p.y + (Math.sin(a) * v * 0.3 * ms) / 1000;\n    if (i % 3) dot(g, p.x, py, c);\n    else {\n      // a chunk: body, deep underside and a glint\n      dot(g, p.x, py, c, 2);\n      dot(g, p.x, py + 2, ramp(c).deep, 2);\n      dot(g, p.x, py, ramp(c).hi);\n    }\n  }\n}\n\n"],"names":["WHITE","snap","n","dot","g","x","y","color","size","px","py","dithered","c","grade","capturing","dy","dx","record","held","batchFor","stageRun","Plot","pixelKey","k","PixelLayer","graded","fillRuns","hline","w","x0","width","outlined","outline","draw","beginOutline","endOutline","stroke","a","b","len","steps","nx","ny","r","ramp","rows","i","end","glint","off","edge","ring","phase","cy","tones","plot","seg","near","tone","diamond","row","left","half","shards","t","inward","d","blob","flat","ry","down","drop","vx","vy","ms","ground","xMark","dashStreak","core","from","puffBlob","body","light","frame","opacity","alpha","currentCoverage","flushBatch","runAt","runW","runTone","runAlpha","noise","arc","a0","a1","thick","rr","dust","spread","debris","count","speed","colors","v","p"],"mappings":"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"}

package/dist/pixel/pixelTone.js

@@ -0,0 +1,164 @@
+import { PixelLayer as y } from "./PixelLayer.js";
+const R = /* @__PURE__ */ new Map();
+function S(t) {
+  const n = (t >> 16 & 255) / 255, e = (t >> 8 & 255) / 255, o = (t & 255) / 255, r = Math.max(n, e, o), c = Math.min(n, e, o), s = (r + c) / 2;
+  if (r === c) return [0, 0, s];
+  const i = r - c, u = s > 0.5 ? i / (2 - r - c) : i / (r + c);
+  return [(r === n ? (e - o) / i + (e < o ? 6 : 0) : r === e ? (o - n) / i + 2 : (n - e) / i + 4) / 6, u, s];
+}
+function M(t, n, e) {
+  const o = (i, u, h) => {
+    const m = (h + 1) % 1;
+    return m < 0.16666666666666666 ? i + (u - i) * 6 * m : m < 0.5 ? u : m < 0.6666666666666666 ? i + (u - i) * (0.6666666666666666 - m) * 6 : i;
+  }, r = e < 0.5 ? e * (1 + n) : e + n - e * n, c = 2 * e - r, s = (i) => Math.round(Math.max(0, Math.min(1, n === 0 ? e : o(c, r, i))) * 255);
+  return s(t + 1 / 3) << 16 | s(t) << 8 | s(t - 1 / 3);
+}
+function g(t, n, e) {
+  let o = n - t;
+  return o > 0.5 && (o -= 1), o < -0.5 && (o += 1), (t + Math.sign(o) * Math.min(Math.abs(o), e) + 1) % 1;
+}
+const v = /* @__PURE__ */ new Map();
+function P(t) {
+  const n = Symbol.iterator in t ? t : Object.entries(t).map(([e, o]) => [Number(e), o]);
+  for (const [e, o] of n) v.set(e, { ...o, base: e });
+}
+function G(t) {
+  return v.get(t) ?? H(t);
+}
+function H(t) {
+  let n = R.get(t);
+  if (n) return n;
+  const [e, o, r] = S(t), c = g(e, 0.72, 0.06), s = g(e, 0.14, 0.04);
+  return n = {
+    shade: M(c, Math.min(1, o * 0.85), Math.max(0.08, r * 0.38)),
+    deep: M(g(e, 0.72, 0.03), o, Math.max(0.14, r * 0.66)),
+    base: t,
+    light: M(s, o * 0.9, Math.min(0.9, r + (1 - r) * 0.45)),
+    hi: M(s, o * 0.5, Math.min(0.97, r + (1 - r) * 0.8))
+  }, R.set(t, n), n;
+}
+const k = /* @__PURE__ */ new Map();
+function C(t) {
+  let n = k.get(t);
+  if (n !== void 0) return n;
+  const [e, o, r] = S(t), c = r > 0.82 ? 0.82 + (r - 0.82) * 0.55 : r;
+  return n = M(r > 0.82 ? g(e, 0.12, 0.05) : e, o * (r > 0.82 ? 0.55 : 0.74), c * 0.97), k.set(t, n), n;
+}
+let d = null;
+const b = (t, n) => t + 32768 << 16 | n + 32768 & 65535;
+function N() {
+  return d;
+}
+const w = [1, 0, -1, 0, 0, 1, 0, -1];
+function Y() {
+  d = /* @__PURE__ */ new Map();
+}
+function j(t, n) {
+  const e = d;
+  if (d = null, !e) return;
+  const o = /* @__PURE__ */ new Set();
+  for (const c of e.keys()) {
+    const s = (c >>> 16) - 32768, i = (c & 65535) - 32768;
+    for (let u = 0; u < 8; u += 2) {
+      const h = b(s + w[u], i + w[u + 1]);
+      e.has(h) || o.add(h);
+    }
+  }
+  const r = C(n);
+  x(t, new Map([...o].map((c) => [c, r]))), x(t, e);
+}
+function x(t, n) {
+  if (l !== null && t === l) {
+    if (a) for (const [e, o] of n) a.stage((e >>> 16) - 32768, (e & 65535) - 32768, 1, o);
+    else for (const [e, o] of n) f.set(e, o);
+    return;
+  }
+  B(t, n);
+}
+let f = null, a = null, l = null;
+const A = [];
+function z(t) {
+  A.push({ batch: f, direct: a, g: l }), t instanceof y ? (f = null, a = t) : (f = /* @__PURE__ */ new Map(), a = null), l = t;
+}
+function F() {
+  D();
+  const t = A.pop();
+  f = t?.batch ?? null, a = t?.direct ?? null, l = t?.g ?? null;
+}
+function I(t) {
+  return l === null || t !== l ? null : a ?? f;
+}
+function K(t, n, e, o, r) {
+  if (t instanceof y) {
+    t.stage(n, e, o, r);
+    return;
+  }
+  for (let c = 0; c < o; c++) t.set(b(n + c, e), r);
+}
+function D() {
+  if (a) {
+    a.commit();
+    return;
+  }
+  if (!f || !l || f.size === 0) return;
+  const t = f;
+  f = /* @__PURE__ */ new Map(), B(l, t);
+}
+function B(t, n) {
+  if (t instanceof y) {
+    for (const [i, u] of n) t.stage((i >>> 16) - 32768, (i & 65535) - 32768, 1, u);
+    t.commit();
+    return;
+  }
+  const e = [...n.keys()].sort((i, u) => (i & 65535) - (u & 65535) || (i >>> 16) - (u >>> 16));
+  let o = 0, r = 0, c = 0, s = -1;
+  for (const i of e) {
+    const u = (i >>> 16) - 32768, h = (i & 65535) - 32768, m = n.get(i);
+    if (c > 0 && h === r && u === o + c && m === s) {
+      c++;
+      continue;
+    }
+    c > 0 && t.fillStyle(s, 1).fillRect(o, r, c, 1), o = u, r = h, c = 1, s = m;
+  }
+  c > 0 && t.fillStyle(s, 1).fillRect(o, r, c, 1);
+}
+function L(t, n) {
+  return b(t, n);
+}
+function T(t, n, e) {
+  d?.set(b(t, n), e);
+}
+const E = [0, 8, 2, 10, 12, 4, 14, 6, 3, 11, 1, 9, 15, 7, 13, 5];
+let p = 1;
+function W(t) {
+  p = t;
+}
+function X() {
+  return p;
+}
+function _(t, n) {
+  if (p >= 1) return !1;
+  const e = (Math.round(t) & 3) >>> 0, o = (Math.round(n) & 3) >>> 0;
+  return E[o * 4 + e] / 16 >= p;
+}
+export {
+  I as batchFor,
+  z as beginBatch,
+  Y as beginOutline,
+  N as capturing,
+  X as currentCoverage,
+  H as derivedRamp,
+  _ as dithered,
+  F as endBatch,
+  j as endOutline,
+  x as fillRuns,
+  D as flushBatch,
+  C as grade,
+  L as pixelKey,
+  G as ramp,
+  T as record,
+  P as registerHandRamps,
+  W as setCoverage,
+  K as stageRun
+};
+//# sourceMappingURL=pixelTone.js.map

package/dist/pixel/pixelTone.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"pixelTone.js","sources":["../../src/pixel/pixelTone.ts"],"sourcesContent":["import type { Graphics } from '../core/Graphics';\nimport { PixelLayer } from './PixelLayer';\n\n/*\n * Colour ramps and ordered dithering for the pixel effects. A ramp turns one colour into five tones the way pixel\n * artists shade: shadows shift toward blue-violet and lose saturation, highlights shift toward yellow. The dither fade\n * drops pixels in a 4x4 Bayer order, so an effect thins out pixel by pixel instead of vanishing in one frame.\n */\n\nexport interface Ramp {\n  /** Darkest: under-shade and outline pixels. */\n  shade: number;\n  deep: number;\n  base: number;\n  light: number;\n  /** Near-white glint. */\n  hi: number;\n}\n\nconst RAMPS = new Map<number, Ramp>();\n\nfunction toHsl(c: number): [number, number, number] {\n  const r = ((c >> 16) & 255) / 255;\n  const g = ((c >> 8) & 255) / 255;\n  const b = (c & 255) / 255;\n  const max = Math.max(r, g, b);\n  const min = Math.min(r, g, b);\n  const l = (max + min) / 2;\n  if (max === min) return [0, 0, l];\n  const d = max - min;\n  const s = l > 0.5 ? d / (2 - max - min) : d / (max + min);\n  const h = max === r ? (g - b) / d + (g < b ? 6 : 0) : max === g ? (b - r) / d + 2 : (r - g) / d + 4;\n  return [h / 6, s, l];\n}\n\nfunction fromHsl(h: number, s: number, l: number): number {\n  const hue = (p: number, q: number, t: number) => {\n    const u = (t + 1) % 1;\n    if (u < 1 / 6) return p + (q - p) * 6 * u;\n    if (u < 1 / 2) return q;\n    if (u < 2 / 3) return p + (q - p) * (2 / 3 - u) * 6;\n    return p;\n  };\n  const q = l < 0.5 ? l * (1 + s) : l + s - l * s;\n  const p = 2 * l - q;\n  const ch = (t: number) => Math.round(Math.max(0, Math.min(1, s === 0 ? l : hue(p, q, t))) * 255);\n  return (ch(h + 1 / 3) << 16) | (ch(h) << 8) | ch(h - 1 / 3);\n}\n\n/** Hue moved `amount` (turns) toward `target`, the short way round. */\nfunction drift(h: number, target: number, amount: number): number {\n  let d = target - h;\n  if (d > 0.5) d -= 1;\n  if (d < -0.5) d += 1;\n  return (h + Math.sign(d) * Math.min(Math.abs(d), amount) + 1) % 1;\n}\n\n/**\n * Ramps picked by hand for the colours a game's effects are built on (`registerHandRamps`): an effect paints its\n * crescents, rings and trails in one material colour and lets the shapes shade themselves, so a hand ramp is how a\n * game's own colours get shades better than the formula's. `ramp` of one of these colours returns its hand ramp;\n * every other colour gets `derivedRamp`. `base` is always the colour itself.\n */\nconst HAND = new Map<number, Ramp>();\n\n/** Gives these colours ramps picked by hand (darkest `shade` … brightest `hi`); a colour registered again is replaced. */\nexport function registerHandRamps(ramps: Iterable<readonly [number, Omit<Ramp, 'base'>]> | Record<number, Omit<Ramp, 'base'>>): void {\n  const entries = Symbol.iterator in ramps ? ramps : Object.entries(ramps).map(([c, r]) => [Number(c), r] as const);\n  for (const [c, r] of entries) HAND.set(c, { ...r, base: c });\n}\n\nexport function ramp(color: number): Ramp {\n  return HAND.get(color) ?? derivedRamp(color);\n}\n\n/** The formula's five tones for any colour: shadows cool and desaturate, highlights warm. */\nexport function derivedRamp(color: number): Ramp {\n  let r = RAMPS.get(color);\n  if (r) return r;\n  const [h, s, l] = toHsl(color);\n  const cool = drift(h, 0.72, 0.06);\n  const warm = drift(h, 0.14, 0.04);\n  r = {\n    shade: fromHsl(cool, Math.min(1, s * 0.85), Math.max(0.08, l * 0.38)),\n    deep: fromHsl(drift(h, 0.72, 0.03), s, Math.max(0.14, l * 0.66)),\n    base: color,\n    light: fromHsl(warm, s * 0.9, Math.min(0.9, l + (1 - l) * 0.45)),\n    hi: fromHsl(warm, s * 0.5, Math.min(0.97, l + (1 - l) * 0.8)),\n  };\n  RAMPS.set(color, r);\n  return r;\n}\n\nconst GRADED = new Map<number, number>();\n\n/**\n * The colour a pixel is actually painted with: effects are authored in bright, saturated colours, and this pulls them\n * into the world's palette (muted earth, grass and wood) — saturation down by a quarter, near-whites toned down and\n * warmed, so an effect sits in the scene instead of glowing on top of it. Glints keep most of their lift.\n */\nexport function grade(color: number): number {\n  let out = GRADED.get(color);\n  if (out !== undefined) return out;\n  const [h, s, l] = toHsl(color);\n  const lift = l > 0.82 ? 0.82 + (l - 0.82) * 0.55 : l;\n  out = fromHsl(l > 0.82 ? drift(h, 0.12, 0.05) : h, s * (l > 0.82 ? 0.55 : 0.74), lift * 0.97);\n  GRADED.set(color, out);\n  return out;\n}\n\n/*\n * Outline capture: while one is open, `dot` and `hline` record pixels instead of painting them, and `endOutline`\n * paints a dark 1px rim round the recorded silhouette before the pixels themselves — the same outline the character\n * and prop sprites carry, for effects that have a shape (a shield, a skull, a flask, a bolt).\n */\nlet capture: Map<number, number> | null = null;\nconst key = (x: number, y: number) => ((x + 32768) << 16) | ((y + 32768) & 0xffff);\n\nexport function capturing(): Map<number, number> | null {\n  return capture;\n}\n\n/** The four sides a rim pixel may lie on, as dx, dy pairs. */\nconst RIM_STEPS = [1, 0, -1, 0, 0, 1, 0, -1];\n\nexport function beginOutline(): void {\n  capture = new Map();\n}\n\nexport function endOutline(g: Graphics, outline: number): void {\n  const pixels = capture;\n  capture = null;\n  if (!pixels) return;\n  // each rim pixel once, however many silhouette pixels it touches\n  const rim = new Set<number>();\n  for (const k of pixels.keys()) {\n    const x = (k >>> 16) - 32768;\n    const y = (k & 0xffff) - 32768;\n    for (let i = 0; i < 8; i += 2) {\n      const n = key(x + RIM_STEPS[i]!, y + RIM_STEPS[i + 1]!);\n      if (!pixels.has(n)) rim.add(n);\n    }\n  }\n  const ink = grade(outline);\n  fillRuns(g, new Map([...rim].map((k) => [k, ink])));\n  fillRuns(g, pixels);\n}\n\n/**\n * Lays pixels (keyed by `key`, each with its colour already graded) row by row, one rect for every run of one colour:\n * the same pixels as one rect each, at a fraction of the rects (single-pixel rects ran to 5,000–9,000 a frame for one\n * big ring or smoke, enough to be felt as lag).\n */\nexport function fillRuns(g: Graphics, pixels: Map<number, number>): void {\n  if (batchG !== null && g === batchG) {\n    if (direct) for (const [k, c] of pixels) direct.stage((k >>> 16) - 32768, (k & 0xffff) - 32768, 1, c);\n    else for (const [k, c] of pixels) batch!.set(k, c);\n    return;\n  }\n  layRuns(g, pixels);\n}\n\n/*\n * A frame's batch (`beginBatch` / `endBatch`): while one is open every solid pixel `dot`, `hline` and `fillRuns` paint goes into it,\n * the last write of a pixel winning as it would on screen, and it is laid as runs when the frame is done — so an\n * effect that plots a pixel at a time costs a rect a run, not a rect a pixel. A translucent fill (smoke, a heat wash)\n * calls `flushBatch` first, so what was painted before it stays under it.\n *\n * On a `PixelLayer` the batch is the layer's own staging: each pixel goes\n * straight into its list in the order painted and `commit` lays them, the later winning — the same pixels the map,\n * its sort and its runs gave, without them. Any other Graphics keeps the map.\n */\nlet batch: Map<number, number> | null = null;\nlet direct: PixelLayer | null = null;\nlet batchG: Graphics | null = null;\n/** Batches opened under this one (a layer painted from inside another's paint), each laid and closed on its own. */\nconst outer: { batch: Map<number, number> | null; direct: PixelLayer | null; g: Graphics | null }[] = [];\n\nexport function beginBatch(g: Graphics): void {\n  outer.push({ batch, direct, g: batchG });\n  if (g instanceof PixelLayer) {\n    batch = null;\n    direct = g;\n  } else {\n    batch = new Map();\n    direct = null;\n  }\n  batchG = g;\n}\n\nexport function endBatch(): void {\n  flushBatch();\n  const was = outer.pop();\n  batch = was?.batch ?? null;\n  direct = was?.direct ?? null;\n  batchG = was?.g ?? null;\n}\n\n/**\n * Where a solid pixel painted on `g` goes while its batch is open: the layer's staging, the batch's map, or nowhere\n * (paint it now). `stagePixel` writes into whichever it is.\n */\nexport function batchFor(g: Graphics): Map<number, number> | PixelLayer | null {\n  if (batchG === null || g !== batchG) return null;\n  return direct ?? batch;\n}\n\n/** Writes a solid run of `w` pixels at (x, y) into what `batchFor` returned. */\nexport function stageRun(held: Map<number, number> | PixelLayer, x: number, y: number, w: number, color: number): void {\n  if (held instanceof PixelLayer) {\n    held.stage(x, y, w, color);\n    return;\n  }\n  for (let i = 0; i < w; i++) held.set(key(x + i, y), color);\n}\n\n/** Lays what the batch holds now, so a translucent fill that follows lies over it. */\nexport function flushBatch(): void {\n  if (direct) {\n    direct.commit();\n    return;\n  }\n  if (!batch || !batchG || batch.size === 0) return;\n  const held = batch;\n  batch = new Map();\n  layRuns(batchG, held);\n}\n\nfunction layRuns(g: Graphics, pixels: Map<number, number>): void {\n  if (g instanceof PixelLayer) {\n    // the layer lays its own runs; nothing between here and its commit is drawn\n    for (const [k, c] of pixels) g.stage((k >>> 16) - 32768, (k & 0xffff) - 32768, 1, c);\n    g.commit();\n    return;\n  }\n  const keys = [...pixels.keys()].sort((a, b) => (a & 0xffff) - (b & 0xffff) || (a >>> 16) - (b >>> 16));\n  let runX = 0;\n  let runY = 0;\n  let runW = 0;\n  let runC = -1;\n  for (const k of keys) {\n    const x = (k >>> 16) - 32768;\n    const y = (k & 0xffff) - 32768;\n    const c = pixels.get(k)!;\n    if (runW > 0 && y === runY && x === runX + runW && c === runC) {\n      runW++;\n      continue;\n    }\n    if (runW > 0) g.fillStyle(runC, 1).fillRect(runX, runY, runW, 1);\n    runX = x;\n    runY = y;\n    runW = 1;\n    runC = c;\n  }\n  if (runW > 0) g.fillStyle(runC, 1).fillRect(runX, runY, runW, 1);\n}\n\n/** The key `capturing()` and `fillRuns` file a world pixel under. */\nexport function pixelKey(x: number, y: number): number {\n  return key(x, y);\n}\n\nexport function record(x: number, y: number, color: number): void {\n  capture?.set(key(x, y), color);\n}\n\nconst BAYER = [0, 8, 2, 10, 12, 4, 14, 6, 3, 11, 1, 9, 15, 7, 13, 5];\n\n/** 1 draws every pixel, 0 none; set around each paint so every shape thins out together. */\nlet coverage = 1;\n\nexport function setCoverage(value: number): void {\n  coverage = value;\n}\n\n/** The current dither fade (1 while nothing fades), for translucent fills that fade with their layer. */\nexport function currentCoverage(): number {\n  return coverage;\n}\n\n/** Whether the world pixel at (x, y) is dropped by the current dither fade. */\nexport function dithered(x: number, y: number): boolean {\n  if (coverage >= 1) return false;\n  const cx = (Math.round(x) & 3) >>> 0;\n  const cy = (Math.round(y) & 3) >>> 0;\n  return BAYER[cy * 4 + cx]! / 16 >= coverage;\n}\n"],"names":["RAMPS","toHsl","c","r","g","b","max","min","l","d","s","fromHsl","h","hue","p","q","t","u","ch","drift","target","amount","HAND","registerHandRamps","ramps","entries","ramp","color","derivedRamp","cool","warm","GRADED","grade","out","lift","capture","key","x","y","capturing","RIM_STEPS","beginOutline","endOutline","outline","pixels","rim","k","i","n","ink","fillRuns","batchG","direct","batch","layRuns","outer","beginBatch","PixelLayer","endBatch","flushBatch","was","batchFor","stageRun","held","w","keys","a","runX","runY","runW","runC","pixelKey","record","BAYER","coverage","setCoverage","value","currentCoverage","dithered","cx","cy"],"mappings":"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"}

package/dist/pixel/propKit.js

@@ -0,0 +1,41 @@
+import { P as d } from "./palette.js";
+import { rgba as h } from "./pixel.js";
+import { outlineOf as p, hueShade as m } from "./ramp.js";
+function S(e, f, i) {
+  return { canvas: e.toCanvas(), anchorX: f, anchorY: i };
+}
+function b(e, f = d.outline) {
+  const { w: i, h: c } = e, a = new Uint8Array(i * c);
+  for (let t = 0; t < i * c; t++) a[t] = e.data[t] >>> 24 === 255 ? 1 : 0;
+  const r = (t, o) => t >= 0 && o >= 0 && t < i && o < c && a[o * i + t] === 1;
+  for (let t = 0; t < c; t++)
+    for (let o = 0; o < i; o++) {
+      if (a[t * i + o]) continue;
+      const n = r(o, t - 1), l = r(o - 1, t), s = r(o + 1, t), u = r(o, t + 1);
+      (n || l || s || u) && e.px(o, t, n || l ? f : p(e.get(s ? o + 1 : o, s ? t : t + 1)));
+    }
+}
+function v(e, f, i, c, a, r = w, t = M) {
+  for (let o = Math.floor(i - a); o <= Math.ceil(i + a); o++)
+    for (let n = Math.floor(f - c); n <= Math.ceil(f + c); n++) {
+      if (!e.inBounds(n, o) || e.alphaAt(n, o)) continue;
+      const l = (n + 0.5 - f) / c, s = (o + 0.5 - i) / a, u = l * l + s * s;
+      u <= 0.55 ? e.px(n, o, r) : u <= 1 && e.px(n, o, t);
+    }
+}
+const w = h(26, 22, 44, 78), M = h(26, 22, 44, 40);
+function B(e, f, i, c, a, r, t) {
+  for (let o = i; o < i + a; o++)
+    for (let n = f; n < f + c; n++) {
+      if (!e.inBounds(n, o)) continue;
+      const l = e.get(n, o);
+      !(l >>> 24) || t && !t(n, o) || e.px(n, o, m(l, r, "shadow"));
+    }
+}
+export {
+  S as art,
+  v as groundShadow,
+  b as litOutline,
+  B as shadeBox
+};
+//# sourceMappingURL=propKit.js.map

package/dist/pixel/propKit.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"propKit.js","sources":["../../src/pixel/propKit.ts"],"sourcesContent":["import { P } from './palette';\nimport { type Color, PixelGrid, rgba } from './pixel';\nimport { hueShade, outlineOf } from './ramp';\n\n/*\n * Pieces for painting map props (trees, rocks, buildings) in code. A prop is anchored at the bottom-centre of its tile\n * footprint: `anchorX/anchorY` are pixel coordinates inside its canvas.\n */\n\nexport interface PropArt {\n  canvas: HTMLCanvasElement;\n  anchorX: number;\n  anchorY: number;\n}\n\nexport function art(g: PixelGrid, anchorX: number, anchorY: number): PropArt {\n  return { canvas: g.toCanvas(), anchorX, anchorY };\n}\n\n/**\n * The selective outline a prop takes, lit from the upper left like the map: the same ring a plain outline lays, but\n * full dark only where the silhouette meets the ground (under it) and on its shadow side (the right); along the top\n * and the left it is the darkest tone of the fill it borders (`outlineOf`), so a lit edge reads as the thing's own\n * shade rather than a sticker's line. Translucent pixels (a cast\n * shadow on the ground) are not part of the silhouette.\n */\nexport function litOutline(g: PixelGrid, dark: Color = P.outline): void {\n  const { w, h } = g;\n  const on = new Uint8Array(w * h);\n  for (let i = 0; i < w * h; i++) on[i] = g.data[i]! >>> 24 === 255 ? 1 : 0;\n  const at = (x: number, y: number) => x >= 0 && y >= 0 && x < w && y < h && on[y * w + x] === 1;\n  for (let y = 0; y < h; y++)\n    for (let x = 0; x < w; x++) {\n      if (on[y * w + x]) continue;\n      const above = at(x, y - 1);\n      const left = at(x - 1, y);\n      const right = at(x + 1, y);\n      const below = at(x, y + 1);\n      if (!(above || left || right || below)) continue;\n      g.px(x, y, above || left ? dark : outlineOf(g.get(right ? x + 1 : x, right ? y : y + 1)));\n    }\n}\n\n/**\n * A soft shadow thrown down and to the right onto the ground, laid only on empty pixels (call it after `litOutline`,\n * or the outline would ring the shadow): a darker `core` and a fainter `rim`, by default a translucent violet.\n */\nexport function groundShadow(g: PixelGrid, cx: number, cy: number, rx: number, ry: number, core: Color = SHADOW_CORE, rim: Color = SHADOW_RIM): void {\n  for (let y = Math.floor(cy - ry); y <= Math.ceil(cy + ry); y++)\n    for (let x = Math.floor(cx - rx); x <= Math.ceil(cx + rx); x++) {\n      if (!g.inBounds(x, y) || g.alphaAt(x, y)) continue;\n      const dx = (x + 0.5 - cx) / rx;\n      const dy = (y + 0.5 - cy) / ry;\n      const d = dx * dx + dy * dy;\n      if (d <= 0.55) g.px(x, y, core);\n      else if (d <= 1) g.px(x, y, rim);\n    }\n}\n\nconst SHADOW_CORE = rgba(26, 22, 44, 78);\nconst SHADOW_RIM = rgba(26, 22, 44, 40);\n/*\n * ── Ramp-shaded pieces ──\n * `shadeBox` shades with hue-shifted ramps (`ramp.ts`) instead of `shade`; with `litOutline` above, a prop painted\n * with them looks like rig-drawn people standing next to it.\n */\n\n/**\n * Moves every opaque pixel of a box one step into shadow (or, with `f > 1`, into light) along its own hue: the eave's\n * shadow on a wall, the dark side of a chimney, a porch's shade. `mask` limits it to some pixels of the box.\n */\nexport function shadeBox(g: PixelGrid, x: number, y: number, w: number, h: number, f: number, mask?: (x: number, y: number) => boolean): void {\n  for (let yy = y; yy < y + h; yy++)\n    for (let xx = x; xx < x + w; xx++) {\n      if (!g.inBounds(xx, yy)) continue;\n      const c = g.get(xx, yy);\n      if (!(c >>> 24) || (mask && !mask(xx, yy))) continue;\n      g.px(xx, yy, hueShade(c, f, 'shadow'));\n    }\n}\n"],"names":["art","g","anchorX","anchorY","litOutline","dark","P","w","h","on","i","at","x","y","above","left","right","below","outlineOf","groundShadow","cx","cy","rx","ry","core","SHADOW_CORE","rim","SHADOW_RIM","dx","dy","d","rgba","shadeBox","f","mask","yy","xx","c","hueShade"],"mappings":";;;AAeO,SAASA,EAAIC,GAAcC,GAAiBC,GAA0B;AAC3E,SAAO,EAAE,QAAQF,EAAE,SAAA,GAAY,SAAAC,GAAS,SAAAC,EAAA;AAC1C;AASO,SAASC,EAAWH,GAAcI,IAAcC,EAAE,SAAe;AACtE,QAAM,EAAE,GAAAC,GAAG,GAAAC,EAAA,IAAMP,GACXQ,IAAK,IAAI,WAAWF,IAAIC,CAAC;AAC/B,WAASE,IAAI,GAAGA,IAAIH,IAAIC,GAAGE,IAAK,CAAAD,EAAGC,CAAC,IAAIT,EAAE,KAAKS,CAAC,MAAO,OAAO,MAAM,IAAI;AACxE,QAAMC,IAAK,CAACC,GAAWC,MAAcD,KAAK,KAAKC,KAAK,KAAKD,IAAIL,KAAKM,IAAIL,KAAKC,EAAGI,IAAIN,IAAIK,CAAC,MAAM;AAC7F,WAASC,IAAI,GAAGA,IAAIL,GAAGK;AACrB,aAASD,IAAI,GAAGA,IAAIL,GAAGK,KAAK;AAC1B,UAAIH,EAAGI,IAAIN,IAAIK,CAAC,EAAG;AACnB,YAAME,IAAQH,EAAGC,GAAGC,IAAI,CAAC,GACnBE,IAAOJ,EAAGC,IAAI,GAAGC,CAAC,GAClBG,IAAQL,EAAGC,IAAI,GAAGC,CAAC,GACnBI,IAAQN,EAAGC,GAAGC,IAAI,CAAC;AACzB,OAAMC,KAASC,KAAQC,KAASC,MAChChB,EAAE,GAAGW,GAAGC,GAAGC,KAASC,IAAOV,IAAOa,EAAUjB,EAAE,IAAIe,IAAQJ,IAAI,IAAIA,GAAGI,IAAQH,IAAIA,IAAI,CAAC,CAAC,CAAC;AAAA,IAC1F;AACJ;AAMO,SAASM,EAAalB,GAAcmB,GAAYC,GAAYC,GAAYC,GAAYC,IAAcC,GAAaC,IAAaC,GAAkB;AACnJ,WAASd,IAAI,KAAK,MAAMQ,IAAKE,CAAE,GAAGV,KAAK,KAAK,KAAKQ,IAAKE,CAAE,GAAGV;AACzD,aAASD,IAAI,KAAK,MAAMQ,IAAKE,CAAE,GAAGV,KAAK,KAAK,KAAKQ,IAAKE,CAAE,GAAGV,KAAK;AAC9D,UAAI,CAACX,EAAE,SAASW,GAAGC,CAAC,KAAKZ,EAAE,QAAQW,GAAGC,CAAC,EAAG;AAC1C,YAAMe,KAAMhB,IAAI,MAAMQ,KAAME,GACtBO,KAAMhB,IAAI,MAAMQ,KAAME,GACtBO,IAAIF,IAAKA,IAAKC,IAAKA;AACzB,MAAIC,KAAK,OAAM7B,EAAE,GAAGW,GAAGC,GAAGW,CAAI,IACrBM,KAAK,KAAG7B,EAAE,GAAGW,GAAGC,GAAGa,CAAG;AAAA,IACjC;AACJ;AAEA,MAAMD,IAAcM,EAAK,IAAI,IAAI,IAAI,EAAE,GACjCJ,IAAaI,EAAK,IAAI,IAAI,IAAI,EAAE;AAW/B,SAASC,EAAS/B,GAAcW,GAAWC,GAAWN,GAAWC,GAAWyB,GAAWC,GAAgD;AAC5I,WAASC,IAAKtB,GAAGsB,IAAKtB,IAAIL,GAAG2B;AAC3B,aAASC,IAAKxB,GAAGwB,IAAKxB,IAAIL,GAAG6B,KAAM;AACjC,UAAI,CAACnC,EAAE,SAASmC,GAAID,CAAE,EAAG;AACzB,YAAME,IAAIpC,EAAE,IAAImC,GAAID,CAAE;AACtB,MAAI,EAAEE,MAAM,OAAQH,KAAQ,CAACA,EAAKE,GAAID,CAAE,KACxClC,EAAE,GAAGmC,GAAID,GAAIG,EAASD,GAAGJ,GAAG,QAAQ,CAAC;AAAA,IACvC;AACJ;"}