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

package/dist/types/mesh/trinketKinds.d.ts

@@ -0,0 +1,72 @@
+import { type D2, type D3 } from './sdfShapes.js';
+export interface FlatKind {
+    /** A 2D outline of the flat part (a circle, a rounded rectangle). */
+    outline: D2;
+    /** Thickness of the plate in mm. */
+    thick: number;
+    /** Width of the raised rim in mm (0 for none), and how far it stands above the face. */
+    rim?: {
+        width: number;
+        height: number;
+    };
+    /** Raised artwork (lettering, a crown) and how far it stands above the face. */
+    relief?: {
+        shape: D2;
+        height: number;
+    };
+    /** Sunk artwork and how deep it goes. */
+    engrave?: {
+        shape: D2;
+        depth: number;
+    };
+    /** Holes through the plate (a key-chain hole). */
+    holes?: D2[];
+    /** A recess in the back (the floor) for gluing in a pin back or a magnet, as a solid to cut away (see pinBack). */
+    pocket?: D3;
+}
+/** A plate with its rim, relief, engraving and holes: the face is at z = thick. */
+export declare function plate(k: FlatKind): D3;
+/** The outline for a key-chain tag: a rounded rectangle of half sizes hx, hy. */
+export declare const tagOutline: (hx: number, hy: number, r: number) => D2;
+export declare const holeAt: (x: number, y: number, r: number) => D2;
+/**
+ * A die: a rounded cube of `size` mm with a dimple of radius `pipR` for each pip (the usual 1..6 on opposite faces summing to 7).
+ * The dimples are deep (about three quarters of a radius), so the pips read in plain light; `pips` is the union of them, to color
+ * the pips apart (a point on a dimple's surface has `pips` near zero).
+ */
+export declare function die(size: number, pipR: number, corner?: number): D3 & {
+    pips: D3;
+};
+/** A regular polygon outline (a hexagonal badge, a shield point up), `n` sides, radius `r`. */
+export declare const regular2: (n: number, r: number, turn?: number) => D2;
+/**
+ * The pocket for a pin back: a bar-shaped recess `len` mm long and `w` mm wide at the floor, centered on (cx, cy), to glue a
+ * bar pin into (give it as `pocket`). Its roof is a gable at 45 degrees, so it prints without supports.
+ */
+export declare const pinBack: (cx?: number, cy?: number, len?: number, w?: number) => D3;
+/** A key-chain ring tab: a round lug of outer radius `r + wall` with a hole of radius `r`, at (x, y). Join `shape` to the outline with union2 and give `hole` to `holes`. */
+export declare const ringTab: (x: number, y: number, r?: number, wall?: number) => {
+    shape: D2;
+    hole: D2;
+};
+export interface GemShape {
+    /** Sides of the table and girdle (6 or 8). */
+    sides: number;
+    /** Apothems in mm: the flat table the gem stands on, and the widest part (the girdle). */
+    table: number;
+    girdle: number;
+    /** Height of the crown (table to girdle) and of the pavilion (girdle to the point), in mm. */
+    crown: number;
+    pavilion: number;
+    /** Turn the pavilion's facets by half a side, as a brilliant cut does (default true). */
+    offset?: boolean;
+}
+/**
+ * A faceted gem standing on its table (flat down), the crown flaring out as it rises and the pavilion narrowing to the point:
+ * the crown leans out at under 45 degrees from vertical, so it prints without supports. Also the shape of a crystal shard.
+ * `facet(x, y, z)` is the number of the facet a surface point belongs to, for coloring.
+ */
+export declare function gem(g: GemShape): {
+    field: D3;
+    facet: (x: number, y: number, z: number) => number;
+};

package/dist/types/mesh/trinketTool.d.ts

@@ -0,0 +1,26 @@
+import type { FieldTrinket } from './fieldTrinket.js';
+export interface TrinketToolDef {
+    id: string;
+    title: string;
+    blurb: string;
+    /** Printed height and width in mm, only to start the biggest first. */
+    height: number;
+    maxWidth: number;
+    /** How many separate solids it is (default 1), such as a coin printed in three pieces. */
+    pieces?: number;
+}
+export interface TrinketTool<D extends TrinketToolDef> {
+    /** The folder id in web/public/trinkets and the manifest's `game`. */
+    game: string;
+    /** The game's title, in the STL and 3MF names. */
+    gameTitle: string;
+    out: string;
+    /** The files, and folders (each file in them, sorted), the trinkets are made from: the key of the manifest. */
+    keyFiles: string[];
+    defs: D[];
+    make: (def: D) => FieldTrinket;
+    args: string[];
+}
+/** A hash of the sources, so an up-to-date set of trinkets is not made again. */
+export declare function sourceKey(entries: string[]): string;
+export declare function runTrinketTool<D extends TrinketToolDef>(tool: TrinketTool<D>): Promise<void>;

package/dist/types/mesh/voxel.d.ts

@@ -0,0 +1,10 @@
+import type { Mesh } from './mesh.js';
+export interface VoxelGrid {
+    nx: number;
+    ny: number;
+    nz: number;
+    /** True where a voxel is filled. Outside the grid is empty. */
+    has: (x: number, y: number, z: number) => boolean;
+}
+/** The surface of the filled voxels as a mesh. A voxel touching another only along an edge makes a non-manifold edge: avoid that in the grid. */
+export declare function voxelMesh(g: VoxelGrid, size?: number): Mesh;

package/dist/types/mesh/zipFile.d.ts

@@ -0,0 +1,13 @@
+export interface ZipEntry {
+    name: string;
+    data: Uint8Array;
+}
+export interface ZipCodec {
+    /** Raw deflate (no zlib header). */
+    deflate?: (data: Uint8Array) => Uint8Array;
+    /** Raw inflate, needed to read deflated entries. */
+    inflate?: (data: Uint8Array) => Uint8Array;
+}
+export declare function crc32(data: Uint8Array): number;
+export declare function writeZip(entries: ZipEntry[], codec?: ZipCodec): Uint8Array;
+export declare function readZip(data: Uint8Array, codec?: ZipCodec): ZipEntry[];

package/dist/types/microFont.d.ts

@@ -0,0 +1,6 @@
+export type MicroGlyphs = Readonly<Record<string, string>>;
+export declare const MICRO_GLYPHS: MicroGlyphs;
+/** Square letterforms for technical labels, with the full punctuation repertoire. */
+export declare const MICRO_SQUARE_GLYPHS: MicroGlyphs;
+/** Select an exact repertoire when preserving an existing font's fallback behavior. */
+export declare function microGlyphs(characters: string, square?: boolean): MicroGlyphs;

package/dist/types/music/compose.d.ts

@@ -0,0 +1,51 @@
+/** An SBI instrument from its operator settings (modulator, carrier). */
+export declare function sbi(o: {
+    modChar: number;
+    carChar: number;
+    modLevel: number;
+    carLevel: number;
+    modAD: number;
+    carAD: number;
+    modSR: number;
+    carSR: number;
+    modWave?: number;
+    carWave?: number;
+    feedback: number;
+}): Uint8Array;
+/**
+ * A few classic FM patches, written for this project. (The piano and the brass were once
+ * AdLib's STANDARD.BNK PIANO1 and BRASS1 register values; they are now our own.)
+ */
+export declare const INSTRUMENTS: {
+    piano: Uint8Array<ArrayBufferLike>;
+    bass: Uint8Array<ArrayBufferLike>;
+    strings: Uint8Array<ArrayBufferLike>;
+    brass: Uint8Array<ArrayBufferLike>;
+    lead: Uint8Array<ArrayBufferLike>;
+    bell: Uint8Array<ArrayBufferLike>;
+    organ: Uint8Array<ArrayBufferLike>;
+    pad: Uint8Array<ArrayBufferLike>;
+    pluck: Uint8Array<ArrayBufferLike>;
+};
+/** "C#4" → MIDI 61; "r" → rest. */
+export declare function midi(name: string): number | null;
+export interface Voice {
+    /** MIDI channel 0..8 (each gets its own instrument). */
+    channel: number;
+    instrument: Uint8Array;
+    /** "C4 q, E4 e., r e, [C4 E4 G4] h" — brackets play a chord, its notes on this channel and the next ones (leave them free). */
+    notes: string;
+    velocity?: number;
+    /** Shift every note by semitones. */
+    transpose?: number;
+}
+/**
+ * Writes the song. `bpm` sets the speed; Game-Maker plays 146 ticks a second. Songs loop
+ * when they end, as PLAYGAME restarts them.
+ */
+export declare function song(bpm: number, voices: Voice[]): Uint8Array;
+/**
+ * A new, empty song: piano on every channel and one silent bar at `bpm` (a song with nothing
+ * in it at all would end the moment it starts, and PLAYGAME restarts a song when it ends).
+ */
+export declare function blankSong(bpm?: number): Uint8Array;

package/dist/types/pack/meshPack.d.ts

@@ -0,0 +1,26 @@
+/** Bytes of `size`-byte values split into planes: every value's first byte, then every second byte... */
+export declare function toPlanes(data: Uint8Array, size: number): Uint8Array;
+/** `toPlanes` undone. */
+export declare function fromPlanes(data: Uint8Array, size: number): Uint8Array;
+/** Vertex numbers as varints: each one's distance back from one past the highest so far, zigzagged; `starts` restart the count (a block per part). */
+export declare function packIndices(ix: ArrayLike<number>, starts?: Set<number>): Uint8Array;
+/** `count` vertex numbers from `packIndices`'s bytes. */
+export declare function unpackIndices(data: Uint8Array, count: number, starts?: Set<number>): Uint32Array;
+/** A binary STL packed: its header, a table of its distinct corners, each triangle's corner numbers and attribute, and any normal that is not the one worked out again. */
+export declare function packStl(stl: Uint8Array): Uint8Array;
+/** The binary STL `packStl` packed, byte for byte. */
+export declare function unpackStl(pack: Uint8Array): Uint8Array;
+/** Several named files in one pack (a ZIP's worth, to zip in the browser): each binary STL packed by `packStl`, the rest as they are. */
+export declare function packFiles(files: {
+    name: string;
+    data: Uint8Array;
+}[]): Uint8Array;
+/** The files `packFiles` packed, each byte for byte. */
+export declare function unpackFiles(pack: Uint8Array): {
+    name: string;
+    data: Uint8Array;
+}[];
+/** A file of float32s then uint32 vertex numbers (little-endian, as the phone kit's parts.bin), packed: the floats in byte planes, the numbers as varints counted afresh at each of `starts` (a part's first number). */
+export declare function packFloatsAndIndices(bin: Uint8Array, floats: number, starts: number[]): Uint8Array;
+/** The file `packFloatsAndIndices` packed, byte for byte. */
+export declare function unpackFloatsAndIndices(pack: Uint8Array): Uint8Array;

package/dist/types/pack/threeMfPack.d.ts

@@ -0,0 +1,11 @@
+import { type Part } from '../mesh/threeMf.js';
+import { type ZipCodec, type ZipEntry } from '../mesh/zipFile.js';
+/** The files inside the 3MF write3mf writes for these parts, before any deflate (write3mf stores them when given no codec). */
+export declare function threeMfEntries(parts: Part[], title: string): ZipEntry[];
+/** A 3MF from write3mf, packed (deflate the result); throws when its inner files would not come back the same. */
+export declare function pack3mf(file: Uint8Array, codec: Pick<ZipCodec, 'inflate'>): Uint8Array;
+/** A packed 3MF's title and parts, ready for write3mf or threeMfEntries. */
+export declare function unpack3mf(pack: Uint8Array): {
+    title: string;
+    parts: Part[];
+};

package/dist/types/palettePresetData.d.ts

@@ -0,0 +1,4 @@
+export declare const ATARI_NTSC_RGB = "\n000000 404040 6c6c6c 909090 b0b0b0 c8c8c8 dcdcdc ececec\n444400 646410 848424 a0a034 b8b840 d0d050 e8e85c fcfc68\n702800 844414 985c28 ac783c bc8c4c cca05c dcb468 e8cc7c\n841800 983418 ac5030 c06848 d0805c e09470 eca880 fcbc94\n880000 9c2020 b03c3c c05858 d07070 e08888 eca0a0 fcb4b4\n78005c 8c2074 a03c88 b0589c c070b0 d084c0 dc9cd0 ecb0e0\n480078 602090 783ca4 8c58b8 a070cc b484dc c49cec d4b0fc\n140084 302098 4c3cac 6858c0 7c70d0 9488e0 a8a0ec bcb4fc\n000088 1c209c 3840b0 505cc0 6874d0 7c8ce0 90a4ec a4b8fc\n00187c 1c3890 3854a8 5070bc 6888cc 7c9cdc 90b4ec a4c8fc\n002c5c 1c4c78 386890 5084ac 689cc0 7cb4d4 90cce8 a4e0fc\n00402c 1c5c48 387c64 509c80 68b494 7cd0ac 90e4c0 a4fcd4\n003c00 205c20 407c40 5c9c5c 74b474 8cd08c a4e4a4 b8fcb8\n143800 345c1c 507c38 6c9850 84b468 9ccc7c b4e490 c8fca4\n2c3000 4c501c 687034 848c4c 9ca864 b4c078 ccd488 e0ec9c\n442800 644818 846830 a08444 b89c58 d0b46c e8cc7c fce08c\n";
+export declare const ATARI_PAL_RGB = "\n000000 404040 6c6c6c 909090 b0b0b0 c8c8c8 dcdcdc ececec\n805800 947020 a8843c bc9c58 ccac70 dcc084 ecd09c fce0b0\n445c00 5c7820 74903c 8cac58 a0c070 b0d484 c0e89c d4fcb0\n703400 885020 a0683c b48458 c89870 dcac84 ecc09c fcd4b0\n006414 208034 3c9850 58b06c 70c484 84d89c 9ce8b4 b0fcc8\n700014 882034 a03c50 b4586c c87084 dc849c ec9cb4 fcb0c8\n005c5c 207474 3c8c8c 58a4a4 70b8b8 84c8c8 9cdcdc b0ecec\n70005c 842074 943c88 a8589c b470b0 c484c0 d09cd0 e0b0e0\n003c70 1c5888 3874a0 508cb4 68a4c8 7cb8dc 90ccec a4e0fc\n580070 6c2088 803ca0 9458b4 a470c8 b484dc c49cec d4b0fc\n002070 1c3c88 3858a0 5074b4 6888c8 7ca0dc 90b4ec a4c8fc\n3c0080 542094 6c3ca8 8058bc 9470cc a884dc b89cec c8b0fc\n000088 20209c 3c3cb0 5858c0 7070d0 8484e0 9c9cec b0b0fc\n";
+export declare const NES_RGB = "\n575757 000c8e 0800a6 340096 550061 630015 5a0000 3c0e00\n112800 003b00 004200 003a05 002652 000000 a5a5a5 0041d9\n2f1eff 6704f2 9400b4 aa0057 a31800 803900 4b5b00 137600\n008100 007923 006288 ffffff 4a9fff 797eff af63ff dd55ff\nf757c2 f76a63 dc8810 aea900 78c400 4ad211 2fcf64 2fbdc4\n414141 b9ddff cad1ff dec6ff f0c0ff fcc0ee fdc6ca f5d0aa\ne4dd95 d0e892 bdeea2 b2eec0 b0e8e3 b3b3b3\n";
+export declare const C64_RGB = "\n000000 ffffff fa3200 1de0ff a84bcc 68ba51 004ad0 ffe94d\nff5b00 c13e00 ff723e 605e62 8c937f b2ff90 458aff c3b8d7\n";

package/dist/types/palettePresets.d.ts

@@ -0,0 +1,12 @@
+import type { Palette } from '@lewismoten/gamemaker-sandbox-engine/formats/palette';
+export interface PalettePreset {
+    readonly id: string;
+    readonly name: string;
+    readonly stem: string;
+    /** Occupied entries, including menu black; index 255 is always reserved. */
+    readonly entries: number;
+    readonly description: string;
+}
+export declare const PALETTE_PRESETS: readonly PalettePreset[];
+/** A fresh 768-byte VGA palette. Black is moved to index 0; unused entries and 255 are black. */
+export declare function createPalettePreset(id: string): Palette;

package/dist/types/paletteReserve.d.ts

@@ -0,0 +1,52 @@
+import type { Block } from '@lewismoten/gamemaker-sandbox-engine/formats/blocks';
+import { type ReduceScore } from './colorReduce.js';
+/** Color numbers 1-15 hold the engine's own interface colors (an inference from PLAYGAME's Box calls), so a proposed range starts at 16. */
+export declare const FIRST_FREE = 16;
+export declare const LAST_FREE = 254;
+/** A sprite range never grows past this many colors; blocks with more get reduced. */
+export declare const RANGE_CAP = 48;
+export interface RoleDemand {
+    role: 'monster' | 'character';
+    /** Different colors (by RGB) the role's shown blocks draw. */
+    distinct: number;
+    /** How many pixels of the role's blocks use each color number, as drawn in their first palette. */
+    usage: number[];
+}
+export interface Proposed {
+    first: number;
+    last: number;
+    role: 'monster' | 'character';
+    /** Pixels of other blocks that already use a color number in this range (the sync must move or reduce them first). */
+    conflicts: number;
+}
+/** Windows for each sprite role, biggest first. `others[i]` counts pixels of other (background) blocks using color i. */
+export declare function planRanges(demands: readonly RoleDemand[], others: readonly number[]): Proposed[];
+export interface SyncFile {
+    blocks: Block[];
+    /** The block numbers scenes show. */
+    shown: ReadonlySet<number>;
+    /** Keys of the palettes the file is shown with; the first is its reference. */
+    palettes: string[];
+}
+export interface SyncResult {
+    ok: true;
+    /** Per file, the blocks whose pixels were renumbered. */
+    pixels: Map<number, Map<number, Uint8Array>>;
+    /** Per palette key, the new 768 bytes (only palettes that changed). */
+    palettes: Map<string, Uint8Array>;
+    score: ReduceScore;
+    /** Blocks (file index, number) whose picture changes, worst first. */
+    changed: {
+        file: number;
+        n: number;
+        mean: number;
+    }[];
+    /** Colors the range holds, and colors that were more than it holds. */
+    used: number;
+    reduced: number;
+}
+/** Makes `first..last` the same in every palette: the role's colors move in, scored. `blocked` is per palette the color numbers other files draw with. */
+export declare function syncRange(files: readonly SyncFile[], palettes: ReadonlyMap<string, Uint8Array>, first: number, last: number, blocked: ReadonlyMap<string, ReadonlySet<number>>): SyncResult | {
+    ok: false;
+    why: string;
+};

package/dist/types/palettes.d.ts

@@ -0,0 +1,4 @@
+import type { Palette } from '@lewismoten/gamemaker-sandbox-engine/formats/palette';
+export { PALETTE_PRESETS, createPalettePreset, type PalettePreset } from './palettePresets.js';
+/** A fresh copy of the original Library palette (768 VGA bytes, black at index zero). */
+export declare function libraryDefaultPalette(): Palette;

package/dist/types/releaseNotes.d.ts

@@ -0,0 +1,3 @@
+import type { DiskDiff } from './diskDiff.js';
+/** Release-note text for a diff, or '' when nothing differs. Sentences: Changed, Added, Removed. */
+export declare function releaseNotes(d: DiskDiff): string;

package/dist/types/simulation.d.ts

@@ -0,0 +1,6 @@
+export { Sim, type SimScene } from './kit/sceneSim.js';
+export { GameSim, readDisk, diskSim, TICKS_PER_SECOND } from './kit/gameSim.js';
+export { newCharInfo, type CharInfo } from '@lewismoten/gamemaker-sandbox-engine/engine/world';
+export * from './kit/sceneInit.js';
+export * from './kit/routeChecks.js';
+export { type State as GameSimState } from './kit/gameSim.js';

package/dist/types/text.d.ts

@@ -0,0 +1,41 @@
+import { FONT_CP437 } from '@lewismoten/gamemaker-sandbox-engine/gfx/cp437Glyphs';
+import { toCp437, fromCp437 } from '@lewismoten/gamemaker-sandbox-engine/text/cp437';
+import { Pixels } from './kit/pixels.js';
+import { MICRO_GLYPHS, MICRO_SQUARE_GLYPHS } from './microFont.js';
+export { FONT_CP437, toCp437, fromCp437, MICRO_GLYPHS, MICRO_SQUARE_GLYPHS };
+export type TextFont = 'cp437' | 'micro' | 'micro-square';
+/** Encode Unicode DOS symbols, including box drawing. Unsupported characters throw. */
+export declare function encodeText(s: string): Uint8Array;
+/** A fresh copy of a glyph's rows; bit 0 is the leftmost pixel. */
+export declare function glyphRows(code: number, font?: TextFont): Uint8Array;
+export interface TextOptions {
+    font?: TextFont;
+    /** Palette index, 0..254; 255 is reserved for transparent pixels. */
+    color?: number;
+    scale?: number;
+    /** A one-output-pixel outline, including diagonal neighbors. */
+    outline?: number;
+    /** Shadow offset in output pixels, independent of glyph scale. */
+    shadow?: {
+        color: number;
+        dx?: number;
+        dy?: number;
+    };
+}
+export interface TextImage {
+    width: number;
+    height: number;
+    /** Row-major palette indexes; transparent pixels are 255. */
+    pixels: Uint8Array;
+    /** Where the unadorned first text cell begins within the image. */
+    originX: number;
+    originY: number;
+}
+/** Same-size shadowed sprite; pixels beyond the source canvas are clipped. */
+export declare function dropShadow(src: Pixels, ink: number, dx?: number, dy?: number): Pixels;
+/**
+ * Render Unicode text (LF/CRLF separated lines) or raw CP437 bytes (one row, including
+ * control-code glyphs). Returns native indexed pixels, with enough padding for effects.
+ * CP437 cells are 8×8; micro cells are 3×5 plus a 1px gap, with no trailing gap.
+ */
+export declare function renderText(text: string | Uint8Array, options?: TextOptions): TextImage;

package/package.json

@@ -1,6 +1,192 @@
 {
   "name": "@lewismoten/gamemaker-sandbox-tools",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "3.4.0",
+  "description": "Development tools for building and checking games in RSD Game-Maker formats",
+  "type": "module",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/lewismoten/GameMaker-SandboxEdition.git",
+    "directory": "web/packages/tools"
+  },
+  "engines": {
+    "node": ">=22.12.0"
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "CHANGELOG.md",
+    "LICENSE",
+    "NOTICE.md"
+  ],
+  "exports": {
+    "./drawing": {
+      "types": "./dist/types/drawing.d.ts",
+      "browser": null,
+      "gamemaker-source": "./src/drawing.ts",
+      "import": "./dist/drawing.js"
+    },
+    "./audio": {
+      "types": "./dist/types/audio.d.ts",
+      "gamemaker-source": "./src/audio.ts",
+      "import": "./dist/audio.js"
+    },
+    "./images": {
+      "types": "./dist/types/images.d.ts",
+      "gamemaker-source": "./src/images.ts",
+      "import": "./dist/images.js"
+    },
+    "./simulation": {
+      "types": "./dist/types/simulation.d.ts",
+      "browser": null,
+      "gamemaker-source": "./src/simulation.ts",
+      "import": "./dist/simulation.js"
+    },
+    "./formats/*": {
+      "types": "./dist/types/formats/*.d.ts",
+      "browser": null,
+      "gamemaker-source": "./src/formats/*.ts",
+      "import": "./dist/formats/*.js"
+    },
+    "./kit/tar": {
+      "types": "./dist/types/kit/tar.d.ts",
+      "gamemaker-source": "./src/kit/tar.ts",
+      "import": "./dist/kit/tar.js"
+    },
+    "./kit/fliShrink": {
+      "types": "./dist/types/kit/fliShrink.d.ts",
+      "gamemaker-source": "./src/kit/fliShrink.ts",
+      "import": "./dist/kit/fliShrink.js"
+    },
+    "./kit/blockRoles": {
+      "types": "./dist/types/kit/blockRoles.d.ts",
+      "gamemaker-source": "./src/kit/blockRoles.ts",
+      "import": "./dist/kit/blockRoles.js"
+    },
+    "./kit/levelGen": {
+      "types": "./dist/types/kit/levelGen/index.d.ts",
+      "gamemaker-source": "./src/kit/levelGen/index.ts",
+      "import": "./dist/kit/levelGen.js"
+    },
+    "./kit/*": {
+      "types": "./dist/types/kit/*.d.ts",
+      "browser": null,
+      "gamemaker-source": "./src/kit/*.ts",
+      "import": "./dist/kit/*.js"
+    },
+    "./music/*": {
+      "types": "./dist/types/music/*.d.ts",
+      "gamemaker-source": "./src/music/*.ts",
+      "import": "./dist/music/*.js"
+    },
+    "./embroidery/*": {
+      "types": "./dist/types/embroidery/*.d.ts",
+      "gamemaker-source": "./src/embroidery/*.ts",
+      "import": "./dist/embroidery/*.js"
+    },
+    "./mesh/*": {
+      "types": "./dist/types/mesh/*.d.ts",
+      "gamemaker-source": "./src/mesh/*.ts",
+      "import": "./dist/mesh/*.js"
+    },
+    "./pack/*": {
+      "types": "./dist/types/pack/*.d.ts",
+      "gamemaker-source": "./src/pack/*.ts",
+      "import": "./dist/pack/*.js"
+    },
+    "./image/*": {
+      "types": "./dist/types/image/*.d.ts",
+      "gamemaker-source": "./src/image/*.ts",
+      "import": "./dist/image/*.js"
+    },
+    "./audio-files": {
+      "types": "./dist/types/audioFiles.d.ts",
+      "browser": null,
+      "gamemaker-source": "./src/audioFiles.ts",
+      "import": "./dist/audio-files.js"
+    },
+    "./block-merge": {
+      "types": "./dist/types/blockMerge.d.ts",
+      "gamemaker-source": "./src/blockMerge.ts",
+      "import": "./dist/block-merge.js"
+    },
+    "./look-alike": {
+      "types": "./dist/types/lookAlike.d.ts",
+      "gamemaker-source": "./src/lookAlike.ts",
+      "import": "./dist/look-alike.js"
+    },
+    "./palette-reserve": {
+      "types": "./dist/types/paletteReserve.d.ts",
+      "gamemaker-source": "./src/paletteReserve.ts",
+      "import": "./dist/palette-reserve.js"
+    },
+    "./gif-shrink": {
+      "types": "./dist/types/gifShrink.d.ts",
+      "gamemaker-source": "./src/gifShrink.ts",
+      "import": "./dist/gif-shrink.js"
+    },
+    "./color-reduce": {
+      "types": "./dist/types/colorReduce.d.ts",
+      "gamemaker-source": "./src/colorReduce.ts",
+      "import": "./dist/color-reduce.js"
+    },
+    "./delta": {
+      "types": "./dist/types/delta.d.ts",
+      "gamemaker-source": "./src/delta.ts",
+      "import": "./dist/delta.js"
+    },
+    "./disk-diff": {
+      "types": "./dist/types/diskDiff.d.ts",
+      "gamemaker-source": "./src/diskDiff.ts",
+      "import": "./dist/disk-diff.js"
+    },
+    "./release-notes": {
+      "types": "./dist/types/releaseNotes.d.ts",
+      "gamemaker-source": "./src/releaseNotes.ts",
+      "import": "./dist/release-notes.js"
+    },
+    "./menu-version": {
+      "types": "./dist/types/menuVersionEntry.d.ts",
+      "gamemaker-source": "./src/menuVersionEntry.ts",
+      "import": "./dist/menu-version.js"
+    },
+    "./microFont": {
+      "types": "./dist/types/microFont.d.ts",
+      "gamemaker-source": "./src/microFont.ts",
+      "import": "./dist/microFont.js"
+    },
+    "./colors": {
+      "types": "./dist/types/colors.d.ts",
+      "gamemaker-source": "./src/colors.ts",
+      "import": "./dist/colors.js"
+    },
+    "./text": {
+      "types": "./dist/types/text.d.ts",
+      "gamemaker-source": "./src/text.ts",
+      "import": "./dist/text.js"
+    },
+    "./palettes": {
+      "types": "./dist/types/palettes.d.ts",
+      "gamemaker-source": "./src/palettes.ts",
+      "import": "./dist/palettes.js"
+    }
+  },
+  "scripts": {
+    "build": "node build.js",
+    "prepack": "npm run build",
+    "verify": "npm run build && node verify.js"
+  },
+  "devDependencies": {
+    "@types/node": "^22.20.5",
+    "typescript": "~5.9.0",
+    "vite": "^7.1.0"
+  },
+  "publishConfig": {
+    "registry": "https://npm.pkg.github.com/"
+  },
+  "dependencies": {
+    "@lewismoten/gamemaker-sandbox-engine": "^3.2.0",
+    "@lewismoten/gamemaker-sandbox-archives": "^3.2.0"
+  },
+  "author": "Lewis Moten"
+}