1681-engine 0.0.0-stage → 0.5.9

package/dist/pixel/pixelTone.js

@@ -0,0 +1,163 @@
+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
+};

package/dist/pixel/propKit.js

@@ -0,0 +1,40 @@
+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
+};

package/dist/pixel/ramp.js

@@ -0,0 +1,101 @@
+import { shade as R, mix as T, channels as $, rgba as x } from "./pixel.js";
+const d = {
+  // wool and linen: violet shadows, faintly warm lights
+  cloth: { cool: 255, coolDeg: 14, coolSat: 0.06, warm: 50, warmDeg: 6 },
+  // hide: its shadows go red-brown, never grey
+  leather: { cool: 8, coolDeg: 12, coolSat: 0.08, warm: 45, warmDeg: 8 },
+  // steel: blue shadows, lights close to white
+  mail: { cool: 232, coolDeg: 16, coolSat: 0.07, warm: 52, warmDeg: 4 },
+  plate: { cool: 235, coolDeg: 18, coolSat: 0.08, warm: 50, warmDeg: 6 },
+  // scale: crimson-violet shadows, ember-orange lights
+  dragon: { cool: 330, coolDeg: 16, coolSat: 0.06, warm: 36, warmDeg: 12 },
+  fur: { cool: 262, coolDeg: 10, coolSat: 0.04, warm: 48, warmDeg: 6 },
+  // skin: shadows go to blood-red, never to grey or green
+  skin: { cool: 350, coolDeg: 14, coolSat: 0.09, warm: 42, warmDeg: 5 },
+  hair: { cool: 262, coolDeg: 14, coolSat: 0.05, warm: 46, warmDeg: 10 },
+  gold: { cool: 14, coolDeg: 14, coolSat: 0.05, warm: 58, warmDeg: 8 },
+  gem: { cool: 262, coolDeg: 8, coolSat: 0.02, warm: 50, warmDeg: 2 },
+  // the side turned away from the light, whatever it is made of (the far limbs)
+  shadow: { cool: 255, coolDeg: 12, coolSat: 0.04, warm: 50, warmDeg: 0 }
+}, D = {
+  cloth: [0.5, 0.66, 0.82, 1.12, 1.25],
+  leather: [0.46, 0.62, 0.8, 1.16, 1.3],
+  mail: [0.44, 0.6, 0.78, 1.22, 1.42],
+  plate: [0.44, 0.56, 0.72, 1.2, 1.45],
+  dragon: [0.42, 0.56, 0.74, 1.14, 1.32],
+  fur: [0.56, 0.7, 0.84, 1.15, 1.26],
+  skin: [0.6, 0.72, 0.86, 1.12, 1.24],
+  hair: [0.5, 0.66, 0.8, 1.2, 1.36],
+  gold: [0.42, 0.62, 0.8, 1.3, 1.5],
+  gem: [0.32, 0.5, 0.78, 1.45, 1.65],
+  shadow: [0.5, 0.66, 0.82, 1.12, 1.25]
+}, b = Object.keys(d), E = [...new Set(Object.values(D).flat())];
+function _(t, c) {
+  d[t] = c.light, D[t] = c.factors, b.includes(t) || b.push(t);
+  const o = E;
+  for (const e of c.factors) o.includes(e) || o.push(e);
+  for (const e of [p, k]) for (const n of [...e.keys()]) n.endsWith(`:${t}`) && e.delete(n);
+}
+const C = (t) => d[t] ?? d.cloth, H = (t) => D[t] ?? D.cloth;
+function M(t) {
+  const [c, o, e] = $(t), n = Math.max(c, o, e), l = Math.min(c, o, e), r = n - l;
+  let a = 0;
+  return r > 0 && (n === c ? a = ((o - e) / r + 6) % 6 : n === o ? a = (e - c) / r + 2 : a = (c - o) / r + 4), [a * 60, n === 0 ? 0 : r / n, n / 255];
+}
+function w(t, c, o, e) {
+  const n = (t % 360 + 360) % 360 / 60, l = Math.floor(n), r = n - l, a = o * (1 - c), s = o * (1 - c * r), i = o * (1 - c * (1 - r)), [g, u, m] = [[o, i, a], [s, o, a], [a, o, i], [a, s, o], [i, a, o], [o, a, s]][l % 6];
+  return x(g * 255, u * 255, m * 255, e);
+}
+function A(t, c, o) {
+  let e = c - t;
+  return e > 180 && (e -= 360), e < -180 && (e += 360), t + Math.sign(e) * Math.min(Math.abs(e), o);
+}
+const h = (t) => Math.max(0, Math.min(1, t)), p = /* @__PURE__ */ new Map();
+function y(t, c, o) {
+  if (c === 1) return t;
+  const e = `${t}:${c}:${o}`;
+  let n = p.get(e);
+  if (n !== void 0) return n;
+  const l = C(o), r = R(t, c), [a, s, i] = M(r), g = r >>> 24, u = h(1 - M(t)[1] / 0.14);
+  let m, S;
+  if (c < 1) {
+    const f = (1 - c) / 0.5;
+    m = w(A(a, l.cool, l.coolDeg * f), h(s + l.coolSat * f), i, g), S = w(l.cool, h(s + l.coolSat * f * 1.2), i, g);
+  } else {
+    const f = Math.min(1.5, (c - 1) / 0.3);
+    m = w(A(a, l.warm, l.warmDeg * f), h(s * 1.08), i, g), S = w(l.warm, h(s + 0.03 * f), i, g);
+  }
+  return n = u > 0 ? T(m, S, u) : m, p.set(e, n), n;
+}
+const k = /* @__PURE__ */ new Map();
+function P(t, c) {
+  const o = `${t}:${c}`;
+  let e = k.get(o);
+  if (!e) {
+    const [n, l, r, a, s] = H(c).map((i) => y(t, i, c));
+    e = { deep: n, dark: l, mid: r, base: t, light: a, glint: s }, k.set(o, e);
+  }
+  return e;
+}
+function j(t, c) {
+  const o = P(t, c);
+  return [o.deep, o.dark, o.mid, o.base, o.light, o.glint];
+}
+const O = /* @__PURE__ */ new Map();
+function F(t) {
+  let c = O.get(t);
+  if (c === void 0) {
+    const [o, e, n] = M(y(t, 0.42, "shadow"));
+    c = w(o, h(e * 1.1 + 0.08), Math.min(n, 0.3), 255), O.set(t, c);
+  }
+  return c;
+}
+export {
+  b as MATERIALS,
+  E as RAMP_FACTOR_SET,
+  y as hueShade,
+  F as outlineOf,
+  P as ramp,
+  j as rampTones,
+  _ as registerMaterial
+};

package/dist/pixel/selout.js

@@ -0,0 +1,34 @@
+import { P as d } from "./palette.js";
+import { outlineOf as v } from "./ramp.js";
+function P(w, g = 1, M = d.outline) {
+  const { w: n, h: c, data: f } = w, i = new Uint8Array(f.length);
+  let m = n, p = c, h = -1, y = -1;
+  for (let o = 0; o < c; o++) {
+    const e = o * n;
+    for (let t = 0; t < n; t++)
+      f[e + t] >>> 24 && (i[e + t] = 1, t < m && (m = t), t > h && (h = t), o < p && (p = o), y = o);
+  }
+  if (h < 0) return;
+  let s = [];
+  for (let o = Math.max(0, p - 1); o <= Math.min(c - 1, y + 1); o++)
+    for (let e = Math.max(0, m - 1); e <= Math.min(n - 1, h + 1); e++) {
+      const t = o * n + e;
+      if (i[t]) continue;
+      const l = o > 0 && i[t - n] === 1, a = e + 1 < n && i[t + 1] === 1, u = e > 0 && i[t - 1] === 1, r = o + 1 < c && i[t + n] === 1;
+      (l || a || u || r) && (f[t] = l || a ? M : v(f[u ? t - 1 : t + n]), s.push(t));
+    }
+  for (const o of s) i[o] = 1;
+  for (let o = 1; o < g && s.length; o++) {
+    const e = [];
+    for (const t of s) {
+      const l = t % n, a = t / n | 0, u = f[t], r = (b, x) => {
+        !b || i[x] || (i[x] = 1, f[x] = u, e.push(x));
+      };
+      r(l > 0, t - 1), r(l + 1 < n, t + 1), r(a > 0, t - n), r(a + 1 < c, t + n);
+    }
+    s = e;
+  }
+}
+export {
+  P as selectiveOutline
+};

package/dist/pixel/spritePixels.js

@@ -0,0 +1,58 @@
+class C {
+  constructor(e, t, a, d) {
+    this.dx = e, this.dy = t, this.color = a, this.length = d;
+  }
+  dx;
+  dy;
+  color;
+  length;
+  *[Symbol.iterator]() {
+    const e = { dx: 0, dy: 0, color: 0 };
+    for (let t = 0; t < this.length; t++)
+      e.dx = this.dx[t], e.dy = this.dy[t], e.color = this.color[t], yield e;
+  }
+}
+const M = new C(new Float32Array(0), new Float32Array(0), new Uint32Array(0), 0), I = M, b = 512 * 512, k = 256, p = 3e5, r = /* @__PURE__ */ new Map();
+let E = 0;
+function v(c, e) {
+  for (r.set(c, e), E += e.length; r.size > k || E > p; ) {
+    const t = r.keys().next();
+    if (t.done) break;
+    E -= r.get(t.value).length, r.delete(t.value);
+  }
+}
+function L(c, e, t) {
+  const a = `${c.textureKey}|${c.frameName}|${e}`;
+  if (!t) {
+    const o = r.get(a);
+    if (o)
+      return r.delete(a), r.set(a, o), o;
+  }
+  const d = c.texture, m = d.source.resource;
+  if (!(m instanceof HTMLCanvasElement)) return M;
+  const f = d.frame, l = Math.round(f.width), u = Math.round(f.height);
+  if (l <= 0 || u <= 0 || l * u > b) return M;
+  let h;
+  try {
+    h = m.getContext("2d").getImageData(Math.round(f.x), Math.round(f.y), l, u).data;
+  } catch {
+    return M;
+  }
+  const s = Math.max(1, Math.round(e)), A = Math.floor(l / s), g = Math.floor(u / s), y = Math.floor(s / 2);
+  let i = 0;
+  for (let o = 0; o < g; o++) for (let n = 0; n < A; n++) h[((o * s + y) * l + n * s + y) * 4 + 3] >= 128 && i++;
+  const P = new Float32Array(i), F = new Float32Array(i), X = new Uint32Array(i);
+  let w = 0;
+  for (let o = 0; o < g; o++)
+    for (let n = 0; n < A; n++) {
+      const x = ((o * s + y) * l + n * s + y) * 4;
+      h[x + 3] < 128 || (P[w] = n - A / 2, F[w] = o - g, X[w] = h[x] << 16 | h[x + 1] << 8 | h[x + 2], w++);
+    }
+  const _ = new C(P, F, X, i);
+  return t || v(a, _), _;
+}
+export {
+  I as NO_PIXELS,
+  C as PackedPixels,
+  L as spritePixels
+};

package/dist/pixel/swayRig.js

@@ -0,0 +1,86 @@
+function m(n) {
+  const r = n.length;
+  let i = 1 / 0;
+  for (let o = Math.floor(r * 0.4); o < r; o++) n[o] > 0 && (i = Math.min(i, n[o]));
+  if (!Number.isFinite(i)) return null;
+  const e = i + 2;
+  let c = null, t = -1;
+  for (let o = Math.floor(r * 0.3); o <= r; o++) {
+    const f = o < r && n[o] > 0 && n[o] <= e;
+    f && t < 0 && (t = o), !f && t >= 0 && ((!c || o - t > c[1] - c[0]) && (c = [t, o]), t = -1);
+  }
+  if (!c || c[1] - c[0] < 3) return null;
+  let s = 0;
+  for (let o = 0; o < c[0]; o++) s = Math.max(s, n[o]);
+  return s >= e * 1.5 ? c[0] : null;
+}
+function p(n, r, i) {
+  const e = r - n;
+  if (e <= 0) return [];
+  if (e < 20) return [{ rect: { x: 0, y: n, w: i, h: e }, weight: 1, lag: 0 }];
+  const c = n + Math.round(e * 0.5);
+  return [
+    { rect: { x: 0, y: n, w: i, h: c - n }, weight: 1, lag: 0 },
+    { rect: { x: 0, y: c, w: i, h: r - c }, weight: 0.55, lag: 0.04 }
+  ];
+}
+function g(n, r, i) {
+  const e = [.../* @__PURE__ */ new Set([0, r, ...i.flatMap((t) => [t.y, t.y + t.h])])].filter((t) => t >= 0 && t <= r).sort((t, s) => t - s), c = [];
+  for (let t = 0; t + 1 < e.length; t++) {
+    const s = e[t], o = e[t + 1] - s, f = i.filter((u) => u.y <= s && u.y + u.h >= s + o).sort((u, h) => u.x - h.x);
+    let a = 0;
+    for (const u of f)
+      u.x > a && c.push({ x: a, y: s, w: u.x - a, h: o }), a = Math.max(a, u.x + u.w);
+    a < n && c.push({ x: a, y: s, w: n - a, h: o });
+  }
+  return c.sort((t, s) => s.w * s.h - t.w * t.h);
+}
+function w(n, r, i, e) {
+  const c = n.tufts?.[String(e)] ?? n.tufts?.["*"] ?? [], t = [];
+  for (const [s, o, f, a, u = 1] of c) {
+    const h = Math.min(r, f), l = Math.min(i, a);
+    h <= s || l <= o || t.push({ rect: { x: s, y: o, w: h - s, h: l - o }, weight: u, lag: (1 - u) * 0.08 });
+  }
+  return t;
+}
+function b(n, r, i, e, c = 0) {
+  if (n.mode === "tufts") {
+    const s = w(n, r, i, c);
+    return { pieces: s.length ? g(r, i, s.map((o) => o.rect)) : [], strips: s };
+  }
+  if (n.mode === "hang" && n.cloth) {
+    const [s, o, f, a] = n.cloth, u = Math.min(r, f), h = Math.min(i, a), l = o + Math.round((h - o) * 0.3), x = [];
+    for (let M = l; M < h; M += 2) {
+      const y = Math.min(2, h - M);
+      x.push({ rect: { x: s, y: M, w: u - s, h: y }, weight: (M + y - l) / (h - l), lag: (M - l) * 0.03 });
+    }
+    return { pieces: [
+      { x: 0, y: 0, w: r, h: l },
+      { x: 0, y: h, w: r, h: i - h },
+      { x: 0, y: l, w: s, h: h - l },
+      { x: u, y: l, w: r - u, h: h - l }
+    ].filter((M) => M.w > 0 && M.h > 0), strips: x };
+  }
+  let t = null;
+  return n.mode === "crown" && e && (t = m(e)), t === null && (t = Math.round(i * Math.min(0.9, n.mode === "top" ? n.top ?? 0.5 : 0.6))), t = Math.max(1, Math.min(i - 1, t)), { pieces: [{ x: 0, y: t, w: r, h: i - t }], strips: p(0, t, r) };
+}
+function I(n, r, i = 0) {
+  let e = Math.imul(n + 40503, 2246822507) ^ Math.imul(r + 31161 + i * 131, 3266489909);
+  return e ^= e >>> 15, e = Math.imul(e, 668265263), e ^= e >>> 13, (e >>> 0) / 4294967296;
+}
+function P(n, r, i, e) {
+  return 0.65 + 0.35 * Math.sin(2 * Math.PI * (n / i - r / e));
+}
+function S(n, r, i, e, c, t, s, o, f = 0) {
+  if (t <= 0) return 0;
+  const a = n * r + i - e, u = 0.3 * t + 0.72 * Math.sin(2 * Math.PI * a) + 0.28 * Math.sin(2 * Math.PI * (a * 0.43 + i * 1.7)), h = Math.max(c * t * s, f), l = Math.round(h * o * u);
+  return l === 0 ? 0 : l;
+}
+export {
+  b as buildRig,
+  g as complement,
+  P as gustAt,
+  S as swayOffset,
+  I as tileHash,
+  m as trunkPivot
+};

package/dist/pixel/vignetteMask.js

@@ -0,0 +1,23 @@
+const x = [0, 8, 2, 10, 12, 4, 14, 6, 3, 11, 1, 9, 15, 7, 13, 5].map((n) => (n + 0.5) / 16);
+function d(n, c) {
+  if (n <= c) return 0;
+  const a = Math.min(1, (n - c) / (1 - c));
+  return a * a;
+}
+function f(n, c, a, i = 0.55) {
+  const r = Math.max(1, Math.ceil(n)), h = Math.max(1, Math.ceil(c)), e = new Uint8Array(r * h);
+  for (let t = 0; t < h; t++)
+    for (let o = 0; o < r; o++) {
+      const u = (o + 0.5) / r - 0.5, M = (t + 0.5) / h - 0.5, s = (u * u + M * M) * 2;
+      s <= i * i || d(Math.sqrt(s), i) * a <= x[(t & 3) * 4 + (o & 3)] || (e[t * r + o] = 1);
+    }
+  return e;
+}
+function l(n, c, a = 6, i = 1e3, r = 500) {
+  const h = Math.max(0, Math.min(1, c)), e = i - h * (i - r), t = (n % e + e) % e / e, o = t < 0.15 ? t / 0.15 : Math.max(0, 1 - (t - 0.15) / 0.55), u = (0.35 + h * 0.4) * (0.45 + 0.55 * o);
+  return a > 0 ? Math.round(u * a) / a : u;
+}
+export {
+  l as heartbeat,
+  f as vignetteMask
+};

package/dist/pixel/weatherArt.js

@@ -0,0 +1,60 @@
+const d = {
+  rainHead: "rgba(214,230,248,0.85)",
+  rainBody: "rgba(168,190,216,0.7)",
+  rainTail: "rgba(128,150,180,0.5)",
+  snow: "#f6f9ff",
+  snowShade: "#b8c8e0",
+  ashLight: "#8a827c",
+  ash: "#5c5652",
+  ashDark: "#3e3a38",
+  ember: "#ffa040",
+  emberDeep: "#c0501c",
+  mist: "rgba(226,232,222,0.62)"
+};
+function w(i, t, l, a) {
+  const n = [];
+  let s = l;
+  const _ = () => (s = Math.imul(s, 1103515245) + 12345 & 2147483647, s / 2147483647);
+  for (let r = 0; r < t; r++)
+    for (let h = 0; h < i; h++) {
+      if ((h + r) % 2) continue;
+      const c = (h - i / 2) / (i / 2), e = (r - t / 2) / (t / 2), f = 1 - (c * c + e * e);
+      f > 0 && _() < f * 0.9 && n.push([h, r, a]);
+    }
+  return n;
+}
+function o(i, t, l, a, n) {
+  if (i.exists(t)) return;
+  const s = document.createElement("canvas");
+  s.width = l, s.height = a;
+  const _ = s.getContext("2d");
+  if (_) {
+    for (const [r, h, c] of n)
+      _.fillStyle = c, _.fillRect(r, h, 1, 1);
+    i.addCanvas(t, s);
+  }
+}
+function m(i, t = {}, l = "wx_") {
+  const a = { ...d, ...t }, n = (s) => l + s;
+  return o(i, n("rain_0"), 2, 5, [[1, 0, a.rainHead], [1, 1, a.rainBody], [1, 2, a.rainBody], [0, 3, a.rainTail], [0, 4, a.rainTail]]), o(i, n("rain_1"), 2, 4, [[1, 0, a.rainHead], [1, 1, a.rainBody], [0, 2, a.rainBody], [0, 3, a.rainTail]]), o(i, n("splash_0"), 5, 2, [[2, 0, a.rainHead], [1, 1, a.rainBody], [3, 1, a.rainBody]]), o(i, n("splash_1"), 5, 2, [[0, 0, a.rainTail], [4, 0, a.rainTail], [2, 1, a.rainTail]]), o(i, n("snow_0"), 1, 1, [[0, 0, a.snow]]), o(i, n("snow_1"), 2, 2, [[0, 0, a.snow], [1, 0, a.snow], [0, 1, a.snow], [1, 1, a.snowShade]]), o(i, n("snow_2"), 3, 3, [[1, 0, a.snow], [0, 1, a.snow], [1, 1, a.snow], [2, 1, a.snowShade], [1, 2, a.snowShade]]), o(i, n("ash_0"), 2, 1, [[0, 0, a.ashLight], [1, 0, a.ash]]), o(i, n("ash_1"), 2, 2, [[0, 0, a.ash], [1, 1, a.ashDark]]), o(i, n("ash_2"), 1, 2, [[0, 0, a.ember], [0, 1, a.emberDeep]]), o(i, n("fog_0"), 72, 14, w(72, 14, 7, a.mist)), o(i, n("fog_1"), 56, 12, w(56, 12, 31, a.mist)), {
+    rain: { motion: "fall", max: 170, keys: [n("rain_0"), n("rain_1")], splash: [n("splash_0"), n("splash_1")], tint: 4214890, tintAlpha: 0.1 },
+    // the big flake one in five, the big ash an ember one in seven
+    snow: { motion: "flake", max: 120, keys: [n("snow_2"), n("snow_1"), n("snow_0"), n("snow_1"), n("snow_0")], sway: 5, tint: 14214384, tintAlpha: 0.08 },
+    ash: {
+      motion: "flake",
+      max: 90,
+      keys: [n("ash_2"), n("ash_1"), n("ash_0"), n("ash_1"), n("ash_0"), n("ash_1"), n("ash_0")],
+      vx: [12, 24],
+      vy: [10, 22],
+      sway: 3,
+      tint: 5917248,
+      tintAlpha: 0.08
+    },
+    fog: { motion: "bank", max: 12, keys: [n("fog_0"), n("fog_1")], tint: 13160644, tintAlpha: 0.24 }
+  };
+}
+export {
+  d as WEATHER_COLORS,
+  w as mistPixels,
+  m as paintWeatherArt
+};

package/dist/pixel.js

@@ -0,0 +1,96 @@
+import { PixelLayer as i, addPixelLayer as a } from "./pixel/PixelLayer.js";
+import { CLEAR as s, PixelGrid as x, PixelWindow as m, channels as l, hash2 as f, hex as h, makeSheet as n, mix as P, mulberry32 as d, rgba as R, shade as g, toCss as A, upscale as L, valueNoise as u, withAlpha as E } from "./pixel/pixel.js";
+import { P as T } from "./pixel/palette.js";
+import { art as M, groundShadow as O, litOutline as _, shadeBox as v } from "./pixel/propKit.js";
+import { MATERIALS as k, RAMP_FACTOR_SET as w, hueShade as y, outlineOf as C, ramp as W, rampTones as H, registerMaterial as N } from "./pixel/ramp.js";
+import { selectiveOutline as D } from "./pixel/selout.js";
+import { chevronPixels as G, discRuns as V, ellipsePixels as q, ringPixels as B } from "./pixel/aimPixels.js";
+import { PixelMarks as j } from "./pixel/PixelMarks.js";
+import * as e from "./pixel/pixelPaint.js";
+import * as r from "./pixel/pixelTone.js";
+import { registerHandRamps as J } from "./pixel/pixelTone.js";
+import { paintLayer as Q } from "./pixel/paintLayer.js";
+import { Evaporation as Y } from "./pixel/Evaporation.js";
+import { NO_PIXELS as $, PackedPixels as ee, spritePixels as re } from "./pixel/spritePixels.js";
+import { CARRIED_LIGHT as oe, Darkness as ie, LAMP_DIM as ae, WARM_LIGHT as pe } from "./pixel/Darkness.js";
+import { carriedLight as xe, clearLights as me, flashLight as le, liveLights as fe } from "./pixel/lights.js";
+import { NightShade as ne } from "./pixel/NightShade.js";
+import { WEATHER_COLORS as de, mistPixels as Re, paintWeatherArt as ge } from "./pixel/weatherArt.js";
+import { buildRig as Le, complement as ue, gustAt as Ee, swayOffset as Se, tileHash as Te, trunkPivot as ce } from "./pixel/swayRig.js";
+import { SwayProp as Oe, opaqueRowWidths as _e } from "./pixel/SwayProp.js";
+import { heartbeat as Ie, vignetteMask as ke } from "./pixel/vignetteMask.js";
+import { DitherVignette as ye, ditherVignette as Ce } from "./pixel/DitherVignette.js";
+import { FRAME_CORNERS as He, FRAME_TWINS as Ne, frameSvg as be, nineSlice as De } from "./pixel/nineSlice.js";
+export {
+  oe as CARRIED_LIGHT,
+  s as CLEAR,
+  ie as Darkness,
+  ye as DitherVignette,
+  Y as Evaporation,
+  He as FRAME_CORNERS,
+  Ne as FRAME_TWINS,
+  ae as LAMP_DIM,
+  k as MATERIALS,
+  $ as NO_PIXELS,
+  ne as NightShade,
+  T as PALETTE,
+  ee as PackedPixels,
+  x as PixelGrid,
+  i as PixelLayer,
+  j as PixelMarks,
+  m as PixelWindow,
+  w as RAMP_FACTOR_SET,
+  Oe as SwayProp,
+  pe as WARM_LIGHT,
+  de as WEATHER_COLORS,
+  a as addPixelLayer,
+  M as art,
+  Le as buildRig,
+  xe as carriedLight,
+  l as channels,
+  G as chevronPixels,
+  me as clearLights,
+  ue as complement,
+  V as discRuns,
+  Ce as ditherVignette,
+  q as ellipsePixels,
+  le as flashLight,
+  be as frameSvg,
+  O as groundShadow,
+  Ee as gustAt,
+  f as hash2,
+  Ie as heartbeat,
+  h as hex,
+  y as hueShade,
+  _ as litOutline,
+  fe as liveLights,
+  n as makeSheet,
+  Re as mistPixels,
+  P as mix,
+  d as mulberry32,
+  De as nineSlice,
+  _e as opaqueRowWidths,
+  C as outlineOf,
+  Q as paintLayer,
+  ge as paintWeatherArt,
+  e as pixelPaint,
+  r as pixelTone,
+  W as ramp,
+  H as rampTones,
+  J as registerHandRamps,
+  N as registerMaterial,
+  R as rgba,
+  B as ringPixels,
+  D as selectiveOutline,
+  g as shade,
+  v as shadeBox,
+  re as spritePixels,
+  Se as swayOffset,
+  Te as tileHash,
+  A as toCss,
+  ce as trunkPivot,
+  L as upscale,
+  u as valueNoise,
+  ke as vignetteMask,
+  E as withAlpha
+};

package/dist/platform/appResume.js

@@ -0,0 +1,18 @@
+function r(c, n = globalThis) {
+  const i = n.document, o = n.window, s = n.now ?? (() => Date.now());
+  let e = null;
+  const l = () => {
+    const t = e === null ? 0 : Math.max(0, s() - e);
+    e = null, c(t);
+  }, d = () => {
+    i?.visibilityState === "hidden" ? e = s() : e !== null && l();
+  }, a = (t) => {
+    t.persisted && l();
+  };
+  return i?.addEventListener("visibilitychange", d), o?.addEventListener("pageshow", a), () => {
+    i?.removeEventListener("visibilitychange", d), o?.removeEventListener("pageshow", a);
+  };
+}
+export {
+  r as onAppResume
+};