@lewismoten/gamemaker-sandbox-engine 0.0.0-stage → 3.3.0

package/dist/formats/gif.js

@@ -0,0 +1,125 @@
+import { PALETTE_SIZE as G, vga8 as v } from "./palette.js";
+function M(n) {
+  return n[0] === 71 && n[1] === 73 && n[2] === 70;
+}
+function B(n) {
+  if (!M(n)) throw new Error("Not a GIF file");
+  let t = 6;
+  const o = () => {
+    const r = n[t] | n[t + 1] << 8;
+    return t += 2, r;
+  };
+  o(), o();
+  let i = n[t++];
+  t += 2;
+  const c = new Uint8Array(G), e = (r) => {
+    c.fill(0);
+    for (let h = 0; h < r; h++)
+      c[h * 3] = (n[t++] ?? 0) >> 2, c[h * 3 + 1] = (n[t++] ?? 0) >> 2, c[h * 3 + 2] = (n[t++] ?? 0) >> 2;
+  };
+  for (i & 128 && e(2 << (i & 7)); ; ) {
+    const r = n[t++];
+    if (r === 33) {
+      for (t++; t < n.length && n[t] !== 0; ) t += n[t] + 1;
+      t++;
+    } else {
+      if (r === 44) break;
+      throw new Error("GIF has no image");
+    }
+  }
+  t += 4;
+  const u = o(), l = o();
+  i = n[t++];
+  const p = (i & 64) !== 0;
+  i & 128 && e(2 << (i & 7));
+  const w = n[t++], d = [];
+  for (; t < n.length; ) {
+    const r = n[t++];
+    if (!r) break;
+    for (let h = 0; h < r && t < n.length; h++) d.push(n[t++]);
+  }
+  const s = m(Uint8Array.from(d), w, u * l), f = new Uint8Array(u * l);
+  if (!p) f.set(s.subarray(0, f.length));
+  else {
+    let r = 0;
+    for (const [h, A] of [
+      [0, 8],
+      [4, 8],
+      [2, 4],
+      [1, 2]
+    ])
+      for (let U = h; U < l; U += A)
+        f.set(s.subarray(r, r + u), U * u), r += u;
+  }
+  return { width: u, height: l, pixels: f, palette: c };
+}
+function m(n, t, o, i) {
+  const c = new Uint8Array(o), e = 1 << t, u = e + 1, l = new Int16Array(4096), p = new Uint8Array(4096), w = new Uint8Array(4096), d = new Uint8Array(4097);
+  let s = t + 1, f = e + 2, r = -1, h = 0, A = 0, U = 0, E = 0;
+  for (let a = 0; a < e; a++)
+    l[a] = -1, p[a] = a, w[a] = a;
+  for (; E < o; ) {
+    for (; A < s; ) {
+      if (U >= n.length)
+        return i && (i.count = E), c;
+      h |= n[U++] << A, A += 8;
+    }
+    const a = h & (1 << s) - 1;
+    if (h >>>= s, A -= s, a === e) {
+      s = t + 1, f = e + 2, r = -1;
+      continue;
+    }
+    if (a === u) break;
+    let g = a, k = 0;
+    for (r >= 0 && a >= f && (d[k++] = w[r], g = r); g >= e && k < 4096; )
+      d[k++] = p[g], g = l[g];
+    d[k++] = g;
+    const I = g;
+    for (; k > 0 && E < o; ) c[E++] = d[--k];
+    r >= 0 && f < 4096 && (l[f] = r, p[f] = I, w[f] = w[r], f++, f === 1 << s && s < 12 && s++), r < 0 && (w[a] = a), r = a;
+  }
+  return i && (i.count = E), c;
+}
+function F(n) {
+  const t = [], o = (e) => t.push(e & 255, e >> 8 & 255);
+  t.push(71, 73, 70, 56, 55, 97), o(n.width), o(n.height), t.push(247, 0, 0);
+  for (let e = 0; e < G; e++) t.push(v(n.palette[e]));
+  t.push(44), o(0), o(0), o(n.width), o(n.height), t.push(0);
+  const i = 8;
+  t.push(i);
+  const c = x(n.pixels, i);
+  for (let e = 0; e < c.length; e += 255) {
+    const u = Math.min(255, c.length - e);
+    t.push(u);
+    for (let l = 0; l < u; l++) t.push(c[e + l]);
+  }
+  return t.push(0, 59), Uint8Array.from(t);
+}
+function x(n, t) {
+  const o = 1 << t, i = o + 1, c = [];
+  let e = t + 1, u = i + 1, l = 0, p = 0;
+  const w = (f) => {
+    for (l |= f << p, p += e; p >= 8; )
+      c.push(l & 255), l >>>= 8, p -= 8;
+  };
+  let d = /* @__PURE__ */ new Map();
+  if (w(o), n.length === 0)
+    return w(i), p && c.push(l & 255), Uint8Array.from(c);
+  let s = n[0];
+  for (let f = 1; f < n.length; f++) {
+    const r = n[f], h = s << 8 | r, A = d.get(h);
+    if (A !== void 0) {
+      s = A;
+      continue;
+    }
+    w(s), u < 4096 ? (d.set(h, u++), u > 1 << e && e < 12 && e++) : (w(o), d = /* @__PURE__ */ new Map(), e = t + 1, u = i + 1), s = r;
+  }
+  return w(s), w(i), p && c.push(l & 255), Uint8Array.from(c);
+}
+export {
+  B as decodeGif,
+  F as encodeGif,
+  M as isGif,
+  m as lzwDecode,
+  x as lzwEncode
+};

package/dist/formats/gifProgressive.js

@@ -0,0 +1,99 @@
+import { lzwDecode as A, lzwEncode as E } from "./gif.js";
+import { vga8 as M, PALETTE_SIZE as S } from "./palette.js";
+const g = [
+  // [first row, step, rows it stands in for]
+  [0, 8, 8],
+  [4, 8, 4],
+  [2, 4, 2],
+  [1, 2, 1]
+];
+function v(t, e) {
+  if (!e) return Array.from({ length: t }, (o, i) => ({ y: i, span: 1 }));
+  const r = [];
+  for (const [o, i, l] of g) for (let a = o; a < t; a += i) r.push({ y: a, span: l });
+  return r;
+}
+function k(t) {
+  if (t.length < 13 || t[0] !== 71 || t[1] !== 73 || t[2] !== 70) return;
+  let e = 10, r = t[e++];
+  e++;
+  const o = t[e++], i = new Uint8Array(S);
+  let l = 0;
+  const a = (u) => {
+    if (l = 2 << (u & 7), e + l * 3 > t.length) return !1;
+    i.fill(0);
+    for (let f = 0; f < l * 3; f++) i[f] = t[e++] >> 2;
+    return !0;
+  };
+  if (r & 128 && !a(r)) return;
+  for (; ; ) {
+    if (e >= t.length) return;
+    const u = t[e++];
+    if (u === 44) break;
+    if (u !== 33) return;
+    for (e++; e < t.length && t[e] !== 0; ) e += t[e] + 1;
+    e++;
+  }
+  if (e + 10 > t.length) return;
+  e += 4;
+  const c = t[e] | t[e + 1] << 8, n = t[e + 2] | t[e + 3] << 8;
+  if (e += 4, r = t[e++], r & 128 && !a(r)) return;
+  const s = t[e++], h = new Uint8Array(Math.max(0, t.length - e));
+  let p = 0, d = !1;
+  for (; e < t.length; ) {
+    const u = t[e++];
+    if (!u) {
+      d = !0;
+      break;
+    }
+    const f = Math.min(u, t.length - e);
+    h.set(t.subarray(e, e + f), p), p += f, e += f;
+  }
+  const w = { count: 0 }, x = A(h.subarray(0, p), s, c * n, w);
+  return {
+    width: c,
+    height: n,
+    palette: i,
+    colors: l,
+    interlaced: (r & 64) !== 0,
+    stored: x,
+    received: w.count,
+    complete: d || w.count >= c * n,
+    aspect: o ? (o + 15) / 64 : 1
+  };
+}
+function z(t, e = 0) {
+  const { width: r, height: o, stored: i } = t, l = new Uint8Array(r * o).fill(e), a = v(o, t.interlaced);
+  for (let c = 0; c < a.length; c++) {
+    const n = c * r;
+    if (n >= t.received) break;
+    const s = Math.min(r, t.received - n), { y: h, span: p } = a[c];
+    for (let d = h; d < Math.min(o, h + p); d++) l.set(i.subarray(n, n + s), d * r);
+  }
+  return l;
+}
+function P(t, e = {}) {
+  let r = 1;
+  for (; 1 << r < (e.colors ?? 256); ) r++;
+  const o = [], i = (n) => o.push(n & 255, n >> 8 & 255);
+  o.push(71, 73, 70, 56, 57, 97), i(t.width), i(t.height), o.push(128 | r - 1 << 4 | r - 1, 0, e.aspect ?? 0);
+  for (let n = 0; n < 3 << r; n++) o.push(M(t.palette[n] ?? 0));
+  o.push(44), i(0), i(0), i(t.width), i(t.height), o.push(e.interlaced ? 64 : 0);
+  let l = t.pixels;
+  e.interlaced && (l = new Uint8Array(t.pixels.length), v(t.height, !0).forEach(({ y: n }, s) => l.set(t.pixels.subarray(n * t.width, (n + 1) * t.width), s * t.width)));
+  const a = Math.max(2, r);
+  o.push(a);
+  const c = E(l, a);
+  for (let n = 0; n < c.length; n += 255) {
+    const s = Math.min(255, c.length - n);
+    o.push(s);
+    for (let h = 0; h < s; h++) o.push(c[n + h]);
+  }
+  return o.push(0, 59), Uint8Array.from(o);
+}
+export {
+  k as decodePartialGif,
+  P as encodeGif89,
+  z as partialPixels,
+  v as storedRows
+};

package/dist/formats/graphicScripts.js

@@ -0,0 +1,44 @@
+import { Reader as c, latin1Text as o, textBytes as a } from "./binary.js";
+function p(n) {
+  const e = new c(n), t = e.i16(), s = e.i16(), i = o(n.subarray(4, 43)).split(/[\r\n\0]/)[0].trim();
+  return { x: t, y: s, gif: i };
+}
+function u(n) {
+  const e = a(n.gif), t = new Uint8Array(4 + e.length);
+  return t[0] = n.x & 255, t[1] = n.x >> 8 & 255, t[2] = n.y & 255, t[3] = n.y >> 8 & 255, t.set(e, 4), t;
+}
+function f(n) {
+  const e = [];
+  for (const t of o(n).split(`
+`)) {
+    const s = t.replace(/[\r\x1a]/g, ""), r = /^([^ ]{0,15})[^ ]* *(.*)$/.exec(s);
+    if (!r || !r[1]) continue;
+    const i = r[2].trim();
+    e.push({ name: r[1].toLowerCase(), pause: i ? parseInt(i, 10) || 0 : void 0 });
+  }
+  return e;
+}
+function x(n) {
+  return a(n.map((e) => e.pause === void 0 ? e.name : `${e.name} ${e.pause}`).join(`\r
+`) + `\r
+`);
+}
+function m(n) {
+  const e = o(n).replace(/\x1a.*$/s, "").replace(/\r\n/g, `
+`), t = [];
+  for (let s = 0; s < e.length; ) {
+    let r = s;
+    for (; r < e.length && r - s < 31 && e[r++] !== `
+`; )
+      ;
+    t.push(e.slice(s, r).replace(/\n$/, "")), s = r;
+  }
+  return t;
+}
+export {
+  p as parseBackdrop,
+  f as parseSlideList,
+  u as serializeBackdrop,
+  x as serializeSlideList,
+  m as textLines
+};

package/dist/formats/highscore.js

@@ -0,0 +1,30 @@
+import { Reader as c, Writer as s } from "./binary.js";
+const o = 10;
+function l(n) {
+  const r = new c(n);
+  return Array.from({ length: o }, () => ({ score: r.i32(), name: r.cstr(30) }));
+}
+function u(n) {
+  const r = new s(o * 34);
+  for (let e = 0; e < o; e++) {
+    const t = n[e] ?? { score: 0, name: "" };
+    r.i32(t.score).cstr(t.name, 30);
+  }
+  return r.toBytes();
+}
+function a(n, r) {
+  for (let e = 0; e < o; e++) if (r > (n[e]?.score ?? 0)) return e;
+  return -1;
+}
+function f(n, r, e) {
+  const t = n.slice(0, o);
+  for (; t.length < o; ) t.push({ score: 0, name: "" });
+  return t.splice(r, 0, e), t.slice(0, o);
+}
+export {
+  o as HIGH_SCORES,
+  f as insertHighScore,
+  l as parseHighScores,
+  a as placeFor,
+  u as serializeHighScores
+};

package/dist/formats/jpeg.js

@@ -0,0 +1,359 @@
+const S = Int32Array.from([
+  0,
+  1,
+  8,
+  16,
+  9,
+  2,
+  3,
+  10,
+  17,
+  24,
+  32,
+  25,
+  18,
+  11,
+  4,
+  5,
+  12,
+  19,
+  26,
+  33,
+  40,
+  48,
+  41,
+  34,
+  27,
+  20,
+  13,
+  6,
+  7,
+  14,
+  21,
+  28,
+  35,
+  42,
+  49,
+  56,
+  57,
+  50,
+  43,
+  36,
+  29,
+  22,
+  15,
+  23,
+  30,
+  37,
+  44,
+  51,
+  58,
+  59,
+  52,
+  45,
+  38,
+  31,
+  39,
+  46,
+  53,
+  60,
+  61,
+  54,
+  47,
+  55,
+  62,
+  63
+]);
+class R extends Error {
+}
+function O(n, I) {
+  const k = new Int32Array(18).fill(-1), r = new Int32Array(17), o = new Int32Array(17);
+  let g = 0, p = 0;
+  for (let h = 1; h <= 16; h++)
+    r[h] = p, o[h] = g, g += n[h - 1], p += n[h - 1], k[h] = n[h - 1] ? g - 1 : -1, g <<= 1;
+  return k[17] = 2147483647, { maxcode: k, valptr: r, mincode: o, vals: I };
+}
+function Z(n) {
+  return n[0] === 255 && n[1] === 216;
+}
+function Q(n) {
+  if (!Z(n)) return;
+  const I = [], k = [], r = [];
+  let o = [], g = 0, p = 0, h = !1, q = 0, l = 1, y = 1, v = 0, M = 0, F = 1, U = 0, C = !1, x = 2;
+  const L = (f) => n[f] << 8 | n[f + 1];
+  e: for (; x + 1 < n.length; ) {
+    if (n[x] !== 255) {
+      x++;
+      continue;
+    }
+    const f = n[x + 1];
+    if (f === 255) {
+      x++;
+      continue;
+    }
+    if (f === 217) {
+      C = !0;
+      break;
+    }
+    if (f >= 208 && f <= 215) {
+      x += 2;
+      continue;
+    }
+    if (x + 4 > n.length) break;
+    const w = L(x + 2), c = x + 4, A = x + 2 + w;
+    if (f !== 218 && A > n.length) break;
+    switch (f) {
+      case 224:
+        if (n[c] === 74 && n[c + 1] === 70 && n[c + 7] === 0) {
+          const a = L(c + 8), e = L(c + 10);
+          a && e && (F = a / e);
+        }
+        break;
+      case 219:
+        for (let a = c; a < A; ) {
+          const e = n[a] >> 4, t = n[a] & 15;
+          a++;
+          const s = new Int32Array(64);
+          for (let i = 0; i < 64; i++)
+            s[S[i]] = e ? L(a) : n[a], a += e ? 2 : 1;
+          I[t] = s;
+        }
+        break;
+      case 192:
+      case 193:
+      case 194: {
+        h = f === 194, p = L(c + 1), g = L(c + 3);
+        const a = n[c + 5];
+        o = [];
+        for (let e = 0; e < a; e++) {
+          const t = c + 6 + e * 3;
+          o.push({
+            id: n[t],
+            h: n[t + 1] >> 4,
+            v: n[t + 1] & 15,
+            tq: n[t + 2],
+            blocksPerLine: 0,
+            blocksPerColumn: 0,
+            stride: 0,
+            coeffs: new Int16Array(0),
+            ready: new Uint8Array(0),
+            pred: 0
+          });
+        }
+        l = Math.max(...o.map((e) => e.h)), y = Math.max(...o.map((e) => e.v)), v = Math.ceil(g / (8 * l)), M = Math.ceil(p / (8 * y));
+        for (const e of o)
+          e.blocksPerLine = Math.ceil(Math.ceil(g * e.h / l) / 8), e.blocksPerColumn = Math.ceil(Math.ceil(p * e.v / y) / 8), e.stride = v * e.h, e.coeffs = new Int16Array(M * e.v * e.stride * 64), e.ready = new Uint8Array(e.coeffs.length / 64);
+        break;
+      }
+      case 196:
+        for (let a = c; a < A; ) {
+          const e = n[a] >> 4, t = n[a] & 15, s = n.subarray(a + 1, a + 17), i = s.reduce((P, m) => P + m, 0), b = O(s, n.slice(a + 17, a + 17 + i));
+          (e ? r : k)[t] = b, a += 17 + i;
+        }
+        break;
+      case 221:
+        q = L(c);
+        break;
+      case 218: {
+        if (A > n.length || !o.length) break e;
+        const a = n[c], e = [];
+        for (let d = 0; d < a; d++) {
+          const z = o.find((T) => T.id === n[c + 1 + d * 2]);
+          z.dc = k[n[c + 2 + d * 2] >> 4], z.ac = r[n[c + 2 + d * 2] & 15], e.push(z);
+        }
+        const t = c + 1 + a * 2, s = n[t], i = n[t + 1], b = n[t + 2] >> 4, P = n[t + 2] & 15, m = B(n, A, e, { progressive: h, ss: s, se: i, ah: b, al: P, restart: q, mcusPerLine: v, mcusPerColumn: M });
+        if (!m.done) break e;
+        U++, x = m.pos;
+        continue;
+      }
+    }
+    x = A;
+  }
+  if (!o.length || !g || !p) return;
+  const E = new Uint8Array(g * p), u = o[0];
+  for (let f = 0; f < p; f++)
+    for (let w = 0; w < g; w++) {
+      const c = Math.floor(w * u.h / l / 8), A = Math.floor(f * u.v / y / 8);
+      E[f * g + w] = u.ready[A * u.stride + c];
+    }
+  return {
+    width: g,
+    height: p,
+    channels: o.length === 1 ? 1 : 3,
+    pixels: D(o, I, g, p, l, y),
+    shown: E,
+    progressive: h,
+    scans: U,
+    complete: C,
+    aspect: F
+  };
+}
+function B(n, I, k, r) {
+  let o = I, g = 0, p = 0, h = 0;
+  const q = () => {
+    if (!p) {
+      if (o >= n.length) throw new R();
+      const e = n[o];
+      if (e === 255) {
+        if (o + 1 >= n.length) throw new R();
+        if (n[o + 1] !== 0) throw new R();
+        o += 2;
+      } else o++;
+      g = e, p = 8;
+    }
+    return p--, g >> p & 1;
+  }, l = (e) => {
+    let t = 0;
+    for (; e--; ) t = t << 1 | q();
+    return t;
+  }, y = (e) => {
+    if (!e) return 0;
+    const t = l(e);
+    return t < 1 << e - 1 ? t - (1 << e) + 1 : t;
+  }, v = (e) => {
+    let t = 0;
+    for (let s = 1; s <= 16; s++)
+      if (t = t << 1 | q(), t <= e.maxcode[s]) return e.vals[e.valptr[s] + t - e.mincode[s]];
+    throw new R();
+  }, M = (e, t) => {
+    const s = v(e.dc);
+    e.pred += y(s), e.coeffs[t] = e.pred;
+    for (let i = 1; i < 64; ) {
+      const b = v(e.ac), P = b >> 4, m = b & 15;
+      if (!m) {
+        if (P < 15) break;
+        i += 16;
+        continue;
+      }
+      if (i += P, i > 63) break;
+      e.coeffs[t + S[i]] = y(m), i++;
+    }
+  }, F = (e, t) => {
+    const s = v(e.dc);
+    e.pred += y(s) * (1 << r.al), e.coeffs[t] = e.pred;
+  }, U = (e, t) => {
+    q() && (e.coeffs[t] |= 1 << r.al);
+  }, C = (e, t) => {
+    if (h > 0) {
+      h--;
+      return;
+    }
+    for (let s = r.ss; s <= r.se; ) {
+      const i = v(e.ac), b = i >> 4, P = i & 15;
+      if (!P) {
+        if (b < 15) {
+          h = (1 << b) - 1 + l(b);
+          break;
+        }
+        s += 16;
+        continue;
+      }
+      if (s += b, s > 63) break;
+      e.coeffs[t + S[s]] = y(P) * (1 << r.al), s++;
+    }
+  }, x = (e, t) => {
+    const s = 1 << r.al, i = -1 << r.al, b = e.coeffs, P = (d) => {
+      q() && (b[d] & s) === 0 && (b[d] += b[d] >= 0 ? s : i);
+    };
+    let m = r.ss;
+    if (h === 0)
+      for (; m <= r.se; m++) {
+        const d = v(e.ac);
+        let z = d >> 4;
+        const T = d & 15;
+        let G = 0;
+        if (T) G = q() ? s : i;
+        else if (z !== 15) {
+          h = 1 << z, z && (h += l(z));
+          break;
+        }
+        for (; m <= r.se; m++) {
+          const J = t + S[m];
+          if (b[J] !== 0) P(J);
+          else if (--z < 0) break;
+        }
+        G && m <= r.se && (b[t + S[m]] = G);
+      }
+    if (h > 0) {
+      for (; m <= r.se; m++) {
+        const d = t + S[m];
+        b[d] !== 0 && P(d);
+      }
+      h--;
+    }
+  }, L = r.progressive ? r.ss === 0 ? r.ah ? U : F : r.ah ? x : C : M;
+  for (const e of k) e.pred = 0;
+  const E = k.length === 1, u = k[0], f = E ? u.blocksPerLine * u.blocksPerColumn : r.mcusPerLine * r.mcusPerColumn;
+  let w = 0;
+  const c = [], A = new Int16Array(64 * (E ? 1 : k.reduce((e, t) => e + t.h * t.v, 0))), a = (e, t) => {
+    A.set(e.coeffs.subarray(t, t + 64), c.length * 64), c.push({ c: e, o: t }), L(e, t);
+  };
+  try {
+    for (; w < f; ) {
+      const e = r.restart ? Math.min(r.restart, f - w) : f - w;
+      for (let t = 0; t < e; t++, w++) {
+        if (E) {
+          const s = Math.floor(w / u.blocksPerLine), i = w % u.blocksPerLine;
+          a(u, (s * u.stride + i) * 64);
+        } else {
+          const s = Math.floor(w / r.mcusPerLine), i = w % r.mcusPerLine;
+          for (const b of k) for (let P = 0; P < b.v; P++) for (let m = 0; m < b.h; m++) a(b, ((s * b.v + P) * b.stride + i * b.h + m) * 64);
+        }
+        if (!r.progressive || r.ss === 0 && r.ah === 0) for (const { c: s, o: i } of c) s.ready[i / 64] = 1;
+        c.length = 0;
+      }
+      if (w >= f) break;
+      p = 0, h = 0;
+      for (const t of k) t.pred = 0;
+      if (o + 1 >= n.length) throw new R();
+      n[o] === 255 && n[o + 1] >= 208 && n[o + 1] <= 215 && (o += 2);
+    }
+  } catch (e) {
+    if (!(e instanceof R)) throw e;
+    return c.forEach(({ c: t, o: s }, i) => t.coeffs.set(A.subarray(i * 64, (i + 1) * 64), s)), { done: !1, pos: o };
+  }
+  for (; o + 1 < n.length && !(n[o] === 255 && n[o + 1] !== 0 && (n[o + 1] < 208 || n[o + 1] > 215)); ) o++;
+  return { done: o + 1 < n.length, pos: o };
+}
+const H = new Float32Array(64);
+for (let n = 0; n < 8; n++) for (let I = 0; I < 8; I++) H[n * 8 + I] = (I ? 1 : Math.SQRT1_2) * 0.5 * Math.cos((2 * n + 1) * I * Math.PI / 16);
+function D(n, I, k, r, o, g) {
+  const p = n.map((l) => {
+    const y = l.stride * 8, v = l.coeffs.length / 64 / l.stride, M = new Uint8Array(y * v * 8), F = I[l.tq] ?? new Int32Array(64).fill(1), U = new Float32Array(64), C = new Float32Array(64);
+    for (let x = 0; x < v; x++)
+      for (let L = 0; L < l.stride; L++) {
+        const E = (x * l.stride + L) * 64;
+        for (let u = 0; u < 64; u++) U[u] = l.coeffs[E + u] * F[u];
+        for (let u = 0; u < 8; u++)
+          for (let f = 0; f < 8; f++) {
+            let w = 0;
+            for (let c = 0; c < 8; c++) w += H[f * 8 + c] * U[u * 8 + c];
+            C[u * 8 + f] = w;
+          }
+        for (let u = 0; u < 8; u++)
+          for (let f = 0; f < 8; f++) {
+            let w = 0;
+            for (let A = 0; A < 8; A++) w += H[f * 8 + A] * C[A * 8 + u];
+            const c = Math.round(w + 128);
+            M[(x * 8 + f) * y + L * 8 + u] = c < 0 ? 0 : c > 255 ? 255 : c;
+          }
+      }
+    return { plane: M, w: y, sx: l.h / o, sy: l.v / g };
+  });
+  if (n.length === 1) {
+    const { plane: l, w: y } = p[0], v = new Uint8Array(k * r);
+    for (let M = 0; M < r; M++) v.set(l.subarray(M * y, M * y + k), M * k);
+    return v;
+  }
+  const h = new Uint8Array(k * r * 3), q = (l) => l < 0 ? 0 : l > 255 ? 255 : Math.round(l);
+  for (let l = 0; l < r; l++)
+    for (let y = 0; y < k; y++) {
+      const [v, M, F] = p.map((C) => C.plane[Math.floor(l * C.sy) * C.w + Math.floor(y * C.sx)] ?? 128), U = (l * k + y) * 3;
+      h[U] = q(v + 1.402 * (F - 128)), h[U + 1] = q(v - 0.344136 * (M - 128) - 0.714136 * (F - 128)), h[U + 2] = q(v + 1.772 * (M - 128));
+    }
+  return h;
+}
+export {
+  Q as decodePartialJpeg,
+  Z as isJpeg
+};

package/dist/formats/map.js

@@ -0,0 +1,38 @@
+import { Reader as m, Writer as f } from "./binary.js";
+const e = 100, a = 100, u = 200, s = e * a;
+function l(t) {
+  const r = new m(t), n = new Uint8Array(s), c = new Uint8Array(s);
+  for (let o = 0; o < s; o++)
+    n[o] = r.u8(), c[o] = r.u8();
+  const i = [];
+  for (let o = 0; o < u; o++)
+    i.push({ monnum: r.u8(), status: r.i16(), xtra: r.u8(), curx: r.i16(), cury: r.i16(), extra: r.i16() });
+  return { blocks: n, mons: c, monsters: i };
+}
+function y(t) {
+  const r = new f(s * 2 + u * 10);
+  for (let n = 0; n < s; n++) r.u8(t.blocks[n]).u8(t.mons[n]);
+  for (const n of t.monsters) r.u8(n.monnum).i16(n.status).u8(n.xtra).i16(n.curx).i16(n.cury).i16(n.extra);
+  return r.toBytes();
+}
+function M() {
+  return {
+    blocks: new Uint8Array(s),
+    mons: new Uint8Array(s).fill(u),
+    monsters: Array.from({ length: u }, () => ({ monnum: 64, status: 0, xtra: 0, curx: 0, cury: 0, extra: 0 }))
+  };
+}
+function w(t) {
+  t.mons.fill(u), t.monsters.forEach((r, n) => {
+    r.monnum < 64 && r.curx >= 0 && r.curx < e && r.cury >= 0 && r.cury < a && (t.mons[r.cury * e + r.curx] = n);
+  });
+}
+export {
+  u as LASTMM,
+  e as MLEN,
+  a as MWID,
+  M as newMap,
+  l as parseMap,
+  w as reindexMonsters,
+  y as serializeMap
+};