@lewismoten/gamemaker-sandbox-tools 3.1.0 → 3.4.0

package/dist/kit/levelGrid.js

@@ -0,0 +1,33 @@
+class n {
+  constructor(t, i) {
+    this.width = t, this.height = i, this.cells = Array.from({ length: i }, () => Array(t).fill(" "));
+  }
+  width;
+  height;
+  cells;
+  /** One block. */
+  put(t, i, r) {
+    if (t < 0 || i < 0 || t >= this.width || i >= this.height) throw new Error(`Grid: (${t}, ${i}) is outside ${this.width}x${this.height}`);
+    return this.cells[i][t] = r, this;
+  }
+  /** A rectangle of `ch`, w blocks wide and h high. */
+  fill(t, i, r, h, e) {
+    for (let s = i; s < i + h; s++) for (let l = t; l < t + r; l++) this.put(l, s, e);
+    return this;
+  }
+  /** Blocks `x0` to `x1` (both included) along row `y`. */
+  row(t, i, r, h) {
+    return this.fill(i, t, r - i + 1, 1, h);
+  }
+  /** Blocks `y0` to `y1` (both included) down column `x`. */
+  col(t, i, r, h) {
+    return this.fill(t, i, 1, r - i + 1, h);
+  }
+  /** The level as rows of text, for StarterMap. */
+  rows() {
+    return this.cells.map((t) => t.join(""));
+  }
+}
+export {
+  n as Grid
+};

package/dist/kit/levelPicture.js

@@ -0,0 +1,27 @@
+import { orientIndex as k } from "@lewismoten/gamemaker-sandbox-engine/formats/blocks";
+import { Pixels as v } from "./pixels.js";
+function P(m, b, d, y, e, c, u, l, g = []) {
+  const i = new v(u * 20, l * 20);
+  for (let o = 0; o < l; o++)
+    for (let n = 0; n < u; n++) {
+      const r = b[m.blocks[(c + o) * 100 + e + n]];
+      for (let t = 0; t < 400; t++) i.px[(o * 20 + Math.floor(t / 20)) * i.w + n * 20 + t % 20] = r.pixels[t];
+    }
+  const p = (o, n, r, t = 0) => {
+    for (let f = 0; f < 20; f++)
+      for (let s = 0; s < 20; s++) {
+        const x = o[k(t, s, f)];
+        x !== 255 && i.set(n + s, r + f, x);
+      }
+  };
+  for (const o of m.monsters) {
+    if (o.monnum >= 64) continue;
+    const r = y[o.monnum]?.pic[0][0];
+    r === void 0 || r >= 100 || o.curx < e || o.cury < c || o.curx >= e + u || o.cury >= c + l || p(d[r].pixels, (o.curx - e) * 20, (o.cury - c) * 20);
+  }
+  for (const o of g) p(o.pixels, (o.x - e) * 20, (o.y - c) * 20);
+  return i;
+}
+export {
+  P as renderRegion
+};

package/dist/kit/menuVersion.js

@@ -0,0 +1,19 @@
+import { isGif as x, decodeGif as g, encodeGif as h } from "@lewismoten/gamemaker-sandbox-engine/formats/gif";
+import { parseGame as w } from "@lewismoten/gamemaker-sandbox-engine/formats/game";
+import { Pixels as G } from "./pixels.js";
+import { outlined as k, textWidth as v } from "./pcText.js";
+const y = 318, P = 190, n = (t, s) => 0.2126 * t[s * 3] + 0.7152 * t[s * 3 + 1] + 0.0722 * t[s * 3 + 2];
+function E(t, s, c = {}) {
+  if (c === !1) return;
+  const p = [...t.keys()].find((o) => o.endsWith(".gam")), i = p && w(t.get(p)).scenes[0]?.files[2]?.toLowerCase(), d = i ? t.get(i) : void 0;
+  if (!d || !x(d)) return;
+  const e = g(d), m = new G(e.width, e.height);
+  m.px.set(e.pixels);
+  const l = [...new Set(e.pixels)], a = l.reduce((o, r) => n(e.palette, r) > n(e.palette, o) ? r : o), f = l.reduce((o, r) => n(e.palette, r) < n(e.palette, o) ? r : o);
+  if (n(e.palette, a) - n(e.palette, f) < 32) throw new Error(`${i}: no light and dark colors to letter the version in`);
+  const u = `v${s}`;
+  k(m, c.x ?? y - v(u), c.y ?? P, u, a, f), t.set(i, h({ ...e, pixels: m.px }));
+}
+export {
+  E as stampMenuVersion
+};

package/dist/kit/microText.js

@@ -0,0 +1,35 @@
+import { MICRO_GLYPHS as k } from "../microFont.js";
+import { textInk as w } from "./textBounds.js";
+function y(f = {}) {
+  const { glyphs: t = k, fallback: m = "?", trailingGap: C = !1, glyphCase: a = !0, custom: g } = f;
+  if (!(m in t)) throw new RangeError("Micro font must contain its fallback glyph");
+  return (h, s, u, p, M, o = 1) => {
+    const d = w(h, p, void 0, (r) => r in t || r.toUpperCase() in t || !!g?.(r)), l = (r, i, e = M) => {
+      h.rect(r, i, o, o, e), d?.add(r, i, o, o);
+    };
+    let c = s;
+    for (const r of a ? p : p.toUpperCase()) {
+      const i = g?.(r);
+      if (i) {
+        for (let e = 0; e < i.h; e++)
+          for (let n = 0; n < i.w; n++) {
+            const x = i.get(n, e);
+            x !== 255 && l(c + n * o, u + e * o, x);
+          }
+        c += (i.w + 1) * o;
+      } else {
+        const e = (a ? t[r] ?? t[r.toUpperCase()] : t[r]) ?? t[m];
+        for (let n = 0; n < 15; n++) e[n] === "1" && l(c + n % 3 * o, u + Math.floor(n / 3) * o);
+        c += 4 * o;
+      }
+    }
+    return d?.end(), c - s - (C ? 0 : o);
+  };
+}
+const U = (f, t = 1) => f.length * 4 * t - t, G = (f, t = 1) => Math.max(0, U(f, t)), I = y();
+export {
+  y as createMicroText,
+  I as micro,
+  U as microAdvance,
+  G as microWidth
+};

package/dist/kit/mumble.js

@@ -0,0 +1,74 @@
+import { encodeVoc as P } from "@lewismoten/gamemaker-sandbox-engine/formats/voc";
+const E = {
+  a: [800, 1250],
+  e: [520, 1850],
+  i: [310, 2250],
+  o: [520, 950],
+  u: [340, 850]
+}, S = {
+  bright: { pitch: 300, speed: 1 },
+  deep: { pitch: 125, speed: 0.8 },
+  small: { pitch: 420, speed: 1.3 }
+};
+function z(e) {
+  let t = 0, s = 0;
+  return (i, h, a) => {
+    const l = Math.exp(-Math.PI * a / e), m = 2 * l * Math.cos(2 * Math.PI * h / e), f = -l * l, n = (1 - m - f) * i + m * t + f * s;
+    return s = t, t = n, n;
+  };
+}
+function C(e) {
+  return e.reduce((t, s) => t + s[3] + (s[4] ?? 0), 0);
+}
+function F(e, t = {}) {
+  const s = t.rate ?? 11025, i = t.gain ?? 1.6, h = C(e), a = Math.round(h * s), l = new Float32Array(a), m = z(s), f = z(s);
+  let n = 0, c = t.noiseSeed ?? 11;
+  const p = () => (c = c * 1103515245 + 12345 & 2147483647, c / 1073741823 - 1), b = (r) => {
+    let u = 0, o, d = 0;
+    for (const y of e) {
+      const w = y[3] + (y[4] ?? 0);
+      if (r < u + w) {
+        o = y, d = r - u;
+        break;
+      }
+      u += w;
+    }
+    if (!o || d > o[3]) return 0;
+    const M = d / o[3], g = o[1] + (o[2] - o[1]) * M, [I, V] = E[o[0]];
+    n += g / s, n -= Math.floor(n);
+    const k = (n < 0.5 ? n * 4 - 1 : 3 - n * 4) * 0.8 + (n * 2 - 1) * 0.2, v = p() * Math.max(0, 0.5 - M * 3), L = Math.sin(Math.PI * Math.min(1, M * 1.15)) ** 0.7, x = k + v;
+    return (m(x, I, 90) * 0.9 + f(x, V, 140) * 0.55) * L;
+  };
+  for (let r = 0; r < a; r++) {
+    const u = r / s, o = u / h, d = Math.min(1, o * 40) * Math.min(1, (1 - o) * 25);
+    l[r] = Math.max(-1, Math.min(1, b(u) * d * i));
+  }
+  return l;
+}
+function B(e, t = {}) {
+  return P(F(e, t), t.rate ?? 11025);
+}
+function O(e) {
+  let t = e >>> 0 || 1;
+  return () => (t = Math.imul(t, 1664525) + 1013904223 >>> 0, t / 4294967296);
+}
+function T(e, t = {}) {
+  const s = t.pitch ?? S.bright.pitch, i = Math.max(0.2, t.speed ?? 1), h = O(t.seed ?? 1), a = [], l = e.toLowerCase().match(/[a-z']+[^a-z'\s]*/g) ?? [];
+  for (const m of l) {
+    const f = m.match(/[aeiouy]+/g) ?? ["u"];
+    f.forEach((p, b) => {
+      const r = p.replace("y", "i")[0], u = r in E ? r : "u", o = s * (0.85 + h() * 0.3), d = o * (0.85 + h() * 0.3), M = (0.16 + 0.04 * p.length + h() * 0.06) / i, g = b === f.length - 1;
+      a.push([u, o, d, M, g ? 0.08 / i : 0.02 / i]);
+    });
+    const n = m.match(/[^a-z'\s]+$/)?.[0] ?? "", c = a[a.length - 1];
+    c && n && (/[?]/.test(n) ? c[2] = c[1] * 1.3 : /[.!]/.test(n) && (c[2] = c[1] * 0.7, c[3] *= 1.5), c[4] = (/[,;:]/.test(n) ? 0.14 : 0.25) / i);
+  }
+  return a;
+}
+export {
+  S as MUMBLE_VOICES,
+  F as mumble,
+  C as mumbleSeconds,
+  B as mumbleVoc,
+  T as syllablesFromText
+};

package/dist/kit/music.js

@@ -0,0 +1,8 @@
+import { INSTRUMENTS as n, blankSong as S, midi as b, sbi as g, song as m } from "../music/compose.js";
+export {
+  n as INSTRUMENTS,
+  S as blankSong,
+  b as midi,
+  g as sbi,
+  m as song
+};

package/dist/kit/palRamps.js

@@ -0,0 +1,32 @@
+import { PaletteBuilder as p } from "./palette.js";
+function u(e) {
+  const t = (r) => e.get(r);
+  return {
+    pal: e.pal,
+    r: t,
+    c: (r, n) => {
+      const o = t(r);
+      return o[Math.max(0, Math.min(o.length - 1, n))];
+    }
+  };
+}
+const d = (e) => ({ ...u(e), b: e });
+function h(e, t = {}) {
+  const r = new p();
+  t.designerColors !== !1 && r.designerColors();
+  for (const [n, o, s, c, i, f] of e) {
+    const l = t.overrides?.[n];
+    if (l) {
+      r.ramp(n, o, ...l);
+      continue;
+    }
+    const a = (m) => t.transform?.(n, m, !!f) ?? m;
+    r.ramp(n, o, a(s), a(c), i ? a(i) : void 0);
+  }
+  return d(r);
+}
+export {
+  h as buildRampPalette,
+  u as wrap,
+  d as wrapWithBuilder
+};

package/dist/kit/palette.js

@@ -0,0 +1,49 @@
+class f {
+  pal = new Uint8Array(768);
+  next = 0;
+  ramps = /* @__PURE__ */ new Map();
+  /** One color from 8-bit RGB; returns its index. */
+  color(r, t, e) {
+    const s = this.next++;
+    if (s > 254) throw new Error('Palette full (255 is "clear")');
+    return this.pal.set([r >> 2, t >> 2, e >> 2], s * 3), s;
+  }
+  /** A ramp of n shades from dark to light (8-bit RGB stops); returns the indexes. */
+  ramp(r, t, e, s, n) {
+    const a = [];
+    for (let l = 0; l < t; l++) {
+      const o = t === 1 ? 0 : l / (t - 1), [c, h, p] = n ? o < 0.5 ? [e, n, o * 2] : [n, s, (o - 0.5) * 2] : [e, s, o];
+      a.push(this.color(...c.map((i, u) => Math.round(i + (h[u] - i) * p))));
+    }
+    return this.ramps.set(r, a), a;
+  }
+  get(r) {
+    const t = this.ramps.get(r);
+    if (!t) throw new Error(`No ramp ${r}`);
+    return t;
+  }
+  /**
+   * Game-Maker's designers look for these grays, reds, black and LCD green; keep them. Black
+   * comes first: PLAYGAME clears the screen to color 0 before the high score prompt.
+   */
+  designerColors() {
+    for (const [r, t, e] of [
+      [0, 0, 0],
+      [33, 33, 33],
+      [43, 0, 0],
+      [28, 0, 0],
+      [28, 28, 28],
+      [23, 23, 23],
+      [18, 18, 18],
+      [53, 0, 0],
+      [8, 48, 24]
+    ])
+      this.color(r * 4, t * 4, e * 4);
+  }
+  get used() {
+    return this.next;
+  }
+}
+export {
+  f as PaletteBuilder
+};

package/dist/kit/pcText.js

@@ -0,0 +1,72 @@
+import { textInk as F } from "./textBounds.js";
+import { FONT8X8 as I } from "@lewismoten/gamemaker-sandbox-engine/gfx/font8x8";
+const O = (g, k = 1) => g.length * 8 * k;
+function M(g = {}) {
+  const {
+    custom: k,
+    shadowPixels: T,
+    shadowOffsets: W = [
+      [2, 2],
+      [1, 2],
+      [2, 1]
+    ],
+    outlineDistance: p = () => 1,
+    codePointWidth: A = !1,
+    shadowZero: C = !0
+  } = g;
+  function b(n, i, e, r, h, t = 1, o = !1) {
+    const x = F(n, r), m = (d, u, f = h) => {
+      n.rect(d, u, t, t, f), x?.add(d, u, t, t);
+    };
+    let w = i;
+    for (const d of r) {
+      const u = k?.(d, h, o);
+      if (u)
+        for (let f = 0; f < u.h; f++)
+          for (let c = 0; c < u.w; c++) {
+            const s = u.get(c, f);
+            s !== 255 && m(w + c * t, e + f * t, s);
+          }
+      else {
+        const f = (d.charCodeAt(0) & 255) * 8;
+        for (let c = 0; c < 8; c++) {
+          const s = I[f + c];
+          for (let P = 0; P < 8; P++) s & 1 << P && m(w + P * t, e + c * t);
+        }
+      }
+      w += 8 * t;
+    }
+    return x?.end(), A ? w - i : O(r, t);
+  }
+  function v(n, i, e, r, h, t, o = 1, x) {
+    if (x !== void 0 && (C || x !== 0))
+      for (const [w, d] of T?.(o) ?? W.map(([u, f]) => [u * o, f * o]))
+        b(n, i + w, e + d, r, x, o, !0);
+    const m = p(o);
+    for (const [w, d] of [
+      [-1, 0],
+      [1, 0],
+      [0, -1],
+      [0, 1],
+      [-1, -1],
+      [1, 1],
+      [1, -1],
+      [-1, 1]
+    ])
+      b(n, i + w * m, e + d * m, r, t, o, !0);
+    b(n, i, e, r, h, o);
+  }
+  function D(n, i, e, r, h = 1, t, o = n.w / 2, x) {
+    const m = Math.round(o - O(e, h) / 2);
+    t === void 0 ? b(n, m, i, e, r, h) : v(n, m, i, e, r, t, h, x);
+  }
+  return { text: b, outlined: v, centered: D };
+}
+const { text: Z, outlined: j, centered: q } = M();
+export {
+  q as centered,
+  M as createPcText,
+  j as outlined,
+  Z as text,
+  O as textWidth
+};

package/dist/kit/photo.js

@@ -0,0 +1,150 @@
+import { readFileSync as C } from "node:fs";
+import { decodePartialJpeg as F } from "@lewismoten/gamemaker-sandbox-engine/formats/jpeg";
+const G = 5 / 6;
+function _(t) {
+  const o = F(new Uint8Array(C(t)));
+  if (!o?.complete || o.channels !== 3) throw new Error("JPEG scan did not decode");
+  return { w: o.width, h: o.height, rgb: o.pixels };
+}
+function $(t, o, c = 0, w = [0, 0, 1, 1]) {
+  const [h, n, x, e] = w, a = h * t.w, f = n * t.h, r = (x - h) * t.w, i = (e - n) * t.h;
+  c || (c = Math.round(o * G * i / r));
+  const s = new Uint8Array(o * c * 3), u = r / o, l = i / c;
+  for (let d = 0; d < c; d++)
+    for (let m = 0; m < o; m++) {
+      const y = a + m * u, M = f + d * l, P = y + Math.max(u, 1), v = M + Math.max(l, 1), b = [0, 0, 0];
+      let S = 0;
+      for (let g = Math.floor(M); g < Math.ceil(v); g++)
+        for (let p = Math.floor(y); p < Math.ceil(P); p++) {
+          const E = (Math.min(p + 1, P) - Math.max(p, y)) * (Math.min(g + 1, v) - Math.max(g, M));
+          if (E <= 0) continue;
+          const U = (Math.min(t.h - 1, g) * t.w + Math.min(t.w - 1, p)) * 3;
+          for (let A = 0; A < 3; A++) b[A] += t.rgb[U + A] * E;
+          S += E;
+        }
+      for (let g = 0; g < 3; g++) s[(d * o + m) * 3 + g] = Math.round(b[g] / S);
+    }
+  return { w: o, h: c, rgb: s };
+}
+function I(t, o) {
+  const c = new Uint8Array(t.rgb.length);
+  for (let w = 0; w < c.length; w += 3) {
+    const h = o([t.rgb[w], t.rgb[w + 1], t.rgb[w + 2]]);
+    for (let n = 0; n < 3; n++) c[w + n] = Math.max(0, Math.min(255, Math.round(h[n])));
+  }
+  return { ...t, rgb: c };
+}
+function z(t, o = [40, 24, 10], c = [250, 230, 190], w = 1.1) {
+  return I(t, ([h, n, x]) => {
+    const e = Math.max(0, Math.min(1, ((0.299 * h + 0.587 * n + 0.114 * x) / 255 - 0.5) * w + 0.5));
+    return [0, 1, 2].map((a) => o[a] + (c[a] - o[a]) * e);
+  });
+}
+function J(t, o) {
+  const c = /* @__PURE__ */ new Map();
+  for (let e = 0; e < t.rgb.length; e += 3) {
+    const a = t.rgb[e] >> 3 << 10 | t.rgb[e + 1] >> 3 << 5 | t.rgb[e + 2] >> 3;
+    c.set(a, (c.get(a) ?? 0) + 1);
+  }
+  let h = [[...c.entries()].sort((e, a) => e[0] - a[0]).map(([e, a]) => ({ c: [e >> 10 & 31, e >> 5 & 31, e & 31], n: a }))];
+  const n = (e, a) => {
+    let f = 31, r = 0;
+    for (const i of e)
+      f = Math.min(f, i.c[a]), r = Math.max(r, i.c[a]);
+    return r - f;
+  }, x = (e) => e.reduce((a, f) => a + f.n, 0);
+  for (; h.length < o; ) {
+    let e = -1, a = 0;
+    if (h.forEach((l, d) => {
+      if (l.length < 2) return;
+      const m = Math.max(n(l, 0), n(l, 1), n(l, 2)) * Math.sqrt(x(l));
+      m > a && ([a, e] = [m, d]);
+    }), e < 0) break;
+    const f = h[e], r = [0, 1, 2].reduce((l, d) => n(f, d) > n(f, l) ? d : l, 0);
+    f.sort((l, d) => l.c[r] - d.c[r] || l.c[0] - d.c[0] || l.c[1] - d.c[1] || l.c[2] - d.c[2]);
+    const i = x(f) / 2;
+    let s = 0, u = 1;
+    for (; u < f.length - 1 && !((s += f[u - 1].n) >= i); u++) ;
+    h = [...h.slice(0, e), f.slice(0, u), f.slice(u), ...h.slice(e + 1)];
+  }
+  return h.map((e) => {
+    const a = x(e);
+    return [0, 1, 2].map((f) => Math.min(63, Math.round(e.reduce((r, i) => r + (i.c[f] * 8 + 4) * i.n, 0) / a / 4)));
+  });
+}
+function L(t, o, c = []) {
+  const w = new Set(c);
+  for (let n = 0; n < t.h; n++)
+    for (let x = 0; x < t.w; x++)
+      o && x >= o.x && n >= o.y && x < o.x + o.w && n < o.y + o.h || w.add(t.px[n * t.w + x]);
+  const h = [];
+  for (let n = 0; n < 256; n++) w.has(n) || h.push(n);
+  return h;
+}
+function T(t, o, c) {
+  const w = (r) => r << 2 | r >> 4, h = c.map((r) => [w(o[r * 3]), w(o[r * 3 + 1]), w(o[r * 3 + 2])]), n = /* @__PURE__ */ new Map(), x = (r, i, s) => {
+    const u = r >> 2 << 12 | i >> 2 << 6 | s >> 2;
+    let l = n.get(u);
+    if (l !== void 0) return l;
+    let d = 1 / 0;
+    return l = 0, h.forEach((m, y) => {
+      const M = 3 * (m[0] - r) ** 2 + 4 * (m[1] - i) ** 2 + 2 * (m[2] - s) ** 2;
+      M < d && ([d, l] = [M, y]);
+    }), n.set(u, l), l;
+  }, e = Float32Array.from(t.rgb), a = new Uint8Array(t.w * t.h), f = (r) => Math.max(0, Math.min(255, Math.round(r)));
+  for (let r = 0; r < t.h; r++) {
+    const i = r % 2 === 1;
+    for (let s = 0; s < t.w; s++) {
+      const u = i ? t.w - 1 - s : s, l = r * t.w + u, d = f(e[l * 3]), m = f(e[l * 3 + 1]), y = f(e[l * 3 + 2]), M = x(d, m, y);
+      a[l] = c[M];
+      const P = [d - h[M][0], m - h[M][1], y - h[M][2]], v = i ? -1 : 1, b = (S, g, p) => {
+        const E = u + S * v, U = r + g;
+        if (E < 0 || E >= t.w || U >= t.h) return;
+        const A = (U * t.w + E) * 3;
+        for (let j = 0; j < 3; j++) e[A + j] += P[j] * p;
+      };
+      b(1, 0, 7 / 16), b(-1, 1, 3 / 16), b(0, 1, 5 / 16), b(1, 1, 1 / 16);
+    }
+  }
+  return a;
+}
+function B(t, o, c, w, h, n = {}) {
+  const x = L(t, { x: w, y: h, w: c.w, h: c.h }, n.reserved), e = x.slice(0, n.colors ?? x.length);
+  if (e.length < 16) throw new Error(`pastePhoto: only ${e.length} free palette entries`);
+  const a = o.slice();
+  J(c, e.length).forEach((i, s) => a.set(i, e[s] * 3));
+  let f = e;
+  if (n.share ?? !0) {
+    const i = /* @__PURE__ */ new Set();
+    for (let s = 0; s < t.h; s++) for (let u = 0; u < t.w; u++) (u < w || s < h || u >= w + c.w || s >= h + c.h) && i.add(t.px[s * t.w + u]);
+    f = [...e, ...[...i].filter((s) => !(n.reserved ?? []).includes(s)).sort((s, u) => s - u)];
+  }
+  const r = T(c, a, f);
+  for (let i = 0; i < c.h; i++) for (let s = 0; s < c.w; s++) t.set(w + s, h + i, r[i * c.w + s]);
+  return { pal: a, slots: e };
+}
+function D(t, o, c, w, h, n, x = 14) {
+  const [e, a, f, r] = [o - 4, c - 4, w + 8, h + 4 + x];
+  if ((n.shadow ?? -1) >= 0 && t.rect(e + 3, a + 3, f, r, n.shadow), t.rect(e, a, f, r, n.paper).frame(e, a, f, r, n.edge), (n.tape ?? -1) >= 0)
+    for (const [i, s] of [
+      [e - 5, 1],
+      [e + f - 17, -1]
+    ])
+      for (let u = 0; u < 22; u++)
+        for (let l = 0; l < 7; l++) {
+          const d = i + u, m = a - 6 + l + Math.round((s > 0 ? 21 - u : u) / 3);
+          ((d + m) % 2 === 0 || l === 0 || l === 6) && t.set(d, m, n.tape);
+        }
+  return { cx: e + f / 2, cy: c + h + x / 2 };
+}
+export {
+  T as ditherTo,
+  L as freeColors,
+  J as medianCut,
+  B as pastePhoto,
+  D as polaroid,
+  _ as readScan,
+  $ as resample,
+  z as sepia,
+  I as tone
+};

package/dist/kit/pixels.js

@@ -0,0 +1,79 @@
+class a {
+  constructor(h, t, i = 0) {
+    this.w = h, this.h = t, this.px = new Uint8Array(h * t).fill(i);
+  }
+  w;
+  h;
+  px;
+  get(h, t) {
+    return h < 0 || t < 0 || h >= this.w || t >= this.h ? -1 : this.px[t * this.w + h];
+  }
+  set(h, t, i) {
+    return h = Math.round(h), t = Math.round(t), h >= 0 && t >= 0 && h < this.w && t < this.h && (this.px[t * this.w + h] = i), this;
+  }
+  rect(h, t, i, e, r) {
+    for (let s = t; s < t + e; s++) for (let n = h; n < h + i; n++) this.set(n, s, r);
+    return this;
+  }
+  frame(h, t, i, e, r) {
+    return this.rect(h, t, i, 1, r).rect(h, t + e - 1, i, 1, r), this.rect(h, t, 1, e, r).rect(h + i - 1, t, 1, e, r);
+  }
+  line(h, t, i, e, r) {
+    const s = Math.max(Math.abs(i - h), Math.abs(e - t), 1);
+    for (let n = 0; n <= s; n++) this.set(h + (i - h) * n / s, t + (e - t) * n / s, r);
+    return this;
+  }
+  disc(h, t, i, e) {
+    for (let r = Math.floor(t - i); r <= t + i; r++)
+      for (let s = Math.floor(h - i); s <= h + i; s++) (s - h) ** 2 + (r - t) ** 2 <= i * i && this.set(s, r, e);
+    return this;
+  }
+  ring(h, t, i, e) {
+    for (let r = 0; r < Math.PI * 2; r += 0.5 / Math.max(1, i)) this.set(h + Math.cos(r) * i, t + Math.sin(r) * i, e);
+    return this;
+  }
+  /** Every pixel through fn(x, y, current) → new color (or the same). */
+  map(h) {
+    for (let t = 0; t < this.h; t++) for (let i = 0; i < this.w; i++) this.px[t * this.w + i] = h(i, t, this.px[t * this.w + i]);
+    return this;
+  }
+  /** Copies another picture in, skipping `transparent` pixels. */
+  blit(h, t, i, e = -1) {
+    for (let r = 0; r < h.h; r++)
+      for (let s = 0; s < h.w; s++) {
+        const n = h.px[r * h.w + s];
+        n !== e && this.set(t + s, i + r, n);
+      }
+    return this;
+  }
+  /** A sub-rectangle as a new picture (cutting a 20x20 block out of a big drawing). */
+  crop(h, t, i, e) {
+    const r = new a(i, e);
+    for (let s = 0; s < e; s++) for (let n = 0; n < i; n++) r.px[s * i + n] = this.get(h + n, t + s) & 255;
+    return r;
+  }
+  flipX() {
+    return new a(this.w, this.h).map((t, i) => this.get(this.w - 1 - t, i));
+  }
+  /** ASCII art: each character maps to a color through `key`; others are skipped. */
+  draw(h, t, i, e) {
+    return i.forEach((r, s) => [...r].forEach((n, f) => n in e && this.set(h + f, t + s, e[n]))), this;
+  }
+}
+function l(o) {
+  let h = o >>> 0;
+  return () => {
+    h = h + 1831565813 >>> 0;
+    let t = h;
+    return t = Math.imul(t ^ t >>> 15, t | 1), t ^= t + Math.imul(t ^ t >>> 7, t | 61), ((t ^ t >>> 14) >>> 0) / 4294967296;
+  };
+}
+function u(o, h, t) {
+  const i = [0, 8, 2, 10, 12, 4, 14, 6, 3, 11, 1, 9, 15, 7, 13, 5];
+  return t * 16 > i[(h & 3) * 4 + (o & 3)];
+}
+export {
+  a as Pixels,
+  u as dither,
+  l as rng
+};

package/dist/kit/png.js

@@ -0,0 +1,40 @@
+import { crc32 as x } from "@lewismoten/gamemaker-sandbox-archives/zip";
+import { deflateSync as D } from "node:zlib";
+import { writeFileSync as p } from "node:fs";
+import { Pixels as M } from "./pixels.js";
+function y(h, t) {
+  const r = new Uint8Array(12 + t.length), o = new DataView(r.buffer);
+  o.setUint32(0, t.length);
+  for (let e = 0; e < 4; e++) r[4 + e] = h.charCodeAt(e);
+  return r.set(t, 8), o.setUint32(8 + t.length, x(r.subarray(4, 8 + t.length))), r;
+}
+function v(h, t, r, o = 1) {
+  const e = t.w * o, w = t.h * o, i = new Uint8Array((e * 3 + 1) * w);
+  for (let n = 0; n < w; n++) {
+    i[n * (e * 3 + 1)] = 0;
+    for (let f = 0; f < e; f++) {
+      const u = t.px[Math.floor(n / o) * t.w + Math.floor(f / o)], a = n * (e * 3 + 1) + 1 + f * 3;
+      if (u === 255) {
+        const l = (f >> 3) + (n >> 3) & 1 ? 200 : 160;
+        i[a] = i[a + 1] = i[a + 2] = l;
+      } else for (let l = 0; l < 3; l++) i[a + l] = r[u * 3 + l] << 2 | r[u * 3 + l] >> 4;
+    }
+  }
+  const c = new Uint8Array(13), s = new DataView(c.buffer);
+  s.setUint32(0, e), s.setUint32(4, w), c.set([8, 2, 0, 0, 0], 8);
+  const g = [Uint8Array.from([137, 80, 78, 71, 13, 10, 26, 10]), y("IHDR", c), y("IDAT", D(i)), y("IEND", new Uint8Array(0))], A = g.reduce((n, f) => n + f.length, 0), U = new Uint8Array(A);
+  let m = 0;
+  for (const n of g)
+    U.set(n, m), m += n.length;
+  p(h, U);
+}
+function E(h, t = 16, r = 0) {
+  const o = Math.ceil(h.length / t), e = new M(t * 22, o * 22, r);
+  return h.forEach((w, i) => {
+    for (let c = 0; c < 20; c++) for (let s = 0; s < 20; s++) e.set(i % t * 22 + s, Math.floor(i / t) * 22 + c, w.pixels[c * 20 + s]);
+  }), e;
+}
+export {
+  E as blockSheet,
+  v as writePng
+};