1681-engine 0.0.0-stage → 0.5.8

package/dist/pixel/SwayProp.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"SwayProp.js","sources":["../../src/pixel/SwayProp.ts"],"sourcesContent":["import { Rectangle, Sprite, Texture, type TextureSource } from 'pixi.js';\nimport type { Image } from '../core/Image';\nimport { buildRig, gustAt, swayOffset, type Rect, type SwayDef, type SwayRig } from './swayRig';\n\n/** Sub-textures, one per (frame, rect), shared by every prop cut from the same source. */\nconst SLICES = new WeakMap<TextureSource, Map<string, Texture>>();\n\nfunction slice(frame: Texture, r: Rect): Texture {\n  let cache = SLICES.get(frame.source);\n  if (!cache) SLICES.set(frame.source, (cache = new Map()));\n  const f = frame.frame;\n  const k = `${f.x + r.x},${f.y + r.y},${r.w},${r.h}`;\n  let t = cache.get(k);\n  if (!t) cache.set(k, (t = new Texture({ source: frame.source, frame: new Rectangle(f.x + r.x, f.y + r.y, r.w, r.h) })));\n  return t;\n}\n\n/**\n * The opaque width of each row of a frame, read once off its canvas (a `crown` finds its trunk in them); undefined\n * when the source is not a 2D canvas. The atlas pages are canvases kept on the CPU, so this costs no GPU read-back.\n */\nexport function opaqueRowWidths(frame: Texture): number[] | undefined {\n  const canvas = frame.source.resource as HTMLCanvasElement | undefined;\n  const ctx = canvas?.getContext?.('2d');\n  if (!ctx) return undefined;\n  const { x, y, width: w, height: h } = frame.frame;\n  const data = ctx.getImageData(x, y, w, h).data;\n  const out: number[] = [];\n  for (let row = 0; row < h; row++) {\n    let l = -1;\n    let r = -1;\n    for (let col = 0; col < w; col++)\n      if (data[(row * w + col) * 4 + 3]! > 0) {\n        if (l < 0) l = col;\n        r = col;\n      }\n    out.push(l < 0 ? 0 : r - l + 1);\n  }\n  return out;\n}\n\nexport interface SwayPropOptions {\n  /** Which `tufts` list to read (default 0). */\n  variant?: number;\n  /** This prop's place in the cycle, 0..1 (`tileHash` of its tile keeps it from one visit to the next). */\n  phase?: number;\n  /** Its pace against the def's `speed` (default 1): a little apart per prop, so a wood never sways in step. */\n  pace?: number;\n  /** Row widths for a `crown` (default: read off the frame with `opaqueRowWidths`). */\n  rowWidths?: readonly number[];\n  /** A rig already built for this frame (props of one frame share one). */\n  rig?: SwayRig;\n}\n\nexport interface SwayWind {\n  /** 0 still … 1 a full wind. */\n  wind: number;\n  /** A gust's period (s) and wavelength across the world (px); see `gustAt`. */\n  gustSeconds: number;\n  gustPx: number;\n  /** The least reach while any wind blows (`swayOffset`). */\n  minReach?: number;\n}\n\n/**\n * One sprite swaying in the wind, in whole world pixels. The placed image becomes the rig's first (largest) still\n * piece — so whatever culls, fades or sorts it keeps working — and the other pieces and the strips are sprites beside\n * it in the same parent, at its depth, following its visibility and alpha. A strip's sprite is moved only when its\n * whole-pixel offset changes.\n */\nexport class SwayProp {\n  private readonly parts: Sprite[] = [];\n  private readonly strips: { sprite: Sprite; homeX: number; weight: number; lag: number; offset: number }[] = [];\n  private readonly phase: number;\n  private readonly speed: number;\n  private shown: boolean;\n  private alpha: number;\n  /** False when the frame is too small or the rig has nothing to move: `update` then does nothing. */\n  readonly active: boolean;\n\n  constructor(\n    private readonly img: Image,\n    private readonly def: SwayDef,\n    options: SwayPropOptions = {},\n  ) {\n    this.phase = options.phase ?? 0;\n    this.speed = def.speed * (options.pace ?? 1);\n    this.shown = img.visible;\n    this.alpha = img.alpha;\n    const frame = img.texture;\n    const w = frame.frame.width;\n    const h = frame.frame.height;\n    const parent = img.parent;\n    const rig =\n      options.rig ?? (w >= 2 && h >= 2 ? buildRig(def, w, h, def.mode === 'crown' ? (options.rowWidths ?? opaqueRowWidths(frame)) : undefined, options.variant ?? 0) : null);\n    this.active = !!rig && !!parent && rig.pieces.length > 0 && rig.strips.length > 0;\n    if (!this.active || !rig || !parent) return;\n    const ax = img.anchor.x * w;\n    const ay = img.anchor.y * h;\n    const left = Math.round(img.x - ax);\n    const top = Math.round(img.y - ay);\n    const [first, ...rest] = rig.pieces;\n    img.texture = slice(frame, first!);\n    img.anchor.set((ax - first!.x) / first!.w, (ay - first!.y) / first!.h);\n    const add = (r: Rect): Sprite => {\n      const s = new Sprite(slice(frame, r));\n      s.position.set(left + r.x, top + r.y);\n      s.zIndex = img.zIndex;\n      s.visible = img.visible;\n      s.alpha = img.alpha;\n      parent.addChild(s);\n      this.parts.push(s);\n      return s;\n    };\n    for (const r of rest) add(r);\n    for (const st of rig.strips) this.strips.push({ sprite: add(st.rect), homeX: left + st.rect.x, weight: st.weight, lag: st.lag, offset: 0 });\n  }\n\n  /** `tSec` seconds of any steady clock; `enabled` false stands everything still (an ambient-effects setting). */\n  update(tSec: number, air: SwayWind, enabled = true): void {\n    if (!this.active) return;\n    const shown = this.img.visible;\n    if (shown !== this.shown) {\n      this.shown = shown;\n      for (const p of this.parts) p.visible = shown;\n    }\n    if (!shown) return;\n    if (this.img.alpha !== this.alpha) {\n      this.alpha = this.img.alpha;\n      for (const p of this.parts) p.alpha = this.alpha;\n    }\n    const still = !enabled || air.wind <= 0;\n    const gust = still ? 0 : gustAt(tSec, this.img.x, air.gustSeconds, air.gustPx);\n    for (const st of this.strips) {\n      const off = still ? 0 : swayOffset(tSec, this.speed, this.phase, st.lag, this.def.amp, air.wind, gust, st.weight, air.minReach ?? 0);\n      if (off === st.offset) continue;\n      st.offset = off;\n      st.sprite.x = st.homeX + off;\n    }\n  }\n\n  destroy(): void {\n    for (const p of this.parts) p.destroy();\n    this.parts.length = 0;\n    this.strips.length = 0;\n  }\n}\n"],"names":["SLICES","slice","frame","r","cache","f","k","t","Texture","Rectangle","opaqueRowWidths","ctx","x","y","w","h","data","out","row","l","col","SwayProp","img","def","options","parent","rig","buildRig","ax","ay","left","top","first","rest","add","s","Sprite","st","tSec","air","enabled","shown","p","still","gust","gustAt","off","swayOffset"],"mappings":"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"}

package/dist/pixel/lights.js

@@ -0,0 +1,44 @@
+import { engineSettings as l } from "../settings.js";
+const s = 16773320, i = [], c = 48;
+function g(n, o, t, e, f = s, r = performance.now()) {
+  i.length >= c && i.shift(), i.push({ x: n, y: o, r: t, born: r, until: r + e, fades: !0, color: f });
+}
+const u = 2e4;
+function p(n, o, t = s, e = performance.now()) {
+  const f = n(), r = { x: f.x, y: f.y, r: o, born: e, until: e + u, follow: n, fades: !1, color: t };
+  return i.length >= c && i.shift(), i.push(r), { end: () => r.until = 0 };
+}
+const h = [];
+function d(n) {
+  for (let t = i.length - 1; t >= 0; t--) i[t].until <= n && i.splice(t, 1);
+  const o = l.getState();
+  if (o.combatLights === !1 || o.batterySaver) return h;
+  for (const t of i) {
+    if (!t.follow) continue;
+    let e;
+    try {
+      e = t.follow();
+    } catch {
+      t.until = 0, t.follow = void 0;
+      continue;
+    }
+    t.x = e.x, t.y = e.y;
+  }
+  return i;
+}
+function m(n, o) {
+  if (!n.fades) return n.r;
+  const t = Math.min(1, (o - n.born) / Math.max(1, n.until - n.born));
+  return n.r * Math.sqrt(1 - t);
+}
+function L() {
+  i.length = 0;
+}
+export {
+  p as carriedLight,
+  L as clearLights,
+  g as flashLight,
+  m as lightRadius,
+  d as liveLights
+};
+//# sourceMappingURL=lights.js.map

package/dist/pixel/lights.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"lights.js","sources":["../../src/pixel/lights.ts"],"sourcesContent":["/*\n * Short-lived light: what a fight throws into the dark — a fireball or a bolt in flight, a blast,\n * a blow landing. The map's own darkness (`Darkness`: the underground, a cave, the outdoor night) cuts each\n * one out of its sheet like a lamp, so a spell lights the corridor it flies down. Looks only, client-only; one list\n * for the whole client, since only one map is ever drawn. `engineSettings.combatLights` turns them off, and so does\n * `engineSettings.batterySaver`: the list still keeps time, but nothing reads it, so the dark stays as the map's lamps leave it.\n */\n\nimport { engineSettings } from '../settings';\n\nexport interface TransientLight {\n  x: number;\n  y: number;\n  /** Radius at its brightest, world px. */\n  r: number;\n  born: number;\n  /** When it is gone; a carried light's is pushed to `CARRIED_MAX_MS` and brought in by its `end()`. */\n  until: number;\n  /** A light riding a moving thing reads its place every frame. */\n  follow?: () => { x: number; y: number };\n  /** A flash shrinks as it goes out; a carried light keeps its size. */\n  fades: boolean;\n  /** The colour it lays on what it lights: a fireball's orange, a spell's violet, a blade's white. */\n  color: number;\n}\n\n/** A light nobody named a colour for: the pale gold of a spark. */\nconst SPARK = 0xfff0c8;\n\nconst LIGHTS: TransientLight[] = [];\n/** More than this at once adds nothing a player can see, and each is a sprite in the night's redraw. */\nconst MAX_LIGHTS = 48;\n\n/** A flash at (x, y) in `color`: `r` px at once, shrinking to nothing over `ms`. */\nexport function flashLight(x: number, y: number, r: number, ms: number, color = SPARK, now = performance.now()): void {\n  if (LIGHTS.length >= MAX_LIGHTS) LIGHTS.shift();\n  LIGHTS.push({ x, y, r, born: now, until: now + ms, fades: true, color });\n}\n\n/** The longest a carried light burns when nothing ends it: no shot flies, nor any spell is held, that long. */\nconst CARRIED_MAX_MS = 20_000;\n\n/** A light that rides `at` until `end()` is called (a shot in flight), and never past `CARRIED_MAX_MS`. */\nexport function carriedLight(at: () => { x: number; y: number }, r: number, color = SPARK, now = performance.now()): { end: () => void } {\n  const p = at();\n  const light: TransientLight = { x: p.x, y: p.y, r, born: now, until: now + CARRIED_MAX_MS, follow: at, fades: false, color };\n  if (LIGHTS.length >= MAX_LIGHTS) LIGHTS.shift();\n  LIGHTS.push(light);\n  return { end: () => (light.until = 0) };\n}\n\nconst NONE: readonly TransientLight[] = [];\n\n/** The lights burning at `now`, each with its radius then; spent ones are dropped. None while combat lights are off. */\nexport function liveLights(now: number): readonly TransientLight[] {\n  for (let i = LIGHTS.length - 1; i >= 0; i--) if (LIGHTS[i]!.until <= now) LIGHTS.splice(i, 1);\n  const settings = engineSettings.getState();\n  // the battery saver puts the transient lights out too: each one redraws the night\n  if (settings.combatLights === false || settings.batterySaver) return NONE;\n  for (const l of LIGHTS) {\n    if (!l.follow) continue;\n    // a light whose rider has gone is put out, never left to throw in every frame's night\n    let p: { x: number; y: number };\n    try {\n      p = l.follow();\n    } catch {\n      l.until = 0;\n      l.follow = undefined;\n      continue;\n    }\n    l.x = p.x;\n    l.y = p.y;\n  }\n  return LIGHTS;\n}\n\n/** The radius `l` burns at `now`: a flash eases out from its full size, a carried light holds it. */\nexport function lightRadius(l: TransientLight, now: number): number {\n  if (!l.fades) return l.r;\n  const t = Math.min(1, (now - l.born) / Math.max(1, l.until - l.born));\n  return l.r * Math.sqrt(1 - t);\n}\n\n/** A new map: nothing of the last one's fight is left burning. */\nexport function clearLights(): void {\n  LIGHTS.length = 0;\n}\n"],"names":["SPARK","LIGHTS","MAX_LIGHTS","flashLight","x","y","r","ms","color","now","CARRIED_MAX_MS","carriedLight","at","p","light","NONE","liveLights","i","settings","engineSettings","l","lightRadius","clearLights"],"mappings":";AA2BA,MAAMA,IAAQ,UAERC,IAA2B,CAAA,GAE3BC,IAAa;AAGZ,SAASC,EAAWC,GAAWC,GAAWC,GAAWC,GAAYC,IAAQR,GAAOS,IAAM,YAAY,OAAa;AACpH,EAAIR,EAAO,UAAUC,KAAYD,EAAO,MAAA,GACxCA,EAAO,KAAK,EAAE,GAAAG,GAAG,GAAAC,GAAG,GAAAC,GAAG,MAAMG,GAAK,OAAOA,IAAMF,GAAI,OAAO,IAAM,OAAAC,GAAO;AACzE;AAGA,MAAME,IAAiB;AAGhB,SAASC,EAAaC,GAAoCN,GAAWE,IAAQR,GAAOS,IAAM,YAAY,OAA4B;AACvI,QAAMI,IAAID,EAAA,GACJE,IAAwB,EAAE,GAAGD,EAAE,GAAG,GAAGA,EAAE,GAAG,GAAAP,GAAG,MAAMG,GAAK,OAAOA,IAAMC,GAAgB,QAAQE,GAAI,OAAO,IAAO,OAAAJ,EAAA;AACrH,SAAIP,EAAO,UAAUC,KAAYD,EAAO,MAAA,GACxCA,EAAO,KAAKa,CAAK,GACV,EAAE,KAAK,MAAOA,EAAM,QAAQ,EAAA;AACrC;AAEA,MAAMC,IAAkC,CAAA;AAGjC,SAASC,EAAWP,GAAwC;AACjE,WAASQ,IAAIhB,EAAO,SAAS,GAAGgB,KAAK,GAAGA,IAAK,CAAIhB,EAAOgB,CAAC,EAAG,SAASR,KAAKR,EAAO,OAAOgB,GAAG,CAAC;AAC5F,QAAMC,IAAWC,EAAe,SAAA;AAEhC,MAAID,EAAS,iBAAiB,MAASA,EAAS,aAAc,QAAOH;AACrE,aAAWK,KAAKnB,GAAQ;AACtB,QAAI,CAACmB,EAAE,OAAQ;AAEf,QAAIP;AACJ,QAAI;AACF,MAAAA,IAAIO,EAAE,OAAA;AAAA,IACR,QAAQ;AACN,MAAAA,EAAE,QAAQ,GACVA,EAAE,SAAS;AACX;AAAA,IACF;AACA,IAAAA,EAAE,IAAIP,EAAE,GACRO,EAAE,IAAIP,EAAE;AAAA,EACV;AACA,SAAOZ;AACT;AAGO,SAASoB,EAAYD,GAAmBX,GAAqB;AAClE,MAAI,CAACW,EAAE,MAAO,QAAOA,EAAE;AACvB,QAAM,IAAI,KAAK,IAAI,IAAIX,IAAMW,EAAE,QAAQ,KAAK,IAAI,GAAGA,EAAE,QAAQA,EAAE,IAAI,CAAC;AACpE,SAAOA,EAAE,IAAI,KAAK,KAAK,IAAI,CAAC;AAC9B;AAGO,SAASE,IAAoB;AAClC,EAAArB,EAAO,SAAS;AAClB;"}

package/dist/pixel/nineSlice.js

@@ -0,0 +1,62 @@
+import { CLEAR as $, channels as m, PixelGrid as p, hex as d } from "./pixel.js";
+const v = {
+  /** A window: ink, a two-step brass rim, a gap, a lit bevel, a rivet in the corner. */
+  panel: ["..KKKKKK", ".KHHHHHH", "KHHMMMMM", "KHMKGGGG", "KHMGRSSS", "KHMGSFFF", "KHMGSFFF", "KHMGSFFF"],
+  /** A raised button: a two-step bevel, notched. Give it shadow [0, 1]; pressed, offset [0, 1] with the bevel's colours swapped. */
+  button: [".KKKK", "KHHHH", "KHMMM", "KHMFF", "KHMFF"],
+  /** A small raised button. */
+  smallButton: [".KKK", "KHHH", "KHMM", "KHMF"],
+  /** A text field: a hole in the stone, its lip in shadow top-left (D, G) and lit bottom-right (d, g). */
+  field: [".KKKK", "KDDDD", "KDGGG", "KDGFF", "KDGFF"],
+  /** A sunk well (slots, bars' tracks). */
+  well: [".KK", "KDD", "KDF"],
+  /** A list row: a flat slab lit on the top and left. */
+  row: [".KK", "KSS", "KSF"],
+  /** A thin frame: one pixel of rim (toasts, a cast bar). */
+  thin: [".KK", "KHH", "KHF"]
+}, u = { H: "L", S: "s", M: "m", D: "d", G: "g" }, G = (t) => typeof t == "string" ? d(t) : t;
+function x(t, K, l, s, H) {
+  const o = t.length, e = o * 2 + 1, i = s > o, r = H > o, M = i ? e - 1 - s : s, F = r ? e - 1 - H : H, w = t[Math.min(F, o - 1)][Math.min(M, o - 1)] ?? ".", h = M >= F, S = i && !h || r && h || i && r, n = l[w];
+  return S && n && K[n] !== void 0 ? n : w;
+}
+function y(t) {
+  const { corner: K, palette: l } = t, s = K.length;
+  if (!s || K.some((n) => n.length !== s)) throw new Error("nineSlice: the corner must be square");
+  const H = t.twins ?? u, o = s * 2 + 1, [e, i] = t.shadow ?? [0, 0], [r, M] = t.offset ?? [0, 0], [F, w] = t.pad ?? [e, i], h = new p(o + F, o + w), S = t.shadowColor ?? l.Z ?? 2348810240;
+  if (e || i) {
+    const n = G(S);
+    for (let c = 0; c < o; c++) for (let f = 0; f < o; f++) x(K, l, H, f, c) !== "." && h.px(f + e, c + i, n);
+  }
+  for (let n = 0; n < o; n++)
+    for (let c = 0; c < o; c++) {
+      const f = t.overlay?.[n]?.[c], a = f && f !== "." ? f : x(K, l, H, c, n), g = l[a];
+      a !== "." && g !== void 0 && h.px(c + r, n + M, G(g));
+    }
+  return { grid: h, insets: { top: s, left: s, right: s + F, bottom: s + w } };
+}
+function E(t, K = 2) {
+  const l = [];
+  for (let o = 0; o < t.h; o++) {
+    let e = 0;
+    for (; e < t.w; ) {
+      const i = t.get(e, o);
+      let r = e + 1;
+      for (; r < t.w && t.get(r, o) === i; ) r++;
+      if (i !== $ && i >>> 24 > 0) {
+        const [M, F, w, h] = m(i), S = `#${(M << 16 | F << 8 | w).toString(16).padStart(6, "0")}`, n = h < 255 ? ` fill-opacity="${+(h / 255).toFixed(3)}"` : "";
+        l.push(`<rect x="${e * K}" y="${o * K}" width="${(r - e) * K}" height="${K}" fill="${S}"${n}/>`);
+      }
+      e = r;
+    }
+  }
+  const s = t.w * K, H = t.h * K;
+  return `<svg xmlns="http://www.w3.org/2000/svg" width="${s}" height="${H}" viewBox="0 0 ${s} ${H}" shape-rendering="crispEdges">${l.join("")}</svg>
+`;
+}
+export {
+  v as FRAME_CORNERS,
+  u as FRAME_TWINS,
+  E as frameSvg,
+  y as nineSlice
+};
+//# sourceMappingURL=nineSlice.js.map

package/dist/pixel/nineSlice.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"nineSlice.js","sources":["../../src/pixel/nineSlice.ts"],"sourcesContent":["import { CLEAR, PixelGrid, channels, hex, type Color } from './pixel';\n\n/**\n * Pixel-art 9-slice frames for a UI (windows, buttons, fields, wells), built from one drawn corner so the edge is\n * whole pixels instead of CSS gradients and blurred shadows. The corner is ASCII, one letter a role; the other three\n * corners are its mirrors, and on the far side (right and bottom) each role takes its **twin** — a raised frame's lit\n * rim (H) becomes its dark rim (L), a sunk field's shadowed lip (D) its lit one (d) — so light comes from the up-left\n * without drawing four corners. A hard shadow (the frame's own silhouette, shifted) can lie under it.\n *\n * ```ts\n * const frame = nineSlice({ corner: FRAME_CORNERS.panel, palette: { K: '#0b1018', H: '#c9a869', L: '#4a3a24',\n *   M: '#8b6e45', G: '#121820', S: '#3c434b', s: '#161b22', F: '#1d242e', R: '#ffe2a0' }, shadow: [2, 2] });\n * frame.grid.toCanvas();              // a canvas for a Pixi NineSliceSprite, with frame.insets\n * frameSvg(frame.grid, 2);            // or an SVG for a CSS border-image, sliced at insets × 2\n * ```\n */\n\n/** Ready corners in the roles the default twins know: K ink, H/L lit/dark rim, M/m rim, G/g gap, S/s bevel, F fill, D/d lip, R rivet. */\nexport const FRAME_CORNERS = {\n  /** A window: ink, a two-step brass rim, a gap, a lit bevel, a rivet in the corner. */\n  panel: ['..KKKKKK', '.KHHHHHH', 'KHHMMMMM', 'KHMKGGGG', 'KHMGRSSS', 'KHMGSFFF', 'KHMGSFFF', 'KHMGSFFF'],\n  /** A raised button: a two-step bevel, notched. Give it shadow [0, 1]; pressed, offset [0, 1] with the bevel's colours swapped. */\n  button: ['.KKKK', 'KHHHH', 'KHMMM', 'KHMFF', 'KHMFF'],\n  /** A small raised button. */\n  smallButton: ['.KKK', 'KHHH', 'KHMM', 'KHMF'],\n  /** A text field: a hole in the stone, its lip in shadow top-left (D, G) and lit bottom-right (d, g). */\n  field: ['.KKKK', 'KDDDD', 'KDGGG', 'KDGFF', 'KDGFF'],\n  /** A sunk well (slots, bars' tracks). */\n  well: ['.KK', 'KDD', 'KDF'],\n  /** A list row: a flat slab lit on the top and left. */\n  row: ['.KK', 'KSS', 'KSF'],\n  /** A thin frame: one pixel of rim (toasts, a cast bar). */\n  thin: ['.KK', 'KHH', 'KHF'],\n} as const satisfies Record<string, readonly string[]>;\n\n/** The role each letter takes on the far side; a palette without the twin keeps the letter. */\nexport const FRAME_TWINS: Readonly<Record<string, string>> = { H: 'L', S: 's', M: 'm', D: 'd', G: 'g' };\n\nexport interface NineSliceSpec {\n  /** The top-left corner, square, one letter a role; '.' is nothing. */\n  corner: readonly string[];\n  /** A colour per letter: a packed `Color` or a CSS hex (`#rgb`, `#rrggbb`, `#rrggbbaa` for see-through fills). */\n  palette: Readonly<Record<string, Color | string>>;\n  /** Near-side letter → far-side letter (default `FRAME_TWINS`). */\n  twins?: Readonly<Record<string, string>>;\n  /** The hard shadow's offset in art pixels (default none). */\n  shadow?: readonly [number, number];\n  /** The shadow's colour (default palette `Z`, else black at 55%). */\n  shadowColor?: Color | string;\n  /** Moves the frame inside its canvas (a pressed button sits one pixel lower where its shadow was). */\n  offset?: readonly [number, number];\n  /** Room right and below for the shadow or the offset (default: the shadow). */\n  pad?: readonly [number, number];\n  /** Rows painted over the frame, the frame's full size ('.' leaves it): a tick in a checkbox. */\n  overlay?: readonly string[];\n}\n\n/** How far in from each side the corners reach: the frame's slice lines, in art pixels. */\nexport interface SliceInsets {\n  top: number;\n  right: number;\n  bottom: number;\n  left: number;\n}\n\nexport interface NineSlice {\n  grid: PixelGrid;\n  insets: SliceInsets;\n}\n\nconst toColor = (c: Color | string): Color => (typeof c === 'string' ? hex(c) : c);\n\n/** The frame's letter at (x, y) of the n×n square mirrored out of `corner`, '.' outside it. */\nfunction roleAt(corner: readonly string[], palette: NineSliceSpec['palette'], twins: Readonly<Record<string, string>>, x: number, y: number): string {\n  const c = corner.length;\n  const n = c * 2 + 1;\n  const right = x > c;\n  const bottom = y > c;\n  const cx = right ? n - 1 - x : x;\n  const cy = bottom ? n - 1 - y : y;\n  const r = corner[Math.min(cy, c - 1)]![Math.min(cx, c - 1)] ?? '.';\n  // which edge the cell belongs to in the corner's own coordinates: above the diagonal the top (or bottom) edge\n  const onHorizontal = cx >= cy;\n  const far = (right && !onHorizontal) || (bottom && onHorizontal) || (right && bottom);\n  const twin = twins[r];\n  return far && twin && palette[twin] !== undefined ? twin : r;\n}\n\n/** Builds the frame: a `(2c + 1 + pad)` square-ish grid and its slice insets. */\nexport function nineSlice(spec: NineSliceSpec): NineSlice {\n  const { corner, palette } = spec;\n  const c = corner.length;\n  if (!c || corner.some((row) => row.length !== c)) throw new Error('nineSlice: the corner must be square');\n  const twins = spec.twins ?? FRAME_TWINS;\n  const n = c * 2 + 1;\n  const [sx, sy] = spec.shadow ?? [0, 0];\n  const [ox, oy] = spec.offset ?? [0, 0];\n  const [px, py] = spec.pad ?? [sx, sy];\n  const grid = new PixelGrid(n + px, n + py);\n  const shade = spec.shadowColor ?? palette.Z ?? 0x8c000000;\n  if (sx || sy) {\n    const z = toColor(shade);\n    for (let y = 0; y < n; y++) for (let x = 0; x < n; x++) if (roleAt(corner, palette, twins, x, y) !== '.') grid.px(x + sx, y + sy, z);\n  }\n  for (let y = 0; y < n; y++)\n    for (let x = 0; x < n; x++) {\n      const over = spec.overlay?.[y]?.[x];\n      const r = over && over !== '.' ? over : roleAt(corner, palette, twins, x, y);\n      const col = palette[r];\n      if (r !== '.' && col !== undefined) grid.px(x + ox, y + oy, toColor(col));\n    }\n  return { grid, insets: { top: c, left: c, right: c + px, bottom: c + py } };\n}\n\n/**\n * Any pixel grid as an SVG of `scale`-sized squares (`shape-rendering=\"crispEdges\"`), runs of one colour on a row\n * merged into one rect: what a CSS `border-image` takes, sliced at the insets × `scale`.\n */\nexport function frameSvg(grid: PixelGrid, scale = 2): string {\n  const rects: string[] = [];\n  for (let y = 0; y < grid.h; y++) {\n    let x = 0;\n    while (x < grid.w) {\n      const c = grid.get(x, y);\n      let end = x + 1;\n      while (end < grid.w && grid.get(end, y) === c) end++;\n      if (c !== CLEAR && c >>> 24 > 0) {\n        const [r, g, b, a] = channels(c);\n        const fill = `#${((r << 16) | (g << 8) | b).toString(16).padStart(6, '0')}`;\n        const op = a < 255 ? ` fill-opacity=\"${+(a / 255).toFixed(3)}\"` : '';\n        rects.push(`<rect x=\"${x * scale}\" y=\"${y * scale}\" width=\"${(end - x) * scale}\" height=\"${scale}\" fill=\"${fill}\"${op}/>`);\n      }\n      x = end;\n    }\n  }\n  const w = grid.w * scale;\n  const h = grid.h * scale;\n  return `<svg xmlns=\"http://www.w3.org/2000/svg\" width=\"${w}\" height=\"${h}\" viewBox=\"0 0 ${w} ${h}\" shape-rendering=\"crispEdges\">${rects.join('')}</svg>\\n`;\n}\n"],"names":["FRAME_CORNERS","FRAME_TWINS","toColor","c","hex","roleAt","corner","palette","twins","x","y","n","right","bottom","cx","cy","r","onHorizontal","far","twin","nineSlice","spec","row","sx","sy","ox","oy","px","py","grid","PixelGrid","shade","z","over","col","frameSvg","scale","rects","end","CLEAR","g","b","a","channels","fill","op","w","h"],"mappings":";AAkBO,MAAMA,IAAgB;AAAA;AAAA,EAE3B,OAAO,CAAC,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,UAAU;AAAA;AAAA,EAEtG,QAAQ,CAAC,SAAS,SAAS,SAAS,SAAS,OAAO;AAAA;AAAA,EAEpD,aAAa,CAAC,QAAQ,QAAQ,QAAQ,MAAM;AAAA;AAAA,EAE5C,OAAO,CAAC,SAAS,SAAS,SAAS,SAAS,OAAO;AAAA;AAAA,EAEnD,MAAM,CAAC,OAAO,OAAO,KAAK;AAAA;AAAA,EAE1B,KAAK,CAAC,OAAO,OAAO,KAAK;AAAA;AAAA,EAEzB,MAAM,CAAC,OAAO,OAAO,KAAK;AAC5B,GAGaC,IAAgD,EAAE,GAAG,KAAK,GAAG,KAAK,GAAG,KAAK,GAAG,KAAK,GAAG,IAAA,GAkC5FC,IAAU,CAACC,MAA8B,OAAOA,KAAM,WAAWC,EAAID,CAAC,IAAIA;AAGhF,SAASE,EAAOC,GAA2BC,GAAmCC,GAAyCC,GAAWC,GAAmB;AACnJ,QAAMP,IAAIG,EAAO,QACXK,IAAIR,IAAI,IAAI,GACZS,IAAQH,IAAIN,GACZU,IAASH,IAAIP,GACbW,IAAKF,IAAQD,IAAI,IAAIF,IAAIA,GACzBM,IAAKF,IAASF,IAAI,IAAID,IAAIA,GAC1BM,IAAIV,EAAO,KAAK,IAAIS,GAAIZ,IAAI,CAAC,CAAC,EAAG,KAAK,IAAIW,GAAIX,IAAI,CAAC,CAAC,KAAK,KAEzDc,IAAeH,KAAMC,GACrBG,IAAON,KAAS,CAACK,KAAkBJ,KAAUI,KAAkBL,KAASC,GACxEM,IAAOX,EAAMQ,CAAC;AACpB,SAAOE,KAAOC,KAAQZ,EAAQY,CAAI,MAAM,SAAYA,IAAOH;AAC7D;AAGO,SAASI,EAAUC,GAAgC;AACxD,QAAM,EAAE,QAAAf,GAAQ,SAAAC,EAAA,IAAYc,GACtBlB,IAAIG,EAAO;AACjB,MAAI,CAACH,KAAKG,EAAO,KAAK,CAACgB,MAAQA,EAAI,WAAWnB,CAAC,EAAG,OAAM,IAAI,MAAM,sCAAsC;AACxG,QAAMK,IAAQa,EAAK,SAASpB,GACtBU,IAAIR,IAAI,IAAI,GACZ,CAACoB,GAAIC,CAAE,IAAIH,EAAK,UAAU,CAAC,GAAG,CAAC,GAC/B,CAACI,GAAIC,CAAE,IAAIL,EAAK,UAAU,CAAC,GAAG,CAAC,GAC/B,CAACM,GAAIC,CAAE,IAAIP,EAAK,OAAO,CAACE,GAAIC,CAAE,GAC9BK,IAAO,IAAIC,EAAUnB,IAAIgB,GAAIhB,IAAIiB,CAAE,GACnCG,IAAQV,EAAK,eAAed,EAAQ,KAAK;AAC/C,MAAIgB,KAAMC,GAAI;AACZ,UAAMQ,IAAI9B,EAAQ6B,CAAK;AACvB,aAASrB,IAAI,GAAGA,IAAIC,GAAGD,IAAK,UAASD,IAAI,GAAGA,IAAIE,GAAGF,IAAK,CAAIJ,EAAOC,GAAQC,GAASC,GAAOC,GAAGC,CAAC,MAAM,OAAKmB,EAAK,GAAGpB,IAAIc,GAAIb,IAAIc,GAAIQ,CAAC;AAAA,EACrI;AACA,WAAStB,IAAI,GAAGA,IAAIC,GAAGD;AACrB,aAASD,IAAI,GAAGA,IAAIE,GAAGF,KAAK;AAC1B,YAAMwB,IAAOZ,EAAK,UAAUX,CAAC,IAAID,CAAC,GAC5BO,IAAIiB,KAAQA,MAAS,MAAMA,IAAO5B,EAAOC,GAAQC,GAASC,GAAOC,GAAGC,CAAC,GACrEwB,IAAM3B,EAAQS,CAAC;AACrB,MAAIA,MAAM,OAAOkB,MAAQ,UAAWL,EAAK,GAAGpB,IAAIgB,GAAIf,IAAIgB,GAAIxB,EAAQgC,CAAG,CAAC;AAAA,IAC1E;AACF,SAAO,EAAE,MAAAL,GAAM,QAAQ,EAAE,KAAK1B,GAAG,MAAMA,GAAG,OAAOA,IAAIwB,GAAI,QAAQxB,IAAIyB,IAAG;AAC1E;AAMO,SAASO,EAASN,GAAiBO,IAAQ,GAAW;AAC3D,QAAMC,IAAkB,CAAA;AACxB,WAAS3B,IAAI,GAAGA,IAAImB,EAAK,GAAGnB,KAAK;AAC/B,QAAID,IAAI;AACR,WAAOA,IAAIoB,EAAK,KAAG;AACjB,YAAM1B,IAAI0B,EAAK,IAAIpB,GAAGC,CAAC;AACvB,UAAI4B,IAAM7B,IAAI;AACd,aAAO6B,IAAMT,EAAK,KAAKA,EAAK,IAAIS,GAAK5B,CAAC,MAAMP,IAAG,CAAAmC;AAC/C,UAAInC,MAAMoC,KAASpC,MAAM,KAAK,GAAG;AAC/B,cAAM,CAACa,GAAGwB,GAAGC,GAAGC,CAAC,IAAIC,EAASxC,CAAC,GACzByC,IAAO,KAAM5B,KAAK,KAAOwB,KAAK,IAAKC,GAAG,SAAS,EAAE,EAAE,SAAS,GAAG,GAAG,CAAC,IACnEI,IAAKH,IAAI,MAAM,kBAAkB,EAAEA,IAAI,KAAK,QAAQ,CAAC,CAAC,MAAM;AAClE,QAAAL,EAAM,KAAK,YAAY5B,IAAI2B,CAAK,QAAQ1B,IAAI0B,CAAK,aAAaE,IAAM7B,KAAK2B,CAAK,aAAaA,CAAK,WAAWQ,CAAI,IAAIC,CAAE,IAAI;AAAA,MAC3H;AACA,MAAApC,IAAI6B;AAAA,IACN;AAAA,EACF;AACA,QAAMQ,IAAIjB,EAAK,IAAIO,GACbW,IAAIlB,EAAK,IAAIO;AACnB,SAAO,kDAAkDU,CAAC,aAAaC,CAAC,kBAAkBD,CAAC,IAAIC,CAAC,kCAAkCV,EAAM,KAAK,EAAE,CAAC;AAAA;AAClJ;"}

package/dist/pixel/paintLayer.js

@@ -0,0 +1,36 @@
+import { inView as C } from "../fx/viewCull.js";
+import { addPixelLayer as w } from "./PixelLayer.js";
+import { setCoverage as M, beginBatch as R, endBatch as U } from "./pixelTone.js";
+const _ = 64, b = 192;
+function O(o, a) {
+  const { at: v, duration: n, paint: x, alive: f } = a, s = a.depth ?? ((t) => t + 45), h = 1e3 / (a.fps ?? 12), l = a.every ?? 1, c = Math.min(a.fadeMs ?? 260, n * 0.3), e = w(o);
+  a.onCreate?.(e);
+  const y = { elapsed: 0 };
+  let i = -1, p = b;
+  const d = o.cameras.main, u = () => {
+    if (f && !f()) {
+      e.destroy();
+      return;
+    }
+    const t = v();
+    e.setPosition(d.snap(t.x), d.snap(t.y)).setDepth(typeof s == "number" ? s : s(t.y));
+    let r = Math.floor(y.elapsed / h);
+    if (l > 1 && (r -= r % l), r === i || i >= 0 && !C(d, t.x, t.y, _ + Math.max(p, e.reach()))) return;
+    i = r, e.clear();
+    const m = Math.min(n, r * h);
+    M(c > 0 && m > n - c ? Math.max(0, (n - m) / c) * 0.85 + 0.15 : 1), R(e);
+    try {
+      x(e, m);
+    } finally {
+      U(), M(1);
+    }
+    e.present(), p = Math.max(p, e.reach());
+  };
+  if (u(), !e.active) return e;
+  const L = o.tweens.add({ targets: y, elapsed: n, duration: n, onUpdate: u, onComplete: () => e.destroy() });
+  return e.once("destroyed", () => L.remove()), e;
+}
+export {
+  O as paintLayer
+};
+//# sourceMappingURL=paintLayer.js.map

package/dist/pixel/paintLayer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"paintLayer.js","sources":["../../src/pixel/paintLayer.ts"],"sourcesContent":["import type { Graphics } from '../core/Graphics';\nimport type { Stage } from '../core/Stage';\nimport { inView } from '../fx/viewCull';\nimport { addPixelLayer, type PixelLayer } from './PixelLayer';\nimport type { Point } from './pixelPaint';\nimport { beginBatch, endBatch, setCoverage } from './pixelTone';\n\nexport interface PaintLayerOptions {\n  /** Where the layer stands (world px), read every frame: a caster, a projectile, a fixed point. */\n  at: () => Point;\n  /** How long it plays (ms); its last `fadeMs` dither away instead of popping out. */\n  duration: number;\n  /** Paints one frame `ms` into the effect, in pixels relative to the anchor. */\n  paint: (g: Graphics, ms: number) => void;\n  /**\n   * Its draw order from the anchor's y (`y => y + 45` puts it in front of a body standing there, a negative offset\n   * behind it), or a fixed number (an effect lying on the ground under every body). Default `y + 45`.\n   */\n  depth?: number | ((y: number) => number);\n  /** Returning false removes the layer early (its caster gone, its trap sprung). */\n  alive?: () => boolean;\n  /** Frames a second it is redrawn at (default 12: hand-animated, like the sprites). */\n  fps?: number;\n  /** Paint only every that many frames (an effect thinned out for performance). Default 1. */\n  every?: number;\n  /** The longest fade at the end (ms); it is never more than 30% of the effect. Default 260. */\n  fadeMs?: number;\n  /** Told of the layer as it is made (a game that clears its transient effects on a map change keeps it). */\n  onCreate?: (g: PixelLayer) => void;\n}\n\n/** How far outside the screen a layer's anchor may stand and still be painted, beyond what it has reached so far. */\nconst CULL_MARGIN = 64;\n/**\n * The reach a layer is culled by is never less than this: an effect that grows (a ring, a blast) paints a small first\n * frame, and culled by that one it would never paint again as it swept onto the screen.\n */\nconst CULL_REACH_FLOOR = 192;\n\n/**\n * One effect as its own `PixelLayer`, redrawn at `fps` and shown as a single texture: it follows its anchor to the\n * screen pixel while the art inside stays on the world grid, thins out pixel by pixel over its last frames (ordered\n * dither, `setCoverage`), is neither painted nor uploaded while its anchor is off the screen by more than it has\n * reached, and is destroyed when it ends, when `alive` says so, or with the stage's tweens.\n */\nexport function paintLayer(stage: Stage, o: PaintLayerOptions): PixelLayer {\n  const { at, duration, paint, alive } = o;\n  const depth = o.depth ?? ((y: number) => y + 45);\n  const frameMs = 1000 / (o.fps ?? 12);\n  const every = o.every ?? 1;\n  const fadeMs = Math.min(o.fadeMs ?? 260, duration * 0.3);\n  const g = addPixelLayer(stage);\n  o.onCreate?.(g);\n  const clock = { elapsed: 0 };\n  let previous = -1;\n  let reached = CULL_REACH_FLOOR;\n  const cam = stage.cameras.main;\n  const update = () => {\n    if (alive && !alive()) {\n      g.destroy();\n      return;\n    }\n    const p = at();\n    g.setPosition(cam.snap(p.x), cam.snap(p.y)).setDepth(typeof depth === 'number' ? depth : depth(p.y));\n    let frame = Math.floor(clock.elapsed / frameMs);\n    if (every > 1) frame -= frame % every;\n    if (frame === previous) return;\n    if (previous >= 0 && !inView(cam, p.x, p.y, CULL_MARGIN + Math.max(reached, g.reach()))) return;\n    previous = frame;\n    g.clear();\n    const ms = Math.min(duration, frame * frameMs);\n    setCoverage(fadeMs > 0 && ms > duration - fadeMs ? Math.max(0, (duration - ms) / fadeMs) * 0.85 + 0.15 : 1);\n    beginBatch(g);\n    try {\n      paint(g, ms);\n    } finally {\n      endBatch();\n      setCoverage(1);\n    }\n    g.present();\n    reached = Math.max(reached, g.reach());\n  };\n  update();\n  if (!g.active) return g;\n  const tween = stage.tweens.add({ targets: clock, elapsed: duration, duration, onUpdate: update, onComplete: () => g.destroy() });\n  g.once('destroyed', () => tween.remove());\n  return g;\n}\n"],"names":["CULL_MARGIN","CULL_REACH_FLOOR","paintLayer","stage","o","at","duration","paint","alive","depth","y","frameMs","every","fadeMs","g","addPixelLayer","clock","previous","reached","cam","update","p","frame","inView","ms","setCoverage","beginBatch","endBatch","tween"],"mappings":";;;AAgCA,MAAMA,IAAc,IAKdC,IAAmB;AAQlB,SAASC,EAAWC,GAAcC,GAAkC;AACzE,QAAM,EAAE,IAAAC,GAAI,UAAAC,GAAU,OAAAC,GAAO,OAAAC,MAAUJ,GACjCK,IAAQL,EAAE,UAAU,CAACM,MAAcA,IAAI,KACvCC,IAAU,OAAQP,EAAE,OAAO,KAC3BQ,IAAQR,EAAE,SAAS,GACnBS,IAAS,KAAK,IAAIT,EAAE,UAAU,KAAKE,IAAW,GAAG,GACjDQ,IAAIC,EAAcZ,CAAK;AAC7B,EAAAC,EAAE,WAAWU,CAAC;AACd,QAAME,IAAQ,EAAE,SAAS,EAAA;AACzB,MAAIC,IAAW,IACXC,IAAUjB;AACd,QAAMkB,IAAMhB,EAAM,QAAQ,MACpBiB,IAAS,MAAM;AACnB,QAAIZ,KAAS,CAACA,KAAS;AACrB,MAAAM,EAAE,QAAA;AACF;AAAA,IACF;AACA,UAAMO,IAAIhB,EAAA;AACV,IAAAS,EAAE,YAAYK,EAAI,KAAKE,EAAE,CAAC,GAAGF,EAAI,KAAKE,EAAE,CAAC,CAAC,EAAE,SAAS,OAAOZ,KAAU,WAAWA,IAAQA,EAAMY,EAAE,CAAC,CAAC;AACnG,QAAIC,IAAQ,KAAK,MAAMN,EAAM,UAAUL,CAAO;AAG9C,QAFIC,IAAQ,MAAGU,KAASA,IAAQV,IAC5BU,MAAUL,KACVA,KAAY,KAAK,CAACM,EAAOJ,GAAKE,EAAE,GAAGA,EAAE,GAAGrB,IAAc,KAAK,IAAIkB,GAASJ,EAAE,MAAA,CAAO,CAAC,EAAG;AACzF,IAAAG,IAAWK,GACXR,EAAE,MAAA;AACF,UAAMU,IAAK,KAAK,IAAIlB,GAAUgB,IAAQX,CAAO;AAC7C,IAAAc,EAAYZ,IAAS,KAAKW,IAAKlB,IAAWO,IAAS,KAAK,IAAI,IAAIP,IAAWkB,KAAMX,CAAM,IAAI,OAAO,OAAO,CAAC,GAC1Ga,EAAWZ,CAAC;AACZ,QAAI;AACF,MAAAP,EAAMO,GAAGU,CAAE;AAAA,IACb,UAAA;AACE,MAAAG,EAAA,GACAF,EAAY,CAAC;AAAA,IACf;AACA,IAAAX,EAAE,QAAA,GACFI,IAAU,KAAK,IAAIA,GAASJ,EAAE,OAAO;AAAA,EACvC;AAEA,MADAM,EAAA,GACI,CAACN,EAAE,OAAQ,QAAOA;AACtB,QAAMc,IAAQzB,EAAM,OAAO,IAAI,EAAE,SAASa,GAAO,SAASV,GAAU,UAAAA,GAAU,UAAUc,GAAQ,YAAY,MAAMN,EAAE,QAAA,GAAW;AAC/H,SAAAA,EAAE,KAAK,aAAa,MAAMc,EAAM,QAAQ,GACjCd;AACT;"}

package/dist/pixel/palette.js

@@ -0,0 +1,57 @@
+import { hex as a } from "./pixel.js";
+const r = {
+  outline: a("#1a1220"),
+  outlineSoft: a("#2e2233"),
+  black: a("#0e0b12"),
+  white: a("#f4f0e8"),
+  offWhite: a("#e2dccf"),
+  skin: a("#f2c59a"),
+  skinShade: a("#d99d74"),
+  skinTan: a("#cf9468"),
+  skinTanShade: a("#a86c48"),
+  blush: a("#e88c80"),
+  hairBlack: a("#2a2230"),
+  hairBrown: a("#5b3a29"),
+  hairAuburn: a("#7a3b2a"),
+  hairWhite: a("#e8e4dc"),
+  hairGrey: a("#9a96a0"),
+  red: a("#c8373a"),
+  redDark: a("#8e2331"),
+  crimson: a("#a3243b"),
+  orange: a("#e07a36"),
+  gold: a("#f2c84b"),
+  goldDark: a("#b88a2a"),
+  yellow: a("#f5e06a"),
+  green: a("#5aa04a"),
+  greenDark: a("#2f6b3a"),
+  jade: a("#4fbf8f"),
+  jadeDark: a("#2d8466"),
+  teal: a("#3aa6a0"),
+  sky: a("#7ec4f0"),
+  azure: a("#4a8ad4"),
+  blue: a("#3560b0"),
+  navy: a("#27335e"),
+  indigo: a("#3b2f6e"),
+  purple: a("#7a4bb0"),
+  pink: a("#e89aaa"),
+  brown: a("#7a5234"),
+  brownDark: a("#4e3222"),
+  brownLight: a("#a6784a"),
+  tan: a("#c9a26e"),
+  cream: a("#efe2c0"),
+  grey: a("#8a8690"),
+  greyDark: a("#57535e"),
+  greyLight: a("#bdb9c2"),
+  steel: a("#c8d2dc"),
+  steelDark: a("#7f8a98"),
+  iron: a("#9aa0a8"),
+  wood: a("#9a6a3c"),
+  woodDark: a("#6a4426"),
+  woodLight: a("#bd8c56"),
+  straw: a("#d8b060"),
+  strawDark: a("#a8823e")
+};
+export {
+  r as P
+};
+//# sourceMappingURL=palette.js.map

package/dist/pixel/palette.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"palette.js","sources":["../../src/pixel/palette.ts"],"sourcesContent":["import { hex } from './pixel';\n\n/**\n * The default palette (`PALETTE` from `1681-engine/pixel`): warm fantasy tones, readable on green ground. It is a\n * starting point, not a rule: a game brings its own colours, and the helpers that use one of these (an outline, a\n * shadow) take the colour as a parameter.\n */\nexport const P = {\n  outline: hex('#1a1220'),\n  outlineSoft: hex('#2e2233'),\n  black: hex('#0e0b12'),\n  white: hex('#f4f0e8'),\n  offWhite: hex('#e2dccf'),\n\n  skin: hex('#f2c59a'),\n  skinShade: hex('#d99d74'),\n  skinTan: hex('#cf9468'),\n  skinTanShade: hex('#a86c48'),\n  blush: hex('#e88c80'),\n\n  hairBlack: hex('#2a2230'),\n  hairBrown: hex('#5b3a29'),\n  hairAuburn: hex('#7a3b2a'),\n  hairWhite: hex('#e8e4dc'),\n  hairGrey: hex('#9a96a0'),\n\n  red: hex('#c8373a'),\n  redDark: hex('#8e2331'),\n  crimson: hex('#a3243b'),\n  orange: hex('#e07a36'),\n  gold: hex('#f2c84b'),\n  goldDark: hex('#b88a2a'),\n  yellow: hex('#f5e06a'),\n  green: hex('#5aa04a'),\n  greenDark: hex('#2f6b3a'),\n  jade: hex('#4fbf8f'),\n  jadeDark: hex('#2d8466'),\n  teal: hex('#3aa6a0'),\n  sky: hex('#7ec4f0'),\n  azure: hex('#4a8ad4'),\n  blue: hex('#3560b0'),\n  navy: hex('#27335e'),\n  indigo: hex('#3b2f6e'),\n  purple: hex('#7a4bb0'),\n  pink: hex('#e89aaa'),\n  brown: hex('#7a5234'),\n  brownDark: hex('#4e3222'),\n  brownLight: hex('#a6784a'),\n  tan: hex('#c9a26e'),\n  cream: hex('#efe2c0'),\n  grey: hex('#8a8690'),\n  greyDark: hex('#57535e'),\n  greyLight: hex('#bdb9c2'),\n  steel: hex('#c8d2dc'),\n  steelDark: hex('#7f8a98'),\n  iron: hex('#9aa0a8'),\n  wood: hex('#9a6a3c'),\n  woodDark: hex('#6a4426'),\n  woodLight: hex('#bd8c56'),\n  straw: hex('#d8b060'),\n  strawDark: hex('#a8823e'),\n} as const;\n"],"names":["P","hex"],"mappings":";AAOO,MAAMA,IAAI;AAAA,EACf,SAASC,EAAI,SAAS;AAAA,EACtB,aAAaA,EAAI,SAAS;AAAA,EAC1B,OAAOA,EAAI,SAAS;AAAA,EACpB,OAAOA,EAAI,SAAS;AAAA,EACpB,UAAUA,EAAI,SAAS;AAAA,EAEvB,MAAMA,EAAI,SAAS;AAAA,EACnB,WAAWA,EAAI,SAAS;AAAA,EACxB,SAASA,EAAI,SAAS;AAAA,EACtB,cAAcA,EAAI,SAAS;AAAA,EAC3B,OAAOA,EAAI,SAAS;AAAA,EAEpB,WAAWA,EAAI,SAAS;AAAA,EACxB,WAAWA,EAAI,SAAS;AAAA,EACxB,YAAYA,EAAI,SAAS;AAAA,EACzB,WAAWA,EAAI,SAAS;AAAA,EACxB,UAAUA,EAAI,SAAS;AAAA,EAEvB,KAAKA,EAAI,SAAS;AAAA,EAClB,SAASA,EAAI,SAAS;AAAA,EACtB,SAASA,EAAI,SAAS;AAAA,EACtB,QAAQA,EAAI,SAAS;AAAA,EACrB,MAAMA,EAAI,SAAS;AAAA,EACnB,UAAUA,EAAI,SAAS;AAAA,EACvB,QAAQA,EAAI,SAAS;AAAA,EACrB,OAAOA,EAAI,SAAS;AAAA,EACpB,WAAWA,EAAI,SAAS;AAAA,EACxB,MAAMA,EAAI,SAAS;AAAA,EACnB,UAAUA,EAAI,SAAS;AAAA,EACvB,MAAMA,EAAI,SAAS;AAAA,EACnB,KAAKA,EAAI,SAAS;AAAA,EAClB,OAAOA,EAAI,SAAS;AAAA,EACpB,MAAMA,EAAI,SAAS;AAAA,EACnB,MAAMA,EAAI,SAAS;AAAA,EACnB,QAAQA,EAAI,SAAS;AAAA,EACrB,QAAQA,EAAI,SAAS;AAAA,EACrB,MAAMA,EAAI,SAAS;AAAA,EACnB,OAAOA,EAAI,SAAS;AAAA,EACpB,WAAWA,EAAI,SAAS;AAAA,EACxB,YAAYA,EAAI,SAAS;AAAA,EACzB,KAAKA,EAAI,SAAS;AAAA,EAClB,OAAOA,EAAI,SAAS;AAAA,EACpB,MAAMA,EAAI,SAAS;AAAA,EACnB,UAAUA,EAAI,SAAS;AAAA,EACvB,WAAWA,EAAI,SAAS;AAAA,EACxB,OAAOA,EAAI,SAAS;AAAA,EACpB,WAAWA,EAAI,SAAS;AAAA,EACxB,MAAMA,EAAI,SAAS;AAAA,EACnB,MAAMA,EAAI,SAAS;AAAA,EACnB,UAAUA,EAAI,SAAS;AAAA,EACvB,WAAWA,EAAI,SAAS;AAAA,EACxB,OAAOA,EAAI,SAAS;AAAA,EACpB,WAAWA,EAAI,SAAS;AAC1B;"}

package/dist/pixel/pixel.js

@@ -0,0 +1,278 @@
+const D = 0;
+function b(r, t, n, h = 255) {
+  const s = Math.max(0, Math.min(255, Math.round(r))), o = Math.max(0, Math.min(255, Math.round(t))), i = Math.max(0, Math.min(255, Math.round(n)));
+  return (Math.max(0, Math.min(255, Math.round(h))) << 24 | i << 16 | o << 8 | s) >>> 0;
+}
+function U(r) {
+  let t = r.startsWith("#") ? r.slice(1) : r;
+  t.length === 3 && (t = [...t].map((i) => i + i).join(""));
+  const n = parseInt(t.slice(0, 2), 16), h = parseInt(t.slice(2, 4), 16), s = parseInt(t.slice(4, 6), 16), o = t.length >= 8 ? parseInt(t.slice(6, 8), 16) : 255;
+  return b(n, h, s, o);
+}
+function m(r) {
+  return [r & 255, r >>> 8 & 255, r >>> 16 & 255, r >>> 24 & 255];
+}
+function B(r, t) {
+  const [n, h, s, o] = m(r);
+  if (t >= 1) {
+    const i = Math.min(1, t - 1);
+    return b(n + (255 - n) * i, h + (255 - h) * i, s + (255 - s) * i, o);
+  }
+  return b(n * t, h * t, s * t, o);
+}
+function L(r, t, n) {
+  const h = m(r), s = m(t);
+  return b(h[0] + (s[0] - h[0]) * n, h[1] + (s[1] - h[1]) * n, h[2] + (s[2] - h[2]) * n, h[3] + (s[3] - h[3]) * n);
+}
+function R(r, t) {
+  const [n, h, s] = m(r);
+  return b(n, h, s, t);
+}
+function $(r) {
+  const [t, n, h, s] = m(r);
+  return `rgba(${t},${n},${h},${(s / 255).toFixed(3)})`;
+}
+function C(r, t, n = 0) {
+  let h = r * 374761393 + t * 668265263 + n * 2147483647 | 0;
+  return h = Math.imul(h ^ h >>> 13, 1274126177), ((h ^ h >>> 16) >>> 0) / 4294967296;
+}
+function v(r) {
+  let t = r >>> 0;
+  return () => {
+    t = t + 1831565813 >>> 0;
+    let n = t;
+    return n = Math.imul(n ^ n >>> 15, n | 1), n ^= n + Math.imul(n ^ n >>> 7, n | 61), ((n ^ n >>> 14) >>> 0) / 4294967296;
+  };
+}
+function S(r, t, n, h) {
+  const s = r / n, o = t / n, i = Math.floor(s), e = Math.floor(o), l = s - i, c = o - e, M = l * l * (3 - 2 * l), d = c * c * (3 - 2 * c), w = C(i, e, h), a = C(i + 1, e, h), u = C(i, e + 1, h), f = C(i + 1, e + 1, h);
+  return w + (a - w) * M + (u - w) * d + (w - a - u + f) * M * d;
+}
+class A {
+  constructor(t, n) {
+    this.w = t, this.h = n, this.data = new Uint32Array(t * n);
+  }
+  w;
+  h;
+  data;
+  inBounds(t, n) {
+    return t >= 0 && n >= 0 && t < this.w && n < this.h;
+  }
+  px(t, n, h) {
+    t = Math.floor(t), n = Math.floor(n), t >= 0 && n >= 0 && t < this.w && n < this.h && (this.data[n * this.w + t] = h);
+  }
+  get(t, n) {
+    return t < 0 || n < 0 || t >= this.w || n >= this.h ? 0 : this.data[n * this.w + t] ?? 0;
+  }
+  alphaAt(t, n) {
+    return this.get(t, n) >>> 24;
+  }
+  rect(t, n, h, s, o) {
+    for (let i = Math.floor(n); i < n + s; i++) for (let e = Math.floor(t); e < t + h; e++) this.px(e, i, o);
+  }
+  hline(t, n, h, s) {
+    for (let o = Math.min(t, n); o <= Math.max(t, n); o++) this.px(o, h, s);
+  }
+  vline(t, n, h, s) {
+    for (let o = Math.min(n, h); o <= Math.max(n, h); o++) this.px(t, o, s);
+  }
+  /** Filled ellipse; a pixel is inside when its center lies inside the ellipse. */
+  ellipse(t, n, h, s, o) {
+    if (!(h <= 0 || s <= 0))
+      for (let i = Math.floor(n - s); i <= Math.ceil(n + s); i++)
+        for (let e = Math.floor(t - h); e <= Math.ceil(t + h); e++) {
+          const l = (e + 0.5 - t) / h, c = (i + 0.5 - n) / s;
+          l * l + c * c <= 1 && this.px(e, i, o);
+        }
+  }
+  circle(t, n, h, s) {
+    this.ellipse(t, n, h, h, s);
+  }
+  ring(t, n, h, s, o) {
+    for (let i = Math.floor(n - h - 1); i <= Math.ceil(n + h + 1); i++)
+      for (let e = Math.floor(t - h - 1); e <= Math.ceil(t + h + 1); e++) {
+        const l = Math.hypot(e + 0.5 - t, i + 0.5 - n);
+        l <= h && l >= h - s && this.px(e, i, o);
+      }
+  }
+  line(t, n, h, s, o, i = 1) {
+    t = Math.round(t), n = Math.round(n), h = Math.round(h), s = Math.round(s);
+    const e = Math.abs(h - t), l = -Math.abs(s - n), c = t < h ? 1 : -1, M = n < s ? 1 : -1;
+    let d = e + l;
+    for (; i <= 1 ? this.px(t, n, o) : this.rect(t - Math.floor((i - 1) / 2), n - Math.floor((i - 1) / 2), i, i, o), !(t === h && n === s); ) {
+      const w = 2 * d;
+      w >= l && (d += l, t += c), w <= e && (d += e, n += M);
+    }
+  }
+  /** Filled polygon (even-odd scanline on pixel centers). */
+  poly(t, n) {
+    if (t.length < 3) return;
+    const h = Math.floor(Math.min(...t.map((o) => o[1]))), s = Math.ceil(Math.max(...t.map((o) => o[1])));
+    for (let o = h; o <= s; o++) {
+      const i = o + 0.5, e = [];
+      for (let l = 0; l < t.length; l++) {
+        const c = t[l], M = t[(l + 1) % t.length];
+        (c[1] <= i && M[1] > i || M[1] <= i && c[1] > i) && e.push(c[0] + (i - c[1]) / (M[1] - c[1]) * (M[0] - c[0]));
+      }
+      e.sort((l, c) => l - c);
+      for (let l = 0; l + 1 < e.length; l += 2)
+        for (let c = Math.ceil(e[l] - 0.5); c <= Math.floor(e[l + 1] - 0.5); c++) this.px(c, o, n);
+    }
+  }
+  /**
+   * 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, n = !1, h = 1) {
+    const s = this.w, o = this.h, i = new Uint8Array(this.data.length);
+    let e = s, l = o, c = -1, M = -1;
+    for (let a = 0; a < o; a++)
+      for (let u = 0; u < s; u++) {
+        const f = a * s + u;
+        this.data[f] >>> 24 && (i[f] = 1, u < e && (e = u), u > c && (c = u), a < l && (l = a), M = a);
+      }
+    if (c < 0) return;
+    const d = (a, u, f) => a >= 0 && u >= 0 && a < s && u < o && i[f] === 1;
+    let w = [];
+    for (let a = Math.max(0, l - 1); a <= Math.min(o - 1, M + 1); a++)
+      for (let u = Math.max(0, e - 1); u <= Math.min(s - 1, c + 1); u++) {
+        const f = a * s + u;
+        if (i[f]) continue;
+        let g = d(u - 1, a, f - 1) || d(u + 1, a, f + 1) || d(u, a - 1, f - s) || d(u, a + 1, f + s);
+        !g && n && (g = d(u - 1, a - 1, f - s - 1) || d(u + 1, a - 1, f - s + 1) || d(u - 1, a + 1, f + s - 1) || d(u + 1, a + 1, f + s + 1)), g && (this.data[f] = t, w.push(f));
+      }
+    for (const a of w) i[a] = 1;
+    for (let a = 1; a < h && w.length; a++) {
+      const u = [];
+      for (const f of w) {
+        const g = f % s, p = f / s | 0, x = (E, I, y) => {
+          E < 0 || I < 0 || E >= s || I >= o || i[y] || (i[y] = 1, this.data[y] = t, u.push(y));
+        };
+        x(g - 1, p, f - 1), x(g + 1, p, f + 1), x(g, p - 1, f - s), x(g, p + 1, f + s), n && (x(g - 1, p - 1, f - s - 1), x(g + 1, p - 1, f - s + 1), x(g - 1, p + 1, f + s - 1), x(g + 1, p + 1, f + s + 1));
+      }
+      w = u;
+    }
+  }
+  /** Replaces every pixel whose color matches `from`. */
+  recolor(t, n) {
+    for (let h = 0; h < this.data.length; h++) this.data[h] === t && (this.data[h] = n);
+  }
+  /** Multiplies brightness of opaque pixels matching `pred`. */
+  tint(t, n) {
+    for (let h = 0; h < this.h; h++)
+      for (let s = 0; s < this.w; s++) {
+        const o = h * this.w + s, i = this.data[o] ?? 0;
+        i >>> 24 && n(s, h) && (this.data[o] = B(i, t));
+      }
+  }
+  blit(t, n, h, s = !1) {
+    for (let o = 0; o < t.h; o++)
+      for (let i = 0; i < t.w; i++) {
+        const e = t.data[o * t.w + i] ?? 0;
+        e >>> 24 && this.px(n + (s ? t.w - 1 - i : i), h + o, e);
+      }
+  }
+  /** Alpha-blends a color onto an existing pixel. */
+  blend(t, n, h) {
+    if (!this.inBounds(t, n)) return;
+    const s = n * this.w + t, o = this.data[s] ?? 0, [i, e, l, c] = m(h), M = c / 255, d = m(o);
+    this.data[s] = b(d[0] + (i - d[0]) * M, d[1] + (e - d[1]) * M, d[2] + (l - d[2]) * M, 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 n = new A(t.width, t.height), h = t.getContext("2d").getImageData(0, 0, t.width, t.height);
+    return n.data.set(new Uint32Array(h.data.buffer, h.data.byteOffset, t.width * t.height)), n;
+  }
+  /** The same picture on a grid `factor` times as fine, each pixel becoming a square block. */
+  upscaled(t) {
+    if (t === 1) return this;
+    const n = new A(this.w * t, this.h * t);
+    for (let h = 0; h < this.h; h++)
+      for (let s = 0; s < this.w; s++) {
+        const o = this.data[h * this.w + s] ?? 0;
+        o >>> 24 && n.rect(s * t, h * t, t, t, o);
+      }
+    return n;
+  }
+  /** Same size and same pixels. */
+  equals(t) {
+    if (t.w !== this.w || t.h !== this.h) return !1;
+    for (let n = 0; n < this.data.length; n++) if (this.data[n] !== t.data[n]) return !1;
+    return !0;
+  }
+  /** Cheap hash of the pixels, for grouping identical frames before comparing them. */
+  key() {
+    let t = 2166136261;
+    for (let n = 0; n < this.data.length; n++)
+      t ^= this.data[n], t = Math.imul(t, 16777619) >>> 0;
+    return t >>> 0;
+  }
+  clone() {
+    const t = new A(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 n = t.getContext("2d");
+    if (!n) throw new Error("2D canvas not supported");
+    const h = new Uint8ClampedArray(this.w * this.h * 4);
+    h.set(new Uint8Array(this.data.buffer, this.data.byteOffset, this.data.byteLength));
+    const s = new ImageData(h, this.w, this.h);
+    return n.putImageData(s, 0, 0), t;
+  }
+}
+class O extends A {
+  constructor(t, n, h, s) {
+    super(h, s), this.x0 = t, this.y0 = n;
+  }
+  x0;
+  y0;
+  inBounds(t, n) {
+    return super.inBounds(t - this.x0, n - this.y0);
+  }
+  px(t, n, h) {
+    super.px(Math.floor(t) - this.x0, Math.floor(n) - this.y0, h);
+  }
+  get(t, n) {
+    return super.get(t - this.x0, n - this.y0);
+  }
+  blend(t, n, h) {
+    const s = t - this.x0, o = n - this.y0;
+    if (!super.inBounds(s, o)) return;
+    const i = o * this.w + s, e = this.data[i] ?? 0, [l, c, M, d] = m(h), w = d / 255, a = m(e);
+    this.data[i] = b(a[0] + (l - a[0]) * w, a[1] + (c - a[1]) * w, a[2] + (M - a[2]) * w, Math.max(a[3], d));
+  }
+}
+function W(r, t = 16384) {
+  const n = r[0];
+  if (!n) throw new Error("makeSheet: no frames");
+  const h = Math.max(1, Math.min(r.length, Math.floor(t / n.w))), s = Math.ceil(r.length / h), o = new A(n.w * h, n.h * s);
+  return r.forEach((i, e) => o.blit(i, e % h * n.w, Math.floor(e / h) * n.h)), o.toCanvas();
+}
+function Y(r, t) {
+  const n = document.createElement("canvas");
+  n.width = r.width * t, n.height = r.height * t;
+  const h = n.getContext("2d");
+  if (!h) throw new Error("2D canvas not supported");
+  return h.imageSmoothingEnabled = !1, h.drawImage(r, 0, 0, n.width, n.height), n;
+}
+export {
+  D as CLEAR,
+  A as PixelGrid,
+  O as PixelWindow,
+  m as channels,
+  C as hash2,
+  U as hex,
+  W as makeSheet,
+  L as mix,
+  v as mulberry32,
+  b as rgba,
+  B as shade,
+  $ as toCss,
+  Y as upscale,
+  S as valueNoise,
+  R as withAlpha
+};
+//# sourceMappingURL=pixel.js.map