1681-engine 0.0.0-stage → 0.5.9

package/dist/types/input/AimGesture.d.ts

@@ -0,0 +1,106 @@
+/**
+ * The drag-to-aim gesture of a touch skill button (the MOBA way), kept pure so it can be tested. Pressing an aimed
+ * button opens a circle round it with a knob under the thumb; where the knob sits in that circle is where the skill
+ * goes. A press that never wanders past the tap slop is a tap (the game casts it the way a tap always does: at the
+ * locked target, the nearest enemy, the facing). Letting go over a cancel zone casts nothing; letting go with the knob
+ * back on the button casts as a tap, or cancels when `centreCancels` (the one way to cancel when there is no zone).
+ *
+ * The thumb gets a longer slop in the first `pressMs` of a press: a hard press slides as it lands, and a quick tap
+ * that slid past the plain slop became a drag that flew wherever the slide pointed.
+ *
+ * ```ts
+ * const g = new AimGesture({ radius: 90, centreCancels: !hasCancelZone });
+ * // pointermove:  g.move(dx, dy, overCancelZone, now - downAt)
+ * // pointerup:    const end = g.up(); // 'tap' | 'cast' | 'cancel'
+ * // while g.aiming, draw the aim from aimPoint(caster, shape, g.share, facing)
+ * ```
+ */
+export type AimEnd = 'tap' | 'cast' | 'cancel';
+export interface AimGestureOptions {
+    /** The circle's radius, in the same units as the thumb's offsets (CSS px). */
+    radius: number;
+    /** Scales the thumb's travel into the knob's (a sensitivity setting); the slops stay the thumb's own (default 1). */
+    sensitivity?: number;
+    /** The knob let go back on the button cancels rather than casting as a tap (default true). */
+    centreCancels?: boolean;
+    /** How far the thumb may wander before a press is a drag (default 10). */
+    tapSlop?: number;
+    /** The slop in a press's first `pressMs` (default 28). */
+    earlySlop?: number;
+    /** How long a press is "landing" (default 180 ms). */
+    pressMs?: number;
+    /** Inside this share of the radius the knob is back on the button (default 0.2). */
+    centre?: number;
+}
+export declare const AIM_TAP_SLOP = 10;
+export declare const AIM_EARLY_SLOP = 28;
+export declare const AIM_PRESS_MS = 180;
+export declare const AIM_CENTRE = 0.2;
+/**
+ * How far the thumb must wander, `ms` into a press, before it drags. `early` false keeps the plain slop throughout
+ * (an attack button with nothing locked: there a slide is as good as a drag).
+ */
+export declare function dragSlop(ms: number, early?: boolean, tapSlop?: number, earlySlop?: number, pressMs?: number): number;
+type Point = {
+    x: number;
+    y: number;
+};
+export declare class AimGesture {
+    private dragged;
+    private over;
+    /** Where the knob is drawn, clamped to the circle, relative to the button's centre. */
+    knob: Point;
+    /** The knob as a vector of length ≤ 1: what the world reads. */
+    share: Point;
+    private readonly radius;
+    private readonly sensitivity;
+    private readonly centreCancels;
+    private readonly tapSlop;
+    private readonly earlySlop;
+    private readonly pressMs;
+    private readonly centre;
+    constructor(options: AimGestureOptions);
+    /**
+     * The thumb at `rawX, rawY` from the button's centre, `overCancel` when it is over the cancel zone, `ms` since it
+     * went down (Infinity skips the landing slop). Once a drag, always a drag for this press.
+     */
+    move(rawX: number, rawY: number, overCancel?: boolean, ms?: number): void;
+    /** A drag has begun: show the aim from now on. */
+    get aiming(): boolean;
+    private get centred();
+    /** Letting go now would cast nothing (draw the cancel zone lit). */
+    get cancelling(): boolean;
+    up(): AimEnd;
+}
+/**
+ * How a skill is aimed: at a spot within `range` (a blast, a blink), or along a direction for `length` (a shot, a
+ * dash; `backwards` for a leap away from the aim).
+ */
+export type AimShape = {
+    kind: 'point';
+    range: number;
+} | {
+    kind: 'direction';
+    length: number;
+    backwards?: boolean;
+    snap?: number;
+};
+/**
+ * How far out a spot skill's knob puts it, as a share of its range: from the centre ring's edge to the rim is the
+ * whole reach, so a knob just out of the ring lands at the caster's feet — with `share × range`, nothing nearer than
+ * the ring could ever be reached.
+ */
+export declare function spotReach(len: number, centre?: number): number;
+/** The knob that puts a spot skill `dx, dy` from the caster: `spotReach`'s inverse (aim assist, replays). */
+export declare function spotShare(dx: number, dy: number, range: number, centre?: number): Point;
+/**
+ * Where an aimed skill goes, as a mouse would have said it: the aim angle and the ground point. A knob with no length
+ * keeps `lastAim`. A direction may snap to `snap` radians (0 or none for free aim).
+ */
+export declare function aimPoint(from: Point, shape: AimShape, share: Point, lastAim: number, centre?: number): {
+    aim: number;
+    x: number;
+    y: number;
+};
+export {};
+//# sourceMappingURL=AimGesture.d.ts.map

package/dist/types/input/AimGesture.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AimGesture.d.ts","sourceRoot":"","sources":["../../../src/input/AimGesture.ts"],"names":[],"mappings":"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"}

package/dist/types/input/Keyboard.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Which keys are held, by `KeyboardEvent.code` (the physical key, so WASD stays WASD on any layout). `pressed` and
+ * `released` report edges since the last `endStep`; call that once per simulation step so a tap shorter than a frame
+ * is still seen by exactly one step.
+ *
+ * It only knows keys pressed **after** it was made: a key already held when it is created (the Enter that started a
+ * level, held into it) is not down here until it is pressed again. A scene that makes its own keyboard in a field
+ * therefore starts with every key up, which is usually what a new screen wants; share one keyboard across scenes when
+ * a held key must carry over. Modifier keys are ordinary codes here (`ShiftLeft`); `Actions` reads chords from them.
+ */
+export declare class Keyboard {
+    private readonly held;
+    private readonly down;
+    private readonly up;
+    private readonly cleanup;
+    constructor(target?: Window | HTMLElement);
+    isDown(code: string): boolean;
+    /** Any of these keys is held. */
+    anyDown(...codes: string[]): boolean;
+    /** Went down since the last `endStep`. */
+    pressed(code: string): boolean;
+    /** Came up since the last `endStep`. */
+    released(code: string): boolean;
+    /** -1, 0 or 1 from two sets of keys: `axis(['KeyA', 'ArrowLeft'], ['KeyD', 'ArrowRight'])`. */
+    axis(negative: string[], positive: string[]): number;
+    /** Forgets this step's edges; held keys stay held. */
+    endStep(): void;
+    destroy(): void;
+}
+//# sourceMappingURL=Keyboard.d.ts.map

package/dist/types/input/Keyboard.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Keyboard.d.ts","sourceRoot":"","sources":["../../../src/input/Keyboard.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AACH,qBAAa,QAAQ;IACnB,OAAO,CAAC,QAAQ,CAAC,IAAI,CAAqB;IAC1C,OAAO,CAAC,QAAQ,CAAC,IAAI,CAAqB;IAC1C,OAAO,CAAC,QAAQ,CAAC,EAAE,CAAqB;IACxC,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAsB;gBAElC,MAAM,GAAE,MAAM,GAAG,WAAoB;IA2BjD,MAAM,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO;IAI7B,iCAAiC;IACjC,OAAO,CAAC,GAAG,KAAK,EAAE,MAAM,EAAE,GAAG,OAAO;IAIpC,0CAA0C;IAC1C,OAAO,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO;IAI9B,wCAAwC;IACxC,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO;IAI/B,+FAA+F;IAC/F,IAAI,CAAC,QAAQ,EAAE,MAAM,EAAE,EAAE,QAAQ,EAAE,MAAM,EAAE,GAAG,MAAM;IAIpD,sDAAsD;IACtD,OAAO,IAAI,IAAI;IAKf,OAAO,IAAI,IAAI;CAKhB"}

package/dist/types/input/Keymap.d.ts

@@ -0,0 +1,85 @@
+import type { Actions } from './Actions.js';
+/**
+ * Which keys each action sits on, as the player has rebound them: one table the input, the key hints on screen and
+ * a settings screen all read. A binding is a `KeyboardEvent.code` (`KeyW`, `Digit1`), so it means the same physical
+ * key on every layout. Each action keeps a list (W and ArrowUp, 1 and Q); a settings screen edits the **first** and
+ * leaves the alternates alone.
+ *
+ * Two rules: one key serves one action at a time (a key bound twice would fire both, and the player could not tell
+ * which they meant), and reserved keys (Escape, Enter, Tab by default: the interface's own) are never taken.
+ *
+ * Inputs the player cannot rebind — the gamepad's, a touch button, a reserved key an action should still answer to
+ * (Escape also pausing) — are the keymap's **fixed** inputs: given once to the constructor, laid after the player's
+ * keys by `applyTo`, and untouched by either rule above.
+ *
+ * ```ts
+ * const keys = new Keymap({ jump: ['Space'], left: ['KeyA', 'ArrowLeft'], pause: ['KeyP'] }, undefined, { jump: ['pad:a'], pause: ['Escape'] });
+ * keys.load(keymapStorage('my-game.keys').read());
+ * keys.onChange(() => { keys.applyTo(actions); storage.write(keys.toJSON()); });
+ * keys.bind('pause', 'KeyA'); // 'left' keeps only ArrowLeft
+ * ```
+ */
+export declare class Keymap<A extends string> {
+    private binds;
+    private readonly defaults;
+    private readonly reserved;
+    private readonly fixed;
+    private readonly listeners;
+    /**
+     * `reserved`: keys never bound (default Escape, Enter, Tab; pass `undefined` for the default). `fixed`: inputs each
+     * action always has besides the player's keys (gamepad, touch, a reserved key), never saved or rebound.
+     */
+    constructor(defaults: Readonly<Record<A, readonly string[]>>, reserved?: Iterable<string>, fixed?: Partial<Record<A, readonly string[]>>);
+    private fresh;
+    /** Every action, in the order the defaults named them. */
+    actions(): A[];
+    isReserved(code: string): boolean;
+    /** The keys of one action; the first is the one a settings screen shows and edits. */
+    keysFor(action: A): readonly string[];
+    /** The inputs an action always has besides the player's keys (the constructor's `fixed`). */
+    fixedFor(action: A): readonly string[];
+    /** Which action a key belongs to, or undefined. */
+    actionFor(code: string): A | undefined;
+    /**
+     * Puts `code` first on `action`, taking it off whatever else held it; returns the actions that lost it (to tell the
+     * player). A reserved key is refused (returns null). An action stripped of its last key keeps none: it is unbound
+     * until something is put back on it.
+     */
+    bind(action: A, code: string): A[] | null;
+    /** Takes every key off `action`. */
+    unbind(action: A): void;
+    /** Every action back on its defaults. */
+    reset(): void;
+    /** A plain object to store wherever the game keeps its settings. */
+    toJSON(): Record<A, string[]>;
+    /**
+     * A saved set laid over this build's defaults. Only actions this build knows are read, so an old save cannot leave
+     * a key bound to nothing; an action newer than the save keeps its defaults only where no saved action holds that key
+     * (the saved one is what the player chose). Anything malformed is ignored.
+     */
+    load(saved: unknown): void;
+    /**
+     * Hands the bindings to an `Actions`: each action's keys, then its fixed inputs, then its `extra` ones. Only the
+     * keymap's actions are bound, so the `Actions` may hold more (menu actions alongside the rebindable ones, each on
+     * its own fixed inputs); those are left as they are. Fixed and extra inputs are the game's, so neither the reserved
+     * keys nor one-key-one-action apply to them.
+     */
+    applyTo<B extends string>(actions: Actions<A | B>, extra?: Partial<Record<A, readonly string[]>>): void;
+    /** Called after every change; returns a function that stops it. */
+    onChange(fn: () => void): () => void;
+    private changed;
+}
+/** `saved` laid over `defaults` by `Keymap.load`'s rules, as a fresh object. */
+export declare function mergeKeymap<A extends string>(defaults: Readonly<Record<A, readonly string[]>>, saved: unknown, reserved?: ReadonlySet<string>): Record<A, string[]>;
+/** A place to keep a keymap in the browser, under a key the game names; every failure falls back quietly. */
+export declare function keymapStorage(key: string): {
+    read(): unknown;
+    write(binds: object): void;
+    clear(): void;
+};
+/**
+ * How a key code reads on screen: "KeyW" is W, "Digit1" is 1, "Numpad3" is "Num 3", a chord "Shift+Tab" each part in
+ * turn. `names` overrides any code or modifier (a game's own language for the arrows and modifiers).
+ */
+export declare function keyLabel(code: string, names?: Readonly<Record<string, string>>): string;
+//# sourceMappingURL=Keymap.d.ts.map

package/dist/types/input/Keymap.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Keymap.d.ts","sourceRoot":"","sources":["../../../src/input/Keymap.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAEzC;;;;;;;;;;;;;;;;;;;GAmBG;AACH,qBAAa,MAAM,CAAC,CAAC,SAAS,MAAM;IAClC,OAAO,CAAC,KAAK,CAAsB;IACnC,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAA+B;IACxD,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAsB;IAC/C,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAwC;IAC9D,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAsB;IAEhD;;;OAGG;gBAED,QAAQ,EAAE,QAAQ,CAAC,MAAM,CAAC,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC,CAAC,EAChD,QAAQ,GAAE,QAAQ,CAAC,MAAM,CAA8B,EACvD,KAAK,GAAE,OAAO,CAAC,MAAM,CAAC,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC,CAAM;IAQnD,OAAO,CAAC,KAAK;IAMb,0DAA0D;IAC1D,OAAO,IAAI,CAAC,EAAE;IAId,UAAU,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO;IAIjC,sFAAsF;IACtF,OAAO,CAAC,MAAM,EAAE,CAAC,GAAG,SAAS,MAAM,EAAE;IAIrC,6FAA6F;IAC7F,QAAQ,CAAC,MAAM,EAAE,CAAC,GAAG,SAAS,MAAM,EAAE;IAItC,mDAAmD;IACnD,SAAS,CAAC,IAAI,EAAE,MAAM,GAAG,CAAC,GAAG,SAAS;IAKtC;;;;OAIG;IACH,IAAI,CAAC,MAAM,EAAE,CAAC,EAAE,IAAI,EAAE,MAAM,GAAG,CAAC,EAAE,GAAG,IAAI;IAczC,oCAAoC;IACpC,MAAM,CAAC,MAAM,EAAE,CAAC,GAAG,IAAI;IAMvB,yCAAyC;IACzC,KAAK,IAAI,IAAI;IAKb,oEAAoE;IACpE,MAAM,IAAI,MAAM,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC;IAM7B;;;;OAIG;IACH,IAAI,CAAC,KAAK,EAAE,OAAO,GAAG,IAAI;IAK1B;;;;;OAKG;IACH,OAAO,CAAC,CAAC,SAAS,MAAM,EAAE,OAAO,EAAE,OAAO,CAAC,CAAC,GAAG,CAAC,CAAC,EAAE,KAAK,GAAE,OAAO,CAAC,MAAM,CAAC,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC,CAAM,GAAG,IAAI;IAI3G,mEAAmE;IACnE,QAAQ,CAAC,EAAE,EAAE,MAAM,IAAI,GAAG,MAAM,IAAI;IAQpC,OAAO,CAAC,OAAO;CAGhB;AAED,gFAAgF;AAChF,wBAAgB,WAAW,CAAC,CAAC,SAAS,MAAM,EAC1C,QAAQ,EAAE,QAAQ,CAAC,MAAM,CAAC,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC,CAAC,EAChD,KAAK,EAAE,OAAO,EACd,QAAQ,GAAE,WAAW,CAAC,MAAM,CAAa,GACxC,MAAM,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,CAwBrB;AAED,6GAA6G;AAC7G,wBAAgB,aAAa,CAAC,GAAG,EAAE,MAAM,GAAG;IAAE,IAAI,IAAI,OAAO,CAAC;IAAC,KAAK,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC;IAAC,KAAK,IAAI,IAAI,CAAA;CAAE,CAiCzG;AA2BD;;;GAGG;AACH,wBAAgB,QAAQ,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,GAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAM,GAAG,MAAM,CAQ3F"}

package/dist/types/input/TargetLock.d.ts

@@ -0,0 +1,56 @@
+/**
+ * Picking and holding a target on a touch screen, kept pure so it can be tested. Dragging an attack button points:
+ * the body lying closest to that direction is picked (and of two about as close to it, the nearer). A target button
+ * picks the nearest. The lock then holds — every attack, skill and the facing goes at it, even while a stick walks
+ * the body elsewhere — until that body is gone or leaves `keepRange`; a later drag that points at nothing keeps it.
+ *
+ * Bodies come from a callback as `{ id, x, y }`: the game decides what may be locked (monsters, a duel's opponent).
+ */
+export interface LockBody {
+    id: number;
+    x: number;
+    y: number;
+}
+type Point = {
+    x: number;
+    y: number;
+};
+export declare const LOCK_PICK_RANGE = 220;
+export declare const LOCK_KEEP_RANGE = 300;
+/** Widest angle off the drag a body may stand and still be picked: 50° each side. */
+export declare const LOCK_PICK_CONE: number;
+/**
+ * The body a drag in direction `dir` (any length > 0) picks from `from`, or null. Scored by how far off the drag's
+ * line it stands, with distance as a lighter second weight, so a far body dead ahead beats a near one off to the side.
+ */
+export declare function pickTarget(from: Point, dir: Point, bodies: readonly LockBody[], range?: number, cone?: number): number | null;
+/** The nearest body within `range` (ties to the lower id, so two clients pick alike), or null. */
+export declare function nearestTarget(from: Point, bodies: readonly LockBody[], range?: number): number | null;
+/** The locked body while the lock still holds (present, within `range`), else null. */
+export declare function keptTarget<T extends LockBody>(from: Point, locked: number | null, bodies: readonly T[], range?: number): T | null;
+export interface TargetLockOptions {
+    pickRange?: number;
+    keepRange?: number;
+    /** Half-angle (radians) a drag picks within. */
+    cone?: number;
+}
+/** The lock as state: which body is held, picked by a drag or the nearest, let go when it is gone or too far. */
+export declare class TargetLock<T extends LockBody = LockBody> {
+    private readonly bodies;
+    private id;
+    private readonly pickRange;
+    private readonly keepRange;
+    private readonly cone;
+    constructor(bodies: () => readonly T[], options?: TargetLockOptions);
+    /** The id held, without checking it still stands (use `current` for that). */
+    get locked(): number | null;
+    /** A drag in `dir` from `from`: locks what it points at; pointing at nothing keeps the old lock. */
+    pick(from: Point, dir: Point): number | null;
+    /** Locks the nearest body, every call, whatever was held. */
+    pickNearest(from: Point): number | null;
+    /** The held body if it still holds; a lock that no longer does is dropped. */
+    current(from: Point): T | null;
+    clear(): void;
+}
+export {};
+//# sourceMappingURL=TargetLock.d.ts.map

package/dist/types/input/TargetLock.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"TargetLock.d.ts","sourceRoot":"","sources":["../../../src/input/TargetLock.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,MAAM,WAAW,QAAQ;IACvB,EAAE,EAAE,MAAM,CAAC;IACX,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACX;AAED,KAAK,KAAK,GAAG;IAAE,CAAC,EAAE,MAAM,CAAC;IAAC,CAAC,EAAE,MAAM,CAAA;CAAE,CAAC;AAEtC,eAAO,MAAM,eAAe,MAAM,CAAC;AACnC,eAAO,MAAM,eAAe,MAAM,CAAC;AACnC,qFAAqF;AACrF,eAAO,MAAM,cAAc,QAAuB,CAAC;AAUnD;;;GAGG;AACH,wBAAgB,UAAU,CAAC,IAAI,EAAE,KAAK,EAAE,GAAG,EAAE,KAAK,EAAE,MAAM,EAAE,SAAS,QAAQ,EAAE,EAAE,KAAK,SAAkB,EAAE,IAAI,SAAiB,GAAG,MAAM,GAAG,IAAI,CAmB9I;AAED,kGAAkG;AAClG,wBAAgB,aAAa,CAAC,IAAI,EAAE,KAAK,EAAE,MAAM,EAAE,SAAS,QAAQ,EAAE,EAAE,KAAK,SAAkB,GAAG,MAAM,GAAG,IAAI,CAY9G;AAED,uFAAuF;AACvF,wBAAgB,UAAU,CAAC,CAAC,SAAS,QAAQ,EAAE,IAAI,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,GAAG,IAAI,EAAE,MAAM,EAAE,SAAS,CAAC,EAAE,EAAE,KAAK,SAAkB,GAAG,CAAC,GAAG,IAAI,CAK1I;AAED,MAAM,WAAW,iBAAiB;IAChC,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,gDAAgD;IAChD,IAAI,CAAC,EAAE,MAAM,CAAC;CACf;AAED,iHAAiH;AACjH,qBAAa,UAAU,CAAC,CAAC,SAAS,QAAQ,GAAG,QAAQ;IAOjD,OAAO,CAAC,QAAQ,CAAC,MAAM;IANzB,OAAO,CAAC,EAAE,CAAuB;IACjC,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAS;IACnC,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAS;IACnC,OAAO,CAAC,QAAQ,CAAC,IAAI,CAAS;gBAGX,MAAM,EAAE,MAAM,SAAS,CAAC,EAAE,EAC3C,OAAO,GAAE,iBAAsB;IAOjC,8EAA8E;IAC9E,IAAI,MAAM,IAAI,MAAM,GAAG,IAAI,CAE1B;IAED,oGAAoG;IACpG,IAAI,CAAC,IAAI,EAAE,KAAK,EAAE,GAAG,EAAE,KAAK,GAAG,MAAM,GAAG,IAAI;IAM5C,6DAA6D;IAC7D,WAAW,CAAC,IAAI,EAAE,KAAK,GAAG,MAAM,GAAG,IAAI;IAKvC,8EAA8E;IAC9E,OAAO,CAAC,IAAI,EAAE,KAAK,GAAG,CAAC,GAAG,IAAI;IAM9B,KAAK,IAAI,IAAI;CAGd"}

package/dist/types/input/aimAxis.d.ts

@@ -0,0 +1,9 @@
+/**
+ * An aim turned into the eight-way axis the keyboard makes (each part -1, 0 or 1; `stepMover` scales a diagonal),
+ * so a step sent along it is one a key could have sent. A part counts once the aim leans past 22.5° towards it.
+ */
+export declare function aimAxis(aim: number): {
+    dx: number;
+    dy: number;
+};
+//# sourceMappingURL=aimAxis.d.ts.map

package/dist/types/input/aimAxis.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"aimAxis.d.ts","sourceRoot":"","sources":["../../../src/input/aimAxis.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,wBAAgB,OAAO,CAAC,GAAG,EAAE,MAAM,GAAG;IAAE,EAAE,EAAE,MAAM,CAAC;IAAC,EAAE,EAAE,MAAM,CAAA;CAAE,CAK/D"}

package/dist/types/input/keyChord.d.ts

@@ -0,0 +1,15 @@
+/**
+ * A key binding with modifiers: `Shift+Tab`, `Ctrl+KeyS`, `Ctrl+Shift+KeyZ`. The last part is the key's
+ * `KeyboardEvent.code`; before it, any of `Shift`, `Ctrl`, `Alt`, `Meta`, either side of the keyboard counting.
+ * A chord matches while its key and every modifier it names are held; modifiers it does not name are not looked at.
+ */
+export interface KeyChord {
+    code: string;
+    /** The modifiers' key codes, each a pair: either one held counts. */
+    modifiers: readonly (readonly [string, string])[];
+}
+/** The chord a binding names, or null for a plain key (no `+`) or a malformed one (an unknown modifier). */
+export declare function parseChord(binding: string): KeyChord | null;
+/** Whether `chord` is held, given which keys are down. */
+export declare function chordHeld(chord: KeyChord, down: (code: string) => boolean): boolean;
+//# sourceMappingURL=keyChord.d.ts.map

package/dist/types/input/keyChord.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"keyChord.d.ts","sourceRoot":"","sources":["../../../src/input/keyChord.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,MAAM,WAAW,QAAQ;IACvB,IAAI,EAAE,MAAM,CAAC;IACb,qEAAqE;IACrE,SAAS,EAAE,SAAS,CAAC,SAAS,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,EAAE,CAAC;CACnD;AASD,4GAA4G;AAC5G,wBAAgB,UAAU,CAAC,OAAO,EAAE,MAAM,GAAG,QAAQ,GAAG,IAAI,CAY3D;AAED,0DAA0D;AAC1D,wBAAgB,SAAS,CAAC,KAAK,EAAE,QAAQ,EAAE,IAAI,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,OAAO,GAAG,OAAO,CAInF"}

package/dist/types/input/longPress.d.ts

@@ -0,0 +1,21 @@
+/**
+ * A long press, as pure timing so it can be tested: a finger that stays down `ms` without moving more than `slop`
+ * CSS px fires once, where it went down. A second finger, a move past the slop or a lift before the time is up is
+ * not a long press — a tap stays a tap. The caller owns the clock (`fire(now)` from a timer or a frame).
+ */
+export declare class LongPress {
+    readonly ms: number;
+    readonly slop: number;
+    private finger;
+    private done;
+    constructor(ms?: number, slop?: number);
+    down(id: number, x: number, y: number, now: number): void;
+    move(id: number, x: number, y: number): void;
+    up(id: number): void;
+    /** Where the press is, the first time this is asked at or after `ms`; null otherwise. */
+    fire(now: number): {
+        x: number;
+        y: number;
+    } | null;
+}
+//# sourceMappingURL=longPress.d.ts.map

package/dist/types/input/longPress.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"longPress.d.ts","sourceRoot":"","sources":["../../../src/input/longPress.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,qBAAa,SAAS;IAKlB,QAAQ,CAAC,EAAE;IACX,QAAQ,CAAC,IAAI;IALf,OAAO,CAAC,MAAM,CAAiE;IAC/E,OAAO,CAAC,IAAI,CAAS;gBAGV,EAAE,SAAM,EACR,IAAI,SAAK;IAGpB,IAAI,CAAC,EAAE,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,IAAI;IAWzD,IAAI,CAAC,EAAE,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,IAAI;IAK5C,EAAE,CAAC,EAAE,EAAE,MAAM,GAAG,IAAI;IAKpB,yFAAyF;IACzF,IAAI,CAAC,GAAG,EAAE,MAAM,GAAG;QAAE,CAAC,EAAE,MAAM,CAAC;QAAC,CAAC,EAAE,MAAM,CAAA;KAAE,GAAG,IAAI;CAMnD"}

package/dist/types/input/rumble.d.ts

@@ -0,0 +1,41 @@
+/**
+ * Gamepad rumble through the Gamepad Extensions' `vibrationActuator` (`'dual-rumble'`: Chrome, Edge, Firefox behind a
+ * flag, Safari 16.4+). A pad without one, a browser without the API, or a refusal is a silent no-op that resolves
+ * false: rumble is seasoning, never something a game should wait on or crash over.
+ */
+export interface RumbleOptions {
+    /** The low-frequency (heavy) motor, 0–1 (default 0). */
+    strong?: number;
+    /** The high-frequency (light) motor, 0–1 (default 0). */
+    weak?: number;
+    /** How long it shakes (ms, default 200). */
+    durationMs?: number;
+    /** Wait before starting (ms, default 0). */
+    startDelayMs?: number;
+}
+/** What rumble needs of a pad; `navigator.getGamepads()` entries satisfy it where the API exists. */
+export interface RumblePad {
+    readonly vibrationActuator?: {
+        playEffect?(type: 'dual-rumble', params: {
+            duration: number;
+            startDelay: number;
+            strongMagnitude: number;
+            weakMagnitude: number;
+        }): Promise<unknown>;
+        reset?(): Promise<unknown>;
+    } | null;
+}
+/** The effect's parameters as the API wants them, clamped (pure, for tests and custom transports). */
+export declare function rumbleParams(options: RumbleOptions): {
+    duration: number;
+    startDelay: number;
+    strongMagnitude: number;
+    weakMagnitude: number;
+};
+/** Rumbles one pad directly; resolves true when the effect played to its end. */
+export declare function rumblePad(pad: RumblePad | null | undefined, options: RumbleOptions): Promise<boolean>;
+/** Rumbles the pad at `padIndex` (as in `navigator.getGamepads()`); resolves false where it cannot. */
+export declare function rumble(padIndex: number, options: RumbleOptions, pads?: () => readonly (RumblePad | null)[]): Promise<boolean>;
+/** Stops whatever the pad at `padIndex` is playing. */
+export declare function stopRumble(padIndex: number, pads?: () => readonly (RumblePad | null)[]): Promise<void>;
+//# sourceMappingURL=rumble.d.ts.map

package/dist/types/input/rumble.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rumble.d.ts","sourceRoot":"","sources":["../../../src/input/rumble.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,MAAM,WAAW,aAAa;IAC5B,wDAAwD;IACxD,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,yDAAyD;IACzD,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,4CAA4C;IAC5C,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,4CAA4C;IAC5C,YAAY,CAAC,EAAE,MAAM,CAAC;CACvB;AAED,qGAAqG;AACrG,MAAM,WAAW,SAAS;IACxB,QAAQ,CAAC,iBAAiB,CAAC,EAAE;QAC3B,UAAU,CAAC,CAAC,IAAI,EAAE,aAAa,EAAE,MAAM,EAAE;YAAE,QAAQ,EAAE,MAAM,CAAC;YAAC,UAAU,EAAE,MAAM,CAAC;YAAC,eAAe,EAAE,MAAM,CAAC;YAAC,aAAa,EAAE,MAAM,CAAA;SAAE,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;QACrJ,KAAK,CAAC,IAAI,OAAO,CAAC,OAAO,CAAC,CAAC;KAC5B,GAAG,IAAI,CAAC;CACV;AAOD,sGAAsG;AACtG,wBAAgB,YAAY,CAAC,OAAO,EAAE,aAAa,GAAG;IAAE,QAAQ,EAAE,MAAM,CAAC;IAAC,UAAU,EAAE,MAAM,CAAC;IAAC,eAAe,EAAE,MAAM,CAAC;IAAC,aAAa,EAAE,MAAM,CAAA;CAAE,CAS7I;AAQD,iFAAiF;AACjF,wBAAsB,SAAS,CAAC,GAAG,EAAE,SAAS,GAAG,IAAI,GAAG,SAAS,EAAE,OAAO,EAAE,aAAa,GAAG,OAAO,CAAC,OAAO,CAAC,CAY3G;AAED,uGAAuG;AACvG,wBAAgB,MAAM,CAAC,QAAQ,EAAE,MAAM,EAAE,OAAO,EAAE,aAAa,EAAE,IAAI,GAAE,MAAM,SAAS,CAAC,SAAS,GAAG,IAAI,CAAC,EAAkB,GAAG,OAAO,CAAC,OAAO,CAAC,CAE5I;AAED,uDAAuD;AACvD,wBAAsB,UAAU,CAAC,QAAQ,EAAE,MAAM,EAAE,IAAI,GAAE,MAAM,SAAS,CAAC,SAAS,GAAG,IAAI,CAAC,EAAkB,GAAG,OAAO,CAAC,IAAI,CAAC,CAM3H"}

package/dist/types/input/stickAxis.d.ts

@@ -0,0 +1,26 @@
+/**
+ * The virtual joystick's arithmetic, kept pure so it can be tested. The stick hands the game the **same** axis
+ * the keyboard does — `stepMover` clamps every step to -1/0/1 on each axis (movement is eight-way, and the server
+ * reads it the same way), so an analog stick would only be rounded there anyway. The rounding happens here instead,
+ * by eight 45° sectors, so a thumb held a little off the horizontal walks straight rather than flickering between
+ * east and north-east.
+ */
+/** Below this share of the stick's radius the thumb is resting: no movement, and the aim falls back (touchAim.ts). */
+export declare const STICK_DEAD_ZONE = 0.28;
+export interface StickVector {
+    x: number;
+    y: number;
+}
+/** The thumb's offset from where the stick was planted, as a vector of length at most 1 (radius = full tilt). */
+export declare function stickVector(dx: number, dy: number, radius: number): StickVector;
+/** True when the stick is tilted past the dead zone. */
+export declare function stickActive(v: StickVector, deadZone?: number): boolean;
+/**
+ * The keyboard-shaped axis for a stick vector: each of dx, dy is -1, 0 or 1 (screen y grows downward, as the
+ * keyboard's "down" does), nothing inside the dead zone, and the nearest of the eight directions otherwise.
+ */
+export declare function stickToAxis(v: StickVector, deadZone?: number): {
+    dx: number;
+    dy: number;
+};
+//# sourceMappingURL=stickAxis.d.ts.map

package/dist/types/input/stickAxis.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stickAxis.d.ts","sourceRoot":"","sources":["../../../src/input/stickAxis.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,sHAAsH;AACtH,eAAO,MAAM,eAAe,OAAO,CAAC;AAEpC,MAAM,WAAW,WAAW;IAC1B,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACX;AAED,iHAAiH;AACjH,wBAAgB,WAAW,CAAC,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,WAAW,CAM/E;AAED,wDAAwD;AACxD,wBAAgB,WAAW,CAAC,CAAC,EAAE,WAAW,EAAE,QAAQ,SAAkB,GAAG,OAAO,CAE/E;AAED;;;GAGG;AACH,wBAAgB,WAAW,CAAC,CAAC,EAAE,WAAW,EAAE,QAAQ,SAAkB,GAAG;IAAE,EAAE,EAAE,MAAM,CAAC;IAAC,EAAE,EAAE,MAAM,CAAA;CAAE,CAMlG"}

package/dist/types/input/touchDetect.d.ts

@@ -0,0 +1,18 @@
+/** What decides whether the touch controls are shown; read off the browser by `isTouchUi` (`platform/touch.ts`). */
+export interface TouchEnv {
+    /** Running inside a native shell (`setNativeShell`: Capacitor, a kiosk…). */
+    native: boolean;
+    /** `(pointer: coarse)` matches: the **primary** pointer is a finger. */
+    coarse: boolean;
+    /** `navigator.maxTouchPoints`. */
+    touchPoints: number;
+    /** `?touch=1|0` in the URL or `localStorage` (`setTouchOverrideKey`), for trying the controls on a desktop browser. */
+    override: string | null;
+}
+/**
+ * Touch controls only where a finger is the main way in: the native app always, a browser whose primary pointer
+ * is coarse and that reports touch points (a phone or tablet), never a desktop — a laptop with a touch screen
+ * still has a fine primary pointer and keeps its mouse and keyboard.
+ */
+export declare function detectTouch(env: TouchEnv): boolean;
+//# sourceMappingURL=touchDetect.d.ts.map

package/dist/types/input/touchDetect.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"touchDetect.d.ts","sourceRoot":"","sources":["../../../src/input/touchDetect.ts"],"names":[],"mappings":"AAAA,oHAAoH;AACpH,MAAM,WAAW,QAAQ;IACvB,6EAA6E;IAC7E,MAAM,EAAE,OAAO,CAAC;IAChB,wEAAwE;IACxE,MAAM,EAAE,OAAO,CAAC;IAChB,kCAAkC;IAClC,WAAW,EAAE,MAAM,CAAC;IACpB,uHAAuH;IACvH,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAC;CACzB;AAED;;;;GAIG;AACH,wBAAgB,WAAW,CAAC,GAAG,EAAE,QAAQ,GAAG,OAAO,CAKlD"}

package/dist/types/light/LightLayer.d.ts

@@ -0,0 +1,65 @@
+import type { Stage } from '../core/Stage.js';
+/** A light in the world. Change its fields any time (follow a body by writing `x`/`y` each frame). */
+export interface Light {
+    x: number;
+    y: number;
+    /** World px. */
+    radius: number;
+    /** The colour it casts on what it lights (default warm white). */
+    color?: number;
+    /** 0–1: how much of the dark it takes away, and how strong its colour (default 1). */
+    intensity?: number;
+    /** Radius wobble, 0–1 (a torch ≈ 0.08). */
+    flicker?: number;
+    /** A light off is kept but not drawn. */
+    on?: boolean;
+}
+export interface LightLayerOptions {
+    /** Colour of the dark (default deep blue). */
+    ambient?: number;
+    /** 0 no dark at all, 1 black where nothing is lit (default 0.85). */
+    darkness?: number;
+    /** How strongly lights tint what they light, 0–1 (default 0.35). */
+    tint?: number;
+    /** A light's height over its width: the ground is seen at a slant (default 1, round; a 3/4 view ≈ 0.85). */
+    squash?: number;
+}
+/**
+ * Smooth darkness with lights cut out of it, for art that is not pixel art (the pixel module has its own dithered
+ * `Darkness`). The dark is a screen-sized texture: each light erases a soft hole in it, and lays its colour over what
+ * shows through. It sits on the screen layer, over the world and under the HUD you add after it.
+ *
+ * ```ts
+ * const night = new LightLayer(stage, { darkness: 0.9 });
+ * const torch = night.add({ x: 100, y: 80, radius: 90, color: 0xffb060, flicker: 0.08 });
+ * // each frame: torch.x = hero.x; night.update(now);
+ * ```
+ */
+export declare class LightLayer {
+    private readonly stage;
+    private readonly lights;
+    private readonly scratch;
+    private readonly sheet;
+    private readonly holes;
+    private readonly washes;
+    private readonly view;
+    private rt;
+    private readonly pool;
+    private ambient;
+    private darkness;
+    private readonly tint;
+    private readonly squash;
+    private readonly unsubscribe;
+    constructor(stage: Stage, options?: LightLayerOptions);
+    add(light: Light): Light;
+    remove(light: Light): void;
+    clear(): void;
+    /** Changes the dark: its colour and how dark (a day/night cycle eases these). */
+    setAmbient(color: number, darkness: number): void;
+    /** Redraws the dark with this frame's lights. Call once a frame, after the camera moved. */
+    update(now?: number): void;
+    destroy(): void;
+    private sprites;
+    private fit;
+}
+//# sourceMappingURL=LightLayer.d.ts.map

package/dist/types/light/LightLayer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"LightLayer.d.ts","sourceRoot":"","sources":["../../../src/light/LightLayer.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,eAAe,CAAC;AAE3C,sGAAsG;AACtG,MAAM,WAAW,KAAK;IACpB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,gBAAgB;IAChB,MAAM,EAAE,MAAM,CAAC;IACf,kEAAkE;IAClE,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,sFAAsF;IACtF,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,2CAA2C;IAC3C,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,yCAAyC;IACzC,EAAE,CAAC,EAAE,OAAO,CAAC;CACd;AAED,MAAM,WAAW,iBAAiB;IAChC,8CAA8C;IAC9C,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,qEAAqE;IACrE,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,oEAAoE;IACpE,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,4GAA4G;IAC5G,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAyBD;;;;;;;;;;GAUG;AACH,qBAAa,UAAU;IAgBnB,OAAO,CAAC,QAAQ,CAAC,KAAK;IAfxB,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAoB;IAC3C,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAmB;IAC3C,OAAO,CAAC,QAAQ,CAAC,KAAK,CAA6B;IACnD,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAmB;IACzC,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAmB;IAC1C,OAAO,CAAC,QAAQ,CAAC,IAAI,CAAS;IAC9B,OAAO,CAAC,EAAE,CAAgB;IAC1B,OAAO,CAAC,QAAQ,CAAC,IAAI,CAAwC;IAC7D,OAAO,CAAC,OAAO,CAAS;IACxB,OAAO,CAAC,QAAQ,CAAS;IACzB,OAAO,CAAC,QAAQ,CAAC,IAAI,CAAS;IAC9B,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAS;IAChC,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAa;gBAGtB,KAAK,EAAE,KAAK,EAC7B,OAAO,GAAE,iBAAsB;IAgBjC,GAAG,CAAC,KAAK,EAAE,KAAK,GAAG,KAAK;IAKxB,MAAM,CAAC,KAAK,EAAE,KAAK,GAAG,IAAI;IAI1B,KAAK,IAAI,IAAI;IAIb,iFAAiF;IACjF,UAAU,CAAC,KAAK,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,IAAI;IAKjD,4FAA4F;IAC5F,MAAM,CAAC,GAAG,SAAoB,GAAG,IAAI;IAqCrC,OAAO,IAAI,IAAI;IASf,OAAO,CAAC,OAAO;IAgBf,OAAO,CAAC,GAAG;CAOZ"}

package/dist/types/nav/MinHeap.d.ts

@@ -0,0 +1,15 @@
+/**
+ * A binary min-heap of (index, priority) pairs, kept as two parallel arrays so a search over a big grid pushes
+ * numbers, not objects. A stale entry (pushed again at a lower priority) is left in and skipped by the caller's
+ * closed set, which is cheaper than a decrease-key.
+ */
+export declare class MinHeap {
+    private items;
+    private prio;
+    get size(): number;
+    push(index: number, priority: number): void;
+    /** The index with the lowest priority, removed. Only call while `size > 0`. */
+    pop(): number;
+    clear(): void;
+}
+//# sourceMappingURL=MinHeap.d.ts.map

package/dist/types/nav/MinHeap.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"MinHeap.d.ts","sourceRoot":"","sources":["../../../src/nav/MinHeap.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,qBAAa,OAAO;IAClB,OAAO,CAAC,KAAK,CAAgB;IAC7B,OAAO,CAAC,IAAI,CAAgB;IAE5B,IAAI,IAAI,IAAI,MAAM,CAEjB;IAED,IAAI,CAAC,KAAK,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,IAAI;IAe3C,+EAA+E;IAC/E,GAAG,IAAI,MAAM;IAyBb,KAAK,IAAI,IAAI;CAId"}

package/dist/types/nav/findPath.d.ts

@@ -0,0 +1,38 @@
+import { type NavGrid, type NavOptions, type TilePoint } from './navGrid.js';
+/**
+ * Where a path ends. A point goal is met anywhere within `reach` tiles of its tile (centre to centre; 0 = that tile
+ * only): aiming at an exact tile sent auto-walks into a spot inside a hut and left them shuffling against its wall a
+ * step from where they were already close enough. A custom goal names its own tiles, with an `estimate` of the
+ * tiles left that must never be more than the real cost (0, the default, makes the search a plain Dijkstra).
+ */
+export type NavGoal = {
+    x: number;
+    y: number;
+    reach?: number;
+} | {
+    test: (tx: number, ty: number) => boolean;
+    estimate?: (tx: number, ty: number) => number;
+};
+export interface FindPathOptions extends NavOptions {
+    /** Tiles settled before giving up, so a goal walled off on a big map cannot stall a frame. */
+    maxNodes?: number;
+}
+/** Octile distance: the cost of the cheapest eight-way walk over open ground. */
+export declare function octile(dx: number, dy: number): number;
+/**
+ * A* over the grid: the tiles from `from` to the goal, both included, or null when there is no way through. A start
+ * on a wall is moved to the nearest open tile. The path is the cheapest by `cost`, but among equally cheap ones it
+ * is whichever the heap settled on — often a staircase; `straightenPath` irons that out.
+ */
+export declare function findPath(g: NavGrid, from: TilePoint, to: NavGoal, options?: FindPathOptions): TilePoint[] | null;
+/**
+ * Walking cost from one tile to every tile of the grid (row-major, `Infinity` where unreachable), by the same steps
+ * and costs `findPath` takes — for weighing several destinations by real distance rather than by a straight line. An
+ * end-only tile gets a cost (it can be stepped onto) but nothing is reached through it. `maxCost` stops the spread.
+ */
+export declare function floodFill(g: NavGrid, from: TilePoint, options?: NavOptions & {
+    maxCost?: number;
+}): Float32Array;
+/** How many tiles a flood reached: a quick test that a change to the ground walled nothing off. */
+export declare function reachedCount(costs: Float32Array): number;
+//# sourceMappingURL=findPath.d.ts.map

package/dist/types/nav/findPath.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"findPath.d.ts","sourceRoot":"","sources":["../../../src/nav/findPath.ts"],"names":[],"mappings":"AACA,OAAO,EAA8B,KAAK,OAAO,EAAE,KAAK,UAAU,EAAE,KAAK,SAAS,EAAE,MAAM,WAAW,CAAC;AAGtG;;;;;GAKG;AACH,MAAM,MAAM,OAAO,GAAG;IAAE,CAAC,EAAE,MAAM,CAAC;IAAC,CAAC,EAAE,MAAM,CAAC;IAAC,KAAK,CAAC,EAAE,MAAM,CAAA;CAAE,GAAG;IAAE,IAAI,EAAE,CAAC,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,KAAK,OAAO,CAAC;IAAC,QAAQ,CAAC,EAAE,CAAC,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,KAAK,MAAM,CAAA;CAAE,CAAC;AAE9J,MAAM,WAAW,eAAgB,SAAQ,UAAU;IACjD,8FAA8F;IAC9F,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB;AAED,iFAAiF;AACjF,wBAAgB,MAAM,CAAC,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,GAAG,MAAM,CAIrD;AAYD;;;;GAIG;AACH,wBAAgB,QAAQ,CAAC,CAAC,EAAE,OAAO,EAAE,IAAI,EAAE,SAAS,EAAE,EAAE,EAAE,OAAO,EAAE,OAAO,GAAE,eAAoB,GAAG,SAAS,EAAE,GAAG,IAAI,CA2CpH;AAED;;;;GAIG;AACH,wBAAgB,SAAS,CAAC,CAAC,EAAE,OAAO,EAAE,IAAI,EAAE,SAAS,EAAE,OAAO,GAAE,UAAU,GAAG;IAAE,OAAO,CAAC,EAAE,MAAM,CAAA;CAAO,GAAG,YAAY,CAoCpH;AAED,mGAAmG;AACnG,wBAAgB,YAAY,CAAC,KAAK,EAAE,YAAY,GAAG,MAAM,CAIxD"}