@lewismoten/gamemaker-sandbox-archives 0.0.0-stage → 3.2.0

package/CHANGELOG.md

@@ -0,0 +1,22 @@
+# Changelog
+
+Changes to `@lewismoten/gamemaker-sandbox-archives`, released as `archives-v*` tags. The format follows
+[Keep a Changelog](https://keepachangelog.com/en/1.1.0/).
+
+## [Unreleased]
+
+## [3.2.0] - 2026-11-07
+
+The first release: game discovery, ZIP and SFX extraction, ZIP creation and a full import scanner, with no Node-only
+code. Imports check what FLI, GIF and VOC files really hold and keep the player's build and author bytes.
+
+### Added
+
+- Game discovery, ZIP and SFX extraction, and ZIP creation, with no Node-only code.
+- A dedicated entry for the complete import scanner, with documented and verified scan-and-select APIs.
+- Importing checks what FLI, GIF and VOC files really hold, and keeps the player's build and author bytes.
+
+Full list: [changes/release/archives/3.2.0.md](https://github.com/lewismoten/GameMaker-SandboxEdition/blob/archives-v3.2.0/changes/release/archives/3.2.0.md)
+
+[Unreleased]: https://github.com/lewismoten/GameMaker-SandboxEdition/compare/archives-v3.2.0...HEAD
+[3.2.0]: https://github.com/lewismoten/GameMaker-SandboxEdition/releases/tag/archives-v3.2.0

package/LICENSE

@@ -0,0 +1,24 @@
+The MIT License (MIT)
+
+Copyright (c) 2014 gandrewstone
+Copyright (c) 2026 Lewis Moten (modifications: the web port, the 1994 desk, the
+Sandbox Software and Bard of Bizarre games, and the Mac, Windows and Linux players;
+see NOTICE.md)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/NOTICE.md

@@ -0,0 +1,11 @@
+# Notices
+
+This package contains portable archive and game-import code from Game-Maker: Sandbox Edition by Lewis Moten, under the MIT License. See LICENSE for the original copyright and license terms.
+
+The ZIP implementation was written for this project from PKWARE's ZIP file format (APPNOTE). Compression and decompression use the platform's CompressionStream and DecompressionStream; no third-party ZIP library is bundled. The ZIP reader handles stored and deflated files and ZIP-based self-extracting archives. It never executes DOS programs.
+
+Game discovery and player-file recovery follow RSD Game-Maker 3.0 by Recreational Software Designs: G. Andrew Stone, G. Oliver Stone, Oliver Stone Jr. and Joan Stone. Andy Stone released its source under the MIT License in 2014. No original DOS executable or game content is included.
+
+Player identification uses this project's MD5 implementation, written from RFC 1321 (R. Rivest, MIT Laboratory for Computer Science and RSA Data Security, Inc., 1992). It does not include the RFC's reference implementation. The implementation is covered by the project's MIT License.
+
+The underlying ZIP and import code was written with Anthropic Claude Opus 5.5 under Lewis Moten's direction. OpenAI Codex (GPT-6/6.1) consolidated the portable package, API, tests, documentation, and consumer integration under his direction.

package/README.md

@@ -1,3 +1,101 @@
-# Temporary Holding Version
+# @lewismoten/gamemaker-sandbox-archives
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+Discover and unpack Game-Maker games in browsers or Node.js 22.12+. This runtime package works alongside the engine; it does not depend on the development tools.
+
+```sh
+npm install @lewismoten/gamemaker-sandbox-archives
+```
+
+Install through your configured npm registry; configure authentication according to that registry's instructions.
+
+```ts
+import { unpackGame } from '@lewismoten/gamemaker-sandbox-archives';
+import { GameFiles } from '@lewismoten/gamemaker-sandbox-engine';
+
+const response = await fetch('/stripe-chase.zip');
+if (!response.ok) throw new Error('Could not download the game');
+const game = await unpackGame(await response.arrayBuffer());
+const files = new GameFiles(game.entries);
+// Supply files and game.gam to Machine/runGame from the engine package.
+```
+
+Supported inputs:
+
+- File/directory selections (`File[]` preserves `webkitRelativePath`), or portable `ScanFile[]` records with `path`, `size`, and async `read`.
+- ZIPs, ZIPs inside ZIPs, and ZIP-based self-extracting DOS EXEs, including EXEs inside ZIPs. Both ZIP-relative and file-relative SFX offsets are supported.
+- Raw or gzip-compressed GMPK game packs (`.gmpak`).
+
+Executables are inspected as data and never run. Ordinary executables are not archive formats. A supplied Game-Maker player EXE is identified by build (1.0, 1.04, 2.00, 2.02, 2.04 or 3.00: size and MD5, then its About text's version line, with a confidence and reasons). A customized one can restore renamed game-file extensions; its settings (read at each build's own offsets) are returned in `player`, and its other changed bytes in `player.origin.regions` (128-byte blocks, a buyer's owner field never kept), which `applyPlayerPatches` writes back into a 3.00 player. Archives with several games use `unpackGames`; `unpackGame` requires exactly one. Low-level discovery (`scanImport`, `GameReader`, `scanFile`) exposes selection, progress, leftovers, and malformed archive reports using the same importer as the main application.
+
+`UnpackedGame.entries` is a portable tuple array, avoiding a dependency on the engine's class identity. ZIPs are searched up to the importer's existing three archive levels. `maxEntries` (8192) and `maxBytes` (128 MiB) bound each archive and the returned game; `signal` supports cancellation between reads. ZIP64, encrypted ZIPs, and compression methods other than stored/deflate are not supported. HTML game exports are not archive inputs.
+
+## Scan and choose games before reading their files
+
+The full import scanner is included, both at the package root and through `/scan`. It
+finds games in folder selections and nested ZIP/SFX archives, reports damaged or empty
+archives, identifies incomplete leftovers, and recognizes customized DOS player files.
+Scanning reads game headers and archive directories; `GameReader` then reads the chosen
+game's files. This lets an application offer a choice when an archive contains several games.
+
+```ts
+import { scanFile, scanImport, scanSummary, GameReader, type FoundGame }
+  from '@lewismoten/gamemaker-sandbox-archives/scan';
+import { GameFiles } from '@lewismoten/gamemaker-sandbox-engine';
+
+const given = Array.from(input.files ?? [], (file) => scanFile(file));
+const report = await scanImport(given, {
+  signal: controller.signal,
+  zipLimits: { maxEntries: 8192, maxBytes: 128 << 20 },
+  onProgress: (done, total, path) => showProgress(done, total, path),
+});
+showGames(report.games); // Let the user choose a FoundGame.
+showSummary(scanSummary(report));
+
+const reader = new GameReader(given, { maxEntries: 8192, maxBytes: 128 << 20 });
+async function openChosenGame(choice: FoundGame) {
+  const game = await reader.read(choice);
+  return new GameFiles(game.files.entries());
+}
+```
+
+`report.games` holds the choices; `badZips`, `emptyZips`, and `loose` explain the rest.
+`GameReader.file` reads just one chosen resource and `mainGam` identifies a game's entry
+point. `scanFile` adapts browser files, while `ScanFile` records work with any asynchronous
+file source. `/scan` also exports `groupGames`, `playedBy`, `PLAYER_EXE`, `gameFromFiles`,
+and their report types. The higher-level `unpackGame` and `unpackGames` APIs use this same
+scanner and also perform customized-player recovery.
+
+## ZIP reading and writing
+
+```ts
+import { createZip, readZip, listZip } from '@lewismoten/gamemaker-sandbox-archives/zip';
+
+const gameBytes = new Uint8Array([71, 77]); // stand-in for a real .GAM file's bytes
+const bytes = await createZip(
+  [
+    { name: 'GAME/DEMO.GAM', data: gameBytes },
+    { name: 'GAME/README.TXT', data: new TextEncoder().encode('How to play') },
+  ],
+  new Date(2000, 0, 1, 12), // a fixed date and stable entry order make repeatable distribution builds
+);
+const entries = await readZip(bytes);
+const listing = listZip(bytes); // lazy entry.read()
+console.log(entries.map((e) => `${e.name} ${e.data.length}`).join(', '), listing.length);
+// prints: GAME/DEMO.GAM 2, GAME/README.TXT 11 2
+```
+
+A test (`web/test/readmeExamples.test.ts`) runs this block and the engine's in Node against the built package and compares what they print with the `// prints:` line.
+
+ZIP creation uses deflate when available and smaller; otherwise it stores entries. It shares the reader's CRC code and adds no dependency. Consumers that only import unpacking can tree-shake the writer. Entry data is returned in memory; this package writes nothing to the filesystem. For the existing streaming game-pack format, `/pack` exports `encodePack`, `decodePack`, and `PackReader`.
+
+## Subpath exports
+
+`zip` (above), `pack` and `scan` are the main entry points. `project/zip`, `project/gamePack` and `project/importScan` are the same modules under their source names. The other subpaths are `project/importPlayer`, `project/importLeftovers`, `project/extensionNames`, `player/applyPatches` and `player/md5`.
+
+## License and notices
+
+The source is MIT licensed. The published package carries `LICENSE` and `NOTICE.md` (credits for third-party code and formats); it includes no game assets.
+
+## Developing
+
+This package's source lives in [the project's repository](https://github.com/lewismoten/GameMaker-SandboxEdition), in `web/packages/archives`. The folder holds its source in `src/`, build configuration, license and notices. It depends on the engine through its declared npm dependency. Run `npm install`, then `npm run verify` in the package folder. Inside the repository, run `npm ci` at the root and `npm run verify:packages`, which builds isolated source copies and supplies packed workspace dependencies, so unpublished sibling versions can be verified. Use `npm pack` to inspect the distribution. The build is independent of the site's Vite configuration. The distribution includes JavaScript, TypeScript declarations, LICENSE, and NOTICE.md; no game assets. Keep npm tarballs outside source control. The [monorepo guide](https://github.com/lewismoten/GameMaker-SandboxEdition/blob/master/docs/monorepo.md) covers the workspace layout, and the [package release guide](https://github.com/lewismoten/GameMaker-SandboxEdition/blob/master/docs/package-releases.md) covers publishing.

package/dist/applyPatches-yRE1fvi0.js

@@ -0,0 +1,86 @@
+import { md5Hex as h } from "./player/md5.js";
+import { patchEntry as d, patchProblem as u, writePatch as w, readPatch as y, isStock as l, writeStock as E } from "@lewismoten/gamemaker-sandbox-engine/player/patchRules";
+import { extKind as m, extValueProblem as S, extensionClashes as P, writeExtensions as x, readExtensions as C, writeStockExtensions as k } from "@lewismoten/gamemaker-sandbox-engine/player/fileExtensions";
+import { PATCHES as v } from "@lewismoten/gamemaker-sandbox-engine/player/patchTable";
+function A(e) {
+  const n = m(e);
+  if (n) return n.offsets.flatMap((t) => [t + 1, t + 2, t + 3]);
+  const r = d(e);
+  if (!r) return [];
+  const o = (t, f) => Array.from({ length: f }, (s, i) => t + i);
+  switch (r.kind) {
+    case "text":
+    case "format":
+      return o(r.offset, r.length);
+    case "number":
+    case "frame":
+      return r.fields.flatMap((t) => o(t.offset, t.size));
+    case "rgb":
+      return [...r.offsets];
+    case "select":
+    case "fkey":
+      return o(r.offset, 2);
+  }
+}
+const M = (e) => btoa(String.fromCharCode(...e)), p = (e) => Uint8Array.from(atob(e.data), (n) => n.charCodeAt(0));
+function O(e, n, r) {
+  const o = /* @__PURE__ */ new Set();
+  for (const t of /* @__PURE__ */ new Set([...Object.keys(r), ...Object.keys(n.patches)]))
+    if (JSON.stringify(r[t]) !== JSON.stringify(n.patches[t])) for (const f of A(t)) o.add(f);
+  for (const t of n.regions) {
+    const f = p(t);
+    if (t.offset < 0 || t.offset + f.length > e.length) throw new Error("A preserved part of the player lies outside it.");
+    f.forEach((s, i) => {
+      o.has(t.offset + i) || (e[t.offset + i] = s);
+    });
+  }
+}
+function K(e) {
+  const n = [], r = p(e);
+  let o = "", t = 0;
+  for (let f = 0; f <= r.length; f++) {
+    const s = r[f];
+    f < r.length && s >= 32 && s < 127 ? (o || (t = f), o += String.fromCharCode(s)) : (o.trim().length >= 4 && n.push([e.offset + t, o]), o = "");
+  }
+  return n;
+}
+const b = "fcaf47d50ececa0b59cd22b3fae3cda3", g = 160598;
+function L(e, n, r) {
+  if (e.length !== g || h(e) !== b)
+    throw new Error("This is not the Game-Maker 3.00 CD’s XFERPLAY.EXE, so it can’t be customized safely.");
+  const o = e.slice();
+  for (const [t, f] of Object.entries(n)) {
+    const s = m(t);
+    if (s) {
+      const c = S(s.ext, f) ?? P(n).get(s.ext);
+      if (c) throw new Error(`${s.label} (.${s.ext}): ${c}`);
+      continue;
+    }
+    const i = d(t);
+    if (!i) throw new Error(`Unknown player patch ${t}`);
+    const a = u(i, f);
+    if (a) throw new Error(`${i.label} (${t}): ${a}`);
+    w(o, i, f);
+  }
+  return x(o, n), r && O(o, r, n), o;
+}
+function R(e) {
+  if (e.length !== g) return;
+  const n = {}, r = [], o = e.slice();
+  for (const s of v) {
+    const i = y(e, s);
+    i === void 0 || u(s, i) ? i !== void 0 && l(s, i) || r.push(s.id) : l(s, i) || (n[s.id] = i), E(o, s);
+  }
+  const t = C(e);
+  Object.assign(n, t.patches), k(o, t.read);
+  const f = h(o) === b;
+  return { patches: n, explained: f && !r.length, unreadable: r };
+}
+export {
+  b as S,
+  K as a,
+  L as b,
+  A as p,
+  R as r,
+  M as t
+};

package/dist/index.js

@@ -0,0 +1,74 @@
+import { scanFile as u, scanImport as y, GameReader as A } from "./scan.js";
+import { PLAYER_EXE as U, gameFromFiles as B, groupGames as N, playedBy as R, scanSummary as S } from "./scan.js";
+import { adoptPlayer as b } from "./project/importPlayer.js";
+import { decodePack as E } from "./pack.js";
+import { crc32 as F, createZip as L, isZip as M, listZip as j, readZip as C } from "./zip.js";
+async function G(a, c) {
+  const r = new Blob([a]).stream().pipeThrough(new DecompressionStream("gzip")).getReader(), i = [];
+  let t = 0;
+  for (; ; ) {
+    const { done: o, value: f } = await r.read();
+    if (o) break;
+    if (t += f.length, t > c)
+      throw await r.cancel(), new Error("Game archive exceeds the byte limit");
+    i.push(f);
+  }
+  const n = new Uint8Array(t);
+  let h = 0;
+  for (const o of i)
+    n.set(o, h), h += o.length;
+  return n;
+}
+async function v(a, c = {}) {
+  const { signal: r, maxEntries: i = 8192, maxBytes: t = 128 << 20 } = c;
+  if (!Number.isSafeInteger(i) || i < 1 || !Number.isSafeInteger(t) || t < 1)
+    throw new RangeError("Archive limits must be positive integers");
+  r?.throwIfAborted();
+  let n;
+  if (a instanceof Uint8Array || a instanceof ArrayBuffer) {
+    let e = a instanceof Uint8Array ? a : new Uint8Array(a);
+    if (e.length > t) throw new Error("Game archive exceeds the byte limit");
+    if (e[0] === 31 && e[1] === 139 && (e = await G(e, t)), e[0] === 71 && e[1] === 77 && e[2] === 80 && e[3] === 75)
+      n = E(e).map(([s, m]) => ({ path: s, size: m.length, read: () => Promise.resolve(m) }));
+    else {
+      const s = e, m = e[0] === 77 && e[1] === 90 ? ".exe" : ".zip", l = c.name ?? "game";
+      n = [{ path: l.toLowerCase().endsWith(m) ? l : l + m, size: e.length, read: () => Promise.resolve(s) }];
+    }
+  } else n = Array.from(a, (e) => "path" in e ? e : u(e));
+  if (n.length > i || n.some((e) => e.size > t)) throw new Error("Game input exceeds archive limits");
+  const h = { maxEntries: i, maxBytes: t }, o = await y(n, { signal: r, zipLimits: h });
+  if (!o.games.length && o.badZips.length) throw new Error(o.badZips.map((e) => `${e.path}: ${e.error}`).join("; "));
+  const f = new A(n, h), g = [];
+  for (const e of o.games) {
+    r?.throwIfAborted();
+    const s = await f.read(e), m = b(s.files, s.players), l = s.files.mainGame(e.gam);
+    if (!l) throw new Error(`No .GAM file in ${e.name}`);
+    const p = s.files.entries();
+    if (p.length > i || p.reduce((w, [, d]) => w + d.length, 0) > t) throw new Error("Unpacked game exceeds archive limits");
+    g.push({ name: e.name, gam: l, entries: p, ...m ? { player: m } : {} });
+  }
+  return g;
+}
+async function Z(a, c) {
+  const r = await v(a, c);
+  if (r.length !== 1)
+    throw new Error(r.length ? `Archive contains ${r.length} games; choose one with unpackGames` : "No Game-Maker .GAM file was found");
+  return r[0];
+}
+export {
+  A as GameReader,
+  U as PLAYER_EXE,
+  F as crc32,
+  L as createZip,
+  B as gameFromFiles,
+  N as groupGames,
+  M as isZip,
+  j as listZip,
+  R as playedBy,
+  C as readZip,
+  u as scanFile,
+  y as scanImport,
+  S as scanSummary,
+  Z as unpackGame,
+  v as unpackGames
+};

package/dist/pack.js

@@ -0,0 +1,70 @@
+const c = [71, 77, 80, 75], l = 1;
+function g(h) {
+  const s = [new Uint8Array([...c, l])];
+  for (const [t, o] of h) {
+    const n = new TextEncoder().encode(t);
+    if (!n.length || n.length > 255) throw new Error(`gamePack: bad file name ${JSON.stringify(t)}`);
+    const a = new Uint8Array(1 + n.length + 4);
+    a[0] = n.length, a.set(n, 1), new DataView(a.buffer).setUint32(1 + n.length, o.length, !0), s.push(a, o);
+  }
+  s.push(new Uint8Array([0]));
+  const r = new Uint8Array(s.reduce((t, o) => t + o.length, 0));
+  let e = 0;
+  for (const t of s)
+    r.set(t, e), e += t.length;
+  return r;
+}
+class u {
+  chunks = [];
+  total = 0;
+  /** Bytes the next step needs (it waits until that many are in, so a big file is joined once). */
+  want = 5;
+  started = !1;
+  done = !1;
+  push(s) {
+    const r = [];
+    if (this.done || !s.length || (this.chunks.push(s), this.total += s.length, this.total < this.want)) return r;
+    const e = this.chunks.length === 1 ? this.chunks[0] : f(this.chunks, this.total);
+    let t = 0;
+    if (!this.started) {
+      if (c.some((n, a) => e[a] !== n) || e[4] !== l) throw new Error("gamePack: not a game pack");
+      this.started = !0, t = 5;
+    }
+    for (this.want = 1; t < e.length; ) {
+      const n = e[t];
+      if (n === 0) {
+        this.done = !0, t++;
+        break;
+      }
+      if (t + 1 + n + 4 > e.length) {
+        this.want = 1 + n + 4;
+        break;
+      }
+      const a = new DataView(e.buffer, e.byteOffset + t + 1 + n, 4).getUint32(0, !0), i = t + 1 + n + 4;
+      if (i + a > e.length) {
+        this.want = 1 + n + 4 + a;
+        break;
+      }
+      r.push([String.fromCharCode(...e.subarray(t + 1, t + 1 + n)), e.slice(i, i + a)]), t = i + a;
+    }
+    const o = e.subarray(t);
+    return this.chunks = o.length ? [o] : [], this.total = o.length, r;
+  }
+}
+function f(h, s) {
+  const r = new Uint8Array(s);
+  let e = 0;
+  for (const t of h)
+    r.set(t, e), e += t.length;
+  return r;
+}
+function w(h) {
+  const s = new u(), r = s.push(h);
+  if (!s.done) throw new Error("gamePack: the pack is cut short");
+  return r;
+}
+export {
+  u as PackReader,
+  w as decodePack,
+  g as encodePack
+};

package/dist/player/applyPatches.js

@@ -0,0 +1,10 @@
+import "./md5.js";
+import { S as m, b as s, r as P } from "../applyPatches-yRE1fvi0.js";
+import "@lewismoten/gamemaker-sandbox-engine/player/patchTable";
+import "@lewismoten/gamemaker-sandbox-engine/player/patchRules";
+import "@lewismoten/gamemaker-sandbox-engine/player/fileExtensions";
+export {
+  m as STOCK_PLAYER_MD5,
+  s as applyPlayerPatches,
+  P as readPlayerPatches
+};

package/dist/player/md5.js

@@ -0,0 +1,25 @@
+const d = [7, 12, 17, 22, 5, 9, 14, 20, 4, 11, 16, 23, 6, 10, 15, 21], M = Array.from({ length: 64 }, (f, c) => Math.floor(Math.abs(Math.sin(c + 1)) * 2 ** 32) >>> 0);
+function p(f) {
+  const c = f.length * 8, l = new Uint8Array(((f.length + 8 >> 6) + 1) * 64);
+  l.set(f), l[f.length] = 128;
+  const U = new DataView(l.buffer);
+  U.setUint32(l.length - 8, c >>> 0, !0), U.setUint32(l.length - 4, Math.floor(c / 2 ** 32), !0);
+  let h = 1732584193, u = 4023233417, g = 2562383102, w = 271733878;
+  const b = new Uint32Array(16);
+  for (let r = 0; r < l.length; r += 64) {
+    for (let t = 0; t < 16; t++) b[t] = U.getUint32(r + t * 4, !0);
+    let [i, e, o, n] = [h, u, g, w];
+    for (let t = 0; t < 64; t++) {
+      let s, a;
+      t < 16 ? [s, a] = [e & o | ~e & n, t] : t < 32 ? [s, a] = [n & e | ~n & o, (5 * t + 1) % 16] : t < 48 ? [s, a] = [e ^ o ^ n, (3 * t + 5) % 16] : [s, a] = [o ^ (e | ~n), 7 * t % 16];
+      const A = i + s + M[t] + b[a] >>> 0, m = d[(t >> 4) * 4 + t % 4];
+      [i, n, o] = [n, o, e], e = e + (A << m | A >>> 32 - m) >>> 0;
+    }
+    h = h + i >>> 0, u = u + e >>> 0, g = g + o >>> 0, w = w + n >>> 0;
+  }
+  const y = new DataView(new ArrayBuffer(16));
+  return [h, u, g, w].forEach((r, i) => y.setUint32(i * 4, r, !0)), Array.from(new Uint8Array(y.buffer), (r) => r.toString(16).padStart(2, "0")).join("");
+}
+export {
+  p as md5Hex
+};

package/dist/project/extensionNames.js

@@ -0,0 +1,20 @@
+const g = (o) => o.replace(/[\\^$.*+?()[\]{}|-]/g, "\\$&");
+function l(o, n) {
+  const t = /\.([^.]*)$/.exec(o), r = t ? n.get(t[1].toLowerCase()) : void 0;
+  if (!t || r === void 0) return o;
+  const c = /[A-Z]/.test(t[1]) && t[1] === t[1].toUpperCase();
+  return o.slice(0, t.index + 1) + (c ? r.toUpperCase() : r);
+}
+function f(o, n) {
+  const t = o.slice(), r = Array.from(t, (e) => String.fromCharCode(e)).join("").toLowerCase(), c = [...n.keys()].filter((e) => e && e.length === n.get(e).length);
+  if (!c.length) return t;
+  for (const e of r.matchAll(new RegExp(`[a-z0-9_~!@#$%^&()-]\\.(${c.map(g).join("|")})(?![a-z0-9])`, "g"))) {
+    const i = e.index + 2, p = n.get(e[1]), a = t[i] >= 65 && t[i] <= 90;
+    for (let s = 0; s < p.length; s++) t[i + s] = (a ? p[s].toUpperCase() : p[s]).charCodeAt(0);
+  }
+  return t;
+}
+export {
+  f as rewriteNames,
+  l as swapExtension
+};

package/dist/project/importLeftovers.js

@@ -0,0 +1,16 @@
+const s = (t) => t.zips.length ? [t.zips[0].path, ...t.inner].join(`
+`) : void 0;
+function r(t) {
+  const i = t.gam ?? t.paths.filter((e) => /\.gam$/i.test(e)).sort()[0];
+  return (i ? i.slice(i.replace(/\\/g, "/").lastIndexOf("/") + 1) : t.name).toUpperCase();
+}
+function o(t) {
+  const i = new Set(t.filter((e) => !e.missing && !e.leftover).map(s));
+  return t.map((e) => {
+    const n = s(e);
+    return !n || !e.missing || e.leftover || !i.has(n) ? e : { ...e, leftover: `${r(e)}: ${e.missing} of its files ${e.missing === 1 ? "isn’t" : "aren’t"} in the zip` };
+  });
+}
+export {
+  o as markZipLeftovers
+};