@lewismoten/gamemaker-sandbox-tools 3.1.0 → 3.4.0

package/dist/text.js

@@ -0,0 +1,74 @@
+import { FONT_CP437 as T } from "@lewismoten/gamemaker-sandbox-engine/gfx/cp437Glyphs";
+import { FONT_CP437 as z } from "@lewismoten/gamemaker-sandbox-engine/gfx/cp437Glyphs";
+import { toCp437 as M, fromCp437 as P } from "@lewismoten/gamemaker-sandbox-engine/text/cp437";
+import { fromCp437 as D, toCp437 as J } from "@lewismoten/gamemaker-sandbox-engine/text/cp437";
+import { Pixels as N } from "./kit/pixels.js";
+import { MICRO_SQUARE_GLYPHS as Y, MICRO_GLYPHS as k } from "./microFont.js";
+function G(e) {
+  for (const t of e)
+    if (t.charCodeAt(0) >= 128 && M(t) === t && P(t) !== t) throw new RangeError(`No CP437 glyph for ${t}`);
+  const i = M(e), n = new Uint8Array(i.length);
+  for (let t = 0; t < i.length; t++) {
+    const o = i.charCodeAt(t);
+    if (o > 255) throw new RangeError(`No CP437 glyph for ${i[t]}`);
+    n[t] = o;
+  }
+  return n;
+}
+function H(e, i = "cp437") {
+  if (!Number.isInteger(e) || e < 0 || e > 255) throw new RangeError("Glyph code must be 0..255");
+  if (i === "cp437") return T.slice(e * 8, e * 8 + 8);
+  const n = i === "micro-square" ? Y : k, t = P(String.fromCharCode(e)), o = n[t] ?? n[t.toUpperCase()] ?? n["?"];
+  return Uint8Array.from({ length: 5 }, (f, r) => {
+    let a = 0;
+    for (let s = 0; s < 3; s++) o[r * 3 + s] === "1" && (a |= 1 << s);
+    return a;
+  });
+}
+function F(e, i, n = 1, t = 2) {
+  if (x(i), !Number.isInteger(n) || !Number.isInteger(t)) throw new RangeError("Shadow offsets must be integers");
+  const o = new N(e.w, e.h, 255);
+  for (let f = 0; f < e.h; f++) for (let r = 0; r < e.w; r++) e.get(r, f) !== 255 && o.set(r + n, f + t, i);
+  return o.blit(e, 0, 0, 255);
+}
+function x(e) {
+  if (!Number.isInteger(e) || e < 0 || e > 254) throw new RangeError("Ink must be a palette index 0..254");
+}
+function Q(e, i = {}) {
+  const { font: n = "cp437", color: t = 0, scale: o = 1, outline: f, shadow: r } = i;
+  if (x(t), f !== void 0 && x(f), r && x(r.color), !Number.isSafeInteger(o) || o < 1) throw new RangeError("Scale must be a positive integer");
+  const a = r?.dx ?? 1, s = r?.dy ?? 2;
+  if (!Number.isSafeInteger(a) || !Number.isSafeInteger(s)) throw new RangeError("Shadow offsets must be integers");
+  const y = typeof e == "string" ? e.replaceAll(`\r
+`, `
+`).split(`
+`).map(G) : [e], R = Math.max(...y.map((h) => h.length));
+  if (!R) return { width: 0, height: 0, pixels: new Uint8Array(), originX: 0, originY: 0 };
+  const S = n === "cp437" ? 8 : 3, C = n === "cp437" ? 8 : 5, A = n === "cp437" ? 8 : 4, p = f === void 0 ? 0 : 1, E = Math.min(-p, r ? a : 0), I = Math.min(-p, r ? s : 0), _ = Math.max(p, r ? a : 0), v = Math.max(p, r ? s : 0), m = ((R - 1) * A + S) * o + _ - E, w = ((y.length - 1) * (C + 1) + C) * o + v - I, u = new N(m, w, 255);
+  y.forEach(
+    (h, c) => h.forEach((l, g) => {
+      H(l, n).forEach((U, O) => {
+        for (let b = 0; b < S; b++)
+          U & 1 << b && u.rect((g * A + b) * o - E, (c * (C + 1) + O) * o - I, o, o, t);
+      });
+    })
+  );
+  const d = new N(m, w, 255);
+  if (r && d.blit(F(u, r.color, a, s), 0, 0, 255), f !== void 0) {
+    for (let h = 0; h < w; h++)
+      for (let c = 0; c < m; c++)
+        if (u.get(c, h) !== 255) for (let l = -1; l <= 1; l++) for (let g = -1; g <= 1; g++) d.set(c + g, h + l, f);
+  }
+  return d.blit(u, 0, 0, 255), { width: m, height: w, pixels: d.px, originX: -E, originY: -I };
+}
+export {
+  z as FONT_CP437,
+  k as MICRO_GLYPHS,
+  Y as MICRO_SQUARE_GLYPHS,
+  F as dropShadow,
+  G as encodeText,
+  D as fromCp437,
+  H as glyphRows,
+  Q as renderText,
+  J as toCp437
+};

package/dist/types/audio.d.ts

@@ -0,0 +1,4 @@
+export * from './music/compose.js';
+export * from './kit/tune.js';
+export * from './kit/sound.js';
+export * from './kit/synthParts.js';

package/dist/types/audioFiles.d.ts

@@ -0,0 +1,22 @@
+export interface AudioFileOptions {
+    /** Output mono sample rate. Defaults to Game-Maker's usual 11025 Hz. */
+    sampleRate?: number;
+    /** Executable name or path; FFmpeg is installed separately, never bundled. */
+    ffmpegPath?: string;
+    /** Maximum decoded mono samples (default 16 MiB). Exceeding it fails, never truncates. */
+    maxSamples?: number;
+    /** Maximum conversion time, in milliseconds (default 30000). */
+    timeoutMs?: number;
+}
+export interface VocFileOptions extends Omit<AudioFileOptions, 'maxSamples'> {
+    /** Maximum total VOC bytes, including headers (default 65535, the DOS size limit). */
+    maxBytes?: number;
+}
+/**
+ * Decode FLAC, Ogg, WAV or another FFmpeg-supported file to mono samples for encodeVoc.
+ * The unsigned-byte mapping deliberately inverts encodeVoc, retaining all original PCM
+ * values when lossless sources are decoded at their own sample rate. Other rates resample.
+ */
+export declare function decodeAudioFile(file: string | URL, options?: AudioFileOptions): Float32Array;
+/** Convert source audio to a native mono, unsigned 8-bit VOC, enforcing DOS's size limit. */
+export declare function audioFileToVoc(file: string | URL, options?: VocFileOptions): Uint8Array;

package/dist/types/audioWav.d.ts

@@ -0,0 +1,4 @@
+export declare function pcm8Wav(bytes: Uint8Array): {
+    samples: Uint8Array;
+    sampleRate: number;
+} | undefined;

package/dist/types/blockMerge.d.ts

@@ -0,0 +1,24 @@
+import { type Block } from '@lewismoten/gamemaker-sandbox-engine/formats/blocks';
+import type { GameMap } from '@lewismoten/gamemaker-sandbox-engine/formats/map';
+export interface BblMergeInput {
+    keep: Block[];
+    drop: Block[];
+    /** The dropped set's maps (every map its scenes open); each is renumbered. */
+    dropMaps: GameMap[];
+    /** Block numbers of the dropped set its maps draw, with everything those turn into. */
+    dropUsed: ReadonlySet<number>;
+    /** Numbers that must keep their number in the dropped set (pickups, required and starting inventory, 0). */
+    dropPinned: ReadonlySet<number>;
+    /** Slots of the kept set that are in use (drawn, linked to, or pinned): never given away even if they look blank. */
+    keepUsed: ReadonlySet<number>;
+}
+export interface BblMerge {
+    blocks: Block[];
+    maps: GameMap[];
+    /** Where each of the dropped set's drawn blocks is now. */
+    at: Map<number, number>;
+    /** The dropped blocks that moved into a slot of their own (the others reuse a twin). */
+    fresh: number[];
+}
+/** The merge, or why the two sets can't share one file. */
+export declare function mergeBackgroundSets(input: BblMergeInput): BblMerge | string;

package/dist/types/colorReduce.d.ts

@@ -0,0 +1,23 @@
+import type { Block } from '@lewismoten/gamemaker-sandbox-engine/formats/blocks';
+export declare const FLAG_MEAN = 6;
+export declare const FLAG_WORST = 20;
+type Lab = [number, number, number];
+/** CIELAB of palette color `i` (palette bytes are 6-bit VGA values). */
+export declare function labOf(palette: Uint8Array, i: number): Lab;
+export interface ReduceScore {
+    /** Mean delta E over the pixels that changed color, and over every pixel of the changed blocks. */
+    mean: number;
+    worst: number;
+    /** Blocks that passed a threshold. */
+    flagged: number[];
+}
+export interface ReduceResult {
+    /** Block number to its new pixels, only for blocks that changed. */
+    changed: Map<number, Uint8Array>;
+    /** Each color index that moved and where it went. */
+    moves: Map<number, number>;
+    score: ReduceScore;
+}
+/** The blocks `which` with every pixel outside `allowed` (and not 0 or 255) moved to the nearest allowed color in `palettes[0]`; scored under every palette. */
+export declare function reduceBlocks(blocks: Block[], which: Iterable<number>, palettes: Uint8Array[], allowed: ReadonlySet<number>): ReduceResult;
+export {};

package/dist/types/{web/packages/tools/src/colors.d.ts → colors.d.ts}

@@ -1,4 +1,10 @@
 export type RGB = readonly [number, number, number];
+/** Hue in degrees, saturation and value in 0..1. */
+export type HSV = readonly [number, number, number];
+/** Convert eight-bit RGB to hue, saturation and value without changing the input. */
+export declare function rgbToHsv(color: RGB): [number, number, number];
+/** Convert HSV to rounded eight-bit RGB; hue wraps around at 360 degrees. */
+export declare function hsvToRgb(color: HSV): [number, number, number];
 export type TimeOfDay = 'morning' | 'noon' | 'afternoon' | 'sunset' | 'night' | 'show';
 export interface Lighting {
     readonly mul: RGB;

package/dist/types/delta.d.ts

@@ -0,0 +1,32 @@
+export type FileState = Uint8Array;
+/** A file in a delta: new whole, changed by patches, or gone. */
+export type FileDelta = {
+    kind: 'new';
+    bytes: Uint8Array;
+} | {
+    kind: 'bytes';
+    length: number;
+    patches: {
+        at: number;
+        bytes: Uint8Array;
+    }[];
+} | {
+    kind: 'lines';
+    start: number;
+    remove: number;
+    add: string[];
+} | {
+    kind: 'gone';
+};
+/** What changed between two versions of a game: only the files that differ. */
+export type Delta = Record<string, FileDelta>;
+/** The difference that turns `from` (undefined: no such file) into `to` (undefined: removed); undefined when they are the same. */
+export declare function diffFile(name: string, from: FileState | undefined, to: FileState | undefined): FileDelta | undefined;
+/** The file after a delta; undefined when it is gone. */
+export declare function patchFile(from: FileState | undefined, d: FileDelta): FileState | undefined;
+/** The delta between two whole versions (file name to bytes). */
+export declare function diffVersions(from: ReadonlyMap<string, FileState>, to: ReadonlyMap<string, FileState>): Delta;
+/** A version with a delta applied. */
+export declare function applyDelta(from: ReadonlyMap<string, FileState>, delta: Delta): Map<string, FileState>;
+/** Bytes a delta takes to store (patch bytes, new files, added lines), to show what a version costs. */
+export declare function deltaSize(delta: Delta): number;

package/dist/types/diskDiff.d.ts

@@ -0,0 +1,47 @@
+export type DiskFiles = ReadonlyMap<string, Uint8Array>;
+export interface ChangedFile {
+    name: string;
+    kind: string;
+    before: number;
+    after: number;
+    summary: string[];
+}
+export interface DiskDiff {
+    added: {
+        name: string;
+        kind: string;
+        size: number;
+    }[];
+    removed: {
+        name: string;
+        kind: string;
+        size: number;
+    }[];
+    changed: ChangedFile[];
+    unchanged: number;
+}
+/** What a file is, by its first bytes when they say, else by its extension. */
+export declare function sniffKind(name: string, bytes: Uint8Array): string;
+/** Numbers as ranges: 3,4,5,9 -> "3-5, 9". Long lists are cut. */
+export declare function ranges(nums: number[], max?: number): string;
+/** Lines added and removed: shared head and tail dropped, then a longest-common-subsequence. */
+export declare function lineDiff(a: string[], b: string[]): {
+    added: number;
+    removed: number;
+};
+/** Changed map cells grouped into clusters (cells within 3 of each other), as bounding boxes. */
+export declare function cellClusters(cells: number[], width: number): {
+    count: number;
+    x0: number;
+    y0: number;
+    x1: number;
+    y1: number;
+}[];
+/** A short plain-text summary of how one file changed; a parse failure falls back to bytes. */
+export declare function summarizeChange(name: string, a: Uint8Array, b: Uint8Array): {
+    kind: string;
+    summary: string[];
+};
+export declare function diffDisks(a: DiskFiles, b: DiskFiles): DiskDiff;
+/** The plain-text report: counts, then added, removed, and changed files with their summaries. */
+export declare function formatDiff(d: DiskDiff): string;

package/dist/types/drawing.d.ts

@@ -0,0 +1,15 @@
+export * from './kit/pixels.js';
+export * from './kit/palette.js';
+export * from './kit/pcText.js';
+export * from './kit/blit.js';
+export * from './kit/shading.js';
+export * from './kit/textBounds.js';
+export * from './kit/reel.js';
+export { FONT8X8 } from '@lewismoten/gamemaker-sandbox-engine/gfx/font8x8';
+export * from './text.js';
+export * from './colors.js';
+export * from './kit/microText.js';
+export { microGlyphs, type MicroGlyphs } from './microFont.js';
+export * from './kit/transforms.js';
+export * from './kit/coverPaint.js';
+export * from './kit/palRamps.js';

package/dist/types/embroidery/compile.d.ts

@@ -0,0 +1,3 @@
+import { type Design, type Params, type Pattern } from './types.js';
+/** Compiles the design to stitches, ending with an 'end' command; the threads are the blocks' threads in order. */
+export declare function compile(design: Design, params?: Partial<Params>): Pattern;

package/dist/types/embroidery/dst.d.ts

@@ -0,0 +1,13 @@
+import type { Pattern, Stitch } from './types.js';
+/** The DST file for a pattern. */
+export declare function writeDst(pattern: Pattern): Uint8Array;
+/** Reads a DST back into absolute stitches in mm (jumps and color changes included; the header counts are checked by the caller). */
+export declare function readDst(bytes: Uint8Array): {
+    stitches: Stitch[];
+    colorChanges: number;
+    label: string;
+    declared: {
+        stitches: number;
+        colors: number;
+    };
+};

package/dist/types/embroidery/exp.d.ts

@@ -0,0 +1,8 @@
+import type { Pattern, Stitch } from './types.js';
+/** The EXP file for a pattern. */
+export declare function writeExp(pattern: Pattern): Uint8Array;
+/** Reads an EXP back into absolute stitches in mm; the end is where the data stops. */
+export declare function readExp(bytes: Uint8Array): {
+    stitches: Stitch[];
+    colorChanges: number;
+};

package/dist/types/embroidery/fill.d.ts

@@ -0,0 +1,6 @@
+import type { Poly, Pt } from './types.js';
+/**
+ * The chains of needle points that fill the outlines with rows at `angle` degrees. Each chain is sewn in order; moving
+ * between chains is the caller's job.
+ */
+export declare function tatami(polys: Poly[], angle: number, spacing: number, len: number): Pt[][];

package/dist/types/embroidery/geom.d.ts

@@ -0,0 +1,19 @@
+import type { Poly, Pt } from './types.js';
+export declare const dist: (a: Pt, b: Pt) => number;
+/** A circle as a polygon of `n` points, counter-clockwise from the right. */
+export declare function circle(cx: number, cy: number, r: number, n?: number): Poly;
+/** A star with `points` tips (first tip at `start` radians) between an inner and an outer radius. */
+export declare function star(cx: number, cy: number, inner: number, outer: number, points: number, start?: number): Poly;
+/** Points on an elliptical arc from angle a0 to a1 (radians), `n` segments. */
+export declare function arc(cx: number, cy: number, rx: number, ry: number, a0: number, a1: number, n?: number): Pt[];
+/** Signed area (positive when counter-clockwise). */
+export declare function area(p: Poly): number;
+/** The outline moved `d` mm inward (outward when negative), mitered at the corners with the miter length capped. */
+export declare function inset(p: Poly, d: number): Poly;
+/** Even-odd containment in any of the outlines. */
+export declare function inside(polys: Poly[], pt: Pt): boolean;
+/** The path cut into points about `step` mm apart along it (its corners are kept). Closed paths return to the start. */
+export declare function resample(path: Pt[], step: number, closed?: boolean): Pt[];
+/** The path cut at even spacing by arc length (corners are not kept), for satin. */
+export declare function evenly(path: Pt[], step: number, closed?: boolean): Pt[];
+export declare const rotate: (p: Pt, a: number) => Pt;

package/dist/types/embroidery/pes.d.ts

@@ -0,0 +1,10 @@
+import type { Pattern, Stitch } from './types.js';
+/** The PES file for a pattern. */
+export declare function writePes(pattern: Pattern): Uint8Array;
+/** Reads a PES back (the PEC section) into absolute stitches in mm. */
+export declare function readPes(bytes: Uint8Array): {
+    stitches: Stitch[];
+    colorChanges: number;
+    threads: number;
+    label: string;
+};

package/dist/types/embroidery/satin.d.ts

@@ -0,0 +1,11 @@
+import type { Pt } from './types.js';
+/**
+ * The needle points of a satin column along `path` (closed paths end where they began).
+ * Each lane is one list; a column up to `maxWidth` is a single lane.
+ */
+export declare function satin(path: Pt[], width: number, density: number, closed: boolean, maxWidth: number): Pt[][];
+/**
+ * Underlay for a satin column: a walk down its center, and a loose zigzag a little narrower than the column when it is
+ * wide enough to need one.
+ */
+export declare function satinUnderlay(path: Pt[], width: number, run: number, closed: boolean): Pt[][];

package/dist/types/embroidery/simulate.d.ts

@@ -0,0 +1,19 @@
+import type { Pattern, RGB } from './types.js';
+export interface Picture {
+    w: number;
+    h: number;
+    rgb: Uint8Array;
+}
+export interface SimOptions {
+    /** Picture size in mm (square), centered on 0,0. */
+    size: number;
+    pxPerMm: number;
+    /** Thread width, mm (about 0.4 for 40 weight thread, drawn a little heavier to read at small size). */
+    thread?: number;
+    /** Backing fabric color. */
+    backing?: RGB;
+    /** The mm point at the middle of the picture (default 0,0), to look closely at one part. */
+    center?: [number, number];
+}
+/** Draws the pattern. */
+export declare function simulate(pattern: Pattern, o: SimOptions): Picture;

package/dist/types/embroidery/strokeFont.d.ts

@@ -0,0 +1,20 @@
+import type { Pt } from './types.js';
+export interface ArcTextOptions {
+    /** Center of the circle. */
+    cx: number;
+    cy: number;
+    /** Radius of the letters' baselines (their feet), mm; the stroke centers run from here out (top) or in (bottom). */
+    baseline: number;
+    /** Height of the letters in mm (stroke center to stroke center). */
+    height: number;
+    /** Gap between letters, mm. */
+    gap: number;
+    /** 'top' reads left to right over the top with feet toward the center; 'bottom' reads left to right under the bottom with heads toward the center. */
+    side: 'top' | 'bottom';
+    /** Stretches the letters sideways (1 = as drawn). */
+    stretch?: number;
+    /** Where the middle of the word sits, radians (default: straight up for top, straight down for bottom). */
+    center?: number;
+}
+/** The strokes (as paths of points, mm) that spell `text` bent around the circle. */
+export declare function arcText(text: string, o: ArcTextOptions): Pt[][];

package/dist/types/embroidery/svg.d.ts

@@ -0,0 +1,3 @@
+import type { Design, RGB } from './types.js';
+/** The SVG text of the design, `margin` mm of backing around a square of `size` mm. */
+export declare function designSvg(design: Design, size: number, backing?: RGB): string;

package/dist/types/embroidery/types.d.ts

@@ -0,0 +1,70 @@
+export type Pt = [number, number];
+/** A closed outline (the last point joins the first). */
+export type Poly = Pt[];
+export type RGB = [number, number, number];
+export interface Thread {
+    /** A generic color name ("midnight navy"), not a brand. */
+    name: string;
+    rgb: RGB;
+    /** Brother PEC thread-chart index (1-64) for the PES file; the machine shows its own color for it. */
+    pec?: number;
+}
+/** What the needle does next: sew to the point, move without sewing, cut the thread then move, change thread, or finish. */
+export type Cmd = 'stitch' | 'jump' | 'trim' | 'color' | 'end';
+export interface Stitch {
+    x: number;
+    y: number;
+    cmd: Cmd;
+}
+export interface Pattern {
+    name: string;
+    threads: Thread[];
+    stitches: Stitch[];
+}
+/** A shape filled with tatami (rows of stitches), under an optional underlay. */
+export interface FillItem {
+    kind: 'fill';
+    polys: Poly[];
+    /** Direction of the rows, degrees. Regions should alternate it. */
+    angle: number;
+}
+/** A column of satin zigzag along a line, `width` mm wide (split into lanes beyond 7 mm). */
+export interface SatinItem {
+    kind: 'satin';
+    path: Pt[];
+    width: number;
+    closed?: boolean;
+}
+/** A plain line of running stitches. */
+export interface RunItem {
+    kind: 'run';
+    path: Pt[];
+    closed?: boolean;
+}
+export type Item = FillItem | SatinItem | RunItem;
+/** Everything sewn in one thread, in order; a color change comes between blocks. */
+export interface Block {
+    thread: Thread;
+    items: Item[];
+}
+export interface Design {
+    name: string;
+    /** The hoop's sewing field in mm. */
+    hoop: [number, number];
+    /** Blocks in sewing order. */
+    blocks: Block[];
+}
+/** The tuning numbers of the generator, in mm. */
+export interface Params {
+    fillSpacing: number;
+    fillLength: number;
+    satinDensity: number;
+    /** Extra satin width (total) so the thread draws in and still covers its shape. */
+    pullComp: number;
+    /** Outline growth of fills for the same reason. */
+    fillGrow: number;
+    maxStitch: number;
+    underlayRun: number;
+    maxSatin: number;
+}
+export declare const DEFAULTS: Params;

package/dist/types/embroidery/units.d.ts

@@ -0,0 +1,10 @@
+import type { Cmd, Pattern } from './types.js';
+export interface Move {
+    dx: number;
+    dy: number;
+    cmd: Cmd;
+}
+/** Cut-off for one record's move in either direction, in tenths of a millimeter (Tajima DST's limit; EXP and PES take more). */
+export declare const MAX_MOVE = 121;
+/** The pattern's records. Positions are rounded as absolute tenths, so rounding never builds up along a long run. */
+export declare function toRecords(pattern: Pattern, maxMove?: number): Move[];

package/dist/types/embroidery/validate.d.ts

@@ -0,0 +1,22 @@
+import type { Stitch } from './types.js';
+export interface Report {
+    stitches: number;
+    jumps: number;
+    colorChanges: number;
+    /** Longest sewn stitch and longest single jump record, mm. */
+    maxStitch: number;
+    maxJump: number;
+    /** Extents of every needle position, mm: [minX, minY, maxX, maxY]. */
+    extents: [number, number, number, number];
+    width: number;
+    height: number;
+    problems: string[];
+}
+export interface Expect {
+    hoop: [number, number];
+    /** Number of thread colors; the file must change color this many minus one times. */
+    colors: number;
+    /** The longest single record the format allows, mm (12.1 for DST). */
+    maxRecord: number;
+}
+export declare function validate(list: Stitch[], want: Expect): Report;

package/dist/types/formats/blocks.d.ts

@@ -0,0 +1 @@
+export * from '@lewismoten/gamemaker-sandbox-engine/formats/blocks';

package/dist/types/formats/character.d.ts

@@ -0,0 +1 @@
+export * from '@lewismoten/gamemaker-sandbox-engine/formats/character';

package/dist/types/formats/cmf.d.ts

@@ -0,0 +1 @@
+export * from '@lewismoten/gamemaker-sandbox-engine/formats/cmf';

package/dist/types/formats/fli.d.ts

@@ -0,0 +1 @@
+export * from '@lewismoten/gamemaker-sandbox-engine/formats/fli';

package/dist/types/formats/fliLimits.d.ts

@@ -0,0 +1 @@
+export * from '@lewismoten/gamemaker-sandbox-engine/formats/fliLimits';

package/dist/types/formats/game.d.ts

@@ -0,0 +1 @@
+export * from '@lewismoten/gamemaker-sandbox-engine/formats/game';

package/dist/types/formats/gif.d.ts

@@ -0,0 +1 @@
+export * from '@lewismoten/gamemaker-sandbox-engine/formats/gif';

package/dist/types/formats/graphicScripts.d.ts

@@ -0,0 +1 @@
+export * from '@lewismoten/gamemaker-sandbox-engine/formats/graphicScripts';

package/dist/types/formats/map.d.ts

@@ -0,0 +1 @@
+export * from '@lewismoten/gamemaker-sandbox-engine/formats/map';

package/dist/types/formats/monster.d.ts

@@ -0,0 +1 @@
+export * from '@lewismoten/gamemaker-sandbox-engine/formats/monster';

package/dist/types/formats/palette.d.ts

@@ -0,0 +1 @@
+export * from '@lewismoten/gamemaker-sandbox-engine/formats/palette';

package/dist/types/formats/recording.d.ts

@@ -0,0 +1 @@
+export * from '@lewismoten/gamemaker-sandbox-engine/formats/recording';

package/dist/types/formats/sound.d.ts

@@ -0,0 +1 @@
+export * from '@lewismoten/gamemaker-sandbox-engine/formats/sound';

package/dist/types/formats/voc.d.ts

@@ -0,0 +1 @@
+export * from '@lewismoten/gamemaker-sandbox-engine/formats/voc';

package/dist/types/gifShrink.d.ts

@@ -0,0 +1,8 @@
+export interface GifShrink {
+    bytes: Uint8Array;
+    /** Table size before and after. */
+    from: number;
+    to: number;
+}
+/** The smaller file, or undefined when the table can't shrink without changing what PLAYGAME shows. */
+export declare function shrinkGif(bytes: Uint8Array): GifShrink | undefined;

package/dist/types/image/animatedGif.d.ts

@@ -0,0 +1,9 @@
+export interface AnimatedFrame {
+    /** width * height palette indexes. */
+    pixels: Uint8Array;
+    /** 768 bytes, 6 bits per channel. */
+    palette: Uint8Array;
+    /** Hundredths of a second this frame shows. */
+    delay: number;
+}
+export declare function encodeAnimatedGif(width: number, height: number, frames: AnimatedFrame[]): Uint8Array;

package/dist/types/image/surface.d.ts

@@ -0,0 +1,26 @@
+import { Pixels } from '../kit/pixels.js';
+export type SurfaceMirror = 'none' | 'h' | 'v' | 'both';
+/** The pixel and its mirror images across the whole picture, without repeats. */
+export declare function mirrorAll(x: number, y: number, w: number, h: number, mirror: SurfaceMirror): [number, number][];
+type Plot = (x: number, y: number) => void;
+/** Every pixel of a straight line from a to b. */
+export declare function line(a: {
+    x: number;
+    y: number;
+}, b: {
+    x: number;
+    y: number;
+}, plot: Plot): void;
+/** The outline of the box with corners a and b. */
+export declare function box(a: {
+    x: number;
+    y: number;
+}, b: {
+    x: number;
+    y: number;
+}, plot: Plot): void;
+/** Fills one four-connected color region. A mask and writer can preserve missing or shared tiles. */
+export declare function floodFill(px: Uint8Array, w: number, h: number, x: number, y: number, v: number, allowed?: (x: number, y: number) => boolean, paint?: (x: number, y: number, value: number) => void): void;
+/** Move indexed pixels with wrapping at each edge; the input is unchanged. */
+export declare function shiftPixels(src: Pixels, dx: number, dy: number): Pixels;
+export {};

package/dist/types/images.d.ts

@@ -0,0 +1,13 @@
+export { encodePng, type IndexedPicture } from './image/png.js';
+export { crc32 } from '@lewismoten/gamemaker-sandbox-archives/zip';
+export { Pixels } from './kit/pixels.js';
+export { flipX, flipY, turn90, turn180 } from './kit/transforms.js';
+export { mirrorAll, line, box, floodFill, shiftPixels, type SurfaceMirror } from './image/surface.js';
+/** Portable RGBA pixels; accepts ImageData without requiring canvas or a DOM. RGB is treated as opaque. */
+export interface RgbaPixels {
+    width: number;
+    height: number;
+    data: ArrayLike<number>;
+}
+/** Median cut over the given RGBA images: up to `colors` 8-bit colors. */
+export declare function medianCutRgba(images: readonly RgbaPixels[], colors?: number): [number, number, number][];

package/dist/types/kit/actors.d.ts

@@ -0,0 +1,7 @@
+import { type Frame, type Sequence } from '@lewismoten/gamemaker-sandbox-engine/formats/character';
+import { type March, type Monster } from '@lewismoten/gamemaker-sandbox-engine/formats/monster';
+export declare function set(s: Sequence, frames: Frame[], o?: Partial<Omit<Sequence, 'frames'>>): void;
+export declare function mon(pics: [number, number][], o: Partial<Monster>, path?: March[]): Monster;
+export declare const corner: (x: number, y: number, speed: number, orient?: number) => March;
+/** Back and forth `run` blocks (to the right first) at `speed`, facing the way it goes. */
+export declare const pace: (run: number, speed: number, dy?: number) => March[];