1681-engine 0.5.9 → 0.6.0

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

@@ -0,0 +1,42 @@
+/**
+ * A buzz on a phone, per kind of moment (a crit landed, a blow taken, a level gained), rate-limited per kind: a cleave
+ * clipping six bodies is one buzz, a damage-over-time one buzz, not a stutter. How it buzzes is injected: the default
+ * is the Vibration API (`navigator.vibrate`, Android browsers; iOS Safari has none, so it is a silent no-op there), and
+ * a native shell hands in its own plugin's call instead.
+ */
+/** The shortest gap (ms) between two buzzes of each kind; a kind not named is never held back. */
+export type HapticGaps<K extends string> = Readonly<Partial<Record<K, number>>>;
+/** One buzz per kind per its gap. Pure, so the rule is tested. */
+export declare class HapticGate<K extends string> {
+    private readonly gaps;
+    private readonly last;
+    constructor(gaps?: HapticGaps<K>);
+    /** Whether a buzz of `kind` at `now` (ms) may go; one that may is counted. */
+    allow(kind: K, now: number): boolean;
+    /** Forgets every kind's last buzz. */
+    reset(): void;
+}
+export interface HapticsOptions<K extends string> {
+    gaps?: HapticGaps<K>;
+    /** Plays a buzz. A promise it returns may reject: that is swallowed, a buzz is never worth an error. */
+    play?: (kind: K) => unknown;
+    /** The Vibration API pattern per kind for the default `play` (ms, or on/off ms; default 15). */
+    patterns?: Readonly<Partial<Record<K, number | readonly number[]>>>;
+    /** Asked before every buzz (the player's setting, a native-only rule). Default: always. */
+    enabled?: () => boolean;
+    /** Default `performance.now`. */
+    now?: () => number;
+}
+/** The default player: `navigator.vibrate`, where there is one. */
+export declare function vibrate(pattern: number | readonly number[]): boolean;
+/** Buzzes through `play` when `enabled` and the kind's gap has passed. */
+export declare class Haptics<K extends string> {
+    private readonly gate;
+    private readonly play;
+    private readonly enabled;
+    private readonly now;
+    constructor(options?: HapticsOptions<K>);
+    /** Buzzes for `kind`; returns whether it was let through (not whether the device did buzz). */
+    buzz(kind: K): boolean;
+}
+//# sourceMappingURL=haptics.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"haptics.d.ts","sourceRoot":"","sources":["../../../src/input/haptics.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,kGAAkG;AAClG,MAAM,MAAM,UAAU,CAAC,CAAC,SAAS,MAAM,IAAI,QAAQ,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC,EAAE,MAAM,CAAC,CAAC,CAAC,CAAC;AAEhF,kEAAkE;AAClE,qBAAa,UAAU,CAAC,CAAC,SAAS,MAAM;IAG1B,OAAO,CAAC,QAAQ,CAAC,IAAI;IAFjC,OAAO,CAAC,QAAQ,CAAC,IAAI,CAAwB;gBAEhB,IAAI,GAAE,UAAU,CAAC,CAAC,CAAuB;IAEtE,8EAA8E;IAC9E,KAAK,CAAC,IAAI,EAAE,CAAC,EAAE,GAAG,EAAE,MAAM,GAAG,OAAO;IAQpC,sCAAsC;IACtC,KAAK,IAAI,IAAI;CAGd;AAED,MAAM,WAAW,cAAc,CAAC,CAAC,SAAS,MAAM;IAC9C,IAAI,CAAC,EAAE,UAAU,CAAC,CAAC,CAAC,CAAC;IACrB,wGAAwG;IACxG,IAAI,CAAC,EAAE,CAAC,IAAI,EAAE,CAAC,KAAK,OAAO,CAAC;IAC5B,gGAAgG;IAChG,QAAQ,CAAC,EAAE,QAAQ,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC,EAAE,MAAM,GAAG,SAAS,MAAM,EAAE,CAAC,CAAC,CAAC,CAAC;IACpE,2FAA2F;IAC3F,OAAO,CAAC,EAAE,MAAM,OAAO,CAAC;IACxB,iCAAiC;IACjC,GAAG,CAAC,EAAE,MAAM,MAAM,CAAC;CACpB;AAID,mEAAmE;AACnE,wBAAgB,OAAO,CAAC,OAAO,EAAE,MAAM,GAAG,SAAS,MAAM,EAAE,GAAG,OAAO,CAQpE;AAED,0EAA0E;AAC1E,qBAAa,OAAO,CAAC,CAAC,SAAS,MAAM;IACnC,OAAO,CAAC,QAAQ,CAAC,IAAI,CAAgB;IACrC,OAAO,CAAC,QAAQ,CAAC,IAAI,CAAuB;IAC5C,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAgB;IACxC,OAAO,CAAC,QAAQ,CAAC,GAAG,CAAe;gBAEvB,OAAO,GAAE,cAAc,CAAC,CAAC,CAAM;IAO3C,+FAA+F;IAC/F,IAAI,CAAC,IAAI,EAAE,CAAC,GAAG,OAAO;CAUvB"}

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

@@ -0,0 +1,66 @@
+import type { Actions } from './Actions.js';
+/**
+ * A recording of what a player did, step by step, as plain JSON: attach it to a bug report and the bug plays again,
+ * or keep it as a replay. Only changes are kept (an action's value on the step it changed), so a minute of play is a
+ * few hundred numbers, not thousands.
+ */
+export interface InputTape {
+    version: 1;
+    /** The actions, in the order `changes` refers to them. */
+    actions: string[];
+    /** Steps recorded. */
+    steps: number;
+    /** `[step, action index, value]`, in step order: from that step on the action reads `value` (0 up, 1 held). */
+    changes: [number, number, number][];
+    /** The game's own: a seed, a level, a build, whatever the replay needs to start the same. */
+    meta?: Record<string, unknown>;
+}
+/**
+ * Records an `Actions`' every step until stopped.
+ *
+ * ```ts
+ * const rec = new InputRecorder(actions, { seed, level: 'forest-2' });
+ * // … play …
+ * const tape = rec.stop(); // JSON.stringify it into the bug report
+ * ```
+ */
+export declare class InputRecorder<A extends string> {
+    private readonly meta?;
+    private readonly order;
+    private readonly index;
+    private readonly last;
+    private readonly changes;
+    private steps;
+    private readonly untap;
+    private stopped;
+    constructor(actions: Actions<A>, meta?: Record<string, unknown> | undefined);
+    /** Steps recorded so far. */
+    get length(): number;
+    /** Stops recording and returns the tape (the same one on every later call). */
+    stop(): InputTape;
+    private capture;
+    private note;
+}
+/**
+ * Plays a tape into an `Actions`: each `poll` takes the next step from it instead of the devices, and when the tape
+ * ends the devices answer again (`onEnd` says so).
+ *
+ * ```ts
+ * new InputPlayer(tape).playInto(actions, () => console.log('replay over'));
+ * ```
+ */
+export declare class InputPlayer<A extends string = string> {
+    readonly tape: InputTape;
+    private step;
+    private next;
+    private readonly values;
+    constructor(tape: InputTape);
+    /** Steps played so far. */
+    get position(): number;
+    get done(): boolean;
+    /** The next step's values, or null once the tape is over. */
+    read(): ReadonlyMap<A, number> | null;
+    /** Drives `actions` from the tape until it ends; `onEnd` is called on the poll that finds it over. */
+    playInto<B extends string>(actions: Actions<B>, onEnd?: () => void): void;
+}
+//# sourceMappingURL=inputTape.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"inputTape.d.ts","sourceRoot":"","sources":["../../../src/input/inputTape.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAEzC;;;;GAIG;AACH,MAAM,WAAW,SAAS;IACxB,OAAO,EAAE,CAAC,CAAC;IACX,0DAA0D;IAC1D,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB,sBAAsB;IACtB,KAAK,EAAE,MAAM,CAAC;IACd,+GAA+G;IAC/G,OAAO,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,CAAC;IACpC,6FAA6F;IAC7F,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CAChC;AAED;;;;;;;;GAQG;AACH,qBAAa,aAAa,CAAC,CAAC,SAAS,MAAM;IAWvC,OAAO,CAAC,QAAQ,CAAC,IAAI,CAAC;IAVxB,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAW;IACjC,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAwB;IAC9C,OAAO,CAAC,QAAQ,CAAC,IAAI,CAAwB;IAC7C,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAkC;IAC1D,OAAO,CAAC,KAAK,CAAK;IAClB,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAa;IACnC,OAAO,CAAC,OAAO,CAA0B;gBAGvC,OAAO,EAAE,OAAO,CAAC,CAAC,CAAC,EACF,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,YAAA;IAKjD,6BAA6B;IAC7B,IAAI,MAAM,IAAI,MAAM,CAEnB;IAED,+EAA+E;IAC/E,IAAI,IAAI,SAAS;IAQjB,OAAO,CAAC,OAAO;IAQf,OAAO,CAAC,IAAI;CAWb;AAED;;;;;;;GAOG;AACH,qBAAa,WAAW,CAAC,CAAC,SAAS,MAAM,GAAG,MAAM;IAKpC,QAAQ,CAAC,IAAI,EAAE,SAAS;IAJpC,OAAO,CAAC,IAAI,CAAK;IACjB,OAAO,CAAC,IAAI,CAAK;IACjB,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAwB;gBAE1B,IAAI,EAAE,SAAS;IAUpC,2BAA2B;IAC3B,IAAI,QAAQ,IAAI,MAAM,CAErB;IAED,IAAI,IAAI,IAAI,OAAO,CAElB;IAED,6DAA6D;IAC7D,IAAI,IAAI,WAAW,CAAC,CAAC,EAAE,MAAM,CAAC,GAAG,IAAI;IAarC,sGAAsG;IACtG,QAAQ,CAAC,CAAC,SAAS,MAAM,EAAE,OAAO,EAAE,OAAO,CAAC,CAAC,CAAC,EAAE,KAAK,CAAC,EAAE,MAAM,IAAI,GAAG,IAAI;CAQ1E"}

package/dist/types/mobile/backButton.d.ts

@@ -0,0 +1,30 @@
+/** A back handler: true when it used the press (closed a dialog, went up a menu), false to let the next one try. */
+export type BackHandler = () => boolean;
+/**
+ * Who answers Android's back button (and the back gesture): the most recently pushed handler first, then the ones
+ * under it, then `onRoot` when none took it. A dialog pushes "close me" when it opens and pops it when it closes; a
+ * pause menu pushes "resume"; the title screen leaves the press to `onRoot`, which by default asks for a second press
+ * to quit, so a stray swipe never ends a run.
+ */
+export declare class BackStack {
+    private readonly onRoot;
+    private readonly handlers;
+    constructor(onRoot?: () => void);
+    /** Puts `handler` on top; the returned function takes it off (from anywhere in the stack). */
+    push(handler: BackHandler): () => void;
+    get size(): number;
+    /** A back press: offered from the top down; `onRoot` when none uses it. True when a handler used it. */
+    press(): boolean;
+}
+export interface DoubleBackOptions {
+    /** A second press within this (ms) quits (default 2000). */
+    withinMs?: number;
+    /** The first press: tell the player ("press back again to quit"). */
+    notify: () => void;
+    /** The second: leave (Capacitor's `App.exitApp`, or `minimizeApp` to keep the game alive in the background). */
+    exit: () => void;
+    now?: () => number;
+}
+/** An `onRoot` that quits on a second back press soon after the first, and tells the player after the first. */
+export declare function doubleBackToExit(options: DoubleBackOptions): () => void;
+//# sourceMappingURL=backButton.d.ts.map

package/dist/types/mobile/backButton.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"backButton.d.ts","sourceRoot":"","sources":["../../../src/mobile/backButton.ts"],"names":[],"mappings":"AAAA,oHAAoH;AACpH,MAAM,MAAM,WAAW,GAAG,MAAM,OAAO,CAAC;AAExC;;;;;GAKG;AACH,qBAAa,SAAS;IAGR,OAAO,CAAC,QAAQ,CAAC,MAAM;IAFnC,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAqB;gBAEjB,MAAM,GAAE,MAAM,IAAsB;IAEjE,8FAA8F;IAC9F,IAAI,CAAC,OAAO,EAAE,WAAW,GAAG,MAAM,IAAI;IAQtC,IAAI,IAAI,IAAI,MAAM,CAEjB;IAED,wGAAwG;IACxG,KAAK,IAAI,OAAO;CAOjB;AAED,MAAM,WAAW,iBAAiB;IAChC,4DAA4D;IAC5D,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,qEAAqE;IACrE,MAAM,EAAE,MAAM,IAAI,CAAC;IACnB,gHAAgH;IAChH,IAAI,EAAE,MAAM,IAAI,CAAC;IACjB,GAAG,CAAC,EAAE,MAAM,MAAM,CAAC;CACpB;AAED,gHAAgH;AAChH,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,iBAAiB,GAAG,MAAM,IAAI,CAcvE"}

package/dist/types/mobile/capacitor.d.ts

@@ -0,0 +1,62 @@
+import type { BackStack } from './backButton.js';
+/** What a plugin's `addListener` resolves to. */
+export interface ListenerHandle {
+    remove(): Promise<void> | void;
+}
+/** The slice of `@capacitor/app`'s `App` the engine uses. */
+export interface AppLike {
+    addListener(event: 'backButton', cb: (e: {
+        canGoBack: boolean;
+    }) => void): Promise<ListenerHandle> | ListenerHandle;
+    exitApp(): Promise<void> | void;
+    minimizeApp?(): Promise<void> | void;
+    getInfo?(): Promise<{
+        version: string;
+        build: string;
+    }>;
+}
+/**
+ * Sends Android's back button to a `BackStack`. Capacitor's own default (the web view going back in its history,
+ * then closing the app) is replaced as soon as a listener is added, so the stack decides everything. Resolves to
+ * the uninstall.
+ */
+export declare function installBackButton(app: AppLike, stack: BackStack): Promise<() => void>;
+/**
+ * The app's native build as a number, for `pickWebUpdate`'s `nativeBuild`: Android's versionCode, iOS's
+ * CFBundleVersion (its first number, for "508.1"). `Infinity` where there is no native layer (a browser), so every
+ * web update fits; 0 when the build cannot be read, so none that needs native code does.
+ */
+export declare function nativeBuildOf(app: Pick<AppLike, 'getInfo'> | null | undefined): Promise<number>;
+/** Options for `capacitorConfig`: what differs between games. */
+export interface MobileConfigOptions {
+    /** Reverse-domain id, as the stores know it ("com.example.mygame"). */
+    appId: string;
+    appName: string;
+    /** The built web, relative to the project (default 'dist'). */
+    webDir?: string;
+    /** Behind the web view while it loads, and under the safe-area bands (default black). */
+    backgroundColor?: string;
+    /** Let Chrome's and Safari's inspectors attach (default false: on for a debug build only). */
+    debug?: boolean;
+    /** Anything else, laid over the defaults (`plugins`, `server`, …). */
+    extra?: Record<string, unknown>;
+}
+/**
+ * A `capacitor.config.ts` for a game, with the defaults a game wants rather than a web page's:
+ *
+ * - the page is served from `https://localhost` (Android) so cookies, `crypto.subtle` and service workers behave as on
+ *   the web, and nothing is fetched over plain http;
+ * - the web view does not scroll, bounce or zoom on iOS, and draws edge to edge (`contentInset: 'never'`, mind the
+ *   safe area: `safeAreaInsets`);
+ * - the splash screen stays until the game hides it (`SplashScreen.hide()` once the first scene draws), so the player
+ *   never sees a blank web view;
+ * - `@capgo/capacitor-updater` does not update on its own: the engine's `pickWebUpdate` decides.
+ *
+ * ```ts
+ * // capacitor.config.ts
+ * import { capacitorConfig } from '1681-engine/mobile';
+ * export default capacitorConfig({ appId: 'com.example.mygame', appName: 'My Game', debug: process.env.DEBUG === '1' });
+ * ```
+ */
+export declare function capacitorConfig(options: MobileConfigOptions): Record<string, unknown>;
+//# sourceMappingURL=capacitor.d.ts.map

package/dist/types/mobile/capacitor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"capacitor.d.ts","sourceRoot":"","sources":["../../../src/mobile/capacitor.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,cAAc,CAAC;AAQ9C,iDAAiD;AACjD,MAAM,WAAW,cAAc;IAC7B,MAAM,IAAI,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC;CAChC;AAED,6DAA6D;AAC7D,MAAM,WAAW,OAAO;IACtB,WAAW,CAAC,KAAK,EAAE,YAAY,EAAE,EAAE,EAAE,CAAC,CAAC,EAAE;QAAE,SAAS,EAAE,OAAO,CAAA;KAAE,KAAK,IAAI,GAAG,OAAO,CAAC,cAAc,CAAC,GAAG,cAAc,CAAC;IACpH,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC;IAChC,WAAW,CAAC,IAAI,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC;IACrC,OAAO,CAAC,IAAI,OAAO,CAAC;QAAE,OAAO,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;CACzD;AAED;;;;GAIG;AACH,wBAAsB,iBAAiB,CAAC,GAAG,EAAE,OAAO,EAAE,KAAK,EAAE,SAAS,GAAG,OAAO,CAAC,MAAM,IAAI,CAAC,CAK3F;AAED;;;;GAIG;AACH,wBAAsB,aAAa,CAAC,GAAG,EAAE,IAAI,CAAC,OAAO,EAAE,SAAS,CAAC,GAAG,IAAI,GAAG,SAAS,GAAG,OAAO,CAAC,MAAM,CAAC,CASrG;AAED,iEAAiE;AACjE,MAAM,WAAW,mBAAmB;IAClC,uEAAuE;IACvE,KAAK,EAAE,MAAM,CAAC;IACd,OAAO,EAAE,MAAM,CAAC;IAChB,+DAA+D;IAC/D,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,yFAAyF;IACzF,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,8FAA8F;IAC9F,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,sEAAsE;IACtE,KAAK,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CACjC;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,eAAe,CAAC,OAAO,EAAE,mBAAmB,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAoBrF"}

package/dist/types/mobile/index.d.ts

@@ -0,0 +1,4 @@
+export { BackStack, doubleBackToExit, type BackHandler, type DoubleBackOptions } from './backButton.js';
+export { installBackButton, nativeBuildOf, capacitorConfig, type AppLike, type ListenerHandle, type MobileConfigOptions } from './capacitor.js';
+export { safeAreaInsets, keepScreenOn, type Insets, type WakeLockLike } from './screen.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/types/mobile/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/mobile/index.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,SAAS,EAAE,gBAAgB,EAAE,KAAK,WAAW,EAAE,KAAK,iBAAiB,EAAE,MAAM,cAAc,CAAC;AACrG,OAAO,EAAE,iBAAiB,EAAE,aAAa,EAAE,eAAe,EAAE,KAAK,OAAO,EAAE,KAAK,cAAc,EAAE,KAAK,mBAAmB,EAAE,MAAM,aAAa,CAAC;AAC7I,OAAO,EAAE,cAAc,EAAE,YAAY,EAAE,KAAK,MAAM,EAAE,KAAK,YAAY,EAAE,MAAM,UAAU,CAAC"}

package/dist/types/mobile/screen.d.ts

@@ -0,0 +1,27 @@
+/** Px kept clear at each edge: the notch, the rounded corners, the home bar. */
+export interface Insets {
+    top: number;
+    right: number;
+    bottom: number;
+    left: number;
+}
+/**
+ * The safe-area insets as the browser has them now (CSS `env(safe-area-inset-*)`), read through a hidden probe
+ * element: what a canvas HUD must keep its buttons out of when the web view is drawn edge to edge. Zeros where
+ * there is no document or no notch.
+ */
+export declare function safeAreaInsets(doc?: Document | undefined): Insets;
+/** The slice of the Screen Wake Lock API used, so a test can hand in its own. */
+export interface WakeLockLike {
+    request(type: 'screen'): Promise<{
+        release(): Promise<void>;
+        addEventListener?(type: 'release', cb: () => void): void;
+    }>;
+}
+/**
+ * Keeps the screen on while the game runs (a phone dims and locks during a cut scene or a long think otherwise),
+ * through the Screen Wake Lock API. The browser drops the lock whenever the page is hidden, so it is asked for again
+ * each time the page comes back. Resolves to the release; does nothing where the API is missing or refuses.
+ */
+export declare function keepScreenOn(wakeLock?: WakeLockLike | undefined, doc?: Pick<Document, 'visibilityState' | 'addEventListener' | 'removeEventListener'> | undefined): Promise<() => void>;
+//# sourceMappingURL=screen.d.ts.map

package/dist/types/mobile/screen.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"screen.d.ts","sourceRoot":"","sources":["../../../src/mobile/screen.ts"],"names":[],"mappings":"AAAA,gFAAgF;AAChF,MAAM,WAAW,MAAM;IACrB,GAAG,EAAE,MAAM,CAAC;IACZ,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,EAAE,MAAM,CAAC;CACd;AAED;;;;GAIG;AACH,wBAAgB,cAAc,CAAC,GAAG,GAAE,QAAQ,GAAG,SAA+B,GAAG,MAAM,CAatF;AAED,iFAAiF;AACjF,MAAM,WAAW,YAAY;IAC3B,OAAO,CAAC,IAAI,EAAE,QAAQ,GAAG,OAAO,CAAC;QAAE,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;QAAC,gBAAgB,CAAC,CAAC,IAAI,EAAE,SAAS,EAAE,EAAE,EAAE,MAAM,IAAI,GAAG,IAAI,CAAA;KAAE,CAAC,CAAC;CAC1H;AAED;;;;GAIG;AACH,wBAAsB,YAAY,CAChC,QAAQ,GAAE,YAAY,GAAG,SAAmG,EAC5H,GAAG,GAAE,IAAI,CAAC,QAAQ,EAAE,iBAAiB,GAAG,kBAAkB,GAAG,qBAAqB,CAAC,GAAG,SAA+B,GACpH,OAAO,CAAC,MAAM,IAAI,CAAC,CA2BrB"}

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

@@ -0,0 +1,31 @@
+import { type NavGrid, type NavOptions, type TilePoint } from './navGrid.js';
+/**
+ * Which way to step from every tile to reach the nearest goal: one search for a whole crowd. A hundred monsters
+ * chasing one player cost one flow field a re-plan, where a hundred `findPath`s would cost a hundred searches.
+ */
+export interface FlowField {
+    readonly width: number;
+    readonly height: number;
+    /** Walking cost from each tile (row-major) to its nearest goal, `Infinity` where none can be reached. */
+    readonly costs: Float32Array;
+    /** The step to take from each tile, an index into `NAV_STEPS`; -1 on a goal and where nothing is reached. */
+    readonly steps: Int8Array;
+    /** The step from tile (tx, ty) as [dx, dy], or null on a goal, a wall, outside the grid or out of reach. */
+    stepAt(tx: number, ty: number): readonly [number, number] | null;
+    /** The cost from (tx, ty) to its nearest goal (`Infinity` out of reach or outside the grid). */
+    costAt(tx: number, ty: number): number;
+}
+/**
+ * A flow field towards `goals` (any number: every door out of a burning house), by the same steps, corner rules,
+ * costs and end-only tiles `findPath` takes, so a body following it walks the route `findPath` would have found.
+ * `maxCost` stops the spread (bodies further off stand still or wander).
+ */
+export declare function flowField(g: NavGrid, goals: readonly TilePoint[], options?: NavOptions & {
+    maxCost?: number;
+}): FlowField;
+/**
+ * The tiles a body at `from` walks by following the field, to the goal (both ends included), or null when `from` is
+ * out of reach. For drawing the route, and for tests; a body steps one tile at a time with `stepAt`.
+ */
+export declare function followField(field: FlowField, from: TilePoint, maxSteps?: number): TilePoint[] | null;
+//# sourceMappingURL=flowField.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"flowField.d.ts","sourceRoot":"","sources":["../../../src/nav/flowField.ts"],"names":[],"mappings":"AACA,OAAO,EAA8B,KAAK,OAAO,EAAE,KAAK,UAAU,EAAE,KAAK,SAAS,EAAE,MAAM,WAAW,CAAC;AAEtG;;;GAGG;AACH,MAAM,WAAW,SAAS;IACxB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,yGAAyG;IACzG,QAAQ,CAAC,KAAK,EAAE,YAAY,CAAC;IAC7B,6GAA6G;IAC7G,QAAQ,CAAC,KAAK,EAAE,SAAS,CAAC;IAC1B,4GAA4G;IAC5G,MAAM,CAAC,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,GAAG,SAAS,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,IAAI,CAAC;IACjE,gGAAgG;IAChG,MAAM,CAAC,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,GAAG,MAAM,CAAC;CACxC;AAED;;;;GAIG;AACH,wBAAgB,SAAS,CAAC,CAAC,EAAE,OAAO,EAAE,KAAK,EAAE,SAAS,SAAS,EAAE,EAAE,OAAO,GAAE,UAAU,GAAG;IAAE,OAAO,CAAC,EAAE,MAAM,CAAA;CAAO,GAAG,SAAS,CA0D7H;AAED;;;GAGG;AACH,wBAAgB,WAAW,CAAC,KAAK,EAAE,SAAS,EAAE,IAAI,EAAE,SAAS,EAAE,QAAQ,SAA6B,GAAG,SAAS,EAAE,GAAG,IAAI,CAaxH"}

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

@@ -0,0 +1,47 @@
+export interface SteerVec {
+    x: number;
+    y: number;
+}
+/** A body as steering sees it. */
+export interface SteerAgent {
+    x: number;
+    y: number;
+    vx: number;
+    vy: number;
+}
+/** Full speed straight at a point. */
+export declare function seek(agent: SteerAgent, tx: number, ty: number, maxSpeed: number): SteerVec;
+/** Full speed straight away from a point, within `panic` px of it (default always). */
+export declare function flee(agent: SteerAgent, tx: number, ty: number, maxSpeed: number, panic?: number): SteerVec;
+/** Like `seek`, but slowing inside `slowRadius` px so it stops on the point instead of overshooting. */
+export declare function arrive(agent: SteerAgent, tx: number, ty: number, maxSpeed: number, slowRadius: number): SteerVec;
+/**
+ * Away from neighbours closer than `radius` px, harder the closer they are: bodies of a crowd stop stacking on one
+ * tile. A neighbour exactly on top is pushed off along a direction picked from the pair's places, so two bodies
+ * spawned on one spot still part.
+ */
+export declare function separation(agent: SteerAgent, neighbours: Iterable<SteerAgent>, radius: number, strength: number): SteerVec;
+/** Towards the average heading of neighbours within `radius` (a flock turning together). */
+export declare function alignment(agent: SteerAgent, neighbours: Iterable<SteerAgent>, radius: number): SteerVec;
+/** Towards the middle of neighbours within `radius` (a flock keeping together). */
+export declare function cohesion(agent: SteerAgent, neighbours: Iterable<SteerAgent>, radius: number, maxSpeed: number): SteerVec;
+/** What `followFlow` reads: a flow field (`flowField.ts`). */
+export interface StepSource {
+    stepAt(tx: number, ty: number): readonly [number, number] | null;
+    costAt(tx: number, ty: number): number;
+}
+/**
+ * Full speed along a flow field from the tile the body stands on. On a goal it brakes to a stop, so a crowd gathers
+ * there rather than coasting past. Pushed off the field (into a wall, off the grid, by a crowd's shoving), it heads
+ * for the cheapest tile around it that is on the field, so it is never stranded; with none within two tiles, it
+ * brakes.
+ */
+export declare function followFlow(agent: SteerAgent, field: StepSource, tileSize: number, maxSpeed: number): SteerVec;
+/** Weighs steering forces, sums them and caps the sum at `maxForce` (px/s of change a step). */
+export declare function combineSteering(maxForce: number, ...weighted: [SteerVec, number][]): SteerVec;
+/**
+ * One step of steering applied to a body: velocity changed by `force × dt`, capped at `maxSpeed`, position moved.
+ * For bodies with no physics of their own (birds, a crowd of extras); a physics body takes the force instead.
+ */
+export declare function applySteering(agent: SteerAgent, force: SteerVec, maxSpeed: number, dt: number): void;
+//# sourceMappingURL=steering.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"steering.d.ts","sourceRoot":"","sources":["../../../src/nav/steering.ts"],"names":[],"mappings":"AAOA,MAAM,WAAW,QAAQ;IACvB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACX;AAED,kCAAkC;AAClC,MAAM,WAAW,UAAU;IACzB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;CACZ;AAUD,sCAAsC;AACtC,wBAAgB,IAAI,CAAC,KAAK,EAAE,UAAU,EAAE,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,QAAQ,CAE1F;AAED,uFAAuF;AACvF,wBAAgB,IAAI,CAAC,KAAK,EAAE,UAAU,EAAE,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,KAAK,SAAW,GAAG,QAAQ,CAK5G;AAED,wGAAwG;AACxG,wBAAgB,MAAM,CAAC,KAAK,EAAE,UAAU,EAAE,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,GAAG,QAAQ,CAMhH;AAED;;;;GAIG;AACH,wBAAgB,UAAU,CAAC,KAAK,EAAE,UAAU,EAAE,UAAU,EAAE,QAAQ,CAAC,UAAU,CAAC,EAAE,MAAM,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,QAAQ,CA0B1H;AAED,4FAA4F;AAC5F,wBAAgB,SAAS,CAAC,KAAK,EAAE,UAAU,EAAE,UAAU,EAAE,QAAQ,CAAC,UAAU,CAAC,EAAE,MAAM,EAAE,MAAM,GAAG,QAAQ,CAWvG;AAED,mFAAmF;AACnF,wBAAgB,QAAQ,CAAC,KAAK,EAAE,UAAU,EAAE,UAAU,EAAE,QAAQ,CAAC,UAAU,CAAC,EAAE,MAAM,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,QAAQ,CAWxH;AAED,8DAA8D;AAC9D,MAAM,WAAW,UAAU;IACzB,MAAM,CAAC,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,GAAG,SAAS,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,IAAI,CAAC;IACjE,MAAM,CAAC,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,GAAG,MAAM,CAAC;CACxC;AAED;;;;;GAKG;AACH,wBAAgB,UAAU,CAAC,KAAK,EAAE,UAAU,EAAE,KAAK,EAAE,UAAU,EAAE,QAAQ,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,QAAQ,CAuB7G;AAED,gGAAgG;AAChG,wBAAgB,eAAe,CAAC,QAAQ,EAAE,MAAM,EAAE,GAAG,QAAQ,EAAE,CAAC,QAAQ,EAAE,MAAM,CAAC,EAAE,GAAG,QAAQ,CAa7F;AAED;;;GAGG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,UAAU,EAAE,KAAK,EAAE,QAAQ,EAAE,QAAQ,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,GAAG,IAAI,CAUpG"}

package/dist/types/net/ApiClient.d.ts

@@ -0,0 +1,74 @@
+export type ApiMethod = 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE';
+/**
+ * A request that failed. `status` 0 with `code` `'NETWORK'` is no answer at all (offline, a timeout, a refused
+ * connection), `'ABORTED'` the caller's own abort; otherwise `status` is the server's, and `code`, `message` and
+ * `details` are what `describe` read off its body.
+ */
+export declare class ApiError extends Error {
+    readonly status: number;
+    readonly code: string;
+    readonly details?: Readonly<Record<string, string>> | undefined;
+    /** The parsed body of the failed answer, when there was one. */
+    readonly body?: unknown | undefined;
+    constructor(status: number, code: string, message: string, details?: Readonly<Record<string, string>> | undefined, 
+    /** The parsed body of the failed answer, when there was one. */
+    body?: unknown | undefined);
+}
+/** What a failed answer's body says: the default reads `code`, `message` and `details` off a JSON object. */
+export interface ApiErrorInfo {
+    code?: string;
+    message?: string;
+    details?: Readonly<Record<string, string>>;
+}
+/**
+ * What a refresh came back with: a new access token, `'refused'` (the session is over), or null (the server could not
+ * be asked — keep the session and let the next call try again).
+ */
+export type RefreshResult = string | 'refused' | null;
+export interface ApiClientOptions {
+    /** The server's origin (`https://host`), or one chosen per path (accounts on one server, the game on another). */
+    baseUrl: string | ((path: string) => string);
+    /** Headers sent with every request (a client version, a platform), asked afresh each time. */
+    headers?: () => Readonly<Record<string, string>>;
+    /** Default 10 s; a request may give its own. */
+    timeoutMs?: number;
+    /** Turns a failed answer's parsed body into its code, message and details (a game rendering its own messages). */
+    describe?: (body: unknown, status: number) => ApiErrorInfo;
+    /** The message of a request that got no answer (default `'Cannot reach the server.'`). */
+    networkMessage?: string | (() => string);
+    /** Paths a 401 never refreshes for (the login and refresh calls themselves). */
+    noRefresh?: (path: string) => boolean;
+    /** Called with every failed answer before it is thrown (an "update required" gate reading `status` or `code`). */
+    onError?: (error: ApiError) => void;
+    /** Called for answers with one status before it is thrown: `{ 426: (e) => showUpdate(e.details) }`. */
+    onStatus?: Readonly<Record<number, (error: ApiError) => void>>;
+    /** Default the global `fetch`. */
+    fetch?: typeof fetch;
+}
+export interface ApiRequestOptions {
+    timeoutMs?: number;
+    /** The caller's own abort; its abort throws an `ApiError` with code `'ABORTED'`. */
+    signal?: AbortSignal;
+    /** Headers for this request alone, over the client's. */
+    headers?: Readonly<Record<string, string>>;
+}
+/**
+ * A small JSON REST client: a bearer token, JSON in and out, a timeout on every call, and a session kept alive — a 401
+ * is refreshed once (`refresher`) and the request sent again. A game keeps its endpoints and types in a subclass or
+ * beside it; nothing here knows any route.
+ */
+export declare class ApiClient {
+    private readonly options;
+    private token;
+    /** A new access token for a 401 (`RefreshResult`); unset, a 401 is simply thrown. */
+    refresher: (() => Promise<RefreshResult>) | null;
+    /** Called when a 401 ends the session: no refresher, a refused refresh, or a retry refused again. */
+    onUnauthorized: (() => void) | null;
+    constructor(options: ApiClientOptions);
+    get accessToken(): string | null;
+    setToken(token: string | null): void;
+    /** Sends a request and returns its parsed JSON body (undefined for an empty or unreadable one). */
+    request<T>(method: ApiMethod, path: string, body?: unknown, options?: ApiRequestOptions, retried?: boolean): Promise<T>;
+    private networkError;
+}
+//# sourceMappingURL=ApiClient.d.ts.map

package/dist/types/net/ApiClient.d.ts.map

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

package/dist/types/net/InterpolationBuffer.d.ts

@@ -26,6 +26,11 @@ export declare class InterpolationBuffer {
     delayMs?: number, maxExtrapolateMs?: number, keep?: number);
     /** Records every body of a snapshot taken at `time`. */
     push(time: number, updates: readonly EntityUpdate[]): void;
+    /**
+     * The server time bodies are drawn at when it is `now` (`serverNow()`): what a shot should carry, so a server with
+     * lag compensation judges it against the picture the player aimed at.
+     */
+    viewTime(now: number): number;
     /** Forgets a body (it left view). */
     remove(id: number): void;
     has(id: number): boolean;

package/dist/types/net/InterpolationBuffer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"InterpolationBuffer.d.ts","sourceRoot":"","sources":["../../../src/net/InterpolationBuffer.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAahD,MAAM,WAAW,iBAAiB;IAChC,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,GAAG,EAAE,MAAM,CAAC;IACZ,6FAA6F;IAC7F,IAAI,EAAE,MAAM,CAAC;IACb,EAAE,EAAE,MAAM,CAAC;IACX,KAAK,EAAE,MAAM,CAAC;CACf;AAED;;;;;;GAMG;AACH,qBAAa,mBAAmB;IAI5B,yGAAyG;IACzG,QAAQ,CAAC,OAAO;IAChB,OAAO,CAAC,QAAQ,CAAC,gBAAgB;IACjC,OAAO,CAAC,QAAQ,CAAC,IAAI;IANvB,OAAO,CAAC,QAAQ,CAAC,OAAO,CAA+B;;IAGrD,yGAAyG;IAChG,OAAO,SAAM,EACL,gBAAgB,SAAM,EACtB,IAAI,SAAK;IAG5B,wDAAwD;IACxD,IAAI,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,SAAS,YAAY,EAAE,GAAG,IAAI;IAe1D,qCAAqC;IACrC,MAAM,CAAC,EAAE,EAAE,MAAM,GAAG,IAAI;IAIxB,GAAG,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO;IAIxB,GAAG,IAAI,gBAAgB,CAAC,MAAM,CAAC;IAI/B,+FAA+F;IAC/F,MAAM,CAAC,EAAE,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,iBAAiB,GAAG,IAAI;CAqB1D"}
+{"version":3,"file":"InterpolationBuffer.d.ts","sourceRoot":"","sources":["../../../src/net/InterpolationBuffer.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAahD,MAAM,WAAW,iBAAiB;IAChC,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,GAAG,EAAE,MAAM,CAAC;IACZ,6FAA6F;IAC7F,IAAI,EAAE,MAAM,CAAC;IACb,EAAE,EAAE,MAAM,CAAC;IACX,KAAK,EAAE,MAAM,CAAC;CACf;AAED;;;;;;GAMG;AACH,qBAAa,mBAAmB;IAI5B,yGAAyG;IACzG,QAAQ,CAAC,OAAO;IAChB,OAAO,CAAC,QAAQ,CAAC,gBAAgB;IACjC,OAAO,CAAC,QAAQ,CAAC,IAAI;IANvB,OAAO,CAAC,QAAQ,CAAC,OAAO,CAA+B;;IAGrD,yGAAyG;IAChG,OAAO,SAAM,EACL,gBAAgB,SAAM,EACtB,IAAI,SAAK;IAG5B,wDAAwD;IACxD,IAAI,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,SAAS,YAAY,EAAE,GAAG,IAAI;IAe1D;;;OAGG;IACH,QAAQ,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM;IAI7B,qCAAqC;IACrC,MAAM,CAAC,EAAE,EAAE,MAAM,GAAG,IAAI;IAIxB,GAAG,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO;IAIxB,GAAG,IAAI,gBAAgB,CAAC,MAAM,CAAC;IAI/B,+FAA+F;IAC/F,MAAM,CAAC,EAAE,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,iBAAiB,GAAG,IAAI;CAqB1D"}

package/dist/types/net/LagCompensator.d.ts

@@ -0,0 +1,70 @@
+/** A body's position at one recorded moment. */
+export interface RewoundBody {
+    id: number;
+    x: number;
+    y: number;
+}
+/** A body a ray passed through: `along` is how far from the ray's start it was met (px). */
+export interface RewoundHit extends RewoundBody {
+    along: number;
+}
+/**
+ * Lag compensation for a server: where every body was a moment ago, so a shot is judged against what the shooter saw.
+ * A client draws other bodies `delayMs` in the past between two snapshots (`InterpolationBuffer`); the server records
+ * the same positions at the same times, when each snapshot goes out, and blends between them the same way, so a
+ * rewind lands on the very picture the shooter aimed at, not on where the target has walked to since.
+ *
+ * How far back a client may ask is capped (`clampTime`): a client that claims an old time to shoot round a corner
+ * gets no further back than `maxRewindMs`.
+ *
+ * ```ts
+ * // when snapshots go out (RoomHost does this for a Room made with `rewindMs`)
+ * lag.record(now, players);
+ * // a client's shot, sent with `at: buffer.viewTime(serverNow())`
+ * const at = LagCompensator.clampTime(msg.at, now, 250);
+ * const hit = lag.alongRay(at, x, y, dx, dy, range, 6, shooterId)[0];
+ * ```
+ */
+export declare class LagCompensator {
+    readonly keepMs: number;
+    private readonly frames;
+    /** `keepMs`: how much history is kept; at least the longest rewind allowed plus a snapshot interval. */
+    constructor(keepMs?: number);
+    /** The latest recorded time, or -Infinity before any. */
+    get newest(): number;
+    get oldest(): number;
+    /** Records every body's position at `time`. A time not after the last one recorded replaces that frame. */
+    record(time: number, bodies: Iterable<{
+        readonly id: number;
+        readonly x: number;
+        readonly y: number;
+    }>): void;
+    /** Forgets a body everywhere in the history (it left the game, not just the view). */
+    forget(id: number): void;
+    clear(): void;
+    /**
+     * A time a client claims it saw, kept within `[now - maxRewindMs, now]`: the window a rewind is honoured in. A
+     * claim that is not a finite number is taken as `now` (no rewind).
+     */
+    static clampTime(claimed: unknown, now: number, maxRewindMs: number): number;
+    /**
+     * Where body `id` was at `time`, blended between the frames around it as `InterpolationBuffer` blends; null when
+     * the history has no frame of it. Before the oldest frame it is where it was then; after the newest, where it is.
+     */
+    at(id: number, time: number): {
+        x: number;
+        y: number;
+    } | null;
+    /** Every body in the history at `time`. */
+    all(time: number): RewoundBody[];
+    /** The bodies whose centre was within `radius` of (x, y) at `time`, nearest first; `except` (the shooter) left out. */
+    near(time: number, x: number, y: number, radius: number, except?: number): RewoundBody[];
+    /**
+     * A hitscan at `time`: the bodies a ray from (x, y) along (dx, dy) passed within `radius` of, before `range` px, in
+     * the order it met them. `except` (the shooter) is left out. Walls are the game's to check against the first hit.
+     */
+    alongRay(time: number, x: number, y: number, dx: number, dy: number, range: number, radius: number, except?: number): RewoundHit[];
+    /** The two frames around `time` and how far between them it is (0 at the first, 1 at the second). */
+    private around;
+}
+//# sourceMappingURL=LagCompensator.d.ts.map

package/dist/types/net/LagCompensator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"LagCompensator.d.ts","sourceRoot":"","sources":["../../../src/net/LagCompensator.ts"],"names":[],"mappings":"AAAA,gDAAgD;AAChD,MAAM,WAAW,WAAW;IAC1B,EAAE,EAAE,MAAM,CAAC;IACX,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACX;AAED,4FAA4F;AAC5F,MAAM,WAAW,UAAW,SAAQ,WAAW;IAC7C,KAAK,EAAE,MAAM,CAAC;CACf;AAOD;;;;;;;;;;;;;;;;GAgBG;AACH,qBAAa,cAAc;IAIb,QAAQ,CAAC,MAAM;IAH3B,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAe;IAEtC,wGAAwG;gBACnF,MAAM,SAAO;IAElC,yDAAyD;IACzD,IAAI,MAAM,IAAI,MAAM,CAEnB;IAED,IAAI,MAAM,IAAI,MAAM,CAEnB;IAED,2GAA2G;IAC3G,MAAM,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,QAAQ,CAAC;QAAE,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;QAAC,QAAQ,CAAC,CAAC,EAAE,MAAM,CAAC;QAAC,QAAQ,CAAC,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC,GAAG,IAAI;IAY7G,sFAAsF;IACtF,MAAM,CAAC,EAAE,EAAE,MAAM,GAAG,IAAI;IAIxB,KAAK,IAAI,IAAI;IAIb;;;OAGG;IACH,MAAM,CAAC,SAAS,CAAC,OAAO,EAAE,OAAO,EAAE,GAAG,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,GAAG,MAAM;IAK5E;;;OAGG;IACH,EAAE,CAAC,EAAE,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG;QAAE,CAAC,EAAE,MAAM,CAAC;QAAC,CAAC,EAAE,MAAM,CAAA;KAAE,GAAG,IAAI;IAM7D,2CAA2C;IAC3C,GAAG,CAAC,IAAI,EAAE,MAAM,GAAG,WAAW,EAAE;IAahC,uHAAuH;IACvH,IAAI,CAAC,IAAI,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,MAAM,GAAG,WAAW,EAAE;IAKxF;;;OAGG;IACH,QAAQ,CAAC,IAAI,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,MAAM,GAAG,UAAU,EAAE;IAqBlI,qGAAqG;IACrG,OAAO,CAAC,MAAM;CAaf"}