@vgai/engine 0.5.0 → 0.5.1

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

@@ -1,210 +0,0 @@
-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 (roots-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(host.game?.profiler.systemObserver, 'pixijs');
-        systems.add('physics', () => rapier2dWorld.step(eventQueue), { name: 'physics2d.step' });
-        systems.add('postPhysics', () => {
-            collisions2d.drain();
-            writeTransforms2D();
-        }, { name: 'physics2d.sync' });
-        systems.add('render', () => surface.render(), { name: 'pixi.render' });
-        const ctx = {
-            app: surface.app,
-            stage: surface.world,
-            rapier2dWorld,
-            rapier2d: RAPIER,
-            physics2d,
-            collisions2d,
-            components: null,
-            systems,
-            ...(host.game ? { game: host.game } : {}),
-        };
-        // 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
- * `registerThreeWorld` (`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, ...sceneConfig } = config;
-    const adapter = new PixiSceneGameAdapter(sceneConfig);
-    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 });
-    const mounted = await adapter.mount({ canvas, width, height, game });
-    // 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

@@ -1,39 +0,0 @@
-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

@@ -1 +0,0 @@
-{"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

@@ -1,47 +0,0 @@
-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

@@ -1,43 +0,0 @@
-/**
- * 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

@@ -1 +0,0 @@
-{"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

@@ -1,92 +0,0 @@
-/**
- * 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

@@ -1,27 +0,0 @@
-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

@@ -1 +0,0 @@
-{"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;AAoNnE,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"}