sci2-ts 0.0.0-stage → 0.2.2

package/apps/viewer/src/adlib.ts

@@ -0,0 +1,62 @@
+import { AdLibDriver, type AdLibBank, type MidiOutput } from "../../../packages/sci/src/index.ts";
+import workletUrl from "./opl-worklet.ts?worker&url";
+
+/**
+ * AdLib music: Sierra's driver runs here and batches OPL register writes to the chip
+ * emulator in an AudioWorklet (flushed once per microtask, i.e. per burst of MIDI events).
+ */
+export class AdLibOutput implements MidiOutput {
+  private driver: AdLibDriver;
+  private queue: number[] = [];
+  private flushScheduled = false;
+
+  private constructor(
+    private readonly node: AudioWorkletNode,
+    private readonly bank: AdLibBank,
+  ) {
+    this.driver = this.newDriver();
+  }
+
+  static async create(ctx: AudioContext, bank: AdLibBank): Promise<AdLibOutput> {
+    await ctx.audioWorklet.addModule(workletUrl);
+    const node = new AudioWorkletNode(ctx, "opl2", { outputChannelCount: [2] });
+    node.connect(ctx.destination);
+    return new AdLibOutput(node, bank);
+  }
+
+  private newDriver(): AdLibDriver {
+    const chip = {
+      write: (reg: number, value: number) => {
+        this.queue.push(reg, value);
+        if (!this.flushScheduled) {
+          this.flushScheduled = true;
+          queueMicrotask(() => {
+            this.flushScheduled = false;
+            this.node.port.postMessage(this.queue);
+            this.queue = [];
+          });
+        }
+      },
+    };
+    return new AdLibDriver(chip, this.bank);
+  }
+
+  /** Silences the chip and starts from a clean driver (used when switching devices). */
+  reset(): void {
+    this.queue = [];
+    this.node.port.postMessage("reset");
+    this.driver = this.newDriver();
+  }
+
+  send(bytes: number[]): void {
+    this.driver.send(bytes);
+  }
+
+  claimVoices(channel: number, count: number): void {
+    this.driver.claimVoices(channel, count);
+  }
+
+  setMasterVolume(volume: number): void {
+    this.driver.setMasterVolume(volume);
+  }
+}

package/apps/viewer/src/app.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Names this app's browser storage: saved games (IndexedDB) and settings (localStorage).
+ * Changing it hides the saves people already have.
+ */
+export declare const APP_ID = "sci-ts";

package/apps/viewer/src/app.js

@@ -0,0 +1,5 @@
+/**
+ * Names this app's browser storage: saved games (IndexedDB) and settings (localStorage).
+ * Changing it hides the saves people already have.
+ */
+export const APP_ID = "sci-ts";

package/apps/viewer/src/app.ts

@@ -0,0 +1,5 @@
+/**
+ * Names this app's browser storage: saved games (IndexedDB) and settings (localStorage).
+ * Changing it hides the saves people already have.
+ */
+export const APP_ID = "sci-ts";

package/apps/viewer/src/asset-index.d.ts

@@ -0,0 +1,22 @@
+import { ResourceType, type ResourceManager, type ScriptWorld } from "../../../packages/sci/src/index.ts";
+/**
+ * What the game says about its assets. SCI resources carry no names or descriptions, so
+ * they come from the scripts: the room that draws a picture, the objects whose `view` is a
+ * view, and what the game says when you Look at them (the room's or the object's noun, verb
+ * 1, in the room's message file); sounds from Sound objects that declare their number.
+ * Only what's declared on objects is found, not what a script picks at run time.
+ */
+export interface AssetMeta {
+    /** Short labels: room and object names ("rm250", "igor", "room 250"). */
+    tags: string[];
+    /** Who uses it, for the preview: "igor in room 250: Igor is digging…". */
+    uses: {
+        label: string;
+        text?: string;
+    }[];
+}
+export type AssetIndex = Map<string, AssetMeta>;
+export declare const assetKey: (type: ResourceType, number: number) => string;
+export declare function buildAssetIndex(rm: ResourceManager, world: ScriptWorld, onProgress?: (done: number, total: number) => void): Promise<AssetIndex>;
+/** Whether every word of `query` is in the asset's number, tags or descriptions. */
+export declare function matches(query: string, number: number, meta: AssetMeta | undefined): boolean;

package/apps/viewer/src/asset-index.js

@@ -0,0 +1,74 @@
+import { ResourceType, analyzeGame, parseMessages } from "../../../packages/sci/src/index.js";
+export const assetKey = (type, number) => `${type}:${number}`;
+const LOOK = 1;
+export async function buildAssetIndex(rm, world, onProgress) {
+    const index = await analyzeGame(rm, { world, onProgress });
+    const out = new Map();
+    const add = (type, number, tags, use) => {
+        const key = assetKey(type, number);
+        const meta = out.get(key) ?? { tags: [], uses: [] };
+        for (const t of tags)
+            if (t && !meta.tags.includes(t))
+                meta.tags.push(t);
+        if (use && !meta.uses.some((u) => u.label === use.label))
+            meta.uses.push(use);
+        out.set(key, meta);
+    };
+    // Message files, by module (a room's own file is its number).
+    const files = new Map();
+    const messages = async (n) => {
+        if (!files.has(n)) {
+            const id = { type: ResourceType.Message, number: n };
+            files.set(n, rm.has(id) ? parseMessages((await rm.load(id)).data) : undefined);
+        }
+        return files.get(n);
+    };
+    /** What Look says about a noun: the first line, preferring no condition. */
+    const look = async (module, noun) => {
+        if (!noun)
+            return undefined;
+        const records = (await messages(module))?.records.filter((r) => r.noun === noun && r.verb === LOOK && r.text) ?? [];
+        return (records.find((r) => r.cond === 0) ?? records[0])?.text;
+    };
+    const roomName = new Map(index.rooms.map((r) => [r.number, r.name]));
+    for (const room of index.rooms) {
+        const text = await look(room.number, room.noun);
+        if (room.picture >= 0)
+            add(ResourceType.Pic, room.picture, [room.name, `room ${room.number}`], { label: `${room.name} (room ${room.number})`, text });
+        add(ResourceType.Script, room.number, [room.name, "room"], { label: `room ${room.number}`, text });
+        add(ResourceType.Message, room.number, [room.name, `room ${room.number}`], { label: `${room.name}'s text`, text });
+    }
+    for (const script of index.scripts) {
+        const where = script.isRoom ? `room ${script.number}` : `script ${script.number}`;
+        const owner = roomName.get(script.number);
+        for (const obj of script.objects) {
+            const prop = (name) => obj.props.find((p) => p.name === name)?.value;
+            const view = prop("view");
+            const picture = prop("picture");
+            const noun = prop("noun") ?? 0;
+            const text = await look(script.number, noun);
+            if (view !== undefined && view > 0 && view < 0x8000 && rm.has({ type: ResourceType.View, number: view })) {
+                add(ResourceType.View, view, [obj.name, where, ...(owner ? [owner] : [])], { label: `${obj.name} in ${where}`, text });
+            }
+            if (picture !== undefined && picture > 0 && picture < 0x8000 && !script.isRoom) {
+                add(ResourceType.Pic, picture, [obj.name, where], { label: `${obj.name} in ${where}` });
+            }
+            // Sound objects that declare their number (room effects, mostly; music is set by code).
+            const sound = prop("number");
+            if (/sound|song|music/i.test(obj.className) && sound !== undefined && sound > 0 && rm.has({ type: ResourceType.Sound, number: sound })) {
+                add(ResourceType.Sound, sound, [obj.name, where, ...(owner ? [owner] : [])], { label: `${obj.name} in ${where}` });
+            }
+            if (!script.isRoom && obj.name)
+                add(ResourceType.Script, script.number, [obj.name]);
+        }
+    }
+    return out;
+}
+/** Whether every word of `query` is in the asset's number, tags or descriptions. */
+export function matches(query, number, meta) {
+    const words = query.toLowerCase().split(/\s+/).filter(Boolean);
+    if (!words.length)
+        return true;
+    const haystack = [String(number), ...(meta?.tags ?? []), ...(meta?.uses.flatMap((u) => [u.label, u.text ?? ""]) ?? [])].join(" ").toLowerCase();
+    return words.every((w) => haystack.includes(w));
+}

package/apps/viewer/src/asset-index.ts

@@ -0,0 +1,90 @@
+import { ResourceType, analyzeGame, parseMessages, type MessageFile, type ResourceManager, type ScriptWorld } from "../../../packages/sci/src/index.ts";
+
+/**
+ * What the game says about its assets. SCI resources carry no names or descriptions, so
+ * they come from the scripts: the room that draws a picture, the objects whose `view` is a
+ * view, and what the game says when you Look at them (the room's or the object's noun, verb
+ * 1, in the room's message file); sounds from Sound objects that declare their number.
+ * Only what's declared on objects is found, not what a script picks at run time.
+ */
+export interface AssetMeta {
+  /** Short labels: room and object names ("rm250", "igor", "room 250"). */
+  tags: string[];
+  /** Who uses it, for the preview: "igor in room 250: Igor is digging…". */
+  uses: { label: string; text?: string }[];
+}
+
+export type AssetIndex = Map<string, AssetMeta>;
+
+export const assetKey = (type: ResourceType, number: number) => `${type}:${number}`;
+
+const LOOK = 1;
+
+export async function buildAssetIndex(rm: ResourceManager, world: ScriptWorld, onProgress?: (done: number, total: number) => void): Promise<AssetIndex> {
+  const index = await analyzeGame(rm, { world, onProgress });
+  const out: AssetIndex = new Map();
+  const add = (type: ResourceType, number: number, tags: string[], use?: { label: string; text?: string }) => {
+    const key = assetKey(type, number);
+    const meta = out.get(key) ?? { tags: [], uses: [] };
+    for (const t of tags) if (t && !meta.tags.includes(t)) meta.tags.push(t);
+    if (use && !meta.uses.some((u) => u.label === use.label)) meta.uses.push(use);
+    out.set(key, meta);
+  };
+
+  // Message files, by module (a room's own file is its number).
+  const files = new Map<number, MessageFile | undefined>();
+  const messages = async (n: number) => {
+    if (!files.has(n)) {
+      const id = { type: ResourceType.Message, number: n };
+      files.set(n, rm.has(id) ? parseMessages((await rm.load(id)).data) : undefined);
+    }
+    return files.get(n);
+  };
+  /** What Look says about a noun: the first line, preferring no condition. */
+  const look = async (module: number, noun: number): Promise<string | undefined> => {
+    if (!noun) return undefined;
+    const records = (await messages(module))?.records.filter((r) => r.noun === noun && r.verb === LOOK && r.text) ?? [];
+    return (records.find((r) => r.cond === 0) ?? records[0])?.text;
+  };
+  const roomName = new Map(index.rooms.map((r) => [r.number, r.name]));
+
+  for (const room of index.rooms) {
+    const text = await look(room.number, room.noun);
+    if (room.picture >= 0) add(ResourceType.Pic, room.picture, [room.name, `room ${room.number}`], { label: `${room.name} (room ${room.number})`, text });
+    add(ResourceType.Script, room.number, [room.name, "room"], { label: `room ${room.number}`, text });
+    add(ResourceType.Message, room.number, [room.name, `room ${room.number}`], { label: `${room.name}'s text`, text });
+  }
+
+  for (const script of index.scripts) {
+    const where = script.isRoom ? `room ${script.number}` : `script ${script.number}`;
+    const owner = roomName.get(script.number);
+    for (const obj of script.objects) {
+      const prop = (name: string) => obj.props.find((p) => p.name === name)?.value;
+      const view = prop("view");
+      const picture = prop("picture");
+      const noun = prop("noun") ?? 0;
+      const text = await look(script.number, noun);
+      if (view !== undefined && view > 0 && view < 0x8000 && rm.has({ type: ResourceType.View, number: view })) {
+        add(ResourceType.View, view, [obj.name, where, ...(owner ? [owner] : [])], { label: `${obj.name} in ${where}`, text });
+      }
+      if (picture !== undefined && picture > 0 && picture < 0x8000 && !script.isRoom) {
+        add(ResourceType.Pic, picture, [obj.name, where], { label: `${obj.name} in ${where}` });
+      }
+      // Sound objects that declare their number (room effects, mostly; music is set by code).
+      const sound = prop("number");
+      if (/sound|song|music/i.test(obj.className) && sound !== undefined && sound > 0 && rm.has({ type: ResourceType.Sound, number: sound })) {
+        add(ResourceType.Sound, sound, [obj.name, where, ...(owner ? [owner] : [])], { label: `${obj.name} in ${where}` });
+      }
+      if (!script.isRoom && obj.name) add(ResourceType.Script, script.number, [obj.name]);
+    }
+  }
+  return out;
+}
+
+/** Whether every word of `query` is in the asset's number, tags or descriptions. */
+export function matches(query: string, number: number, meta: AssetMeta | undefined): boolean {
+  const words = query.toLowerCase().split(/\s+/).filter(Boolean);
+  if (!words.length) return true;
+  const haystack = [String(number), ...(meta?.tags ?? []), ...(meta?.uses.flatMap((u) => [u.label, u.text ?? ""]) ?? [])].join(" ").toLowerCase();
+  return words.every((w) => haystack.includes(w));
+}

package/apps/viewer/src/audio.d.ts

@@ -0,0 +1,28 @@
+import { type AudioClip, type AudioOutput, type FileSource } from "../../../packages/sci/src/index.ts";
+/**
+ * Plays digital clips through Web Audio. Clips are fetched (HTTP range requests into the
+ * 515 MB RESOURCE.AUD), decoded from SOL and cached. Browsers only allow audio after a
+ * user gesture, so `unlock()` must be called from a click/keypress handler.
+ */
+export declare class WebAudioOutput implements AudioOutput {
+    private readonly files;
+    private readonly preloaded;
+    readonly ctx: AudioContext;
+    private readonly buffers;
+    private readonly playing;
+    private readonly paused;
+    /** Incremented per play/stop so late-arriving decodes don't start stale clips. */
+    private readonly tokens;
+    constructor(files: FileSource, preloaded: (file: string) => Uint8Array | undefined);
+    unlock(): void;
+    private load;
+    private startNode;
+    play(channel: string, clip: AudioClip, { loop, volume }: {
+        loop: boolean;
+        volume: number;
+    }): void;
+    stop(channel: string): void;
+    pause(channel: string): void;
+    resume(channel: string): void;
+    setVolume(channel: string, volume: number): void;
+}

package/apps/viewer/src/audio.js

@@ -0,0 +1,102 @@
+import { decodeSol } from "../../../packages/sci/src/index.js";
+/**
+ * Plays digital clips through Web Audio. Clips are fetched (HTTP range requests into the
+ * 515 MB RESOURCE.AUD), decoded from SOL and cached. Browsers only allow audio after a
+ * user gesture, so `unlock()` must be called from a click/keypress handler.
+ */
+export class WebAudioOutput {
+    files;
+    preloaded;
+    ctx = new AudioContext();
+    buffers = new Map();
+    playing = new Map();
+    paused = new Map();
+    /** Incremented per play/stop so late-arriving decodes don't start stale clips. */
+    tokens = new Map();
+    constructor(files, preloaded) {
+        this.files = files;
+        this.preloaded = preloaded;
+    }
+    unlock() {
+        if (this.ctx.state !== "running")
+            void this.ctx.resume();
+    }
+    load(clip) {
+        const key = `${clip.file}:${clip.offset}`;
+        let p = this.buffers.get(key);
+        if (!p) {
+            p = (async () => {
+                const whole = this.preloaded(clip.file);
+                const bytes = whole ? whole.subarray(clip.offset, clip.offset + clip.length) : await this.files.readRange(clip.file, clip.offset, clip.length);
+                const sol = decodeSol(bytes);
+                if (!sol || !sol.samples.length)
+                    return undefined;
+                const frames = sol.samples.length / sol.channels;
+                const buffer = this.ctx.createBuffer(sol.channels, frames, sol.rate);
+                for (let c = 0; c < sol.channels; c++) {
+                    const data = buffer.getChannelData(c);
+                    for (let i = 0; i < frames; i++)
+                        data[i] = sol.samples[i * sol.channels + c];
+                }
+                return buffer;
+            })();
+            this.buffers.set(key, p);
+        }
+        return p;
+    }
+    startNode(channel, buffer, offset, loop, volume) {
+        const gain = this.ctx.createGain();
+        gain.gain.value = volume;
+        gain.connect(this.ctx.destination);
+        const source = this.ctx.createBufferSource();
+        source.buffer = buffer;
+        source.loop = loop;
+        source.connect(gain);
+        source.onended = () => {
+            if (this.playing.get(channel)?.source === source)
+                this.playing.delete(channel);
+        };
+        source.start(0, offset);
+        this.playing.set(channel, { source, gain, buffer, startedAt: this.ctx.currentTime - offset, offset, loop });
+    }
+    play(channel, clip, { loop, volume }) {
+        this.stop(channel);
+        const token = (this.tokens.get(channel) ?? 0) + 1;
+        this.tokens.set(channel, token);
+        void this.load(clip).then((buffer) => {
+            if (!buffer || this.tokens.get(channel) !== token)
+                return;
+            this.startNode(channel, buffer, 0, loop, volume);
+        });
+    }
+    stop(channel) {
+        this.tokens.set(channel, (this.tokens.get(channel) ?? 0) + 1);
+        this.paused.delete(channel);
+        const p = this.playing.get(channel);
+        if (!p)
+            return;
+        this.playing.delete(channel);
+        p.source.onended = null;
+        p.source.stop();
+        p.gain.disconnect();
+    }
+    pause(channel) {
+        const p = this.playing.get(channel);
+        if (!p)
+            return;
+        this.stop(channel);
+        this.paused.set(channel, { ...p, offset: (this.ctx.currentTime - p.startedAt) % p.buffer.duration });
+    }
+    resume(channel) {
+        const p = this.paused.get(channel);
+        if (!p)
+            return;
+        this.paused.delete(channel);
+        this.startNode(channel, p.buffer, p.offset, p.loop, p.gain.gain.value);
+    }
+    setVolume(channel, volume) {
+        const p = this.playing.get(channel);
+        if (p)
+            p.gain.gain.value = volume;
+    }
+}

package/apps/viewer/src/audio.ts

@@ -0,0 +1,110 @@
+import { decodeSol, type AudioClip, type AudioOutput, type FileSource } from "../../../packages/sci/src/index.ts";
+
+interface Playing {
+  source: AudioBufferSourceNode;
+  gain: GainNode;
+  buffer: AudioBuffer;
+  startedAt: number;
+  offset: number;
+  loop: boolean;
+}
+
+/**
+ * Plays digital clips through Web Audio. Clips are fetched (HTTP range requests into the
+ * 515 MB RESOURCE.AUD), decoded from SOL and cached. Browsers only allow audio after a
+ * user gesture, so `unlock()` must be called from a click/keypress handler.
+ */
+export class WebAudioOutput implements AudioOutput {
+  readonly ctx = new AudioContext();
+  private readonly buffers = new Map<string, Promise<AudioBuffer | undefined>>();
+  private readonly playing = new Map<string, Playing>();
+  private readonly paused = new Map<string, Playing>();
+  /** Incremented per play/stop so late-arriving decodes don't start stale clips. */
+  private readonly tokens = new Map<string, number>();
+
+  constructor(
+    private readonly files: FileSource,
+    private readonly preloaded: (file: string) => Uint8Array | undefined,
+  ) {}
+
+  unlock(): void {
+    if (this.ctx.state !== "running") void this.ctx.resume();
+  }
+
+  private load(clip: AudioClip): Promise<AudioBuffer | undefined> {
+    const key = `${clip.file}:${clip.offset}`;
+    let p = this.buffers.get(key);
+    if (!p) {
+      p = (async () => {
+        const whole = this.preloaded(clip.file);
+        const bytes = whole ? whole.subarray(clip.offset, clip.offset + clip.length) : await this.files.readRange(clip.file, clip.offset, clip.length);
+        const sol = decodeSol(bytes);
+        if (!sol || !sol.samples.length) return undefined;
+        const frames = sol.samples.length / sol.channels;
+        const buffer = this.ctx.createBuffer(sol.channels, frames, sol.rate);
+        for (let c = 0; c < sol.channels; c++) {
+          const data = buffer.getChannelData(c);
+          for (let i = 0; i < frames; i++) data[i] = sol.samples[i * sol.channels + c]!;
+        }
+        return buffer;
+      })();
+      this.buffers.set(key, p);
+    }
+    return p;
+  }
+
+  private startNode(channel: string, buffer: AudioBuffer, offset: number, loop: boolean, volume: number): void {
+    const gain = this.ctx.createGain();
+    gain.gain.value = volume;
+    gain.connect(this.ctx.destination);
+    const source = this.ctx.createBufferSource();
+    source.buffer = buffer;
+    source.loop = loop;
+    source.connect(gain);
+    source.onended = () => {
+      if (this.playing.get(channel)?.source === source) this.playing.delete(channel);
+    };
+    source.start(0, offset);
+    this.playing.set(channel, { source, gain, buffer, startedAt: this.ctx.currentTime - offset, offset, loop });
+  }
+
+  play(channel: string, clip: AudioClip, { loop, volume }: { loop: boolean; volume: number }): void {
+    this.stop(channel);
+    const token = (this.tokens.get(channel) ?? 0) + 1;
+    this.tokens.set(channel, token);
+    void this.load(clip).then((buffer) => {
+      if (!buffer || this.tokens.get(channel) !== token) return;
+      this.startNode(channel, buffer, 0, loop, volume);
+    });
+  }
+
+  stop(channel: string): void {
+    this.tokens.set(channel, (this.tokens.get(channel) ?? 0) + 1);
+    this.paused.delete(channel);
+    const p = this.playing.get(channel);
+    if (!p) return;
+    this.playing.delete(channel);
+    p.source.onended = null;
+    p.source.stop();
+    p.gain.disconnect();
+  }
+
+  pause(channel: string): void {
+    const p = this.playing.get(channel);
+    if (!p) return;
+    this.stop(channel);
+    this.paused.set(channel, { ...p, offset: (this.ctx.currentTime - p.startedAt) % p.buffer.duration });
+  }
+
+  resume(channel: string): void {
+    const p = this.paused.get(channel);
+    if (!p) return;
+    this.paused.delete(channel);
+    this.startNode(channel, p.buffer, p.offset, p.loop, p.gain.gain.value);
+  }
+
+  setVolume(channel: string, volume: number): void {
+    const p = this.playing.get(channel);
+    if (p) p.gain.gain.value = volume;
+  }
+}

package/apps/viewer/src/editor-handles.d.ts

@@ -0,0 +1,63 @@
+/**
+ * Direct manipulation for the room editor: handles drawn from the room's YAML over the
+ * game, which turn drags and brush strokes into edits of the YAML text. Edits replace only
+ * the value they change (a `[x, y]`, a `[l, t, r, b]`, a list of points), so comments and
+ * layout stay as written.
+ */
+type Point = [number, number];
+type Path = (string | number)[];
+/** `text` with the value at `path` replaced by `value`, keeping the rest as written. */
+export declare function setYamlValue(text: string, path: Path, value: number[] | Point[]): string;
+/** `text` with `value` added at the end of the list at `path` (made if missing). */
+export declare function appendYamlItem(text: string, path: Path, value: Point[]): string;
+export type EditMode = "play" | "move" | "floor" | "obstacle";
+export interface EditHost {
+    /** The room's YAML as it is in the editor now. */
+    yaml(): string;
+    /** Replaces the YAML in the editor (an undoable edit). */
+    setYaml(text: string): void;
+    /** Where the room plane is on screen (game pixels). */
+    roomOffset(): Point;
+    /** A prop's drawn box right now (room coordinates), to grab it by. */
+    spriteBox(name: string): {
+        x: number;
+        y: number;
+        w: number;
+        h: number;
+    } | undefined;
+    /** Moves a prop in the running game while it's dragged (the rebuild makes it stick). */
+    previewProp(name: string, at: Point): void;
+    /** Hold rebuilding while a drag or stroke is in progress. */
+    holdBuild(hold: boolean): void;
+}
+/**
+ * An SVG layer over the game. In "move" mode, everything the YAML places has a handle;
+ * "floor" and "obstacle" are brushes that draw a polygon. In "play" it's out of the way.
+ */
+export declare class EditLayer {
+    private readonly host;
+    readonly svg: SVGSVGElement;
+    mode: EditMode;
+    private spec;
+    private specText;
+    private drag;
+    private stroke;
+    private lastWrite;
+    constructor(host: EditHost);
+    setMode(mode: EditMode): void;
+    /** Room coordinates under the pointer. */
+    private point;
+    private readSpec;
+    render(): void;
+    private begin;
+    /** Keep getting the pointer's moves outside the layer (not for synthetic events). */
+    private capture;
+    private down;
+    private move;
+    private up;
+    /** The stroke so far as a polygon in the YAML (simplified to its corners). */
+    private writeStroke;
+}
+/** Ramer-Douglas-Peucker: drop points within `epsilon` of the line through their neighbours. */
+export declare function simplify(points: Point[], epsilon: number): Point[];
+export {};