@lewismoten/gamemaker-sandbox-tools 0.0.0-stage → 3.1.0

package/dist/drawing.js

@@ -0,0 +1,871 @@
+import { P as g, d as K, r as V } from "./pixels-DzfIIUOl.js";
+import { writeFileSync as q, existsSync as Q, readFileSync as Z } from "node:fs";
+import { encodeFli as t0 } from "./formats/fli.js";
+import { vga8 as P } from "./formats/palette.js";
+class E0 {
+  constructor() {
+    this.pal = new Uint8Array(768), this.next = 0, this.ramps = /* @__PURE__ */ new Map();
+  }
+  /** One color from 8-bit RGB; returns its index. */
+  color(f, c, e) {
+    const n = this.next++;
+    if (n > 254) throw new Error('Palette full (255 is "clear")');
+    return this.pal.set([f >> 2, c >> 2, e >> 2], n * 3), n;
+  }
+  /** A ramp of n shades from dark to light (8-bit RGB stops); returns the indexes. */
+  ramp(f, c, e, n, s) {
+    const r = [];
+    for (let o = 0; o < c; o++) {
+      const i = c === 1 ? 0 : o / (c - 1), [a, h, l] = s ? i < 0.5 ? [e, s, i * 2] : [s, n, (i - 0.5) * 2] : [e, n, i];
+      r.push(this.color(...a.map((u, d) => Math.round(u + (h[d] - u) * l))));
+    }
+    return this.ramps.set(f, r), r;
+  }
+  get(f) {
+    const c = this.ramps.get(f);
+    if (!c) throw new Error(`No ramp ${f}`);
+    return c;
+  }
+  /**
+   * 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 [f, c, 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(f * 4, c * 4, e * 4);
+  }
+  get used() {
+    return this.next;
+  }
+}
+const e0 = (t) => /[\x20-\x7e\u25cf\u2022]/.test(t), O = typeof process < "u" ? process.env.TEXT_BOUNDS : void 0, U = [], A = /* @__PURE__ */ new Map(), _ = (t, f, c, e) => `${t}x${f} ${c} ${e}`, c0 = /\/art\/(font|draw|canvas)\.ts|screens\/(draw|screen)\.ts/;
+function f0() {
+  const t = (new Error().stack ?? "").split(`
+`).slice(1).map((e) => /\(?((?:\/|file:)[^():]+):(\d+):\d+\)?\s*$/.exec(e)).filter((e) => !!e).map((e) => ({ path: e[1].replace(/^file:\/\//, "").replace(/^.*\/games\//, ""), line: e[2] })).filter((e) => !/node_modules|kit\/textBounds\.ts/.test(e.path)).map((e) => ({ ...e, helper: c0.test(e.path), name: `${e.path}:${e.line}` })), f = t.findIndex((e) => !e.helper);
+  return {
+    at: t.filter((e) => !e.helper).slice(0, 2).map((e) => e.name).join(" < "),
+    via: t.slice(0, f + 1).map((e) => e.name).join(" > ")
+  };
+}
+O && process.on("exit", () => {
+  const t = {
+    overflows: U,
+    shown: Object.fromEntries([...A].map(([f, c]) => [f, [...c].map((e) => e.split(",").map(Number))]))
+  };
+  q(O, JSON.stringify(t));
+});
+class n0 {
+  constructor(f, c, e, n, s) {
+    this.w = f, this.h = c, this.s = e, this.area = n, this.has = s, this.x0 = 1 / 0, this.y0 = 1 / 0, this.x1 = -1 / 0, this.y1 = -1 / 0;
+  }
+  /** A lit rectangle of the string (a font pixel, scaled). */
+  add(f, c, e = 1, n = 1) {
+    f < this.x0 && (this.x0 = f), c < this.y0 && (this.y0 = c), f + e > this.x1 && (this.x1 = f + e), c + n > this.y1 && (this.y1 = c + n);
+  }
+  end() {
+    if (this.x1 < this.x0) return;
+    const [f, c, e, n] = this.area, s = this.x0 < f - 0.5 || this.y0 < c - 0.5 || this.x1 > e + 0.5 || this.y1 > n + 0.5, { at: r, via: o } = f0(), i = [...new Set(this.s)].filter((a) => !this.has(a)).join("");
+    if (i)
+      U.push({
+        s: this.s,
+        w: this.w,
+        h: this.h,
+        ink: [this.x0, this.y0, this.x1, this.y1].map((a) => Math.round(a)),
+        area: this.area,
+        at: r,
+        via: o,
+        missing: i
+      });
+    else if (s)
+      U.push({ s: this.s, w: this.w, h: this.h, ink: [this.x0, this.y0, this.x1, this.y1].map((a) => Math.round(a)), area: this.area, at: r, via: o });
+    else {
+      const a = _(this.w, this.h, o, this.s);
+      A.has(a) || A.set(a, /* @__PURE__ */ new Set()), A.get(a).add(`${Math.round(this.x0)},${Math.round(this.y0)}`);
+    }
+  }
+}
+function r0(t, f, c, e = e0) {
+  if (!(!O || !f.trim()))
+    return new n0(t.w, t.h, f, c ?? [0, 0, t.w, t.h], e);
+}
+function s0(t) {
+  const f = (n) => (t.shown[_(n.w, n.h, n.via, n.s)] ?? []).some(([s, r]) => Math.abs(s - n.ink[0]) > 2 || Math.abs(r - n.ink[1]) > 2), c = /* @__PURE__ */ new Map(), e = [];
+  for (const n of t.overflows) {
+    const s = _(n.w, n.h, n.via, n.s);
+    if (!n.missing && f(n)) {
+      e.push(n);
+      continue;
+    }
+    const r = c.get(s);
+    r ? r.ink = [Math.min(r.ink[0], n.ink[0]), Math.min(r.ink[1], n.ink[1]), Math.max(r.ink[2], n.ink[2]), Math.max(r.ink[3], n.ink[3])] : c.set(s, { ...n, ink: [...n.ink] });
+  }
+  return { cut: [...c.values()], moving: e };
+}
+function I0(t) {
+  return t.missing ? `"${t.s}" has ${[...t.missing].map((f) => `U+${f.charCodeAt(0).toString(16).toUpperCase()}`).join(" ")}, a box in the PC font (${t.w}x${t.h}) at ${t.at}` : `"${t.s}" ink ${t.ink.join(",")} outside ${t.area.join(",")} (${t.w}x${t.h}) at ${t.at}`;
+}
+function $0(t) {
+  if (!Q(t)) throw new Error(`${t}: the build wrote no text-bounds report`);
+  return s0(JSON.parse(Z(t, "utf8")));
+}
+const o0 = "0000000000000000 183c3c1818001800 3636000000000000 36367f367f363600 0c3e031e301f0c00 006333180c666300 1c361c6e3b336e00 0606030000000000 180c0606060c1800 060c1818180c0600 00663cff3c660000 000c0c3f0c0c0000 00000000000c0c06 0000003f00000000 00000000000c0c00 6030180c06030100 3e63737b6f673e00 0c0e0c0c0c0c3f00 1e33301c06333f00 1e33301c30331e00 383c36337f307800 3f031f3030331e00 1c06031f33331e00 3f3330180c0c0c00 1e33331e33331e00 1e33333e30180e00 000c0c00000c0c00 000c0c00000c0c06 180c0603060c1800 00003f00003f0000 060c1830180c0600 1e3330180c000c00 3e637b7b7b031e00 0c1e33333f333300 3f66663e66663f00 3c66030303663c00 1f36666666361f00 7f46161e16467f00 7f46161e16060f00 3c66030373667c00 3333333f33333300 1e0c0c0c0c0c1e00 7830303033331e00 6766361e36666700 0f06060646667f00 63777f7f6b636300 63676f7b73636300 1c36636363361c00 3f66663e06060f00 1e3333333b1e3800 3f66663e36666700 1e33070e38331e00 3f2d0c0c0c0c1e00 3333333333333f00 33333333331e0c00 6363636b7f776300 6363361c1c366300 3333331e0c0c1e00 7f6331184c667f00 1e06060606061e00 03060c1830604000 1e18181818181e00 081c366300000000 00000000000000ff 0c0c180000000000 00001e303e336e00 0706063e66663b00 00001e3303331e00 3830303e33336e00 00001e333f031e00 1c36060f06060f00 00006e33333e301f 0706366e66666700 0c000e0c0c0c1e00 300030303033331e 070666361e366700 0e0c0c0c0c0c1e00 0000337f7f6b6300 00001f3333333300 00001e3333331e00 00003b66663e060f 00006e33333e3078 00003b6e66060f00 00003e031e301f00 080c3e0c0c2c1800 0000333333336e00 00003333331e0c00 0000636b7f7f3600 000063361c366300 00003333333e301f 00003f190c263f00 380c0c070c0c3800 1818180018181800 070c0c380c0c0700 6e3b000000000000", B = (() => {
+  const t = new Uint8Array(2048), f = [126, 66, 66, 66, 66, 66, 126, 0];
+  for (let c = 0; c < 256; c++) (c >= 128 || c > 0 && c < 32 && c !== 10) && t.set(f, c * 8);
+  return o0.split(" ").forEach((c, e) => {
+    for (let n = 0; n < 8; n++) t[(32 + e) * 8 + n] = parseInt(c.slice(n * 2, n * 2 + 2), 16);
+  }), t;
+})();
+function N(t, f, c, e, n, s = 1) {
+  const r = r0(t, e), o = (i, a, h, l) => {
+    t.rect(i, a, h, l, n), r?.add(i, a, h, l);
+  };
+  return [...e].forEach((i, a) => {
+    const h = i.charCodeAt(0) & 255;
+    for (let l = 0; l < 8; l++) {
+      const u = B[h * 8 + l];
+      for (let d = 0; d < 8; d++) u & 1 << d && o(f + (a * 8 + d) * s, c + l * s, s, s);
+    }
+  }), r?.end(), e.length * 8 * s;
+}
+const i0 = (t, f = 1) => t.length * 8 * f;
+function a0(t, f, c, e, n, s, r = 1, o) {
+  if (o !== void 0)
+    for (const [i, a] of [
+      [2, 2],
+      [1, 2],
+      [2, 1]
+    ])
+      N(t, f + i * r, c + a * r, e, o, r);
+  for (const [i, a] of [
+    [-1, 0],
+    [1, 0],
+    [0, -1],
+    [0, 1],
+    [-1, -1],
+    [1, 1],
+    [1, -1],
+    [-1, 1]
+  ])
+    N(t, f + i, c + a, e, s, r);
+  N(t, f, c, e, n, r);
+}
+function S0(t, f, c, e, n = 1, s, r = t.w / 2, o) {
+  const i = Math.round(r - i0(c, n) / 2);
+  s === void 0 ? N(t, i, f, c, e, n) : a0(t, i, f, c, e, s, n, o);
+}
+const E = 255;
+function C0(t, f, c = 0, e = 0) {
+  return t.blit(f, c, e, E);
+}
+function v0(t, f) {
+  const c = new g(t.w, t.h);
+  return c.px.set(t.px.map(f)), c;
+}
+function A0(t, f, c, e, n, s = !1) {
+  for (let r = 0; r < f.h; r++)
+    for (let o = 0; o < f.w; o++) {
+      const i = f.get(s ? f.w - 1 - o : o, r);
+      i !== E && i >= 0 && t.rect(c + o * n, e + r * n, n, n, i);
+    }
+}
+function N0(t, f) {
+  const c = new g(t.w, t.h, E);
+  c.px.set(t.px);
+  for (let e = 0; e < t.h; e++)
+    for (let n = 0; n < t.w; n++) {
+      if (t.get(n, e) !== E) continue;
+      [t.get(n - 1, e), t.get(n + 1, e), t.get(n, e - 1), t.get(n, e + 1)].some((r) => r !== E && r !== -1) && c.set(n, e, f);
+    }
+  return c;
+}
+function G(t, f, c, e, n, s) {
+  const r = f + Math.max(0, Math.min(1, e)) * (c - f), o = Math.floor(r), i = K(n, s, r - o) ? o + 1 : o;
+  return t[Math.max(0, Math.min(t.length - 1, i))];
+}
+function R0(t, f, c, e, n, s, r, o) {
+  for (let i = c; i < c + n; i++) for (let a = f; a < f + e; a++) t.set(a, i, G(s, r, o, (i - c) / Math.max(1, n - 1), a, i));
+  return t;
+}
+function P0(t, f, c, e, n, s, r, o, i = 1) {
+  for (let a = Math.floor(c - n); a <= c + n; a++)
+    for (let h = Math.floor(f - e); h <= f + e; h++) {
+      const l = (h + 0.5 - f) / e, u = (a + 0.5 - c) / n, d = l * l + u * u;
+      if (d > 1) continue;
+      const m = (0.62 * Math.sqrt(1 - d) - 0.42 * l - 0.52 * u) * i;
+      t.set(h, a, G(s, r, o, (m + 0.35) / 1.2, h, a));
+    }
+  return t;
+}
+function O0(t, f, c, e, n, s, r, o = 1) {
+  t.rect(f, c, e, n, s[r]);
+  const i = s[Math.min(s.length - 1, r + 1)], a = s[Math.max(0, r - 2)];
+  for (let h = 0; h < o; h++)
+    t.rect(f + h, c + h, e - 2 * h, 1, i).rect(f + h, c + h, 1, n - 2 * h, i), t.rect(f + h, c + n - 1 - h, e - 2 * h, 1, a).rect(f + e - 1 - h, c + h, 1, n - 2 * h, a);
+  return t;
+}
+function U0(t, f, c, e, n, s, r, o, i, a = 0.25) {
+  const h = V(i);
+  for (let l = c; l < c + n; l++)
+    for (let u = f; u < f + e; u++) {
+      let d = r;
+      h() < a && (d += h() < 0.5 ? -o : o), t.set(u, l, s[Math.max(0, Math.min(s.length - 1, d))]);
+    }
+  return t;
+}
+function T(t, f) {
+  return t.map((c) => Math.round(c * Math.max(0, Math.min(1, f))));
+}
+class _0 {
+  constructor(f, c = 320, e = 200) {
+    this.pal = f, this.w = c, this.h = e, this.frames = [], this.palettes = [], this.frames.push(new Uint8Array(c * e)), this.palettes.push(new Uint8Array(768));
+  }
+  /** Adds a picture for `hold` frames, its palette faded to `light`. */
+  add(f, c = 1, e = 1, n = this.pal) {
+    const s = Uint8Array.from(f.px), r = e >= 1 ? n : T(n, e);
+    for (let o = 0; o < c; o++)
+      this.frames.push(s), this.palettes.push(r);
+    return this.last = { px: s, pal: n }, this;
+  }
+  /** A picture drawn over a copy of `bg` (the actors over the scenery), for `hold` frames. */
+  frame(f, c, e = 1, n = 1, s = this.pal) {
+    const r = new g(f.w, f.h);
+    return r.px.set(f.px), c(r), this.add(r, e, n, s);
+  }
+  /** The picture fading in from black over `n` frames (the last at full light). */
+  fadeIn(f, c, e = this.pal) {
+    for (let n = 1; n <= c; n++) this.add(f, 1, n / c, e);
+    return this;
+  }
+  /** The last picture fading out to black over `n` frames. */
+  fadeOut(f) {
+    const c = this.last;
+    if (!c) return this;
+    for (let e = f - 1; e >= 0; e--)
+      this.frames.push(c.px), this.palettes.push(T(c.pal, e / f));
+    return this;
+  }
+  /**
+   * A cartoon's closing iris: black closes in on (cx, cy) over `n` frames from the last picture
+   * down to a circle `end` pixels across (round on a 4:3 screen: VGA's pixels are taller than
+   * wide), and holds there `hold` frames. Follow it with fadeOut. Gives an intro whose pictures
+   * are the title's art a last view that isn't the title.
+   */
+  irisOut(f, c, e, n = 64, s = 6) {
+    const r = this.last;
+    if (!r) return this;
+    let o = 0;
+    const i = (l) => r.pal[l * 3] + r.pal[l * 3 + 1] + r.pal[l * 3 + 2];
+    for (let l = 1; l < r.pal.length / 3; l++) i(l) < i(o) && (o = l);
+    const a = Math.hypot(Math.max(f, this.w - f), Math.max(c, this.h - c) * 1.2), h = new g(this.w, this.h);
+    for (let l = 1; l <= e; l++) {
+      const u = l / e, d = a + (n / 2 - a) * (1 - (1 - u) * (1 - u));
+      for (let p = 0; p < this.h; p++)
+        for (let m = 0; m < this.w; m++) {
+          const b = p * this.w + m;
+          h.px[b] = Math.hypot(m - f, (p - c) * 1.2) <= d ? r.px[b] : o;
+        }
+      this.add(h, l === e ? s : 1, 1, r.pal);
+    }
+    return this;
+  }
+  /** The .FLI: `speed` is the wait after each frame in 1/70 s (5 = 14 frames a second). */
+  fli(f) {
+    return t0(this.frames, this.pal, { width: this.w, height: this.h, speed: f, palettes: this.palettes, runs: !0 });
+  }
+  /** How long it plays, in seconds. */
+  seconds(f) {
+    return this.frames.length * f / 70;
+  }
+}
+const h0 = {
+  1: "3c42a581a599423c",
+  // ☺
+  2: "3c7edbffdbe77e3c",
+  // ☻
+  3: "6cfefefe7c381000",
+  // ♥
+  4: "10387cfe7c381000",
+  // ♦
+  5: "387c38fefed61038",
+  // ♣
+  6: "10387cfefe543800",
+  // ♠
+  7: "0000183c3c180000",
+  // •
+  8: "ffffe7c3c3e7ffff",
+  // ◘
+  9: "003c424242423c00",
+  // ○
+  10: "ffc3bdbdbdbdc3ff",
+  // ◙
+  11: "0f03057988888870",
+  // ♂
+  12: "3844444438107c10",
+  // ♀
+  13: "181c16121070f060",
+  // ♪
+  14: "3f21212163e7c600",
+  // ♫
+  15: "925438ee38549200",
+  // ☼
+  16: "80e0f8fef8e08000",
+  // ►
+  17: "020e3efe3e0e0200",
+  // ◄
+  18: "183c7e18187e3c18",
+  // ↕
+  19: "6c6c6c6c6c006c00",
+  // ‼
+  20: "7fdbdb7b1b1b1b00",
+  // ¶ (ext_latin)
+  21: "3e63386c6c38cc78",
+  // § (ext_latin)
+  22: "00000000fefefe00",
+  // ▬
+  23: "183c7e187e3c18ff",
+  // ↨
+  24: "183c7e1818181800",
+  // ↑
+  25: "181818187e3c1800",
+  // ↓
+  26: "00180cfe0c180000",
+  // →
+  27: "003060fe60300000",
+  // ←
+  28: "0000c0c0c0fefe00",
+  // ∟
+  29: "002466ff66240000",
+  // ↔
+  30: "0018183c7eff0000",
+  // ▲
+  31: "00ff7e3c18180000",
+  // ▼
+  127: "102844828282fe00",
+  // ⌂
+  128: "78ccc0cc78180c78",
+  // Ç (ext_latin)
+  129: "00cc00cccccc7e00",
+  // ü (ext_latin)
+  130: "1c0078ccfcc07800",
+  // é (ext_latin)
+  131: "7ec33c063e663f00",
+  // â (ext_latin)
+  132: "cc00780c7ccc7e00",
+  // ä (ext_latin)
+  133: "e000780c7ccc7e00",
+  // à (ext_latin)
+  134: "3030780c7ccc7e00",
+  // å (ext_latin)
+  135: "000078c0c0780c38",
+  // ç (ext_latin)
+  136: "7ec33c667e603c00",
+  // ê (ext_latin)
+  137: "cc0078ccfcc07800",
+  // ë (ext_latin)
+  138: "e00078ccfcc07800",
+  // è (ext_latin)
+  139: "cc00703030307800",
+  // ï (ext_latin)
+  140: "7cc6381818183c00",
+  // î (ext_latin)
+  141: "e000703030307800",
+  // ì (ext_latin)
+  142: "c6386cc6fec6c600",
+  // Ä (ext_latin)
+  143: "30300078ccfccc00",
+  // Å (ext_latin)
+  144: "1c00fc607860fc00",
+  // É (ext_latin)
+  145: "00007f0c7fcc7f00",
+  // æ (ext_latin)
+  146: "3e6cccfeccccce00",
+  // Æ (ext_latin)
+  147: "78cc0078cccc7800",
+  // ô (ext_latin)
+  148: "00cc0078cccc7800",
+  // ö (ext_latin)
+  149: "00e00078cccc7800",
+  // ò (ext_latin)
+  150: "78cc00cccccc7e00",
+  // û (ext_latin)
+  151: "00e000cccccc7e00",
+  // ù (ext_latin)
+  152: "00cc00cccc7c0cf8",
+  // ÿ (ext_latin)
+  153: "c3183c66663c1800",
+  // Ö (ext_latin)
+  154: "cc00cccccccc7800",
+  // Ü (ext_latin)
+  155: "18187ec0c07e1818",
+  // ¢ (ext_latin)
+  156: "386c64f060e6fc00",
+  // £ (ext_latin)
+  157: "cccc78fc30fc3030",
+  // ¥ (ext_latin)
+  158: "f8ccccfac6cfc6c7",
+  // ₧ (misc)
+  159: "0e1b183c1818d870",
+  // ƒ (misc)
+  160: "1c00780c7ccc7e00",
+  // á (ext_latin)
+  161: "3800703030307800",
+  // í (ext_latin)
+  162: "001c0078cccc7800",
+  // ó (ext_latin)
+  163: "001c00cccccc7e00",
+  // ú (ext_latin)
+  164: "00f800f8cccccc00",
+  // ñ (ext_latin)
+  165: "fc00ccecfcdccc00",
+  // Ñ (ext_latin)
+  166: "3c6c6c3e007e0000",
+  // ª (misc)
+  167: "386c6c38007c0000",
+  // º (misc)
+  168: "30003060c0cc7800",
+  // ¿ (ext_latin)
+  169: "000000fcc0c00000",
+  // ⌐ (misc)
+  170: "000000fc0c0c0000",
+  // ¬ (ext_latin)
+  171: "c3c6ccde3366cc0f",
+  // ½ (ext_latin)
+  172: "c3c6ccbd376fcfc0",
+  // ¼ (ext_latin)
+  173: "1818001818181800",
+  // ¡ (ext_latin)
+  174: "003366cc66330000",
+  // « (ext_latin)
+  175: "00cc663366cc0000",
+  // » (ext_latin)
+  176: "2288228822882288",
+  // ░
+  177: "55aa55aa55aa55aa",
+  // ▒
+  178: "dd77dd77dd77dd77",
+  // ▓
+  179: "1818181818181818",
+  // │
+  180: "181818f818181818",
+  // ┤
+  181: "1818f818f8181818",
+  // ╡
+  182: "363636f636363636",
+  // ╢
+  183: "000000fe36363636",
+  // ╖
+  184: "0000f818f8181818",
+  // ╕
+  185: "3636f606f6363636",
+  // ╣
+  186: "3636363636363636",
+  // ║
+  187: "0000fe06f6363636",
+  // ╗
+  188: "3636f606fe000000",
+  // ╝
+  189: "363636fe00000000",
+  // ╜
+  190: "1818f818f8000000",
+  // ╛
+  191: "000000f818181818",
+  // ┐
+  192: "1818181f00000000",
+  // └
+  193: "181818ff00000000",
+  // ┴
+  194: "000000ff18181818",
+  // ┬
+  195: "1818181f18181818",
+  // ├
+  196: "000000ff00000000",
+  // ─
+  197: "181818ff18181818",
+  // ┼
+  198: "18181f181f181818",
+  // ╞
+  199: "3636363736363636",
+  // ╟
+  200: "363637303f000000",
+  // ╚
+  201: "00003f3037363636",
+  // ╔
+  202: "3636f700ff000000",
+  // ╩
+  203: "0000ff00f7363636",
+  // ╦
+  204: "3636373037363636",
+  // ╠
+  205: "0000ff00ff000000",
+  // ═
+  206: "3636f700f7363636",
+  // ╬
+  207: "1818ff00ff000000",
+  // ╧
+  208: "363636ff00000000",
+  // ╨
+  209: "0000ff00ff181818",
+  // ╤
+  210: "000000ff36363636",
+  // ╥
+  211: "3636363f00000000",
+  // ╙
+  212: "18181f181f000000",
+  // ╘
+  213: "00001f181f181818",
+  // ╒
+  214: "0000003f36363636",
+  // ╓
+  215: "363636ff36363636",
+  // ╫
+  216: "1818ff18ff181818",
+  // ╪
+  217: "181818f800000000",
+  // ┘
+  218: "0000001f18181818",
+  // ┌
+  219: "ffffffffffffffff",
+  // █
+  220: "00000000ffffffff",
+  // ▄
+  221: "f0f0f0f0f0f0f0f0",
+  // ▌
+  222: "0f0f0f0f0f0f0f0f",
+  // ▐
+  223: "ffffffff00000000",
+  // ▀
+  224: "000076dcc8dc7600",
+  // α (greek)
+  225: "0078ccf8ccf8c0c0",
+  // ß (ext_latin)
+  226: "fcccc0c0c0c0c000",
+  // Γ (greek)
+  227: "0000fe6c6c6c6c00",
+  // π (greek)
+  228: "fec6603060c6fe00",
+  // Σ (greek)
+  229: "00007ed8d8d87000",
+  // σ (greek)
+  230: "00006666667c60c0",
+  // µ (ext_latin)
+  231: "00007e18181a0c00",
+  // τ (greek)
+  232: "187edbdbdb7e1800",
+  // Φ (greek)
+  233: "386cc6fec66c3800",
+  // Θ (greek)
+  234: "7cc6c6c66c6cee00",
+  // Ω (greek)
+  235: "1c30187ccccc7800",
+  // δ (greek)
+  236: "00006c92926c0000",
+  // ∞
+  237: "00006edbdb7e1800",
+  // φ (greek)
+  238: "000078c070c07800",
+  // ε (greek)
+  239: "003c666666666600",
+  // ∩
+  240: "007e007e007e0000",
+  // ≡
+  241: "18187e1818007e00",
+  // ± (ext_latin)
+  242: "30180c1830007e00",
+  // ≥ (misc)
+  243: "0c1830180c007e00",
+  // ≤ (misc)
+  244: "0e1b1b1818181818",
+  // ⌠
+  245: "18181818d8d87000",
+  // ⌡
+  246: "1818007e00181800",
+  // ÷ (ext_latin)
+  247: "0076dc0076dc0000",
+  // ≈
+  248: "386c6c3800000000",
+  // ° (ext_latin)
+  249: "0000001818000000",
+  // ∙
+  250: "0000000018000000",
+  // ·
+  251: "0f08080888482818",
+  // √
+  252: "f8cccccc00000000",
+  // ⁿ
+  253: "380c18303c000000",
+  // ² (ext_latin)
+  254: "00003c3c3c3c0000",
+  // ■
+  255: "0000000000000000"
+  // NBSP (ext_latin)
+};
+function l0(t) {
+  let f = 0;
+  for (let c = 0; c < 8; c++) t & 1 << c && (f |= 1 << 7 - c);
+  return f;
+}
+const u0 = (() => {
+  const t = B.slice();
+  for (const [f, c] of Object.entries(h0))
+    for (let e = 0; e < 8; e++) t[Number(f) * 8 + e] = l0(parseInt(c.slice(e * 2, e * 2 + 2), 16));
+  return t.fill(0, 0, 8), t;
+})(), H = "\0☺☻♥♦♣♠•◘○◙♂♀♪♫☼►◄↕‼¶§▬↨↑↓→←∟↔▲▼ !\"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_`abcdefghijklmnopqrstuvwxyz{|}~⌂ÇüéâäàåçêëèïîìÄÅÉæÆôöòûùÿÖÜ¢£¥₧ƒáíóúñѪº¿⌐¬½¼¡«»░▒▓│┤╡╢╖╕╣║╗╝╜╛┐└┴┬├─┼╞╟╚╔╩╦╠═╬╧╨╤╥╙╘╒╓╫╪┘┌█▄▌▐▀αßΓπΣσµτΦΘΩδ∞φε∩≡±≥≤⌠⌡÷≈°∙·√ⁿ²■ ", j = /* @__PURE__ */ new Map();
+for (let t = 1; t < 256; t++) (t < 32 || t > 126) && j.set(H[t], t);
+for (const [t, f] of [
+  ["β", 225],
+  // β beta for ß
+  ["μ", 230],
+  // μ mu for µ
+  ["Ω", 234],
+  // Ω ohm for Ω
+  ["∑", 228],
+  // ∑ sum for Σ
+  ["ϕ", 237],
+  // ϕ for φ
+  ["∈", 238]
+  // ∈ for ε
+])
+  j.set(t, f);
+const d0 = { "–": "-", "—": "--", "‘": "'", "’": "'", "“": '"', "”": '"', "…": "...", "×": "x" };
+function F(t) {
+  let f = "";
+  for (const c of t) {
+    const e = j.get(c);
+    f += e !== void 0 ? String.fromCharCode(e) : d0[c] ?? c;
+  }
+  return f;
+}
+function L(t) {
+  let f = "";
+  for (let c = 0; c < t.length; c++) {
+    const e = t.charCodeAt(c);
+    f += e < 256 ? H[e] : t[c];
+  }
+  return f;
+}
+const Y = Object.freeze({
+  A: "010101111101101",
+  B: "110101110101110",
+  C: "011100100100011",
+  D: "110101101101110",
+  E: "111100110100111",
+  F: "111100110100100",
+  G: "011100101101011",
+  H: "101101111101101",
+  I: "111010010010111",
+  J: "001001001101010",
+  K: "101101110101101",
+  L: "100100100100111",
+  M: "101111111101101",
+  N: "110101101101101",
+  O: "010101101101010",
+  P: "110101110100100",
+  Q: "010101101110011",
+  R: "110101110101101",
+  S: "011100010001110",
+  T: "111010010010010",
+  U: "101101101101111",
+  V: "101101101101010",
+  W: "101101111111101",
+  X: "101101010101101",
+  Y: "101101010010010",
+  Z: "111001010100111",
+  0: "111101101101111",
+  1: "010110010010111",
+  2: "110001010100111",
+  3: "110001010001110",
+  4: "101101111001001",
+  5: "111100110001110",
+  6: "011100111101111",
+  7: "111001010010010",
+  8: "111101111101111",
+  9: "111101111001110",
+  $: "011110010011110",
+  "&": "010101010101011",
+  "-": "000000111000000",
+  "!": "010010010000010",
+  ".": "000000000000010",
+  "'": "010010000000000",
+  " ": "000000000000000",
+  ":": "000010000010000",
+  "/": "001001010100100",
+  ",": "000000000010100",
+  "?": "110001010000010",
+  "+": "000010111010000",
+  ">": "100010001010100",
+  "<": "001010100010001",
+  "(": "010100100100010",
+  ")": "010001001001010"
+});
+function p0(t) {
+  for (const e of t)
+    if (e.charCodeAt(0) >= 128 && F(e) === e && L(e) !== e) throw new RangeError(`No CP437 glyph for ${e}`);
+  const f = F(t), c = new Uint8Array(f.length);
+  for (let e = 0; e < f.length; e++) {
+    const n = f.charCodeAt(e);
+    if (n > 255) throw new RangeError(`No CP437 glyph for ${f[e]}`);
+    c[e] = n;
+  }
+  return c;
+}
+function m0(t, f = "cp437") {
+  if (!Number.isInteger(t) || t < 0 || t > 255) throw new RangeError("Glyph code must be 0..255");
+  if (f === "cp437") return u0.slice(t * 8, t * 8 + 8);
+  const c = Y[L(String.fromCharCode(t)).toUpperCase()] ?? Y["?"];
+  return Uint8Array.from({ length: 5 }, (e, n) => {
+    let s = 0;
+    for (let r = 0; r < 3; r++) c[n * 3 + r] === "1" && (s |= 1 << r);
+    return s;
+  });
+}
+function w0(t, f, c = 1, e = 2) {
+  if (R(f), !Number.isInteger(c) || !Number.isInteger(e)) throw new RangeError("Shadow offsets must be integers");
+  const n = new g(t.w, t.h, 255);
+  for (let s = 0; s < t.h; s++) for (let r = 0; r < t.w; r++) t.get(r, s) !== 255 && n.set(r + c, s + e, f);
+  return n.blit(t, 0, 0, 255);
+}
+function R(t) {
+  if (!Number.isInteger(t) || t < 0 || t > 254) throw new RangeError("Ink must be a palette index 0..254");
+}
+function j0(t, f = {}) {
+  const { font: c = "cp437", color: e = 0, scale: n = 1, outline: s, shadow: r } = f;
+  if (R(e), s !== void 0 && R(s), r && R(r.color), !Number.isSafeInteger(n) || n < 1) throw new RangeError("Scale must be a positive integer");
+  const o = r?.dx ?? 1, i = r?.dy ?? 2;
+  if (!Number.isSafeInteger(o) || !Number.isSafeInteger(i)) throw new RangeError("Shadow offsets must be integers");
+  const a = typeof t == "string" ? t.replaceAll(`\r
+`, `
+`).split(`
+`).map(p0) : [t], h = Math.max(...a.map((w) => w.length));
+  if (!h) return { width: 0, height: 0, pixels: new Uint8Array(), originX: 0, originY: 0 };
+  const l = c === "cp437" ? 8 : 3, u = c === "cp437" ? 8 : 5, d = c === "cp437" ? 8 : 4, p = s === void 0 ? 0 : 1, m = Math.min(-p, r ? o : 0), b = Math.min(-p, r ? i : 0), X = Math.max(p, r ? o : 0), z = Math.max(p, r ? i : 0), I = ((h - 1) * d + l) * n + X - m, $ = ((a.length - 1) * (u + 1) + u) * n + z - b, S = new g(I, $, 255);
+  a.forEach(
+    (w, x) => w.forEach((y, k) => {
+      m0(y, c).forEach((J, W) => {
+        for (let v = 0; v < l; v++)
+          J & 1 << v && S.rect((k * d + v) * n - m, (x * (u + 1) + W) * n - b, n, n, e);
+      });
+    })
+  );
+  const C = new g(I, $, 255);
+  if (r && C.blit(w0(S, r.color, o, i), 0, 0, 255), s !== void 0) {
+    for (let w = 0; w < $; w++)
+      for (let x = 0; x < I; x++)
+        if (S.get(x, w) !== 255) for (let y = -1; y <= 1; y++) for (let k = -1; k <= 1; k++) C.set(x + k, w + y, s);
+  }
+  return C.blit(S, 0, 0, 255), { width: I, height: $, pixels: C.px, originX: -m, originY: -b };
+}
+const g0 = {
+  morning: { mul: [1, 0.94, 0.94], add: [14, 4, 10] },
+  noon: { mul: [1, 1, 1], add: [0, 0, 0] },
+  afternoon: { mul: [1.02, 0.96, 0.86], add: [8, 4, 0] },
+  sunset: { mul: [0.9, 0.7, 0.74], add: [30, 10, 16] },
+  night: { mul: [0.46, 0.5, 0.78], add: [8, 8, 30] },
+  // Under the big top at night: warm show lights on everything.
+  show: { mul: [1, 0.9, 0.86], add: [12, 4, 6] }
+}, T0 = {
+  morning: [
+    [120, 150, 230],
+    [255, 214, 200],
+    [200, 190, 240]
+  ],
+  noon: [
+    [70, 130, 230],
+    [200, 232, 255]
+  ],
+  afternoon: [
+    [90, 140, 220],
+    [250, 236, 200],
+    [170, 200, 240]
+  ],
+  sunset: [
+    [60, 40, 120],
+    [255, 170, 90],
+    [210, 90, 120]
+  ],
+  night: [
+    [8, 8, 30],
+    [40, 40, 96]
+  ],
+  show: [
+    [6, 6, 28],
+    [60, 40, 110]
+  ]
+}, D = (t) => Math.max(0, Math.min(255, Math.round(t)));
+function M(t) {
+  if (t.length !== 3 || t.some((f) => !Number.isFinite(f))) throw new RangeError("RGB must contain three finite components");
+}
+function b0(t, f) {
+  M(t);
+  const c = typeof f == "string" ? g0[f] : f;
+  return M(c.mul), M(c.add), t.map((e, n) => D(e * c.mul[n] + c.add[n]));
+}
+function F0(t, f, c, e) {
+  if (!Number.isSafeInteger(t) || t < 1 || t > 256) throw new RangeError("Ramp size must be 1..256");
+  return M(f), M(c), e && M(e), Array.from({ length: t }, (n, s) => {
+    const r = t === 1 ? 0 : s / (t - 1), [o, i, a] = e ? r < 0.5 ? [f, e, r * 2] : [e, c, (r - 0.5) * 2] : [f, c, r];
+    return o.map((h, l) => D(h + (i[l] - h) * a));
+  });
+}
+function Y0(t, f, c = [0, 255]) {
+  if (t.length !== 768 || t.some((s) => s > 63)) throw new RangeError("Expected a 768-byte six-bit VGA palette");
+  if (c.some((s) => !Number.isInteger(s) || s < 0 || s > 255)) throw new RangeError("Preserved palette indexes must be 0..255");
+  const e = new Set(c), n = t.slice();
+  for (let s = 0; s < 256; s++) {
+    if (e.has(s)) continue;
+    const r = [P(t[s * 3]), P(t[s * 3 + 1]), P(t[s * 3 + 2])];
+    n.set(
+      b0(r, f).map((o) => o >> 2),
+      s * 3
+    );
+  }
+  return n;
+}
+export {
+  E as CLEAR,
+  B as FONT8X8,
+  u0 as FONT_CP437,
+  Y as MICRO_GLYPHS,
+  E0 as PaletteBuilder,
+  g as Pixels,
+  _0 as Reel,
+  g0 as TIME_OF_DAY_LIGHT,
+  T0 as TIME_OF_DAY_SKY,
+  Y0 as adjustPalette,
+  O0 as bevel,
+  P0 as blob,
+  S0 as centered,
+  F0 as colorRamp,
+  I0 as describe,
+  T as dimmed,
+  K as dither,
+  w0 as dropShadow,
+  p0 as encodeText,
+  L as fromCp437,
+  m0 as glyphRows,
+  R0 as gradient,
+  b0 as lightColor,
+  N0 as outline,
+  a0 as outlined,
+  C0 as over,
+  $0 as readBounds,
+  v0 as recolor,
+  j0 as renderText,
+  V as rng,
+  A0 as scaleBlit,
+  G as shadeAt,
+  U0 as speckle,
+  N as text,
+  r0 as textInk,
+  i0 as textWidth,
+  F as toCp437
+};