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

package/dist/formats/game.js

@@ -0,0 +1,193 @@
+import { W as F, R as G, c as L } from "../binary-D7wuaC5g.js";
+const w = 65535, O = 1, P = 2, M = 10, x = 20, y = 20, S = 20, B = 283, E = 256, T = 300, H = 8, U = [
+  "Title graphic",
+  "Title song",
+  "Menu graphic",
+  "Menu song",
+  "Storyline graphic",
+  "Storyline song",
+  "Game instructions",
+  "Beginning credits",
+  "High score backdrop",
+  "Load game background",
+  "Save game background",
+  "Demo recording"
+], Y = ["Game won graphic", "Game won song", "Game lost graphic", "Game lost song"], W = [
+  "Palette",
+  "Map",
+  "Background block set",
+  "Monsters",
+  "Monster block set",
+  "Character",
+  "Character block set",
+  "Sound set",
+  "Sound Blaster music",
+  "Level intro graphic",
+  "Level exit graphic"
+], Z = ["pal", "map", "bbl", "mon", "mbl", "chr", "cbl", "snd", "cmf", "graphic", "graphic"], K = ["graphic", "cmf", "graphic", "cmf", "graphic", "cmf", "graphic", "graphic", "graphic", "graphic", "graphic", "rec"], j = ["graphic", "cmf", "graphic", "cmf"], ne = ["gif", "bkd", "fli", "txt", "lst"];
+function z(e) {
+  return e[0] === 71 && e[1] === 77;
+}
+function N() {
+  return { toScene: w, from: { x: 0, y: 0 }, to: { x: 0, y: 0 } };
+}
+function _(e = w) {
+  return {
+    gametype: e,
+    pos: { x: 0, y: 0 },
+    scroll: { up: 255, down: 255, left: 255, right: 255, style: 0, xtra: new Uint8Array(11) },
+    numLinks: S,
+    desc: "",
+    files: new Array(y).fill(""),
+    links: Array.from({ length: S }, N)
+  };
+}
+function R() {
+  const e = new Uint8Array(E);
+  for (let t = 0; t < E - 6; t++) e[6 + t] = "RSD".charCodeAt(t % 3);
+  return e[0] = 71, e[1] = 77, e[2] = T & 255, e[3] = T >> 8, e[4] = 0, e[5] = H, e;
+}
+function se(e = "My Game") {
+  const t = _(O);
+  t.desc = e.slice(0, x - 1), t.pos = { x: 157, y: 36 };
+  const s = _(P);
+  return s.desc = "Game Won", s.pos = { x: 157, y: 184 }, { version: T, header: R(), filesPerScene: y, linksPerScene: S, scenes: [t, s], converted: !1 };
+}
+function oe(e) {
+  return z(e) ? q(e) : Q(e);
+}
+function q(e) {
+  const t = new G(e), s = t.bytesOf(E), i = s[2] | s[3] << 8, n = t.i16(), l = t.i16(), c = t.i16(), o = [];
+  for (let f = 0; f < n; f++) {
+    const g = t.u16(), d = { x: t.i16(), y: t.i16() }, k = { up: t.u8(), down: t.u8(), left: t.u8(), right: t.u8(), style: t.u8(), xtra: t.bytesOf(11) }, b = t.u8(), p = t.bytesOf(x), u = [];
+    for (let h = 0; h < y; h++) u.push(t.u16());
+    const r = [];
+    for (let h = 0; h < S; h++) r.push({ toScene: t.u16(), from: { x: t.i16(), y: t.i16() }, to: { x: t.i16(), y: t.i16() } });
+    o.push({ scene: { gametype: g, pos: d, scroll: k, numLinks: b, desc: L(p), descRaw: p, files: [], links: r }, offsets: u });
+  }
+  const m = t.u16(), a = t.bytesOf(m);
+  for (const { scene: f, offsets: g } of o)
+    f.files = g.map((d) => d === 0 || d >= a.length ? "" : L(a.subarray(d)));
+  return {
+    version: i,
+    header: s,
+    filesPerScene: l,
+    linksPerScene: c,
+    scenes: o.map((f) => f.scene),
+    pool: a,
+    poolOffsets: o.map((f) => f.offsets),
+    converted: !1
+  };
+}
+const C = 330, D = 20, J = [".pal", ".map", ".bbl", ".mon", ".mbl", ".chr", ".cbl", ".snd", ".cmf"];
+function Q(e) {
+  const t = Math.min(D, Math.floor(e.length / C)), s = [];
+  for (let i = 0; i < t; i++) {
+    const n = new G(e, i * C), l = n.u16(), c = n.i16(), o = n.i16(), m = n.cstr(15), a = [];
+    for (let r = 0; r < 9; r++) a.push(n.cstr(10).toLowerCase());
+    const f = [];
+    for (let r = 0; r < 20; r++) {
+      const h = n.i16(), A = n.i16(), v = n.i16(), V = n.i16(), X = n.i16();
+      f.push({ toScene: v === D ? w : v & 65535, from: { x: h, y: A }, to: { x: V, y: X } });
+    }
+    n.skip(3);
+    const g = n.u8(), d = n.u8(), k = n.u8(), b = n.u8(), p = _();
+    p.gametype = l === O || l === P || l === M ? l : w, p.pos = { x: c, y: o }, p.scroll = { up: g, down: d, left: k, right: b, style: 0, xtra: new Uint8Array(11) }, p.desc = m.slice(0, x), p.links = f;
+    const u = (r, h, A) => {
+      p.files[h] = a[r] ? a[r] + A : "";
+    };
+    if (i === 0)
+      u(0, 2, ".bkd"), u(1, 4, ".txt"), u(2, 6, ".txt"), u(3, 7, ".txt"), u(4, 3, ".cmf");
+    else if (i === 1)
+      u(0, 0, ".bkd"), u(3, 1, ".cmf");
+    else
+      for (let r = 0; r < 9; r++) u(r, r, J[r]);
+    s.push(p);
+  }
+  return { version: 0, header: R(), filesPerScene: y, linksPerScene: S, scenes: s, converted: !0 };
+}
+function ce(e) {
+  const t = new F(E + 6 + e.scenes.length * B + 512);
+  t.bytes(e.header, E), t.i16(e.scenes.length).i16(e.filesPerScene).i16(e.linksPerScene);
+  let s, i;
+  return e.pool && e.poolOffsets && e.poolOffsets.length === e.scenes.length && $(e) ? (s = e.pool, i = e.poolOffsets) : { pool: s, offsets: i } = ee(e.scenes), e.scenes.forEach((n, l) => {
+    t.u16(n.gametype).i16(n.pos.x).i16(n.pos.y), t.u8(n.scroll.up).u8(n.scroll.down).u8(n.scroll.left).u8(n.scroll.right).u8(n.scroll.style).bytes(n.scroll.xtra, 11), t.u8(n.numLinks), t.cstrOver(n.desc, n.descRaw, x);
+    for (let c = 0; c < y; c++) t.u16(i[l][c] ?? 0);
+    for (let c = 0; c < S; c++) {
+      const o = n.links[c] ?? N();
+      t.u16(o.toScene).i16(o.from.x).i16(o.from.y).i16(o.to.x).i16(o.to.y);
+    }
+  }), t.u16(s.length).bytes(s), t.toBytes();
+}
+function $(e) {
+  const t = e.pool;
+  return e.scenes.every(
+    (s, i) => s.files.every((n, l) => {
+      const c = e.poolOffsets[i][l];
+      return (c === 0 || c >= t.length ? "" : L(t.subarray(c))) === n;
+    })
+  );
+}
+function ee(e) {
+  const t = [0], s = /* @__PURE__ */ new Map(), i = e.map(
+    (n) => Array.from({ length: y }, (l, c) => {
+      const o = n.files[c] ?? "";
+      if (!o) return 0;
+      let m = s.get(o);
+      if (m === void 0) {
+        m = t.length, s.set(o, m);
+        for (let a = 0; a < o.length; a++) t.push(o.charCodeAt(a) & 255);
+        t.push(0);
+      }
+      return m;
+    })
+  );
+  return { pool: new Uint8Array(t), offsets: i };
+}
+function I(e) {
+  return e.gametype === O ? "start" : e.gametype === P ? "end" : e.gametype === M ? "adventure" : "unused";
+}
+function re(e) {
+  switch (I(e)) {
+    case "start":
+      return U;
+    case "end":
+      return Y;
+    default:
+      return W;
+  }
+}
+function ie(e) {
+  switch (I(e)) {
+    case "start":
+      return K;
+    case "end":
+      return j;
+    default:
+      return Z;
+  }
+}
+export {
+  M as ADVTYPE,
+  Z as ADV_EXTS,
+  W as ADV_FILES,
+  P as ENDTYPE,
+  Y as END_FILES,
+  T as GAM_VERSION,
+  ne as GRAPHIC_EXTS,
+  S as MAXSCENELINKS,
+  w as NOSCENE,
+  x as SCENEDESCLEN,
+  y as SCENEFILES,
+  O as STARTTYPE,
+  U as START_FILES,
+  R as defaultHeader,
+  N as emptyLink,
+  _ as emptyScene,
+  re as fileSlotsFor,
+  se as newGame,
+  oe as parseGame,
+  I as sceneKind,
+  ce as serializeGame,
+  ie as slotExtensions
+};

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/graphicScripts.js

@@ -0,0 +1,44 @@
+import { R as c, l as o, t as a } from "../binary-D7wuaC5g.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/map.js

@@ -0,0 +1,38 @@
+import { R as m, W as f } from "../binary-D7wuaC5g.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
+};

package/dist/formats/monster.js

@@ -0,0 +1,69 @@
+import { W as R, R as g } from "../binary-D7wuaC5g.js";
+const e = 64, p = 20, l = 10, L = 300, C = 0, V = 1;
+function a(t) {
+  return { x: t.i16(), y: t.i16(), pic: t.i16(), orient: t.i16() };
+}
+function f(t, o) {
+  t.i16(o.x).i16(o.y).i16(o.pic).i16(o.orient);
+}
+function j(t) {
+  const o = t.i16(), n = t.i16(), c = t.i16(), M = t.i16(), h = t.u8(), y = t.i8(), s = [];
+  for (let i = 0; i <= p; i++) s.push([t.i16(), t.i16()]);
+  const d = t.u32(), w = t.i8(), A = t.i16(), x = t.bytesOf(21), T = t.i16(), E = t.i16(), O = t.i16(), S = [t.i16(), t.i16()], r = [[], []];
+  for (let i = 0; i < 2; i++) for (let u = 0; u < l; u++) r[i].push(a(t));
+  const N = a(t);
+  return { used: o, fly: n, jump: c, stick: M, power: h, thru: y, pic: s, lasttime: d, newmon: w, upscore: A, xtra: x, activate: T, end: E, towards: O, close: S, march: r, cur: N };
+}
+function k(t, o) {
+  t.i16(o.used).i16(o.fly).i16(o.jump).i16(o.stick).u8(o.power).i8(o.thru);
+  for (const [n, c] of o.pic) t.i16(n).i16(c);
+  t.u32(o.lasttime).i8(o.newmon).i16(o.upscore).bytes(o.xtra, 21).i16(o.activate).i16(o.end).i16(o.towards).i16(o.close[0]).i16(o.close[1]);
+  for (const n of o.march) for (const c of n) f(t, c);
+  f(t, o.cur);
+}
+function W(t) {
+  const o = new g(t);
+  return Array.from({ length: e }, () => j(o));
+}
+function z(t) {
+  const o = new R(e * L);
+  for (const n of t) k(o, n);
+  return o.toBytes();
+}
+function v() {
+  const t = Array.from({ length: p + 1 }, () => [100, 1]), o = () => Array.from({ length: l }, () => ({ x: 0, y: 0, pic: 0, orient: 0 }));
+  return {
+    used: 0,
+    fly: 0,
+    jump: 0,
+    stick: 0,
+    power: 1,
+    thru: 1,
+    pic: t,
+    lasttime: 0,
+    newmon: e,
+    upscore: 0,
+    xtra: new Uint8Array(21),
+    activate: 0,
+    end: 0,
+    towards: 0,
+    close: [0, 0],
+    march: [o(), o()],
+    cur: { x: 0, y: 0, pic: 0, orient: 0 }
+  };
+}
+function B() {
+  return Array.from({ length: e }, () => v());
+}
+export {
+  V as ATTACKMOVEMENT,
+  e as LASTMON,
+  p as LASTSL,
+  l as MAXMARCH,
+  L as MONSTER_SIZE,
+  C as NORMALMOVEMENT,
+  v as emptyMonster,
+  B as newMonsterSet,
+  W as parseMonsters,
+  z as serializeMonsters
+};

package/dist/formats/palette.js

@@ -0,0 +1,58 @@
+const T = 768;
+function h(t) {
+  const r = new Uint8Array(768);
+  return r.set(t.subarray(0, 768)), r;
+}
+function A(t) {
+  return t.slice(0, 768);
+}
+function P(t) {
+  const r = new Uint32Array(256);
+  for (let n = 0; n < 256; n++)
+    r[n] = 255 << 24 | u(t[n * 3 + 2]) << 16 | u(t[n * 3 + 1]) << 8 | u(t[n * 3]);
+  return r;
+}
+function u(t) {
+  const r = t & 63;
+  return r << 2 | r >> 4;
+}
+function b(t, r) {
+  return `rgb(${u(t[r * 3])},${u(t[r * 3 + 1])},${u(t[r * 3 + 2])})`;
+}
+function d(t, r, n, e) {
+  let o = 0, s = 1 / 0;
+  for (let c = 0; c < 256; c++) {
+    const i = (t[c * 3] & 63) - r, f = (t[c * 3 + 1] & 63) - n, a = (t[c * 3 + 2] & 63) - e, E = i * i + f * f + a * a;
+    E < s && (s = E, o = c);
+  }
+  return o;
+}
+function I() {
+  const t = new Uint8Array(768);
+  for (let n = 0; n < 16; n++) t.set([n * 4 + 3, n * 4 + 3, n * 4 + 3], n * 3);
+  let r = 16;
+  for (let n = 0; n < 6; n++)
+    for (let e = 0; e < 6; e++) for (let o = 0; o < 6; o++) t.set([Math.round(n * 63 / 5), Math.round(e * 63 / 5), Math.round(o * 63 / 5)], r++ * 3);
+  for (; r < 255; r++) {
+    const n = (r - 232) / 23 * 6, [e, o, s] = l(n, 1, 1);
+    t.set([e, o, s], r * 3);
+  }
+  return t.set([63, 0, 63], 765), t;
+}
+function l(t, r, n) {
+  const e = (o) => {
+    const s = (o + t) % 6;
+    return Math.round(63 * (n - n * r * Math.max(0, Math.min(s, 4 - s, 1))));
+  };
+  return [e(5), e(3), e(1)];
+}
+export {
+  T as PALETTE_SIZE,
+  I as defaultPalette,
+  d as matchColor,
+  b as paletteCss,
+  P as paletteToRGBA,
+  h as parsePalette,
+  A as serializePalette,
+  u as vga8
+};

package/dist/formats/recording.js

@@ -0,0 +1,17 @@
+import { R as i, W as s } from "../binary-D7wuaC5g.js";
+const r = 1e3;
+function a(t) {
+  const e = new i(t), o = [], c = Math.min(r, Math.floor(t.length / 3));
+  for (let n = 0; n < c; n++) o.push({ delta: e.u16(), key: e.u8() });
+  return o;
+}
+function l(t) {
+  const e = new s(t.length * 3);
+  for (const o of t.slice(0, r)) e.u16(o.delta).u8(o.key);
+  return e.toBytes();
+}
+export {
+  r as RECLEN,
+  a as parseRecording,
+  l as serializeRecording
+};

package/dist/formats/sound.js

@@ -0,0 +1,44 @@
+import { R as f, W as u } from "../binary-D7wuaC5g.js";
+const e = 30, s = 36, d = e * s * 2 + e * 9, w = [
+  "Help (hit points up)",
+  "Kill monster",
+  "Add money",
+  "Subtract money",
+  "Add life",
+  "Add score",
+  "Subtract score",
+  "Add other counter",
+  "Subtract other counter"
+];
+function A(i) {
+  const n = new f(i), o = [];
+  for (let r = 0; r < e; r++) {
+    const c = new Uint16Array(s);
+    for (let a = 0; a < s; a++) c[a] = n.u16();
+    o.push(c);
+  }
+  const t = [];
+  for (let r = 0; r < e; r++) t.push(n.bytesOf(9));
+  const l = t.map((r) => new f(r).cstr(9));
+  return { freqs: o, digital: l, digitalRaw: t };
+}
+function y(i) {
+  const n = new u(d);
+  for (const o of i.freqs) for (let t = 0; t < s; t++) n.u16(o[t] ?? 0);
+  return i.digital.forEach((o, t) => n.cstrOver(o, i.digitalRaw[t], 9)), n.toBytes();
+}
+function p() {
+  return {
+    freqs: Array.from({ length: e }, () => new Uint16Array(s)),
+    digital: new Array(e).fill(""),
+    digitalRaw: Array.from({ length: e }, () => new Uint8Array(9))
+  };
+}
+export {
+  e as LASTSND,
+  s as NUMFREQ,
+  w as SOUND_NAMES,
+  p as newSoundSet,
+  A as parseSoundSet,
+  y as serializeSoundSet
+};