1681-engine 0.0.0-stage → 0.5.9

package/dist/types/core/Stage.d.ts

@@ -0,0 +1,58 @@
+import { Container, type Application } from 'pixi.js';
+import { Camera } from './Camera.js';
+import { Clock } from './Clock.js';
+import { ObjectFactory } from './ObjectFactory.js';
+import { Pointer } from './Pointer.js';
+import type { TextureRegistry } from './TextureRegistry.js';
+import { Tweener } from './Tweener.js';
+/**
+ * What a world object is created in: a world layer the camera moves (children sorted by depth), a screen layer
+ * above it, and the per-frame services (tweens, timers, camera, pointer). Subclasses implement `update`.
+ */
+export declare abstract class Stage {
+    readonly app: Application;
+    readonly textures: TextureRegistry;
+    /** Told of every fault a guarded step caught (error telemetry, if the game sets one). */
+    static onCaught: ((where: string, err: unknown) => void) | null;
+    readonly world: Container<import("pixi.js").ContainerChild>;
+    readonly screen: Container<import("pixi.js").ContainerChild>;
+    readonly add: ObjectFactory;
+    readonly tweens: Tweener;
+    readonly time: Clock;
+    readonly cameras: {
+        main: Camera;
+    };
+    readonly input: {
+        activePointer: Pointer;
+    };
+    private readonly resizeListeners;
+    private lastWidth;
+    private lastHeight;
+    constructor(app: Application, textures: TextureRegistry);
+    get width(): number;
+    get height(): number;
+    get fps(): number;
+    /** Calls `fn` whenever the window changes size; the returned function stops it (a per-map listener must). */
+    onResize(fn: () => void): () => void;
+    abstract update(now: number, delta: number): void;
+    /**
+     * One frame: game logic, then tweens and timers, then the camera. Pixi renders after. Each step is guarded: a
+     * ticker listener that throws never asks for the next animation frame, so one bad frame used to stop the world for
+     * good — the canvas frozen and no input reaching the server (seen on Android).
+     */
+    frame(delta: number): void;
+    private readonly reported;
+    /**
+     * Runs one step of a frame and swallows what it throws, so the steps after it still run. Subclasses guard the parts
+     * of their own `update` too: a fault before the camera follows the player used to leave the view standing on one
+     * spot while the world went on.
+     */
+    protected guard(step: string, fn: () => void): void;
+    /** `guard` for a step that answers something: `fallback` when it threw. */
+    protected guarded<T>(step: string, fn: () => T, fallback: T): T;
+    /** What a guarded step threw: logged once per distinct error, or a fault repeating every frame floods the log at 60 a second. */
+    protected caught(step: string, err: unknown): void;
+    destroy(): void;
+    private syncSize;
+}
+//# sourceMappingURL=Stage.d.ts.map

package/dist/types/core/Stage.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Stage.d.ts","sourceRoot":"","sources":["../../../src/core/Stage.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,KAAK,WAAW,EAAE,MAAM,SAAS,CAAC;AACtD,OAAO,EAAE,MAAM,EAAE,MAAM,UAAU,CAAC;AAClC,OAAO,EAAE,KAAK,EAAE,MAAM,SAAS,CAAC;AAChC,OAAO,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAChD,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AACpC,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAC;AACzD,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAEpC;;;GAGG;AACH,8BAAsB,KAAK;IAgBvB,QAAQ,CAAC,GAAG,EAAE,WAAW;IACzB,QAAQ,CAAC,QAAQ,EAAE,eAAe;IAhBpC,yFAAyF;IACzF,MAAM,CAAC,QAAQ,EAAE,CAAC,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,EAAE,OAAO,KAAK,IAAI,CAAC,GAAG,IAAI,CAAQ;IAEvE,QAAQ,CAAC,KAAK,8CAA6C;IAC3D,QAAQ,CAAC,MAAM,8CAAmB;IAClC,QAAQ,CAAC,GAAG,gBAA2B;IACvC,QAAQ,CAAC,MAAM,UAAiB;IAChC,QAAQ,CAAC,IAAI,QAAe;IAC5B,QAAQ,CAAC,OAAO,EAAE;QAAE,IAAI,EAAE,MAAM,CAAA;KAAE,CAAC;IACnC,QAAQ,CAAC,KAAK,EAAE;QAAE,aAAa,EAAE,OAAO,CAAA;KAAE,CAAC;IAC3C,OAAO,CAAC,QAAQ,CAAC,eAAe,CAAsB;IACtD,OAAO,CAAC,SAAS,CAAK;IACtB,OAAO,CAAC,UAAU,CAAK;gBAGZ,GAAG,EAAE,WAAW,EAChB,QAAQ,EAAE,eAAe;IAUpC,IAAI,KAAK,IAAI,MAAM,CAElB;IAED,IAAI,MAAM,IAAI,MAAM,CAEnB;IAED,IAAI,GAAG,IAAI,MAAM,CAEhB;IAED,6GAA6G;IAC7G,QAAQ,CAAC,EAAE,EAAE,MAAM,IAAI,GAAG,MAAM,IAAI;IAQpC,QAAQ,CAAC,MAAM,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,IAAI;IAEjD;;;;OAIG;IACH,KAAK,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI;IAS1B,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAqB;IAE9C;;;;OAIG;IACH,SAAS,CAAC,KAAK,CAAC,IAAI,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,IAAI,GAAG,IAAI;IAInD,2EAA2E;IAC3E,SAAS,CAAC,OAAO,CAAC,CAAC,EAAE,IAAI,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,CAAC,EAAE,QAAQ,EAAE,CAAC,GAAG,CAAC;IAS/D,iIAAiI;IACjI,SAAS,CAAC,MAAM,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,EAAE,OAAO,GAAG,IAAI;IASlD,OAAO,IAAI,IAAI;IAQf,OAAO,CAAC,QAAQ;CAWjB"}

package/dist/types/core/Text.d.ts

@@ -0,0 +1,22 @@
+import { Text as PixiText } from 'pixi.js';
+export interface TextStyle {
+    fontFamily?: string;
+    fontSize: string | number;
+    color?: string;
+    stroke?: string;
+    strokeThickness?: number;
+    /** Texture pixels per world pixel: world text is zoomed by the camera, so it is rasterised finer. */
+    resolution?: number;
+    align?: 'left' | 'center' | 'right';
+    lineSpacing?: number;
+    wordWrapWidth?: number;
+}
+declare const Text_base: typeof PixiText & (new (...args: any[]) => import("./gameObject.js").GameObjectMembers);
+/** Canvas text in world or screen space. */
+export declare class Text extends Text_base {
+    constructor(x: number, y: number, text: string, style: TextStyle);
+    setOrigin(x?: number, y?: number): this;
+    setText(text: string): this;
+}
+export {};
+//# sourceMappingURL=Text.d.ts.map

package/dist/types/core/Text.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Text.d.ts","sourceRoot":"","sources":["../../../src/core/Text.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,IAAI,QAAQ,EAAyB,MAAM,SAAS,CAAC;AAGlE,MAAM,WAAW,SAAS;IACxB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,QAAQ,EAAE,MAAM,GAAG,MAAM,CAAC;IAC1B,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,qGAAqG;IACrG,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,KAAK,CAAC,EAAE,MAAM,GAAG,QAAQ,GAAG,OAAO,CAAC;IACpC,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,aAAa,CAAC,EAAE,MAAM,CAAC;CACxB;;AAED,4CAA4C;AAC5C,qBAAa,IAAK,SAAQ,SAAoB;gBAChC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,SAAS;IAkBhE,SAAS,CAAC,CAAC,SAAM,EAAE,CAAC,SAAI,GAAG,IAAI;IAK/B,OAAO,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI;CAI5B"}

package/dist/types/core/TextureRegistry.d.ts

@@ -0,0 +1,90 @@
+import { CanvasSource, Texture } from 'pixi.js';
+/** A frame packed on an atlas page (TexturePacker and the like), as `assets/textureAtlas.ts` parses it. */
+export interface PackedFrame {
+    name: string;
+    /** The rect on the page (already swapped to its on-page size when `rotated`). */
+    x: number;
+    y: number;
+    w: number;
+    h: number;
+    /** Stored turned 90° clockwise on the page (Pixi's `rotate: 2`). */
+    rotated: boolean;
+    /** The untrimmed size of the sprite. */
+    sourceW: number;
+    sourceH: number;
+    /** Where the trimmed pixels sit inside the untrimmed sprite; absent when the frame was not trimmed. */
+    trim?: {
+        x: number;
+        y: number;
+        w: number;
+        h: number;
+    };
+    /** The frame's pivot, 0–1, when the packer wrote one. */
+    anchor?: {
+        x: number;
+        y: number;
+    };
+}
+/** A canvas-backed texture with named frames; repaint the canvas, then `refresh()` to upload it. */
+export declare class CanvasTexture {
+    readonly key: string;
+    readonly canvas: HTMLCanvasElement;
+    readonly frames: Map<string, Texture<import("pixi.js").TextureSource<any>>>;
+    readonly source: CanvasSource;
+    readonly whole: Texture;
+    constructor(key: string, canvas: HTMLCanvasElement);
+    get width(): number;
+    get height(): number;
+    get context(): CanvasRenderingContext2D;
+    /** Adds a frame cut from the canvas (`_source` kept for the old call shape). */
+    add(name: string, _source: number, x: number, y: number, w: number, h: number): void;
+    /**
+     * Adds a packed frame cut from `page` (this texture's canvas by default): trimmed frames keep their untrimmed size
+     * (`orig`) so they line up when drawn, and frames the packer turned are turned back (Pixi's `rotate: 2`).
+     */
+    addPacked(frame: PackedFrame, page?: CanvasTexture): void;
+    /**
+     * Registers under this texture a frame that lives on another one (an atlas page after the first), so the frame is
+     * found by this texture's key. A texture of its own over the other page's source: each side frees its own.
+     */
+    adopt(name: string, from: CanvasTexture): void;
+    refresh(): void;
+    destroy(): void;
+}
+/** Every texture of the world by key: the sprite atlas and per-player repainted sheets. */
+export declare class TextureRegistry {
+    private readonly textures;
+    /** Textures repainted or freed while in use (a rig body, its hand): a copy of one must snapshot it first. */
+    private readonly live;
+    private missing;
+    private snapshots;
+    markLive(key: string): void;
+    isLive(key: string): boolean;
+    /** A new texture holding frame `frame` of `key` as it is painted right now; returns its key (one frame, '0'). */
+    snapshot(key: string, frame?: string | number): string;
+    /**
+     * `snapshot` into a texture kept for reuse (`into`): its canvas is repainted in place and uploaded again, and only
+     * made anew when the frame's size changes. Frame '0' is the copy.
+     */
+    snapshotInto(key: string, frame: string | number | undefined, into: string): void;
+    exists(key: string): boolean;
+    addCanvas(key: string, canvas: HTMLCanvasElement): CanvasTexture;
+    /** A canvas cut into equal frames named 0, 1, 2... left to right, then row by row. */
+    addSpriteSheet(key: string, canvas: HTMLCanvasElement, size: {
+        frameWidth: number;
+        frameHeight: number;
+    }): CanvasTexture;
+    /**
+     * A packed atlas (TexturePacker JSON, `AssetLoader.atlas`): the first page under `key`, the others as `key~1`,
+     * `key~2`… like `AtlasBuilder`'s pages, and every frame of every page found under `key` by its name.
+     */
+    addAtlas(key: string, pages: readonly {
+        canvas: HTMLCanvasElement;
+        frames: readonly PackedFrame[];
+    }[]): CanvasTexture;
+    createCanvas(key: string, width: number, height: number): CanvasTexture;
+    remove(key: string): void;
+    get(key: string, frame?: string | number): Texture;
+    private warn;
+}
+//# sourceMappingURL=TextureRegistry.d.ts.map

package/dist/types/core/TextureRegistry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"TextureRegistry.d.ts","sourceRoot":"","sources":["../../../src/core/TextureRegistry.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAa,OAAO,EAAE,MAAM,SAAS,CAAC;AAE3D,2GAA2G;AAC3G,MAAM,WAAW,WAAW;IAC1B,IAAI,EAAE,MAAM,CAAC;IACb,iFAAiF;IACjF,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,oEAAoE;IACpE,OAAO,EAAE,OAAO,CAAC;IACjB,wCAAwC;IACxC,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;IAChB,uGAAuG;IACvG,IAAI,CAAC,EAAE;QAAE,CAAC,EAAE,MAAM,CAAC;QAAC,CAAC,EAAE,MAAM,CAAC;QAAC,CAAC,EAAE,MAAM,CAAC;QAAC,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC;IACtD,yDAAyD;IACzD,MAAM,CAAC,EAAE;QAAE,CAAC,EAAE,MAAM,CAAC;QAAC,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC;CACnC;AAED,oGAAoG;AACpG,qBAAa,aAAa;IAMtB,QAAQ,CAAC,GAAG,EAAE,MAAM;IACpB,QAAQ,CAAC,MAAM,EAAE,iBAAiB;IANpC,QAAQ,CAAC,MAAM,6DAA8B;IAC7C,QAAQ,CAAC,MAAM,EAAE,YAAY,CAAC;IAC9B,QAAQ,CAAC,KAAK,EAAE,OAAO,CAAC;gBAGb,GAAG,EAAE,MAAM,EACX,MAAM,EAAE,iBAAiB;IAMpC,IAAI,KAAK,IAAI,MAAM,CAElB;IAED,IAAI,MAAM,IAAI,MAAM,CAEnB;IAED,IAAI,OAAO,IAAI,wBAAwB,CAEtC;IAED,gFAAgF;IAChF,GAAG,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,IAAI;IAKpF;;;OAGG;IACH,SAAS,CAAC,KAAK,EAAE,WAAW,EAAE,IAAI,GAAE,aAAoB,GAAG,IAAI;IAa/D;;;OAGG;IACH,KAAK,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,aAAa,GAAG,IAAI;IAO9C,OAAO,IAAI,IAAI;IAIf,OAAO,IAAI,IAAI;CAMhB;AAED,2FAA2F;AAC3F,qBAAa,eAAe;IAC1B,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAoC;IAC7D,6GAA6G;IAC7G,OAAO,CAAC,QAAQ,CAAC,IAAI,CAAqB;IAC1C,OAAO,CAAC,OAAO,CAAqB;IACpC,OAAO,CAAC,SAAS,CAAK;IAEtB,QAAQ,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI;IAI3B,MAAM,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO;IAI5B,iHAAiH;IACjH,QAAQ,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,MAAM,GAAG,MAAM,GAAG,MAAM;IAatD;;;OAGG;IACH,YAAY,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,EAAE,IAAI,EAAE,MAAM,GAAG,IAAI;IAkBjF,MAAM,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO;IAI5B,SAAS,CAAC,GAAG,EAAE,MAAM,EAAE,MAAM,EAAE,iBAAiB,GAAG,aAAa;IAOhE,sFAAsF;IACtF,cAAc,CAAC,GAAG,EAAE,MAAM,EAAE,MAAM,EAAE,iBAAiB,EAAE,IAAI,EAAE;QAAE,UAAU,EAAE,MAAM,CAAC;QAAC,WAAW,EAAE,MAAM,CAAA;KAAE,GAAG,aAAa;IAUxH;;;OAGG;IACH,QAAQ,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,SAAS;QAAE,MAAM,EAAE,iBAAiB,CAAC;QAAC,MAAM,EAAE,SAAS,WAAW,EAAE,CAAA;KAAE,EAAE,GAAG,aAAa;IAiBrH,YAAY,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,aAAa;IAOvE,MAAM,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI;IAMzB,GAAG,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,MAAM,GAAG,MAAM,GAAG,OAAO;IAOlD,OAAO,CAAC,IAAI;CAOb"}

package/dist/types/core/Timeline.d.ts

@@ -0,0 +1,115 @@
+import { TimelineBuilder } from './TimelineBuilder.js';
+import type { NestedPlay } from './TimelineChild.js';
+import type { Steppable, Tweener } from './Tweener.js';
+export interface TimelineOptions {
+    /**
+     * The manager that steps it: `stage.tweens` makes it follow the stage's `timeScale` and stop with the stage. Leave
+     * it out to step the timeline yourself with `update(dt)` (a fixed step, a test, a timeline played by another).
+     */
+    tweens?: Tweener;
+    /** Built but not playing until `play()` / `resume()`. */
+    paused?: boolean;
+    /** Extra plays after the first (-1 = forever). */
+    repeat?: number;
+    /** Every second play runs backwards. */
+    yoyo?: boolean;
+    /** Ms of stillness between plays. */
+    repeatDelay?: number;
+    /** Its own speed factor, on top of its manager's. */
+    timeScale?: number;
+    onUpdate?: (timeline: Timeline) => void;
+    onRepeat?: (timeline: Timeline) => void;
+    /** When the playhead reaches the end it is playing toward: the end, or the start when reversed. */
+    onComplete?: (timeline: Timeline) => void;
+}
+/**
+ * Tweens and calls laid out in time and played as one: in sequence by default, overlapping by position (`'<'`,
+ * `'-=100'`, a label), side by side in `parallel` groups, nested (`add`). It can repeat, yoyo, run at its own speed,
+ * pause, seek and play backwards, and `finished` resolves when it completes.
+ *
+ * Built in one go, then it plays: a timeline stepped while empty has nothing left to do and completes, so build it in
+ * the frame it is made (or make it `paused` and `play()` it later). Children are kept sorted by start, which is the
+ * order they are played in going forward (and the reverse going back), so a later tween on the same property wins.
+ */
+export declare class Timeline extends TimelineBuilder implements Steppable, NestedPlay {
+    timeScale: number;
+    readonly repeat: number;
+    readonly yoyo: boolean;
+    readonly repeatDelay: number;
+    /** A timeline holds no targets of its own for `Tweener.killTweensOf`: stop it with `kill()`. */
+    readonly targets: readonly object[];
+    private readonly options;
+    private time;
+    private paused;
+    private reversed;
+    private done;
+    private killed;
+    /** In its manager's list: set again by anything that brings a finished timeline back to life. */
+    private listed;
+    /** The next render starts the run: a call standing at its first point fires. */
+    private fresh;
+    private nestedIn;
+    private resolveFinished;
+    private finishedPromise;
+    private settled;
+    /** Scratch for `locate`, so moving the playhead allocates nothing. */
+    private locCycle;
+    private locLocal;
+    constructor(options?: TimelineOptions);
+    protected adopt(child: TimelineBuilder): NestedPlay;
+    /** Every play and the delays between them, ms; Infinity when it repeats forever. */
+    get totalDuration(): number;
+    /** Where the playhead stands, ms from the start of the first play. */
+    get currentTime(): number;
+    /** 0–1 over the whole run (over the current play when it repeats forever). */
+    get progress(): number;
+    get isPaused(): boolean;
+    get isReversed(): boolean;
+    /** Still has somewhere to go: not completed, not killed. */
+    get isActive(): boolean;
+    /** Resolves when the timeline completes (or is killed, so nothing awaits it forever). A restart makes a new one. */
+    get finished(): Promise<void>;
+    /** Advances by `dt` ms (× `timeScale`): how a timeline with no manager is played. */
+    update(dt: number): void;
+    /** @internal The manager's step: false once there is nothing left to play. */
+    step(dt: number): boolean;
+    pause(): this;
+    /** Carries on the way it was going. */
+    resume(): this;
+    /** Plays forward from where it stands. */
+    play(): this;
+    /** Turns round and plays toward the start (or forward again, if it was reversed). */
+    reverse(): this;
+    /**
+     * Jumps to `to` (ms or a label) and shows it there. Calls on the way are skipped unless `fireCalls`; the playing
+     * state is kept, so a paused timeline stays paused.
+     */
+    seek(to: number | string, fireCalls?: boolean): this;
+    /** Back to the start, playing forward, with a new `finished` if the old one was settled. */
+    restart(): this;
+    /** Stops for good where it stands (nothing is put back) and settles `finished`. */
+    kill(): void;
+    /** @internal The manager's name for `kill` (`Tweener.clear`, a stage destroyed). */
+    remove(): void;
+    /** @internal Played by a parent: its own time and calls, as one span. */
+    playNested(from: number, to: number, fire: boolean, includeStart: boolean): void;
+    private tick;
+    /** Moves the playhead from `from` to `to` (total time), play by play. */
+    private render;
+    /** A play boundary: `onRepeat`, and a forever timeline whose every target is gone ends here. Answers "stop". */
+    private nextPlay;
+    private playCycle;
+    /** Total time → play and time within it, into `locCycle` / `locLocal`. */
+    private locate;
+    /**
+     * Every tween's every target is a destroyed display object. Checked only when a forever timeline turns round, as
+     * `Tween` drops a forever tween whose sprites were freed: otherwise it would hold them for good.
+     */
+    private orphaned;
+    /** Brought back to life (reversed, sought, restarted, resumed): its manager steps it again. */
+    private wake;
+    private relist;
+    private settle;
+    private newPromise;
+}
+//# sourceMappingURL=Timeline.d.ts.map

package/dist/types/core/Timeline.d.ts.map

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

package/dist/types/core/TimelineBuilder.d.ts

@@ -0,0 +1,53 @@
+import { type EaseFn } from './eases.js';
+import { type TimelinePosition } from './timelinePlace.js';
+import { TimelineChild, type NestedPlay } from './TimelineChild.js';
+/** A number to tween to, or `{ from, to }` to start from a given value instead of the target's own. */
+export type TimelineProps = Record<string, number | {
+    from?: number;
+    to: number;
+}>;
+export interface TimelineTweenOptions {
+    /** Ms (default 1000, as `Tweener`'s). */
+    duration?: number;
+    /** A name `easeByName` knows ('Quad.Out' when left out, as `Tweener`'s) or an ease function. */
+    ease?: string | EaseFn;
+    at?: TimelinePosition;
+}
+/**
+ * The building half of `Timeline`: where each tween, call, gap and nested timeline goes. Kept apart from the playing
+ * half so each stays readable; nothing here runs per frame.
+ */
+export declare abstract class TimelineBuilder {
+    /** Sorted by start; equal starts keep the order they were added in. */
+    protected readonly children: TimelineChild[];
+    protected readonly labels: Map<string, number>;
+    /** The longest child's end, kept as children are added rather than summed every frame. */
+    private length;
+    private lastStart;
+    private lastEnd;
+    private group;
+    /** Checks `child` may be played by this timeline and takes it over (it stops being stepped alone). */
+    protected abstract adopt(child: TimelineBuilder): NestedPlay;
+    /** One play, ms (the longest child's end). */
+    get duration(): number;
+    /** Tweens the numeric `props` of `targets` (one object or several), after what came before unless `at` says. */
+    to(targets: object | readonly object[], props: TimelineProps, options?: TimelineTweenOptions): this;
+    /** Calls `fn` when the playhead passes `at` (default: the end so far), going either way. */
+    call(fn: () => void, at?: TimelinePosition): this;
+    /** `ms` of nothing: the next child starts that much later, and a wait at the end makes the timeline longer. */
+    wait(ms: number): this;
+    /** Names a point (default: the end so far), for positions and `seek`. */
+    label(name: string, at?: TimelinePosition): this;
+    /** Where a label stands, if it is set. */
+    labelTime(name: string): number | undefined;
+    /**
+     * Everything `build` adds starts together, at `at` (default: the end so far); a position inside is measured from
+     * the group's start. What follows the group starts at its longest child's end.
+     */
+    parallel(build: (timeline: this) => void, at?: TimelinePosition): this;
+    /** Plays another timeline (built, not repeating forever) as one child of this one; it is no longer stepped alone. */
+    add(child: TimelineBuilder, at?: TimelinePosition): this;
+    private place;
+    private insert;
+}
+//# sourceMappingURL=TimelineBuilder.d.ts.map

package/dist/types/core/TimelineBuilder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"TimelineBuilder.d.ts","sourceRoot":"","sources":["../../../src/core/TimelineBuilder.ts"],"names":[],"mappings":"AAAA,OAAO,EAAc,KAAK,MAAM,EAAE,MAAM,SAAS,CAAC;AAClD,OAAO,EAA8B,KAAK,gBAAgB,EAAE,MAAM,iBAAiB,CAAC;AACpF,OAAO,EAAE,aAAa,EAAE,KAAK,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAGjE,uGAAuG;AACvG,MAAM,MAAM,aAAa,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG;IAAE,IAAI,CAAC,EAAE,MAAM,CAAC;IAAC,EAAE,EAAE,MAAM,CAAA;CAAE,CAAC,CAAC;AAEnF,MAAM,WAAW,oBAAoB;IACnC,yCAAyC;IACzC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,gGAAgG;IAChG,IAAI,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC;IACvB,EAAE,CAAC,EAAE,gBAAgB,CAAC;CACvB;AAED;;;GAGG;AACH,8BAAsB,eAAe;IACnC,uEAAuE;IACvE,SAAS,CAAC,QAAQ,CAAC,QAAQ,EAAE,aAAa,EAAE,CAAM;IAClD,SAAS,CAAC,QAAQ,CAAC,MAAM,sBAA6B;IACtD,0FAA0F;IAC1F,OAAO,CAAC,MAAM,CAAK;IACnB,OAAO,CAAC,SAAS,CAAK;IACtB,OAAO,CAAC,OAAO,CAAK;IACpB,OAAO,CAAC,KAAK,CAA+C;IAE5D,sGAAsG;IACtG,SAAS,CAAC,QAAQ,CAAC,KAAK,CAAC,KAAK,EAAE,eAAe,GAAG,UAAU;IAE5D,8CAA8C;IAC9C,IAAI,QAAQ,IAAI,MAAM,CAErB;IAED,gHAAgH;IAChH,EAAE,CAAC,OAAO,EAAE,MAAM,GAAG,SAAS,MAAM,EAAE,EAAE,KAAK,EAAE,aAAa,EAAE,OAAO,GAAE,oBAAyB,GAAG,IAAI;IAqBvG,4FAA4F;IAC5F,IAAI,CAAC,EAAE,EAAE,MAAM,IAAI,EAAE,EAAE,CAAC,EAAE,gBAAgB,GAAG,IAAI;IAIjD,+GAA+G;IAC/G,IAAI,CAAC,EAAE,EAAE,MAAM,GAAG,IAAI;IAItB,yEAAyE;IACzE,KAAK,CAAC,IAAI,EAAE,MAAM,EAAE,EAAE,CAAC,EAAE,gBAAgB,GAAG,IAAI;IAKhD,0CAA0C;IAC1C,SAAS,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS;IAI3C;;;OAGG;IACH,QAAQ,CAAC,KAAK,EAAE,CAAC,QAAQ,EAAE,IAAI,KAAK,IAAI,EAAE,EAAE,CAAC,EAAE,gBAAgB,GAAG,IAAI;IAgBtE,qHAAqH;IACrH,GAAG,CAAC,KAAK,EAAE,eAAe,EAAE,EAAE,CAAC,EAAE,gBAAgB,GAAG,IAAI;IAMxD,OAAO,CAAC,KAAK;IAMb,OAAO,CAAC,MAAM;CAUf"}

package/dist/types/core/TimelineChild.d.ts

@@ -0,0 +1,51 @@
+import type { EaseFn } from './eases.js';
+import type { TweenTarget } from './Tweener.js';
+/** What a nested timeline offers the timeline playing it. */
+export interface NestedPlay {
+    readonly totalDuration: number;
+    /** Plays from `from` to `to` (its own time, ms); `includeStart` fires a call standing exactly at `from`. */
+    playNested(from: number, to: number, fire: boolean, includeStart: boolean): void;
+}
+export type ChildKind = 'tween' | 'call' | 'gap' | 'nested';
+/**
+ * One thing on a timeline: a tween, a call, an empty gap (`wait`) or a nested timeline, at `start` for `duration` ms.
+ * A tween reads its start values the first time the playhead reaches it — not when it is added — so a tween that
+ * follows another on the same property starts where that one ended, and keeps those values for seeking and reversing.
+ */
+export declare class TimelineChild {
+    readonly kind: ChildKind;
+    readonly start: number;
+    readonly duration: number;
+    readonly targets: readonly TweenTarget[];
+    private readonly props;
+    private readonly ends;
+    /** A start value given as `{ from, to }`, per prop; undefined reads the target's own. */
+    private readonly givenFrom;
+    private readonly ease;
+    private readonly fn;
+    private readonly nested;
+    /** Every target × prop start value, captured once (`inited`). */
+    private readonly froms;
+    private inited;
+    /** Progress (tween) or own time (nested) last written; NaN before the first, so the first always writes. */
+    private last;
+    constructor(kind: ChildKind, start: number, duration: number, targets?: readonly TweenTarget[], props?: readonly string[], ends?: readonly number[], 
+    /** A start value given as `{ from, to }`, per prop; undefined reads the target's own. */
+    givenFrom?: readonly (number | undefined)[], ease?: EaseFn | null, fn?: (() => void) | null, nested?: NestedPlay | null);
+    get end(): number;
+    /**
+     * The playhead moved from `a` to `b` (the parent's own time, either way). Calls fire when `fire` is set and their
+     * time lies in the span with its start left out and its end kept — so a call met at the end of one frame does not
+     * fire again at the start of the next — unless `includeStart` keeps the start too (a run or a repeat beginning).
+     */
+    play(a: number, b: number, fire: boolean, includeStart: boolean): void;
+    private playTween;
+    private capture;
+    private playNested;
+}
+/**
+ * Whether a call at `at` lies in the span the playhead swept from `a` to `b`: the end kept, the start only when
+ * `includeStart` says so.
+ */
+export declare function crossed(a: number, b: number, at: number, includeStart: boolean): boolean;
+//# sourceMappingURL=TimelineChild.d.ts.map

package/dist/types/core/TimelineChild.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"TimelineChild.d.ts","sourceRoot":"","sources":["../../../src/core/TimelineChild.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,SAAS,CAAC;AACtC,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,WAAW,CAAC;AAG7C,6DAA6D;AAC7D,MAAM,WAAW,UAAU;IACzB,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAC;IAC/B,4GAA4G;IAC5G,UAAU,CAAC,IAAI,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,EAAE,IAAI,EAAE,OAAO,EAAE,YAAY,EAAE,OAAO,GAAG,IAAI,CAAC;CAClF;AAED,MAAM,MAAM,SAAS,GAAG,OAAO,GAAG,MAAM,GAAG,KAAK,GAAG,QAAQ,CAAC;AAE5D;;;;GAIG;AACH,qBAAa,aAAa;IAQtB,QAAQ,CAAC,IAAI,EAAE,SAAS;IACxB,QAAQ,CAAC,KAAK,EAAE,MAAM;IACtB,QAAQ,CAAC,QAAQ,EAAE,MAAM;IACzB,QAAQ,CAAC,OAAO,EAAE,SAAS,WAAW,EAAE;IACxC,OAAO,CAAC,QAAQ,CAAC,KAAK;IACtB,OAAO,CAAC,QAAQ,CAAC,IAAI;IACrB,yFAAyF;IACzF,OAAO,CAAC,QAAQ,CAAC,SAAS;IAC1B,OAAO,CAAC,QAAQ,CAAC,IAAI;IACrB,OAAO,CAAC,QAAQ,CAAC,EAAE;IACnB,OAAO,CAAC,QAAQ,CAAC,MAAM;IAjBzB,iEAAiE;IACjE,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAgB;IACtC,OAAO,CAAC,MAAM,CAAS;IACvB,4GAA4G;IAC5G,OAAO,CAAC,IAAI,CAAc;gBAGf,IAAI,EAAE,SAAS,EACf,KAAK,EAAE,MAAM,EACb,QAAQ,EAAE,MAAM,EAChB,OAAO,GAAE,SAAS,WAAW,EAAO,EAC5B,KAAK,GAAE,SAAS,MAAM,EAAO,EAC7B,IAAI,GAAE,SAAS,MAAM,EAAO;IAC7C,yFAAyF;IACxE,SAAS,GAAE,SAAS,CAAC,MAAM,GAAG,SAAS,CAAC,EAAO,EAC/C,IAAI,GAAE,MAAM,GAAG,IAAW,EAC1B,EAAE,GAAE,CAAC,MAAM,IAAI,CAAC,GAAG,IAAW,EAC9B,MAAM,GAAE,UAAU,GAAG,IAAW;IAGnD,IAAI,GAAG,IAAI,MAAM,CAEhB;IAED;;;;OAIG;IACH,IAAI,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,IAAI,EAAE,OAAO,EAAE,YAAY,EAAE,OAAO,GAAG,IAAI;IAgBtE,OAAO,CAAC,SAAS;IAyBjB,OAAO,CAAC,OAAO;IAQf,OAAO,CAAC,UAAU;CAiBnB;AAED;;;GAGG;AACH,wBAAgB,OAAO,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,EAAE,YAAY,EAAE,OAAO,GAAG,OAAO,CAGxF"}

package/dist/types/core/Tweener.d.ts

@@ -0,0 +1,70 @@
+import { Timeline, type TimelineOptions } from './Timeline.js';
+export type TweenTarget = Record<string, unknown> & {
+    destroyed?: boolean;
+};
+/** Tween config in the shape the renderer has always used: numeric props at the top level or under `props`. */
+export interface TweenConfig {
+    targets: object | object[];
+    duration?: number;
+    delay?: number;
+    /** Ms to stay at the end values before a yoyo plays back. */
+    hold?: number;
+    yoyo?: boolean;
+    /** Extra plays after the first (-1 = forever). */
+    repeat?: number;
+    ease?: string;
+    props?: Record<string, number>;
+    onStart?: () => void;
+    onUpdate?: () => void;
+    onComplete?: () => void;
+    [prop: string]: unknown;
+}
+/** One running tween; `remove()` stops it without calling onComplete. */
+export declare class Tween {
+    private readonly cfg;
+    private readonly ends;
+    private tracks;
+    private elapsed;
+    private plays;
+    removed: boolean;
+    readonly targets: TweenTarget[];
+    constructor(cfg: TweenConfig, ends: Record<string, number>);
+    /**
+     * Every target is a destroyed display object: nothing is left to move. A forever tween (`repeat: -1`) on a sprite
+     * its owner freed used to stay in the list for good, holding the sprite, and the list grew with every map loaded.
+     * A plain object (a clock a callback reads) has no `destroyed` and is never taken for one. Only a forever tween is
+     * dropped this way: a finite one still runs out and calls its `onComplete`, which may clean up more than the sprite.
+     */
+    private orphaned;
+    remove(): void;
+    stop(): void;
+    /** Advances by `dt` ms; returns false once the tween is finished. */
+    step(dt: number): boolean;
+}
+/**
+ * Anything the manager can step each frame: a `Tween`, or a `Timeline` it drives. `step` answers false once finished
+ * (the manager then drops it); `remove` stops it for good; `targets` is what `killTweensOf` matches against.
+ */
+export interface Steppable {
+    step(dt: number): boolean;
+    remove(): void;
+    readonly targets: readonly object[];
+}
+/** Frame-driven tween manager (the renderer's replacement for Phaser's TweenManager). */
+export declare class Tweener {
+    /** Global speed factor; hit-stop slows every tween at once. */
+    timeScale: number;
+    private tweens;
+    add(cfg: TweenConfig): Tween;
+    /**
+     * Steps `item` every frame from the next one on, at this manager's `timeScale`, until its `step` answers false or
+     * the manager is cleared (a stage's manager is cleared when the stage is destroyed).
+     */
+    run<T extends Steppable>(item: T): T;
+    /** A `Timeline` driven by this manager: it follows `timeScale` and stops with `clear`. */
+    timeline(options?: Omit<TimelineOptions, 'tweens'>): Timeline;
+    killTweensOf(target: object | object[]): void;
+    update(dt: number): void;
+    clear(): void;
+}
+//# sourceMappingURL=Tweener.d.ts.map

package/dist/types/core/Tweener.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Tweener.d.ts","sourceRoot":"","sources":["../../../src/core/Tweener.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,QAAQ,EAAE,KAAK,eAAe,EAAE,MAAM,YAAY,CAAC;AAG5D,MAAM,MAAM,WAAW,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG;IAAE,SAAS,CAAC,EAAE,OAAO,CAAA;CAAE,CAAC;AAE5E,+GAA+G;AAC/G,MAAM,WAAW,WAAW;IAC1B,OAAO,EAAE,MAAM,GAAG,MAAM,EAAE,CAAC;IAC3B,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,6DAA6D;IAC7D,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,IAAI,CAAC,EAAE,OAAO,CAAC;IACf,kDAAkD;IAClD,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,KAAK,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAC/B,OAAO,CAAC,EAAE,MAAM,IAAI,CAAC;IACrB,QAAQ,CAAC,EAAE,MAAM,IAAI,CAAC;IACtB,UAAU,CAAC,EAAE,MAAM,IAAI,CAAC;IACxB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC;CACzB;AAaD,yEAAyE;AACzE,qBAAa,KAAK;IAQd,OAAO,CAAC,QAAQ,CAAC,GAAG;IACpB,OAAO,CAAC,QAAQ,CAAC,IAAI;IARvB,OAAO,CAAC,MAAM,CAAwB;IACtC,OAAO,CAAC,OAAO,CAAK;IACpB,OAAO,CAAC,KAAK,CAAK;IAClB,OAAO,UAAS;IAChB,QAAQ,CAAC,OAAO,EAAE,WAAW,EAAE,CAAC;gBAGb,GAAG,EAAE,WAAW,EAChB,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC;IAM/C;;;;;OAKG;IACH,OAAO,CAAC,QAAQ;IAQhB,MAAM,IAAI,IAAI;IAId,IAAI,IAAI,IAAI;IAIZ,qEAAqE;IACrE,IAAI,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO;CA+C1B;AAED;;;GAGG;AACH,MAAM,WAAW,SAAS;IACxB,IAAI,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC;IAC1B,MAAM,IAAI,IAAI,CAAC;IACf,QAAQ,CAAC,OAAO,EAAE,SAAS,MAAM,EAAE,CAAC;CACrC;AAED,yFAAyF;AACzF,qBAAa,OAAO;IAClB,+DAA+D;IAC/D,SAAS,SAAK;IACd,OAAO,CAAC,MAAM,CAAmB;IAEjC,GAAG,CAAC,GAAG,EAAE,WAAW,GAAG,KAAK;IAoB5B;;;OAGG;IACH,GAAG,CAAC,CAAC,SAAS,SAAS,EAAE,IAAI,EAAE,CAAC,GAAG,CAAC;IAKpC,0FAA0F;IAC1F,QAAQ,CAAC,OAAO,GAAE,IAAI,CAAC,eAAe,EAAE,QAAQ,CAAM,GAAG,QAAQ;IAIjE,YAAY,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,EAAE,GAAG,IAAI;IAK7C,MAAM,CAAC,EAAE,EAAE,MAAM,GAAG,IAAI;IAiBxB,KAAK,IAAI,IAAI;CAId"}

package/dist/types/core/atlas.d.ts

@@ -0,0 +1,16 @@
+import type { TextureRegistry } from './TextureRegistry.js';
+/**
+ * Packs many small procedurally painted canvases into as few textures as the GPU allows, so Pixi can batch every
+ * sprite of the world into very few draw calls. One page on every desktop (up to 8192 square); a device whose GPU
+ * takes less gets pages of `limit` (`atlasPageLimit`, `planAtlas`). Every frame is registered under the one `key`
+ * whichever page holds it — the pages after the first are textures of their own (`key~1`, `key~2`…) whose frames
+ * the first page's texture adopts — so the world keeps asking for `atlas` and a frame name, and never knows.
+ * Frame names: `name` for single images, `name#i` for sheet frames.
+ */
+export declare class AtlasBuilder {
+    private items;
+    add(name: string, canvas: HTMLCanvasElement): void;
+    addSheet(name: string, canvas: HTMLCanvasElement, frameWidth: number, frameHeight: number): void;
+    build(textures: TextureRegistry, key: string, limit?: number): void;
+}
+//# sourceMappingURL=atlas.d.ts.map

package/dist/types/core/atlas.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"atlas.d.ts","sourceRoot":"","sources":["../../../src/core/atlas.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAC;AAUzD;;;;;;;GAOG;AACH,qBAAa,YAAY;IACvB,OAAO,CAAC,KAAK,CAAmB;IAEhC,GAAG,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,iBAAiB,GAAG,IAAI;IAIlD,QAAQ,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,iBAAiB,EAAE,UAAU,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,GAAG,IAAI;IAIhG,KAAK,CAAC,QAAQ,EAAE,eAAe,EAAE,GAAG,EAAE,MAAM,EAAE,KAAK,SAAkB,GAAG,IAAI;CAuC7E"}

package/dist/types/core/atlasPlan.d.ts

@@ -0,0 +1,34 @@
+export declare const ATLAS_PAD = 2;
+/** The page side every desktop GPU takes, and the one the atlas was built to before pages existed. */
+export declare const ATLAS_PAGE_FULL = 8192;
+/**
+ * How big an atlas page may be on this device: 8192 wherever the GPU takes it (every desktop — unchanged), else
+ * split at 4096, or at the largest power of two the GPU does take if that is smaller still. Unknown: 8192, as before.
+ */
+export declare function atlasPageLimit(maxTextureSize: number | null): number;
+export interface AtlasSize {
+    w: number;
+    h: number;
+}
+export interface AtlasPage {
+    width: number;
+    height: number;
+}
+export interface AtlasPlan {
+    pages: AtlasPage[];
+    /** One per input, in input order: the page and the top-left corner. */
+    places: {
+        page: number;
+        x: number;
+        y: number;
+    }[];
+}
+/**
+ * Shelf-packs the images, tallest first, into pages no larger than `limit` on either side. The page width is the
+ * power of two that fits the widest image and the square root of the total area (at least 1024), capped at `limit`;
+ * a shelf that would run past `limit` starts a new page. With everything fitting under `limit` this is exactly the
+ * single page the atlas always was. An image larger than `limit` itself is given a page of its own (the GPU will
+ * refuse it, but nothing else is lost with it).
+ */
+export declare function planAtlas(sizes: readonly AtlasSize[], limit: number): AtlasPlan;
+//# sourceMappingURL=atlasPlan.d.ts.map

package/dist/types/core/atlasPlan.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"atlasPlan.d.ts","sourceRoot":"","sources":["../../../src/core/atlasPlan.ts"],"names":[],"mappings":"AAKA,eAAO,MAAM,SAAS,IAAI,CAAC;AAE3B,sGAAsG;AACtG,eAAO,MAAM,eAAe,OAAO,CAAC;AAIpC;;;GAGG;AACH,wBAAgB,cAAc,CAAC,cAAc,EAAE,MAAM,GAAG,IAAI,GAAG,MAAM,CAGpE;AAED,MAAM,WAAW,SAAS;IACxB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACX;AAED,MAAM,WAAW,SAAS;IACxB,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;CAChB;AAED,MAAM,WAAW,SAAS;IACxB,KAAK,EAAE,SAAS,EAAE,CAAC;IACnB,uEAAuE;IACvE,MAAM,EAAE;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,CAAC,EAAE,MAAM,CAAC;QAAC,CAAC,EAAE,MAAM,CAAA;KAAE,EAAE,CAAC;CAClD;AAED;;;;;;GAMG;AACH,wBAAgB,SAAS,CAAC,KAAK,EAAE,SAAS,SAAS,EAAE,EAAE,KAAK,EAAE,MAAM,GAAG,SAAS,CAqC/E"}

package/dist/types/core/blendLayer.d.ts

@@ -0,0 +1,23 @@
+import type { BLEND_MODES } from 'pixi.js';
+import type { Group } from './Group.js';
+import type { Stage } from './Stage.js';
+export interface BlendLayerOptions {
+    /** How its sprites blend (default `'add'`, light). Set on the container, so a sprite added needs no blend of its own. */
+    blend?: BLEND_MODES;
+    /**
+     * Its depth among the world's children (default 999,000: over every body sorted by a y under a million px, under
+     * labels a game keeps just below 1,000,000). Applied whenever given, so the first caller need not be the one to set it.
+     */
+    depth?: number;
+    /** A stage may hold several (a light layer and a shadow one): each name is its own container (default the blend's). */
+    name?: string;
+}
+/**
+ * One container per stage (and name) for every sprite of a blend mode: lamp glows, portals, the glow under loot.
+ * Laid among the bodies by depth, each additive sprite switched the blend mode twice and split the sprite batch — in
+ * one game 85–97 draw calls a frame in a fight, two thirds of them blend changes; gathered here they are one run.
+ * The price is that they no longer sort with the bodies: the layer stands over all of them, so put a glow where its
+ * light falls rather than relying on a body to cover it. Made again if destroyed (a scene change).
+ */
+export declare function blendLayer(stage: Stage, options?: BlendLayerOptions): Group;
+//# sourceMappingURL=blendLayer.d.ts.map

package/dist/types/core/blendLayer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"blendLayer.d.ts","sourceRoot":"","sources":["../../../src/core/blendLayer.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,SAAS,CAAC;AAC3C,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,SAAS,CAAC;AACrC,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,SAAS,CAAC;AAErC,MAAM,WAAW,iBAAiB;IAChC,yHAAyH;IACzH,KAAK,CAAC,EAAE,WAAW,CAAC;IACpB;;;OAGG;IACH,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,uHAAuH;IACvH,IAAI,CAAC,EAAE,MAAM,CAAC;CACf;AAID;;;;;;GAMG;AACH,wBAAgB,UAAU,CAAC,KAAK,EAAE,KAAK,EAAE,OAAO,GAAE,iBAAsB,GAAG,KAAK,CAiB/E"}

package/dist/types/core/eases.d.ts

@@ -0,0 +1,3 @@
+export type EaseFn = (t: number) => number;
+export declare function easeByName(name: string | undefined): EaseFn;
+//# sourceMappingURL=eases.d.ts.map

package/dist/types/core/eases.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"eases.d.ts","sourceRoot":"","sources":["../../../src/core/eases.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,MAAM,GAAG,CAAC,CAAC,EAAE,MAAM,KAAK,MAAM,CAAC;AAmB3C,wBAAgB,UAAU,CAAC,IAAI,EAAE,MAAM,GAAG,SAAS,GAAG,MAAM,CAK3D"}