@vgai/engine 0.2.0 → 0.3.0

package/dist/world2d/pixi-game-adapter.js

@@ -0,0 +1,211 @@
+import RAPIER from '@dimforge/rapier2d-compat';
+import { createAssetCache } from '../assets';
+import { createGameLoop } from '../core/game-loop';
+import { createSystemRunner } from '../core/system-runner';
+import { createComponentManager } from '../ecs/component-manager';
+import { createGame, createWorldInstance, } from '../runtime/game';
+import { createCollision2DSystem, createTriggerDispatch2D } from './collision-2d';
+import { createPhysics2DRegistry } from './physics2d-registry';
+import { createPixiSurface } from './pixi-surface';
+import { loadScene2DFromData } from './scene2d-loader';
+import { createTransformWriter2D } from './transform-writer-2d';
+/**
+ * The first-party implementer that mounts an authored world2d scene — the 2D
+ * analog of `VgaiSceneGameAdapter`. It builds the Pixi surface + Rapier 2D world,
+ * registers the engine systems into the shared phase runner, loads the scene (or
+ * runs a setup), and returns a `MountedGame2D`.
+ */
+export class PixiSceneGameAdapter {
+    config;
+    id;
+    constructor(config = {}) {
+        this.config = config;
+        this.id = config.id ?? 'pixi-scene';
+    }
+    async mount(host) {
+        const { sceneData, setup, registry = {} } = this.config;
+        // --- Pixi surface (autoStart:false; engine loop drives render) ---
+        const surface = await createPixiSurface({
+            canvas: host.canvas,
+            width: host.width,
+            height: host.height,
+            ...(sceneData?.background ? { background: sceneData.background } : {}),
+            // T6.1 slice 1 (worlds-path host hints — see `World2DHost`'s fields):
+            // all optional, all no-ops when the host is the legacy
+            // `createWorld2DRuntime` entry (which never sets them), so behavior
+            // there is unchanged.
+            ...(host.dpr !== undefined ? { resolution: host.dpr } : {}),
+            ...(host.transparent ? { transparent: true } : {}),
+            ...(host.preserveDrawingBuffer ? { preserveDrawingBuffer: true } : {}),
+        });
+        // --- Rapier 2D world (separate from the 3D world) ---
+        await RAPIER.init();
+        const gravity = sceneData?.gravity ?? [0, 980];
+        const rapier2dWorld = new RAPIER.World({ x: gravity[0], y: gravity[1] });
+        const eventQueue = new RAPIER.EventQueue(true);
+        const physics2d = createPhysics2DRegistry();
+        const writeTransforms2D = createTransformWriter2D(physics2d);
+        const collisions2d = createCollision2DSystem(rapier2dWorld, eventQueue);
+        const systems = createSystemRunner();
+        systems.add('physics', () => rapier2dWorld.step(eventQueue));
+        systems.add('postPhysics', () => {
+            collisions2d.drain();
+            writeTransforms2D();
+        });
+        systems.add('render', () => surface.render());
+        const uiContainer = host.ui ?? document.createElement('div');
+        const ctx = {
+            app: surface.app,
+            stage: surface.world,
+            rapier2dWorld,
+            rapier2d: RAPIER,
+            physics2d,
+            collisions2d,
+            components: null,
+            systems,
+            uiContainer,
+        };
+        // T7.3 slice 1/2: the pixi world's components attach onto the SAME
+        // unified `ComponentManager` (`ecs/component-manager.ts`) the threejs
+        // path uses, constructed for kind `'pixijs'` — the world2d-silo manager
+        // is deleted (T7.3 slice 2). `ctx` is cast to `GameContext` for the
+        // manager's internal typing only: at runtime this object IS the real
+        // `World2DContext` above, so `GameComponent<'pixijs'>` subclasses that
+        // need real 2D ctx fields (e.g. `Camera2DFollow`, which widens its own
+        // `update`'s ctx param to `GameContext | World2DContext` and narrows
+        // back down) still receive their real ctx, unchanged behavior — the
+        // same cast `test/mirror-tree-guard.test.ts` uses for its unit-level
+        // pixi manager. `createComponentManager`'s positional `physics`
+        // parameter (the 3D `PhysicsRegistry`) is optional (T7.3 slice 2) and
+        // omitted here — a `'pixijs'`-kind manager never reads it (rigidBody/
+        // collider resolve from `physics2d` instead — see `resolvePhysicsRefs`
+        // in `ecs/component-manager.ts`).
+        ctx.components = createComponentManager(ctx, undefined, {
+            kind: 'pixijs',
+            physics2d,
+        });
+        collisions2d.onCollision(createTriggerDispatch2D(physics2d, ctx.components, rapier2dWorld, ctx));
+        // --- Load scene or run setup ---
+        let sceneInstance = null;
+        let cleanup = null;
+        if (sceneData) {
+            sceneInstance = await loadScene2DFromData(sceneData, ctx, registry);
+        }
+        else if (setup) {
+            cleanup = await setup(ctx);
+        }
+        return {
+            kind: 'pixijs',
+            firstParty: true,
+            stage: surface.world,
+            scene: surface.world,
+            camera: surface.world,
+            drivesOwnLoop: false,
+            ctx,
+            update: (dt) => systems.run(dt),
+            resize: (w, h) => surface.resize(w, h),
+            // T7.3 slice 1: no `endFrame` hook — world2d has no per-substep
+            // post-phase work today (no `input.endFrame()` analog; HUD input is
+            // plain DOM events, not routed through an engine InputManager).
+            frame: {
+                runPhase: (phase, dt) => systems.runPhase(phase, dt),
+            },
+            dispose: () => {
+                cleanup?.dispose();
+                sceneInstance?.dispose();
+                ctx.components.clear();
+                physics2d.clear();
+                rapier2dWorld.free();
+                eventQueue.free();
+                surface.dispose();
+            },
+        };
+    }
+}
+/**
+ * Host entry for world2d — the sibling of `createGameRuntime`, kept separate so the
+ * proven THREE host/interfaces are untouched (the stacked-own-root option the spec's
+ * surface-host-backend-neutral allows). Owns the canvas and constructs a real `Game`
+ * (T7.3 slice 1) with exactly one `'pixijs'`-kind `WorldInstance`, driven each fixed
+ * substep through `Game.runFrame` — the world2d analog of `createGameRuntime`'s
+ * `registerDefaultThreeWorld` (`runtime/create-runtime.ts`). Before T7.3 this ran its
+ * own standalone `createGameLoop` calling `mounted.update` directly; that loop is
+ * retired here in favor of one shared frame executor per game root.
+ */
+export async function createWorld2DRuntime(config) {
+    const { canvas, width, height, ui, ...sceneConfig } = config;
+    const adapter = new PixiSceneGameAdapter(sceneConfig);
+    const mounted = await adapter.mount({ canvas, width, height, ...(ui ? { ui } : {}) });
+    const assets = createAssetCache();
+    // `game` is referenced here before its `const` below only textually — this
+    // closure isn't invoked until `loop.start()`, well after `game` exists
+    // (same forward-reference pattern `create-runtime.ts` uses).
+    const loop = createGameLoop({
+        fixedTimestep: 1 / 60,
+        maxSubSteps: 8,
+        update: (dt) => {
+            game.runFrame(dt);
+        },
+    });
+    const game = createGame({ loop, assets });
+    // T7.5: `mounted` (a `MountedGame2D`, extending `MountedPixiWorld`) and
+    // `adapter` (this `PixiSceneGameAdapter`, satisfying `WorldInstance.adapter`'s
+    // minimal `AdapterHandle` shape — see that field's doc comment in
+    // `runtime/game.ts`) now pass through with ZERO cast — previously this cast
+    // through `GameAdapter`/`MountedGame`, which hardwired THREE `scene`/`camera`.
+    const pixiWorld = createWorldInstance({
+        id: 'main',
+        kind: 'pixijs',
+        adapter,
+        mounted,
+        stage: mounted.stage,
+        physics2d: mounted.ctx.physics2d,
+        collisions2d: mounted.ctx.collisions2d,
+        frame: mounted.frame,
+    });
+    // T7.2/T7.3 world-wiring backfill (mirrors `registerThreeWorld` in
+    // `create-runtime.ts`): scene-authored components attach DURING `mount()`,
+    // before this `WorldInstance` exists, so `instance.world` is left
+    // `undefined` for each of them — `adoptWorld` backfills it now, once, for
+    // every already-attached instance still missing a world.
+    mounted.ctx.components.adoptWorld(pixiWorld);
+    game.registerWorld(pixiWorld);
+    loop.start();
+    if (typeof window !== 'undefined' && import.meta.env?.DEV) {
+        window['__vgaiWorld2d'] = {
+            app: mounted.ctx.app,
+            stage: mounted.stage,
+            physics2d: mounted.ctx.physics2d,
+        };
+    }
+    return {
+        stop() {
+            loop.stop();
+            mounted.dispose();
+        },
+        // D10/T7.6: route through the real `Game.play` control surface instead of
+        // `loop.timeScale = 0/1` — that starved the accumulator entirely (per D1,
+        // zero substeps ⇒ zero renders too), the exact bug this control surface
+        // replaces. `Game.play.pause()` freezes this world's simulation (it is
+        // `pausable` by default) while its `render` phase keeps running every
+        // substep — the screen does not go black while paused.
+        pause() {
+            game.play.pause();
+        },
+        resume() {
+            game.play.resume();
+        },
+        step() {
+            game.play.step();
+        },
+        resize(w, h) {
+            // T7.5/T7.6 own real per-world resize routing through the Game/host
+            // surface split (the host is not yet surface-neutral for world2d) —
+            // kept as today's direct host→surface call for this slice.
+            mounted.resize?.(w, h);
+        },
+        get mounted() {
+            return mounted;
+        },
+    };
+}

package/dist/world2d/pixi-surface.d.ts

@@ -0,0 +1,39 @@
+import { Application, Container } from 'pixi.js';
+export interface PixiSurface {
+    app: Application;
+    /** The world container (the 2D "camera": pan/zoom by transforming this). */
+    world: Container;
+    /** Render one frame (called from the engine's `render` phase). */
+    render: () => void;
+    resize: (width: number, height: number) => void;
+    dispose: () => void;
+}
+export interface PixiSurfaceOptions {
+    canvas: HTMLCanvasElement;
+    width: number;
+    height: number;
+    background?: string;
+    resolution?: number;
+    antialias?: boolean;
+    /** Stacked-composition transparency (COMPOSITION-DESIGN.md D5 §1, T6.1
+     *  slice 1): when true, the surface clears with alpha 0
+     *  (`backgroundAlpha:0`) instead of an opaque `background`, so a world
+     *  layered ABOVE another shows the layer below through it. */
+    transparent?: boolean;
+    /** Capture tier cost (D5 §4): flat on `Application.init`, never nested
+     *  under `context:` (the documented pixi trap) — required for any later
+     *  `drawImage()`-based composite capture of this surface. */
+    preserveDrawingBuffer?: boolean;
+}
+/**
+ * Create the world2d render surface — a PixiJS v8 `Application` whose auto-ticker
+ * is DISABLED (`autoStart:false`), so the engine's fixed-timestep loop drives
+ * rendering by calling `render()` from the `render` phase (mirroring how the
+ * Three.js adapter calls `composer.render(dt)`).
+ *
+ * `app.stage` holds a single `world` Container — the 2D camera lives here as a
+ * transform on `world` (pan = world.position, zoom = world.scale), per the spec's
+ * backend-2d-camera resolution. Screen-space HUD stays in the React/DOM overlay.
+ */
+export declare function createPixiSurface(opts: PixiSurfaceOptions): Promise<PixiSurface>;
+//# sourceMappingURL=pixi-surface.d.ts.map

package/dist/world2d/pixi-surface.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pixi-surface.d.ts","sourceRoot":"","sources":["../../src/world2d/pixi-surface.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,SAAS,EAAE,MAAM,SAAS,CAAC;AAEjD,MAAM,WAAW,WAAW;IAC1B,GAAG,EAAE,WAAW,CAAC;IACjB,4EAA4E;IAC5E,KAAK,EAAE,SAAS,CAAC;IACjB,kEAAkE;IAClE,MAAM,EAAE,MAAM,IAAI,CAAC;IACnB,MAAM,EAAE,CAAC,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,KAAK,IAAI,CAAC;IAChD,OAAO,EAAE,MAAM,IAAI,CAAC;CACrB;AAED,MAAM,WAAW,kBAAkB;IACjC,MAAM,EAAE,iBAAiB,CAAC;IAC1B,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;IACf,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB;;;kEAG8D;IAC9D,WAAW,CAAC,EAAE,OAAO,CAAC;IACtB;;iEAE6D;IAC7D,qBAAqB,CAAC,EAAE,OAAO,CAAC;CACjC;AAED;;;;;;;;;GASG;AACH,wBAAsB,iBAAiB,CAAC,IAAI,EAAE,kBAAkB,GAAG,OAAO,CAAC,WAAW,CAAC,CAqCtF"}

package/dist/world2d/pixi-surface.js

@@ -0,0 +1,47 @@
+import { Application, Container } from 'pixi.js';
+/**
+ * Create the world2d render surface — a PixiJS v8 `Application` whose auto-ticker
+ * is DISABLED (`autoStart:false`), so the engine's fixed-timestep loop drives
+ * rendering by calling `render()` from the `render` phase (mirroring how the
+ * Three.js adapter calls `composer.render(dt)`).
+ *
+ * `app.stage` holds a single `world` Container — the 2D camera lives here as a
+ * transform on `world` (pan = world.position, zoom = world.scale), per the spec's
+ * backend-2d-camera resolution. Screen-space HUD stays in the React/DOM overlay.
+ */
+export async function createPixiSurface(opts) {
+    const app = new Application();
+    await app.init({
+        canvas: opts.canvas,
+        width: opts.width,
+        height: opts.height,
+        background: opts.background ?? '#10101a',
+        backgroundAlpha: opts.transparent ? 0 : 1,
+        resolution: opts.resolution ?? (typeof window !== 'undefined' ? window.devicePixelRatio : 1),
+        autoDensity: true,
+        antialias: opts.antialias ?? true,
+        autoStart: false, // engine loop drives rendering — NOT Pixi's ticker
+        preference: 'webgl',
+        // Capture tier cost (D5 §4) — FLAT here, never nested under `context:`
+        // (the documented pixi trap: nesting silently breaks GL bootstrap).
+        ...(opts.preserveDrawingBuffer ? { preserveDrawingBuffer: true } : {}),
+    });
+    // Stop the shared/internal ticker defensively (autoStart:false already prevents start).
+    app.ticker.stop();
+    const world = new Container();
+    world.label = 'world2d-root';
+    app.stage.addChild(world);
+    return {
+        app,
+        world,
+        render: () => app.render(),
+        resize: (width, height) => {
+            app.renderer.resize(width, height);
+        },
+        dispose: () => {
+            // Tear down the Pixi app + GPU context. Children are destroyed by the loader's
+            // own dispose; here we release the renderer/canvas binding.
+            app.destroy({ removeView: false }, { children: true });
+        },
+    };
+}

package/dist/world2d/scene-capture-2d.d.ts

@@ -0,0 +1,43 @@
+/**
+ * Scene capture for world2d — the PixiJS analog of the three.js render
+ * accessor-trap (`adapter/ingest/scene-capture.ts`).
+ *
+ * An unmodified PixiJS game owns its own `Application`, `stage`, renderer, and
+ * ticker. To inspect/host that live scene with ZERO edits to the game, we trap the
+ * render call and capture the game's `stage` + renderer + app on its first frame.
+ *
+ * Unlike three.js's `WebGLRenderer` (whose `render` is an own-instance property,
+ * forcing a prototype getter/setter), PixiJS's `Application.prototype.render` is a
+ * normal prototype method — the standard ticker render path (`ticker → app.render()`)
+ * goes through it — so a direct prototype wrap suffices.
+ *
+ * CRITICAL (same module-identity gatekeeper as the 3D path): the trap must be
+ * installed on the SAME `pixi.js` module instance the game uses. A bundler/dev-server
+ * that dedupes `pixi.js` makes an ESM game's `import 'pixi.js'` resolve to the host
+ * instance, so it is trapped; a game bundling its own pixi cannot be captured this
+ * way (degrade to iframe-reachable or opaque-embed tiers — see the spec).
+ */
+/** A live world2d runtime captured from an external PixiJS game. */
+export interface CapturedRuntime2D {
+    /** The game's root stage Container. */
+    stage: unknown;
+    /** The game's PixiJS renderer. */
+    renderer: unknown;
+    /** The game's Application (so the host can pause/resume its ticker). */
+    app: unknown;
+}
+export interface SceneCapture2DHandle {
+    readonly captured: CapturedRuntime2D | null;
+    waitForCapture(timeoutMs?: number): Promise<CapturedRuntime2D>;
+    getDrawCount(): number;
+    /** Pause/resume the captured game's own ticker (loop-host gating). */
+    setPaused(paused: boolean): void;
+    uninstall(): void;
+}
+/**
+ * Install the render trap on `pixiNamespace.Application.prototype.render`. Pass the
+ * host's `pixi.js` namespace so a shared-instance game is trapped. Install once per
+ * ingest session; `uninstall()` on teardown.
+ */
+export declare function installSceneCapture2D(pixiNamespace: unknown): SceneCapture2DHandle;
+//# sourceMappingURL=scene-capture-2d.d.ts.map

package/dist/world2d/scene-capture-2d.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"scene-capture-2d.d.ts","sourceRoot":"","sources":["../../src/world2d/scene-capture-2d.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAEH,oEAAoE;AACpE,MAAM,WAAW,iBAAiB;IAChC,uCAAuC;IACvC,KAAK,EAAE,OAAO,CAAC;IACf,kCAAkC;IAClC,QAAQ,EAAE,OAAO,CAAC;IAClB,wEAAwE;IACxE,GAAG,EAAE,OAAO,CAAC;CACd;AAED,MAAM,WAAW,oBAAoB;IACnC,QAAQ,CAAC,QAAQ,EAAE,iBAAiB,GAAG,IAAI,CAAC;IAC5C,cAAc,CAAC,SAAS,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,iBAAiB,CAAC,CAAC;IAC/D,YAAY,IAAI,MAAM,CAAC;IACvB,sEAAsE;IACtE,SAAS,CAAC,MAAM,EAAE,OAAO,GAAG,IAAI,CAAC;IACjC,SAAS,IAAI,IAAI,CAAC;CACnB;AAMD;;;;GAIG;AACH,wBAAgB,qBAAqB,CAAC,aAAa,EAAE,OAAO,GAAG,oBAAoB,CAoElF"}

package/dist/world2d/scene-capture-2d.js

@@ -0,0 +1,92 @@
+/**
+ * Scene capture for world2d — the PixiJS analog of the three.js render
+ * accessor-trap (`adapter/ingest/scene-capture.ts`).
+ *
+ * An unmodified PixiJS game owns its own `Application`, `stage`, renderer, and
+ * ticker. To inspect/host that live scene with ZERO edits to the game, we trap the
+ * render call and capture the game's `stage` + renderer + app on its first frame.
+ *
+ * Unlike three.js's `WebGLRenderer` (whose `render` is an own-instance property,
+ * forcing a prototype getter/setter), PixiJS's `Application.prototype.render` is a
+ * normal prototype method — the standard ticker render path (`ticker → app.render()`)
+ * goes through it — so a direct prototype wrap suffices.
+ *
+ * CRITICAL (same module-identity gatekeeper as the 3D path): the trap must be
+ * installed on the SAME `pixi.js` module instance the game uses. A bundler/dev-server
+ * that dedupes `pixi.js` makes an ESM game's `import 'pixi.js'` resolve to the host
+ * instance, so it is trapped; a game bundling its own pixi cannot be captured this
+ * way (degrade to iframe-reachable or opaque-embed tiers — see the spec).
+ */
+/**
+ * Install the render trap on `pixiNamespace.Application.prototype.render`. Pass the
+ * host's `pixi.js` namespace so a shared-instance game is trapped. Install once per
+ * ingest session; `uninstall()` on teardown.
+ */
+export function installSceneCapture2D(pixiNamespace) {
+    const PIXI = pixiNamespace;
+    const proto = PIXI.Application.prototype;
+    let captured = null;
+    let drawCount = 0;
+    const waiters = [];
+    const priorRender = Object.getOwnPropertyDescriptor(proto, 'render');
+    const realRender = proto['render'];
+    Object.defineProperty(proto, 'render', {
+        configurable: true,
+        writable: true,
+        value: function (...args) {
+            drawCount++;
+            const stage = this['stage'];
+            if (!captured && stage) {
+                captured = { stage, renderer: this['renderer'], app: this };
+                for (const resolve of waiters.splice(0))
+                    resolve(captured);
+            }
+            return realRender?.apply(this, args);
+        },
+    });
+    return {
+        get captured() {
+            return captured;
+        },
+        getDrawCount() {
+            return drawCount;
+        },
+        setPaused(paused) {
+            const app = captured?.app;
+            if (!app?.ticker)
+                return;
+            if (paused)
+                app.ticker.stop();
+            else
+                app.ticker.start();
+        },
+        waitForCapture(timeoutMs = 10_000) {
+            if (captured)
+                return Promise.resolve(captured);
+            return new Promise((resolve, reject) => {
+                const timer = setTimeout(() => {
+                    const i = waiters.indexOf(wrapped);
+                    if (i >= 0)
+                        waiters.splice(i, 1);
+                    reject(new Error(`world2d scene capture timed out after ${timeoutMs}ms — the game never ` +
+                        `rendered, or it bundles its own (un-shared) copy of pixi.js.`));
+                }, timeoutMs);
+                const wrapped = (rt) => {
+                    clearTimeout(timer);
+                    resolve(rt);
+                };
+                waiters.push(wrapped);
+            });
+        },
+        uninstall() {
+            if (priorRender)
+                Object.defineProperty(proto, 'render', priorRender);
+            else if (realRender)
+                Object.defineProperty(proto, 'render', {
+                    configurable: true,
+                    writable: true,
+                    value: realRender,
+                });
+        },
+    };
+}

package/dist/world2d/scene2d-loader.d.ts

@@ -0,0 +1,27 @@
+import { Container } from 'pixi.js';
+import { type Scene2DFile } from './schema/entity2d';
+import type { Component2DRegistry, World2DContext } from './types';
+/** A loaded world2d scene instance: the root display objects + an update/dispose. */
+export interface Scene2DInstance {
+    roots: Container[];
+    /** id → display object map for editor/lookup (the 2D analog of the loader's entity map). */
+    byId: Map<string, Container>;
+    dispose(): void;
+}
+/**
+ * Load a world2d scene from authored data — the 2D analog of `loadSceneFromData`.
+ * Three passes: (1) spawn all entities (recursing into children), building an
+ * id→display map and creating Rapier 2D bodies; (2) [no joints in 2D yet];
+ * (3) `componentManager.initAll()` once everything exists.
+ *
+ * Re-validates `data` even though the fetch path (`fetchScene2DFile` in
+ * `packages/editor/src/adapter-resolver.ts`) already validates before calling
+ * in — not every caller goes through that path (test-constructed
+ * `PixiSceneConfig.sceneData` literals reach here unvalidated), so a malformed
+ * payload still throws a `SceneParseError` naming the file, not a raw
+ * `ZodError` (T4.6 convention, closing §7.1-14). `sourceName` is optional
+ * because not every caller knows the originating file path; callers that do
+ * (or gain the ability to) should thread it through for a better message.
+ */
+export declare function loadScene2DFromData(data: Scene2DFile, ctx: World2DContext, registry: Component2DRegistry, sourceName?: string): Promise<Scene2DInstance>;
+//# sourceMappingURL=scene2d-loader.d.ts.map

package/dist/world2d/scene2d-loader.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"scene2d-loader.d.ts","sourceRoot":"","sources":["../../src/world2d/scene2d-loader.ts"],"names":[],"mappings":"AAEA,OAAO,EAKL,SAAS,EAIV,MAAM,SAAS,CAAC;AAGjB,OAAO,EAAiB,KAAK,WAAW,EAAiB,MAAM,mBAAmB,CAAC;AAGnF,OAAO,KAAK,EAAE,mBAAmB,EAAE,cAAc,EAAE,MAAM,SAAS,CAAC;AAmNnE,qFAAqF;AACrF,MAAM,WAAW,eAAe;IAC9B,KAAK,EAAE,SAAS,EAAE,CAAC;IACnB,4FAA4F;IAC5F,IAAI,EAAE,GAAG,CAAC,MAAM,EAAE,SAAS,CAAC,CAAC;IAC7B,OAAO,IAAI,IAAI,CAAC;CACjB;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAsB,mBAAmB,CACvC,IAAI,EAAE,WAAW,EACjB,GAAG,EAAE,cAAc,EACnB,QAAQ,EAAE,mBAAmB,EAC7B,UAAU,CAAC,EAAE,MAAM,GAClB,OAAO,CAAC,eAAe,CAAC,CAmD1B"}