@lewismoten/gamemaker-sandbox-tools 3.1.0 → 3.4.0

package/dist/kit/songFx.js

@@ -0,0 +1,179 @@
+import { midi as x } from "../music/compose.js";
+const M = { kick: 11, snare: 12, tom: 13, cymbal: 14, hat: 15 }, A = { w: 4, h: 2, q: 1, e: 0.5, s: 0.25, t: 1 / 3, x: 1 / 6 };
+function E(l) {
+  const t = [];
+  for (const r of l.split(",").map((n) => n.trim()).filter(Boolean)) {
+    const n = /^(~+)?(\S+)\s+([whqestx])(\.?)(\\+)?([!-]*)$/.exec(r);
+    if (!n) throw new Error(`Bad note "${r}"`);
+    const o = A[n[3]] * (n[4] ? 1.5 : 1), s = [...n[6]].reduce((i, h) => i + (h === "!" ? 14 : -18), 0);
+    if (n[2] === "_") {
+      const i = t[t.length - 1];
+      if (!i) throw new Error("A hold with nothing to hold");
+      t.push({ n: i.n, beats: o, scoop: 0, fall: n[5] ? n[5].length * 2 : 0, accent: 0, tie: !0 });
+      continue;
+    }
+    t.push({ n: x(n[2]), beats: o, scoop: n[1] ? n[1].length * 2 : 0, fall: n[5] ? n[5].length * 2 : 0, accent: s, tie: !1 });
+  }
+  return t;
+}
+function U(l, t) {
+  const r = Uint8Array.from(l);
+  return t.mod !== void 0 && (r[2] = r[2] & 192 | Math.max(0, Math.min(63, Math.round(t.mod)))), t.car !== void 0 && (r[3] = r[3] & 192 | Math.max(0, Math.min(63, Math.round(t.car)))), r;
+}
+function B(l) {
+  const t = Uint8Array.from(l);
+  return t[0] ^= 64, t[1] ^= 64, t;
+}
+function q(l, t, r) {
+  const n = Uint8Array.from(l);
+  return n[8] = t & 3, n[9] = r & 3, n;
+}
+function F(l, t, r, n) {
+  const o = (s, i, h) => s === void 0 || i === void 0 ? void 0 : s + (i - s) * h;
+  return Array.from({ length: t }, (s, i) => {
+    const h = t === 1 ? 1 : i / (t - 1);
+    return U(l, { mod: o(r.mod, n.mod, h), car: o(r.car, n.car, h) });
+  });
+}
+const v = (l, t, r) => Math.max(1, Math.min(127, Math.round(l + (t - l) * Math.max(0, Math.min(1, r)))));
+class R {
+  constructor(t) {
+    this.w = t;
+  }
+  w;
+  /** The patch each channel has now (after its program changes). */
+  now = /* @__PURE__ */ new Map();
+  /** Where each section starts (beat), for the preview tools. */
+  sections = [];
+  tick(t) {
+    return Math.round(t * this.w.tpb);
+  }
+  /** The channel's opening patch (instrument n for channel n, loaded before the first note). */
+  open(t, r) {
+    return this.w.instruments[t] = r, this.now.set(t, r), this;
+  }
+  /** The instrument number of a patch: a channel's own opening patch, or one of the extra ones from 16 up (128 at most). */
+  patch(t) {
+    const r = this.w.instruments;
+    for (let o = 0; o < r.length; o++) if (r[o] && (r[o] === t || k(r[o], t))) return o;
+    const n = Math.max(16, r.length);
+    if (n >= 128) throw new Error("A CMF holds 128 instruments");
+    return r[n] = t, n;
+  }
+  /** A program change at beat `at` (nothing if the channel already has the patch). */
+  program(t, r, n) {
+    const o = this.now.get(t);
+    return o && (o === n || k(o, n)) ? this : (this.w.events.push({ tick: this.tick(r), data: [192 | t, this.patch(n)] }), this.now.set(t, n), this);
+  }
+  /** A section's start: a CMF marker (controller 0x66, value = its number) that PLAYGAME skips. */
+  marker(t, r) {
+    return this.sections.push({ at: t, name: r }), this.w.events.push({ tick: this.tick(t), data: [176, 102, Math.min(127, this.sections.length)] }), this;
+  }
+  /** One note, `len` beats from `at` (legato: the part of it held before letting go). */
+  note(t, r, n, o, s, i = 0.92) {
+    return this.w.note(t, r, n, o, Math.max(1, Math.min(127, Math.round(s))), i), this;
+  }
+  /**
+   * A phrase from beat `at` on one channel (see tones()): scoops slide up into their note in
+   * two-tick steps, falls slide away at the end, ties hold on. Returns its length in beats.
+   */
+  phrase(t, r, n, o, s = 0, i = 0.92) {
+    const h = E(n);
+    let e = r;
+    for (let c = 0; c < h.length; c++) {
+      const a = h[c];
+      if (a.n === null || a.tie) {
+        e += a.beats;
+        continue;
+      }
+      let p = a.beats, u = a.fall;
+      for (let d = c + 1; d < h.length && h[d].tie; d++)
+        p += h[d].beats, u = h[d].fall || u;
+      const f = a.n + s, w = o + a.accent;
+      let m = e;
+      a.scoop && (m = this.slide(t, e, f - a.scoop, f - 1, 2, w - 10));
+      const b = u ? u * 2 / this.w.tpb : 0, g = Math.max(1 / this.w.tpb, e + p * i - m - b);
+      u ? this.note(t, m, g + 1 / this.w.tpb, f, w, 1) : this.note(t, m, e + p - m, f, w, i), u && this.slide(t, m + g + 1 / this.w.tpb, f - 1, f - u, 2, w - 20), e += a.beats;
+    }
+    return e - r;
+  }
+  /** Semitone steps from `from` to `to`, `ticks` timer ticks each, on one channel; returns the beat it ends on. */
+  slide(t, r, n, o, s, i) {
+    const h = o >= n ? 1 : -1, e = s / this.w.tpb;
+    let c = r;
+    for (let a = n; h > 0 ? a <= o : a >= o; a += h)
+      this.note(t, c, e, a, i, 1), c += e;
+    return c;
+  }
+  /** The same notes on two channels at once, the second with the twin patch (a two-voice choir). */
+  choir(t, r, n, o, s, i = 0) {
+    return this.phrase(t, n, o, s, i), this.phrase(r, n, o, s - 8, i);
+  }
+  /** Program changes on `chs` stepping through `patches` evenly over `beats` from `at` (a swell or a filter sweep). */
+  swell(t, r, n, o) {
+    return o.forEach((s, i) => {
+      const h = r + (o.length === 1 ? 0 : n * i / (o.length - 1));
+      for (const e of t) this.program(e, h, s);
+    }), this;
+  }
+  /** A chord on one channel: its notes in turn, one every `every` beats, for `beats` ('up', 'down', 'updown'). */
+  arp(t, r, n, o, s, i, h = "up") {
+    const e = h === "up" ? o : h === "down" ? [...o].reverse() : [...o, ...o.slice(1, -1).reverse()], c = Math.round(n / s);
+    for (let a = 0; a < c; a++) this.note(t, r + a * s, s, e[a % e.length], i, 0.95);
+    return this;
+  }
+  /** A chord spread round several channels, a note every `every` beats; each rings on until its channel's next note (a harp). */
+  harp(t, r, n, o, s, i) {
+    const h = Math.round(n / s);
+    for (let e = 0; e < h; e++) {
+      const c = Math.min(h, e + t.length) * s, a = typeof i == "number" ? i : i(e);
+      this.note(t[e % t.length], r + e * s, c - e * s, o[e % o.length], a, 0.97);
+    }
+    return this;
+  }
+  /** The phrase again on `ch`, `delay` beats later, `times` times, each softer (an echo). */
+  echo(t, r, n, o, s, i = 1, h = 0.6, e = 0) {
+    for (let c = 1; c <= i; c++) this.phrase(t, r + s * c, n, o * h ** c, e, 0.7);
+    return this;
+  }
+  /** One note retriggered on its own channel `times` times, `gap` beats apart, each softer. */
+  stutter(t, r, n, o, s, i, h = 0.72) {
+    for (let e = 0; e < o; e++) this.note(t, r + e * s, s, n, i * h ** e, 0.8);
+    return this;
+  }
+  /** The bass drum as a pitched voice (its patch from boomPatch). */
+  boom(t, r, n, o) {
+    return this.note(M.kick, t, r, n, o, 0.9);
+  }
+  /** A drum hit every `every` beats for `beats`, velocity ramping (a roll); tuned drums (tom, kick) walk through `notes`. */
+  drumRoll(t, r, n, o, s, i, h = [t === M.tom ? 48 : t === M.cymbal ? 72 : 55]) {
+    const e = Math.round(n / o);
+    for (let c = 0; c < e; c++)
+      this.note(t, r + c * o, Math.min(o, 0.5), h[c % h.length], v(s, i, e === 1 ? 1 : c / (e - 1)), 0.6);
+    return this;
+  }
+  /** Puts every drum channel back on its opening patch and the song's length in bars, then writes the CMF. */
+  cmf(t) {
+    this.w.bar = t;
+    for (const r of [11, 12, 13, 14, 15]) {
+      const n = this.w.instruments[r];
+      n && this.program(r, t * 4, n);
+    }
+    return this.w.cmf();
+  }
+}
+const k = (l, t) => l.length === t.length && l.every((r, n) => r === t[n]);
+function _(l = {}) {
+  const t = l.growl ?? 32;
+  return Uint8Array.from([33, 33, t, 0, 244, 240 | (l.decay ?? 3), 15, 16 | (l.release ?? 6), 0, 0, 4, 0, 0, 0, 0, 0]);
+}
+export {
+  M as DRUM,
+  R as Fx,
+  _ as boomPatch,
+  B as detuned,
+  U as leveled,
+  F as sweep,
+  E as tones,
+  q as waved
+};

package/dist/kit/sound.js

@@ -0,0 +1,52 @@
+import { encodeVoc as M } from "@lewismoten/gamemaker-sandbox-engine/formats/voc";
+import { NUMFREQ as u } from "@lewismoten/gamemaker-sandbox-engine/formats/sound";
+import { rng as h } from "./pixels.js";
+function a(t) {
+  return Uint16Array.from({ length: u }, (n, e) => Math.max(0, Math.min(8192, Math.round(t(e, e / (u - 1))))));
+}
+const k = {
+  rise: (t = 200, n = 2e3) => a((e, r) => t * (n / t) ** r),
+  fall: (t = 2e3, n = 150) => a((e, r) => t * (n / t) ** r),
+  coin: () => a((t) => t < 4 ? 988 : t < 18 ? 1319 : 0),
+  hurt: () => a((t) => (t % 2 ? 140 : 95) * (1 - t / 60)),
+  zap: () => a((t) => 3e3 - t * 75 + t % 3 * 300),
+  chirp: () => a((t) => t < 12 ? 1200 + t * 120 : 0),
+  arpeggio: (t = [523, 659, 784, 1047]) => a((n) => n < t.length * 6 ? t[Math.floor(n / 6)] : 0),
+  noise: (t = 1, n = 100, e = 2e3) => {
+    const r = h(t);
+    return a((o) => o < 30 ? n + r() * (e - n) : 0);
+  },
+  warble: (t = 600, n = 300, e = 1.3) => a((r) => t + Math.sin(r * e) * n)
+}, f = {
+  sine: (t) => {
+    let n = 0, e = 0;
+    return (r) => {
+      const o = typeof t == "number" ? t : t(r);
+      return n += 2 * Math.PI * o * (r - e), e = r, Math.sin(n);
+    };
+  },
+  square: (t) => {
+    const n = f.sine(t);
+    return (e) => n(e) >= 0 ? 1 : -1;
+  },
+  noise: (t = 7) => {
+    const n = h(t);
+    return () => n() * 2 - 1;
+  }
+};
+function v(t, n, e = {}) {
+  const r = e.rate ?? 11025, o = Math.round(t * r), i = new Float32Array(o), l = e.attack ?? 5e-3;
+  for (let c = 0; c < o; c++) {
+    const s = c / r, m = e.envelope ? e.envelope(s / t) : Math.min(1, s / l) * (1 - s / t) ** 1.5;
+    i[c] = Math.max(-1, Math.min(1, n(s) * m * (e.gain ?? 0.9)));
+  }
+  return M(i, r);
+}
+const y = (...t) => (n) => t.reduce((e, [r, o]) => e + r(n) * o, 0);
+export {
+  k as SPEAKER,
+  y as mix,
+  f as osc,
+  v as sample,
+  a as speaker
+};

package/dist/kit/synthParts.js

@@ -0,0 +1,20 @@
+import { rng as s } from "./pixels.js";
+function i(e, t) {
+  const n = s(e);
+  let r = 0;
+  return (a) => {
+    const o = typeof t == "number" ? t : t(a);
+    return r += o * (n() * 2 - 1 - r), r * (1.4 / Math.sqrt(Math.max(0.05, o)));
+  };
+}
+const c = (e, t, n) => (r) => r >= t && r < n ? e(r) : 0, h = (e, t) => (n) => Math.min(1, n / e) * Math.max(0, 1 - n) ** t;
+function l(e, t) {
+  let n = 0;
+  return (r) => n += (e(r) - n) * t;
+}
+export {
+  h as env,
+  c as gate,
+  i as lowNoise,
+  l as lowpass
+};

package/dist/kit/tar.js

@@ -0,0 +1,53 @@
+const h = new TextEncoder();
+function s(e, r, t, n) {
+  const c = typeof n == "string" ? h.encode(n) : n;
+  if (c.length > t) throw new Error(`Tar field too long: ${typeof n == "string" ? n : c.length}`);
+  e.set(c, r);
+}
+const i = (e, r) => e.toString(8).padStart(r - 1, "0");
+function y(e) {
+  if (h.encode(e).length <= 100) return [e, ""];
+  for (let r = e.lastIndexOf("/", e.length - 2); r > 0; r = e.lastIndexOf("/", r - 1)) {
+    const [t, n] = [e.slice(0, r), e.slice(r + 1)];
+    if (h.encode(n).length <= 100 && h.encode(t).length <= 155) return [n, t];
+  }
+  throw new Error(`Path too long for a tar archive: ${e}`);
+}
+function x(e, r) {
+  const t = new Uint8Array(512), n = e.path.endsWith("/"), [c, o] = y(e.path);
+  s(t, 0, 100, c), s(t, 100, 8, i(e.mode ?? (n ? 493 : 420), 8)), s(t, 108, 8, i(0, 8)), s(t, 116, 8, i(0, 8)), s(t, 124, 12, i(n ? 0 : e.data?.length ?? 0, 12)), s(t, 136, 12, i(r, 12)), t.fill(32, 148, 156), t[156] = n ? 53 : 48, s(t, 257, 6, "ustar\0"), s(t, 263, 2, "00"), s(t, 265, 32, "gamemaker"), s(t, 297, 32, "gamemaker"), s(t, 345, 155, o);
+  const a = t.reduce((f, d) => f + d, 0);
+  return s(t, 148, 8, `${i(a, 7)}\0`), t;
+}
+function T(e, r = /* @__PURE__ */ new Date()) {
+  const t = Math.floor(r.getTime() / 1e3), n = [];
+  for (const a of e)
+    n.push(x(a, t)), a.data && !a.path.endsWith("/") && (n.push(a.data), a.data.length % 512 && n.push(new Uint8Array(512 - a.data.length % 512)));
+  n.push(new Uint8Array(1024));
+  const c = new Uint8Array(n.reduce((a, f) => a + f.length, 0));
+  let o = 0;
+  for (const a of n)
+    c.set(a, o), o += a.length;
+  return c;
+}
+async function g(e, r) {
+  return new Uint8Array(await new Response(new Blob([e]).stream().pipeThrough(r)).arrayBuffer());
+}
+async function k(e, r) {
+  return g(T(e, r), new CompressionStream("gzip"));
+}
+async function A(e) {
+  const r = e[0] === 31 && e[1] === 139 ? await g(e, new DecompressionStream("gzip")) : e, t = new TextDecoder(), n = (o, a) => t.decode(r.subarray(o, o + a)).replace(/\0.*$/s, ""), c = [];
+  for (let o = 0; o + 512 <= r.length && !r.subarray(o, o + 512).every((u) => u === 0); ) {
+    const a = parseInt(n(o + 148, 8).trim(), 8), f = r.subarray(o, o + 512).reduce((u, w, p) => u + (p >= 148 && p < 156 ? 32 : w), 0);
+    if (a !== f) throw new Error("Bad tar header checksum.");
+    const d = n(o + 345, 155), m = (d ? `${d}/` : "") + n(o, 100), l = parseInt(n(o + 124, 12), 8);
+    c.push({ path: m, mode: parseInt(n(o + 100, 8), 8), data: r.slice(o + 512, o + 512 + l) }), o += 512 + Math.ceil(l / 512) * 512;
+  }
+  return c;
+}
+export {
+  T as createTar,
+  k as createTarGz,
+  A as readTar
+};

package/dist/kit/textBounds.js

@@ -0,0 +1,84 @@
+const f = () => process.getBuiltinModule("node:fs"), x = (s) => /[\x20-\x7e\u25cf\u2022]/.test(s), u = typeof process < "u" ? process.env.TEXT_BOUNDS : void 0, p = [], o = /* @__PURE__ */ new Map(), d = (s, n, e, t) => `${s}x${n} ${e} ${t}`, m = /\/art\/(font|draw|canvas)\.ts|screens\/(draw|screen)\.ts/;
+function w() {
+  const s = (new Error().stack ?? "").split(`
+`).slice(1).map((t) => /\(?((?:\/|file:)[^():]+):(\d+):\d+\)?\s*$/.exec(t)).filter((t) => !!t).map((t) => ({ path: t[1].replace(/^file:\/\//, "").replace(/^.*\/games\//, ""), line: t[2] })).filter((t) => !/node_modules|kit\/textBounds\.ts/.test(t.path)).map((t) => ({ ...t, helper: m.test(t.path), name: `${t.path}:${t.line}` })), n = s.findIndex((t) => !t.helper);
+  return {
+    at: s.filter((t) => !t.helper).slice(0, 2).map((t) => t.name).join(" < "),
+    via: s.slice(0, n + 1).map((t) => t.name).join(" > ")
+  };
+}
+u && process.on("exit", () => {
+  const s = {
+    overflows: p,
+    shown: Object.fromEntries([...o].map(([n, e]) => [n, [...e].map((t) => t.split(",").map(Number))]))
+  };
+  f().writeFileSync(u, JSON.stringify(s));
+});
+class k {
+  constructor(n, e, t, i, r) {
+    this.w = n, this.h = e, this.s = t, this.area = i, this.has = r;
+  }
+  w;
+  h;
+  s;
+  area;
+  has;
+  x0 = 1 / 0;
+  y0 = 1 / 0;
+  x1 = -1 / 0;
+  y1 = -1 / 0;
+  /** A lit rectangle of the string (a font pixel, scaled). */
+  add(n, e, t = 1, i = 1) {
+    n < this.x0 && (this.x0 = n), e < this.y0 && (this.y0 = e), n + t > this.x1 && (this.x1 = n + t), e + i > this.y1 && (this.y1 = e + i);
+  }
+  end() {
+    if (this.x1 < this.x0) return;
+    const [n, e, t, i] = this.area, r = this.x0 < n - 0.5 || this.y0 < e - 0.5 || this.x1 > t + 0.5 || this.y1 > i + 0.5, { at: a, via: c } = w(), l = [...new Set(this.s)].filter((h) => !this.has(h)).join("");
+    if (l)
+      p.push({
+        s: this.s,
+        w: this.w,
+        h: this.h,
+        ink: [this.x0, this.y0, this.x1, this.y1].map((h) => Math.round(h)),
+        area: this.area,
+        at: a,
+        via: c,
+        missing: l
+      });
+    else if (r)
+      p.push({ s: this.s, w: this.w, h: this.h, ink: [this.x0, this.y0, this.x1, this.y1].map((h) => Math.round(h)), area: this.area, at: a, via: c });
+    else {
+      const h = d(this.w, this.h, c, this.s);
+      o.has(h) || o.set(h, /* @__PURE__ */ new Set()), o.get(h).add(`${Math.round(this.x0)},${Math.round(this.y0)}`);
+    }
+  }
+}
+function $(s, n, e, t = x) {
+  if (!(!u || !n.trim()))
+    return new k(s.w, s.h, n, e ?? [0, 0, s.w, s.h], t);
+}
+function y(s) {
+  const n = (i) => (s.shown[d(i.w, i.h, i.via, i.s)] ?? []).some(([r, a]) => Math.abs(r - i.ink[0]) > 2 || Math.abs(a - i.ink[1]) > 2), e = /* @__PURE__ */ new Map(), t = [];
+  for (const i of s.overflows) {
+    const r = d(i.w, i.h, i.via, i.s);
+    if (!i.missing && n(i)) {
+      t.push(i);
+      continue;
+    }
+    const a = e.get(r);
+    a ? a.ink = [Math.min(a.ink[0], i.ink[0]), Math.min(a.ink[1], i.ink[1]), Math.max(a.ink[2], i.ink[2]), Math.max(a.ink[3], i.ink[3])] : e.set(r, { ...i, ink: [...i.ink] });
+  }
+  return { cut: [...e.values()], moving: t };
+}
+function g(s) {
+  return s.missing ? `"${s.s}" has ${[...s.missing].map((n) => `U+${n.charCodeAt(0).toString(16).toUpperCase()}`).join(" ")}, a box in the PC font (${s.w}x${s.h}) at ${s.at}` : `"${s.s}" ink ${s.ink.join(",")} outside ${s.area.join(",")} (${s.w}x${s.h}) at ${s.at}`;
+}
+function M(s) {
+  if (!f().existsSync(s)) throw new Error(`${s}: the build wrote no text-bounds report`);
+  return y(JSON.parse(f().readFileSync(s, "utf8")));
+}
+export {
+  g as describe,
+  M as readBounds,
+  $ as textInk
+};

package/dist/kit/textfit.js

@@ -0,0 +1,246 @@
+import { readdirSync as O, readFileSync as j } from "node:fs";
+import { join as G } from "node:path";
+import { isGif as W, decodeGif as z } from "@lewismoten/gamemaker-sandbox-engine/formats/gif";
+import { isFli as D, parseFli as H, newFliCanvas as _, applyFliFrame as B } from "@lewismoten/gamemaker-sandbox-engine/formats/fli";
+import { parseBackdrop as Y, textLines as N, parseSlideList as Q } from "@lewismoten/gamemaker-sandbox-engine/formats/graphicScripts";
+import { parseGame as R } from "@lewismoten/gamemaker-sandbox-engine/formats/game";
+import { parsePalette as X, matchColor as Z } from "@lewismoten/gamemaker-sandbox-engine/formats/palette";
+import { FONT8X8 as q } from "@lewismoten/gamemaker-sandbox-engine/gfx/font8x8";
+const y = 320, w = 200, k = [63, 10, 10], C = [10, 10, 63], J = [63, 63, 0], v = 768, I = [50, 10, 50];
+function ft(t) {
+  const e = /* @__PURE__ */ new Map();
+  for (const o of O(t)) e.set(o.toLowerCase(), new Uint8Array(j(G(t, o))));
+  return e;
+}
+const K = (t) => (/\.[^.]*$/.exec(t)?.[0] ?? "").toLowerCase(), b = (t, e) => Z(t, e[0], e[1], e[2]);
+class $ {
+  pixels = new Uint8Array(y * w);
+  palette = new Uint8Array(v);
+  /** The `cols` a slide list hands from entry to entry (the last picture's palette). */
+  cols = new Uint8Array(v);
+  clone() {
+    const e = new $();
+    return e.pixels.set(this.pixels), e.palette.set(this.palette), e.cols.set(this.cols), e;
+  }
+}
+function A(t, e, o, n, c = 0, i = 0) {
+  for (let l = 0; l < n; l++) {
+    const m = l + i;
+    if (!(m < 0 || m >= w))
+      for (let r = 0; r < o; r++) {
+        const f = r + c;
+        f >= 0 && f < y && (t.pixels[m * y + f] = e[l * o + r]);
+      }
+  }
+}
+function F(t, e, o, n, c, i, l, m = I) {
+  const r = t.get(e.toLowerCase());
+  if (!r) return;
+  const f = K(e);
+  if (f === ".gif" || f === ".bkd") {
+    let s = e, a = 0, p = 0;
+    if (f === ".bkd") {
+      const u = Y(r);
+      [s, a, p] = [u.gif, u.x, u.y];
+    }
+    const x = t.get(s.toLowerCase());
+    if (!x || !W(x)) return;
+    const h = z(x);
+    A(o, h.pixels, h.width, h.height, a, p), o.cols.set(h.palette), o.palette.set(h.palette);
+  } else if (f === ".fli") {
+    if (!D(r)) return;
+    const s = H(r), a = _(s);
+    a.palette.set(o.palette), a.pixels.set(o.pixels.subarray(0, a.pixels.length));
+    for (let p = 0; p < s.frameCount; p++) B(s, p, a);
+    A(o, a.pixels, s.width, s.height), o.palette.set(a.palette), o.cols.set(a.palette);
+  } else if (f === ".txt") {
+    const s = b(l ?? n, m), a = b(n, k), p = N(r);
+    for (let x = 0; x * 16 < p.length; x++) {
+      const h = p.slice(x * 16, x * 16 + 16).map((u, d) => ({ x: 40, y: (5 + d) * 8, col: s, text: u }));
+      p.length > (x + 1) * 16 && h.push({ x: 224, y: 168, col: a, text: "MORE...", want: k }), c.push({ name: `${i}${e}${p.length > 16 ? ` p${x + 1}` : ""}`, kind: "page", pixels: o.pixels.slice(), palette: o.palette.slice(), texts: h });
+    }
+  } else if (f === ".lst")
+    for (const s of Q(r)) F(t, s.name, o, n, c, `${i}${e} > `, o.cols, m);
+}
+function M(t, e, o) {
+  const n = t.scenes[e]?.files[o];
+  return n ? n.toLowerCase() : void 0;
+}
+function S(t, e) {
+  const o = new $();
+  return F(t, e, o, o.palette, [], ""), o;
+}
+function pt(t, e = I) {
+  const o = [...t.keys()].find((f) => f.endsWith(".gam"));
+  if (!o) throw new Error("no .gam on the disk");
+  const n = R(t.get(o)), c = [], i = M(n, 0, 2), l = i ? S(t, i) : new $(), m = /* @__PURE__ */ new Set();
+  if (n.scenes.forEach((f, s) => {
+    const a = s === 0 ? [0, 4, 6, 7] : s === 1 ? [0, 2] : [9, 10];
+    let p = l.palette;
+    if (s > 1) {
+      const x = M(n, s, 0), h = x && t.get(x);
+      h && (p = X(h));
+    }
+    for (const x of a) {
+      const h = M(n, s, x);
+      if (!h || m.has(h)) continue;
+      m.add(h);
+      const u = s === 0 && x !== 0 ? l.clone() : new $();
+      F(t, h, u, p, c, "", void 0, e);
+    }
+  }), i) {
+    const f = b(l.palette, C), s = [{ x: 96, y: 104, col: f, text: n.scenes[0].desc }];
+    ["Play", "Read Instructions", "Read Storyline", "See Credits", "See Highest Scores", "Quit"].forEach((a, p) => {
+      s.push({ x: 80, y: (15 + p) * 8, col: f, text: a }), s.push({ x: 70, y: 113 + (p + 1) * 8, col: f, text: "", box: { w: 6, h: 5 } });
+    }), c.push({ name: `menu ${i}`, kind: "menu", pixels: l.pixels, palette: l.palette, texts: s });
+  }
+  const r = M(n, 0, 8);
+  if (r) {
+    const f = S(t, r), s = b(f.palette, k), a = b(f.palette, C), p = [{ x: 104, y: 0, col: s, text: "Top Ten Scores" }];
+    let x = 22, h = 27;
+    for (let u = 0; u < 10; u++)
+      p.push({ x: 20, y: h, col: a, text: `${String(1234567890 - u)} ${"M".repeat(22)}` }), h += x, u % 2 === 0 && x--, x--;
+    p.push({ x: 20, y: h, col: a, text: `${"1234".padStart(10)} Your Latest Score` }), p.push({ x: 116, y: 192, col: s, text: "Hit any key" }), c.push({ name: `scores ${r}`, kind: "scores", pixels: f.pixels, palette: f.palette, texts: p });
+  }
+  for (const [f, s] of [
+    [9, "load"],
+    [10, "save"]
+  ]) {
+    const a = M(n, 0, f);
+    if (!a) continue;
+    const p = S(t, a), x = b(p.palette, J), h = b(p.palette, k), u = b(p.palette, C), d = [];
+    for (let g = 0; g < 10; g++)
+      d.push({ x: 80, y: 40 + g * 14, col: x, text: "M".repeat(20) }), d.push({ x: 60, y: 27 + (g + 1) * 14, col: h, text: "", box: { w: 6, h: 5 } });
+    s === "load" ? d.push({ x: 40, y: 185, col: u, text: "This game has not been saved!" }) : d.push({ x: 112, y: 185, col: u, text: "Game Saved!" }), c.push({ name: `${s} ${a}`, kind: s, pixels: p.pixels, palette: p.palette, texts: d });
+  }
+  return c;
+}
+function T(t) {
+  const e = [];
+  if (t.box) {
+    for (let o = 0; o < t.box.h; o++) for (let n = 0; n < t.box.w; n++) e.push([t.x + n, t.y + o]);
+    return e;
+  }
+  for (let o = 0; o < t.text.length; o++) {
+    const n = (t.text.charCodeAt(o) & 255) * 8;
+    for (let c = 0; c < 8; c++) {
+      const i = q[n + c];
+      for (let l = 0; l < 8; l++) i & 1 << l && e.push([t.x + o * 8 + l, t.y + c]);
+    }
+  }
+  return e;
+}
+const E = (t, e) => [0, 1, 2].map((o) => t[e * 3 + o] << 2 | t[e * 3 + o] >> 4), L = (t) => {
+  const e = t / 255;
+  return e <= 0.03928 ? e / 12.92 : ((e + 0.055) / 1.055) ** 2.4;
+}, P = (t) => 0.2126 * L(t[0]) + 0.7152 * L(t[1]) + 0.0722 * L(t[2]), V = (t, e) => {
+  const [o, n] = [P(t), P(e)].sort((c, i) => i - c);
+  return (o + 0.05) / (n + 0.05);
+};
+function U(t, e) {
+  const o = T(t);
+  if (!o.length) return;
+  let [n, c, i, l] = [1 / 0, 1 / 0, -1 / 0, -1 / 0];
+  for (const [m, r] of o) [n, c, i, l] = [Math.min(n, m), Math.min(c, r), Math.max(i, m), Math.max(l, r)];
+  return { x0: n - e, y0: c - e, x1: i + e, y1: l + e };
+}
+function tt(t, e) {
+  const o = [[], [], []];
+  for (const n of t.texts) {
+    const c = U(n, e);
+    if (c)
+      for (let i = Math.max(0, c.y0); i <= Math.min(w - 1, c.y1); i++)
+        for (let l = Math.max(0, c.x0); l <= Math.min(y - 1, c.x1); l++) {
+          const m = E(t.palette, t.pixels[i * y + l]);
+          for (let r = 0; r < 3; r++) o[r].push(m[r]);
+        }
+  }
+  return o.map((n) => (n.sort((c, i) => c - i), n[n.length >> 1] ?? 0));
+}
+function xt(t, e = {}, o) {
+  const n = e.margin ?? 2, c = e.artDistance ?? 72, i = e.allowArt ?? 0, l = e.minContrast ?? 3, m = [];
+  for (const r of t.texts) {
+    const f = U(r, n);
+    if (!f) continue;
+    const s = [];
+    (f.x0 + n < 0 || f.y0 + n < 0 || f.x1 - n >= y || f.y1 - n >= w) && s.push("off the screen");
+    const a = { ...t, texts: [r] }, p = tt(a, n);
+    let x = 0;
+    for (let u = Math.max(0, f.y0); u <= Math.min(w - 1, f.y1); u++)
+      for (let d = Math.max(0, f.x0); d <= Math.min(y - 1, f.x1); d++) {
+        const g = E(t.palette, t.pixels[u * y + d]);
+        Math.hypot(g[0] - p[0], g[1] - p[1], g[2] - p[2]) > c && (x++, o && (o[u * y + d] = 1));
+      }
+    x > i && s.push(`${x} art pixels within ${n}px`);
+    const h = V(E(t.palette, r.col), p);
+    if (h < l && s.push(`contrast ${h.toFixed(2)}`), r.want) {
+      const u = [0, 1, 2].map((d) => t.palette[r.col * 3 + d]);
+      Math.hypot(u[0] - r.want[0], u[1] - r.want[1], u[2] - r.want[2]) > 30 && s.push(`ink shows as rgb(${u.join(",")}), not rgb(${r.want.join(",")})`);
+    }
+    s.length && m.push({ screen: t.name, text: r.box ? "[marker]" : r.text, x: r.x, y: r.y, artPixels: x, contrast: h, problems: s });
+  }
+  return m;
+}
+function ht(t, e) {
+  const o = new Uint8Array(y * w * 3), n = t.pixels.slice();
+  for (const c of t.texts) for (const [i, l] of T(c)) i >= 0 && l >= 0 && i < y && l < w && (n[l * y + i] = c.col);
+  for (let c = 0; c < y * w; c++) {
+    let i = E(t.palette, n[c]);
+    e?.[c] && n[c] === t.pixels[c] && (i = [255, 0, 255]), o.set(i, c * 3);
+  }
+  return o;
+}
+function ut(t) {
+  const e = [...t.keys()].find((i) => i.endsWith(".gam"));
+  if (!e) throw new Error("no .gam on the disk");
+  const o = R(t.get(e)), n = [], c = /* @__PURE__ */ new Set();
+  return o.scenes.forEach((i, l) => {
+    if (!(l < 2))
+      for (const m of [9, 10]) {
+        const r = M(o, l, m);
+        if (!r || c.has(r) || !t.has(r)) continue;
+        c.add(r);
+        const f = S(t, r);
+        n.push({ name: `scene ${l} ${r}`, pixels: f.pixels, palette: f.palette });
+      }
+  }), n;
+}
+function mt(t) {
+  const e = (s, a) => t.pixels[a * y + s], o = e(24, 16);
+  let [n, c, i, l] = [24, 24, 16, 16];
+  for (; n > 0 && e(n - 1, 16) === o; ) n--;
+  for (; c < y - 1 && e(c + 1, 16) === o; ) c++;
+  for (let s = n + 2; s <= c - 2; s++) {
+    if (e(s, 16) !== o) continue;
+    let [a, p] = [16, 16];
+    for (; a > 0 && e(s, a - 1) === o; ) a--;
+    for (; p < w - 1 && e(s, p + 1) === o; ) p++;
+    i = Math.min(i, a), l = Math.max(l, p);
+  }
+  if (c - n < 100 || l - i < 30 || l - i > 90) return [];
+  const m = /* @__PURE__ */ new Set();
+  for (let s = Math.max(0, n - 6); s <= Math.min(y - 1, c + 6); s++) for (let a = Math.max(0, i - 6); a < i; a++) m.add(e(s, a));
+  for (let s = i; s <= Math.min(l, i + 6); s++) for (const a of [n - 1, n - 2, n - 3, c + 1, c + 2, c + 3]) m.add(e(a, s));
+  const r = /* @__PURE__ */ new Set();
+  for (let s = i; s <= l; s++) for (let a = n; a <= c; a++) e(a, s) !== o && !m.has(e(a, s)) && r.add(e(a, s));
+  const f = [];
+  for (const [s, a, p] of [
+    ["left", n - 14, n - 1],
+    ["right", c + 1, c + 14]
+  ]) {
+    let x = 0;
+    for (let h = i; h <= l; h++) for (let u = Math.max(0, a); u <= Math.min(y - 1, p); u++) r.has(e(u, h)) && x++;
+    x && f.push(`text runs past the ${s} edge of its box (${x} pixels outside it)`);
+  }
+  return f;
+}
+export {
+  w as H,
+  y as W,
+  mt as cardOverflow,
+  xt as checkTextScreen,
+  ut as levelCards,
+  ft as readDisk,
+  ht as renderRgb,
+  pt as textScreens
+};