@vgai/engine 0.5.5 → 0.5.7

package/dist/render/light-camera-factory.js

@@ -0,0 +1,71 @@
+/**
+ * Shared light + camera factory (T1.13 — DEFAULTS truth).
+ *
+ * `createLight`/`createCamera` used to be duplicated verbatim between the
+ * runtime loader (`scene-loader.ts`) and the editor preview
+ * (`entity-factory.ts`) — both hardcoded the same fallback literals (color
+ * '#ffffff', fov 60, near 0.1, far 1000, etc.) that happened to agree with
+ * `DEFAULTS.light`/`DEFAULTS.camera` by luck rather than by reading them. Any
+ * edit to one copy (or to `DEFAULTS`) could silently diverge from the other.
+ *
+ * This module is now the ONE place that builds a `THREE.Light`/`THREE.Camera`
+ * from a `LightDescriptor`/`CameraDescriptor` descriptor, reading its fallbacks from
+ * `DEFAULTS` (the single source of truth for scene default values — see
+ * `defaults.ts`). Both the loader and the editor import it, so they
+ * can no longer disagree.
+ */
+import * as THREE from 'three';
+// Area lights. `RectAreaLight` requires its LTC lookup-texture uniforms
+// initialized once before the first instance is constructed; three.js ships
+// that setup as an addon, not part of core. Imported via the
+// `three/addons/*` alias (package.json `exports`: `"./addons/*":
+// "./examples/jsm/*"` — the identical file as
+// `three/examples/jsm/lights/RectAreaLightUniformsLib.js`) because a literal
+// `/examples/` specifier trips `engine-host-no-game-imports.test.ts`'s
+// game/editor-example guard (a same-substring false positive against this
+// repo's OWN `packages/editor/template/src/examples/` convention, unrelated
+// to three.js's addon folder naming).
+import { RectAreaLightUniformsLib } from 'three/addons/lights/RectAreaLightUniformsLib.js';
+import { DEFAULTS } from '../defaults';
+let rectAreaLightUniformsInitialized = false;
+/** Build a Three.js light from a `LightDescriptor` descriptor. */
+export function createLight(def) {
+    const d = DEFAULTS.light;
+    const color = def.color ?? d.color;
+    const intensity = def.intensity ?? d.intensity;
+    switch (def.type) {
+        case 'directional':
+            return new THREE.DirectionalLight(color, intensity);
+        case 'point':
+            return new THREE.PointLight(color, intensity, def.distance ?? d.distance, def.decay ?? d.decay);
+        case 'spot': {
+            const light = new THREE.SpotLight(color, intensity, def.distance ?? d.distance, def.angle ?? d.angle, def.penumbra ?? d.penumbra);
+            light.decay = def.decay ?? d.decay;
+            return light;
+        }
+        case 'hemisphere':
+            return new THREE.HemisphereLight(color, def.groundColor ?? d.groundColor, intensity);
+        case 'area': {
+            // No shadow map is ever wired for this light (RectAreaLight does not
+            // support shadows in three.js — see the honesty note on the schema
+            // field's .describe(); degrade loudly, not silently).
+            if (!rectAreaLightUniformsInitialized) {
+                RectAreaLightUniformsLib.init();
+                rectAreaLightUniformsInitialized = true;
+            }
+            return new THREE.RectAreaLight(color, intensity, def.width ?? d.width, def.height ?? d.height);
+        }
+        default:
+            return new THREE.DirectionalLight(color, intensity);
+    }
+}
+/** Build a Three.js camera from a `CameraDescriptor` descriptor. */
+export function createCamera(def) {
+    const d = DEFAULTS.camera;
+    const aspect = (def.width ?? d.width) / (def.height ?? d.height);
+    if (def.type === 'orthographic') {
+        const size = def.orthoSize ?? d.orthoSize;
+        return new THREE.OrthographicCamera(-size * aspect, size * aspect, size, -size, def.near ?? d.near, def.far ?? d.far);
+    }
+    return new THREE.PerspectiveCamera(def.fov ?? d.fov, aspect, def.near ?? d.near, def.far ?? d.far);
+}

package/dist/render/lod.d.ts

@@ -0,0 +1,13 @@
+import type * as THREE from 'three';
+/**
+ * Per-frame LOD tick. `THREE.LOD` only swaps its active level when
+ * `.update(camera)` runs, so every `THREE.LOD` in the scene graph needs this
+ * called once a frame. Wired into the runtime's `preRender` system in
+ * `adapter/setup-three-root-adapter.ts`.
+ *
+ * Format-neutral: it matches THREE's own `isLOD` marker and knows nothing about
+ * how the LOD was built. Formerly `@engine/scene/scene-loader`'s
+ * `updateSceneLODs`, relocated here when WO-8 deleted the `.vscn` scene loader.
+ */
+export declare function updateSceneLODs(scene: THREE.Object3D, camera: THREE.Camera): void;
+//# sourceMappingURL=lod.d.ts.map

package/dist/render/lod.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lod.d.ts","sourceRoot":"","sources":["../../src/render/lod.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,KAAK,MAAM,OAAO,CAAC;AAEpC;;;;;;;;;GASG;AACH,wBAAgB,eAAe,CAAC,KAAK,EAAE,KAAK,CAAC,QAAQ,EAAE,MAAM,EAAE,KAAK,CAAC,MAAM,GAAG,IAAI,CAIjF"}

package/dist/render/lod.js

@@ -0,0 +1,16 @@
+/**
+ * Per-frame LOD tick. `THREE.LOD` only swaps its active level when
+ * `.update(camera)` runs, so every `THREE.LOD` in the scene graph needs this
+ * called once a frame. Wired into the runtime's `preRender` system in
+ * `adapter/setup-three-root-adapter.ts`.
+ *
+ * Format-neutral: it matches THREE's own `isLOD` marker and knows nothing about
+ * how the LOD was built. Formerly `@engine/scene/scene-loader`'s
+ * `updateSceneLODs`, relocated here when WO-8 deleted the `.vscn` scene loader.
+ */
+export function updateSceneLODs(scene, camera) {
+    scene.traverse((o) => {
+        if (o.isLOD)
+            o.update(camera);
+    });
+}

package/dist/render/material-factory.d.ts

@@ -0,0 +1,15 @@
+import * as THREE from 'three';
+import type { MaterialDescriptor } from '../asset-formats/material';
+import type { MeshDescriptor } from '../asset-formats/mesh';
+/**
+ * Single source of truth for turning a `MeshDescriptor` / `MaterialDescriptor` descriptor
+ * into Three.js geometry/material. Both the runtime scene-loader and the editor's
+ * entity-factory import these, so the editor preview renders exactly what the game
+ * renders (the WYSIWYG guarantee). Previously these were
+ * copy-pasted in two places and had to be hand-synced — any new material feature
+ * added to one and not the other silently broke that guarantee.
+ *
+ */
+export declare function createGeometry(mesh: MeshDescriptor): THREE.BufferGeometry;
+export declare function createMaterial(mat?: MaterialDescriptor): THREE.Material;
+//# sourceMappingURL=material-factory.d.ts.map

package/dist/render/material-factory.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"material-factory.d.ts","sourceRoot":"","sources":["../../src/render/material-factory.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAC/B,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,2BAA2B,CAAC;AACpE,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,uBAAuB,CAAC;AAI5D;;;;;;;;GAQG;AAEH,wBAAgB,cAAc,CAAC,IAAI,EAAE,cAAc,GAAG,KAAK,CAAC,cAAc,CAwBzE;AAGD,wBAAgB,cAAc,CAAC,GAAG,CAAC,EAAE,kBAAkB,GAAG,KAAK,CAAC,QAAQ,CA6JvE"}

package/dist/render/material-factory.js

@@ -0,0 +1,186 @@
+import * as THREE from 'three';
+import { loadTexture } from '../asset-loaders';
+import { DEFAULTS } from '../defaults';
+/**
+ * Single source of truth for turning a `MeshDescriptor` / `MaterialDescriptor` descriptor
+ * into Three.js geometry/material. Both the runtime scene-loader and the editor's
+ * entity-factory import these, so the editor preview renders exactly what the game
+ * renders (the WYSIWYG guarantee). Previously these were
+ * copy-pasted in two places and had to be hand-synced — any new material feature
+ * added to one and not the other silently broke that guarantee.
+ *
+ */
+// biome-ignore lint/complexity/noExcessiveCognitiveComplexity: straightforward type-based switch with fallback args
+export function createGeometry(mesh) {
+    const args = mesh.args ?? [];
+    switch (mesh.type) {
+        case 'box':
+            return new THREE.BoxGeometry(args[0] ?? 1, args[1] ?? 1, args[2] ?? 1);
+        case 'sphere':
+            return new THREE.SphereGeometry(args[0] ?? 0.5, args[1] ?? 32, args[2] ?? 16);
+        case 'plane':
+            // args[2]/args[3] (width/height segments) matter for vertex-displacing
+            // materials (e.g. the Water shader) — they used to be silently dropped,
+            // which collapsed the water demo to a 2-triangle quad.
+            return new THREE.PlaneGeometry(args[0] ?? 1, args[1] ?? 1, args[2] ?? 1, args[3] ?? 1);
+        case 'cylinder':
+            return new THREE.CylinderGeometry(args[0] ?? 0.5, args[1] ?? 0.5, args[2] ?? 1, args[3] ?? 32);
+        case 'capsule':
+            return new THREE.CapsuleGeometry(args[0] ?? 0.5, args[1] ?? 1, args[2] ?? 4, args[3] ?? 16);
+        default:
+            return new THREE.BoxGeometry(1, 1, 1);
+    }
+}
+// biome-ignore lint/complexity/noExcessiveCognitiveComplexity: flat type-based switch building Three materials
+export function createMaterial(mat) {
+    if (!mat)
+        return new THREE.MeshStandardMaterial({ color: DEFAULTS.material.color });
+    // Only include texture props when actually defined (Three.js warns on undefined values)
+    const textures = {};
+    if (mat.map)
+        textures.map = loadTexture(mat.map);
+    if (mat.normalMap)
+        textures.normalMap = loadTexture(mat.normalMap);
+    if (mat.emissiveMap)
+        textures.emissiveMap = loadTexture(mat.emissiveMap);
+    if (mat.aoMap)
+        textures.aoMap = loadTexture(mat.aoMap);
+    if (mat.lightMap)
+        textures.lightMap = loadTexture(mat.lightMap);
+    if (mat.roughnessMap)
+        textures.roughnessMap = loadTexture(mat.roughnessMap);
+    if (mat.metalnessMap)
+        textures.metalnessMap = loadTexture(mat.metalnessMap);
+    // R1c — every fallback below reads DEFAULTS.material.* instead of
+    // duplicating its value as a bare literal, so DEFAULTS stays the single
+    // source of truth for what an omitted field renders as (see
+    // defaults-out-of-scope-consistency.test.ts / material-factory.test.ts's
+    // "omitted-field" locks, which fail if either copy drifts from the other).
+    const dMat = DEFAULTS.material;
+    const sideValue = mat.side ?? dMat.side;
+    const side = sideValue === 'back'
+        ? THREE.BackSide
+        : sideValue === 'double'
+            ? THREE.DoubleSide
+            : THREE.FrontSide;
+    const opacity = mat.opacity ?? dMat.opacity;
+    const transparent = mat.transparent ?? dMat.transparent;
+    switch (mat.type) {
+        case 'basic':
+            return new THREE.MeshBasicMaterial({
+                color: mat.color ?? dMat.color,
+                ...textures,
+                lightMapIntensity: mat.lightMapIntensity ?? 1,
+                opacity,
+                transparent,
+                side,
+            });
+        case 'toon':
+            return new THREE.MeshToonMaterial({
+                color: mat.color ?? dMat.color,
+                ...textures,
+                lightMapIntensity: mat.lightMapIntensity ?? 1,
+                emissive: mat.emissive ?? dMat.emissive,
+                emissiveIntensity: mat.emissiveIntensity ?? dMat.emissiveIntensity,
+                opacity,
+                transparent,
+                side,
+            });
+        case 'physical':
+            return new THREE.MeshPhysicalMaterial({
+                color: mat.color ?? dMat.color,
+                metalness: mat.metalness ?? dMat.metalness,
+                roughness: mat.roughness ?? dMat.roughness,
+                ...textures,
+                lightMapIntensity: mat.lightMapIntensity ?? 1,
+                emissive: mat.emissive ?? dMat.emissive,
+                emissiveIntensity: mat.emissiveIntensity ?? dMat.emissiveIntensity,
+                opacity,
+                transparent,
+                side,
+                flatShading: mat.flatShading ?? dMat.flatShading,
+                // Clearcoat
+                ...(mat.clearcoat
+                    ? {
+                        clearcoat: mat.clearcoat.clearcoat,
+                        clearcoatRoughness: mat.clearcoat.clearcoatRoughness ?? dMat.clearcoat.clearcoatRoughness,
+                        ...(mat.clearcoat.clearcoatMap
+                            ? { clearcoatMap: loadTexture(mat.clearcoat.clearcoatMap) }
+                            : {}),
+                        ...(mat.clearcoat.clearcoatRoughnessMap
+                            ? { clearcoatRoughnessMap: loadTexture(mat.clearcoat.clearcoatRoughnessMap) }
+                            : {}),
+                    }
+                    : {}),
+                // Transmission — `thickness` used to hardcode a literal `0` here,
+                // silently diverging from DEFAULTS.material.transmission.thickness
+                // (0.5, per the editor's Transmission inspector default). Fixed:
+                // read DEFAULTS directly, like every other fallback in this file.
+                ...(mat.transmission
+                    ? {
+                        transmission: mat.transmission.transmission,
+                        ior: mat.transmission.ior ?? dMat.transmission.ior,
+                        thickness: mat.transmission.thickness ?? dMat.transmission.thickness,
+                        ...(mat.transmission.attenuationColor
+                            ? { attenuationColor: new THREE.Color(mat.transmission.attenuationColor) }
+                            : {}),
+                        attenuationDistance: mat.transmission.attenuationDistance ?? Infinity,
+                        ...(mat.transmission.transmissionMap
+                            ? { transmissionMap: loadTexture(mat.transmission.transmissionMap) }
+                            : {}),
+                    }
+                    : {}),
+                // Sheen
+                ...(mat.sheen
+                    ? {
+                        sheen: mat.sheen.sheen,
+                        sheenColor: new THREE.Color(mat.sheen.sheenColor ?? dMat.sheen.sheenColor),
+                        sheenRoughness: mat.sheen.sheenRoughness ?? dMat.sheen.sheenRoughness,
+                        ...(mat.sheen.sheenColorMap
+                            ? { sheenColorMap: loadTexture(mat.sheen.sheenColorMap) }
+                            : {}),
+                        ...(mat.sheen.sheenRoughnessMap
+                            ? { sheenRoughnessMap: loadTexture(mat.sheen.sheenRoughnessMap) }
+                            : {}),
+                    }
+                    : {}),
+                // Iridescence
+                ...(mat.iridescence
+                    ? {
+                        iridescence: mat.iridescence.iridescence,
+                        iridescenceIOR: mat.iridescence.iridescenceIOR ?? dMat.iridescence.iridescenceIOR,
+                        iridescenceThicknessRange: mat.iridescence.iridescenceThicknessRange ??
+                            dMat.iridescence.iridescenceThicknessRange,
+                        ...(mat.iridescence.iridescenceMap
+                            ? { iridescenceMap: loadTexture(mat.iridescence.iridescenceMap) }
+                            : {}),
+                        ...(mat.iridescence.iridescenceThicknessMap
+                            ? {
+                                iridescenceThicknessMap: loadTexture(mat.iridescence.iridescenceThicknessMap),
+                            }
+                            : {}),
+                    }
+                    : {}),
+                // Displacement
+                ...(mat.displacementMap ? { displacementMap: loadTexture(mat.displacementMap) } : {}),
+                ...(mat.displacementScale !== undefined
+                    ? { displacementScale: mat.displacementScale }
+                    : {}),
+                ...(mat.displacementBias !== undefined ? { displacementBias: mat.displacementBias } : {}),
+            });
+        default:
+            return new THREE.MeshStandardMaterial({
+                color: mat.color ?? dMat.color,
+                metalness: mat.metalness ?? dMat.metalness,
+                roughness: mat.roughness ?? dMat.roughness,
+                ...textures,
+                lightMapIntensity: mat.lightMapIntensity ?? 1,
+                emissive: mat.emissive ?? dMat.emissive,
+                emissiveIntensity: mat.emissiveIntensity ?? dMat.emissiveIntensity,
+                opacity,
+                transparent,
+                side,
+                flatShading: mat.flatShading ?? dMat.flatShading,
+            });
+    }
+}

package/dist/render/mesh-shadow.d.ts

@@ -0,0 +1,11 @@
+import * as THREE from 'three';
+/**
+ * Apply the authored mesh-shadow contract to every renderable in a model.
+ *
+ * Primitive scene entities contain one Mesh, while glTF entities usually
+ * contain a Group with many Mesh/SkinnedMesh descendants. Keeping this walk
+ * shared prevents editor preview and runtime Play from disagreeing by source
+ * format.
+ */
+export declare function setMeshShadowEnabled(root: THREE.Object3D, enabled: boolean | undefined): void;
+//# sourceMappingURL=mesh-shadow.d.ts.map

package/dist/render/mesh-shadow.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mesh-shadow.d.ts","sourceRoot":"","sources":["../../src/render/mesh-shadow.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAE/B;;;;;;;GAOG;AACH,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,KAAK,CAAC,QAAQ,EAAE,OAAO,EAAE,OAAO,GAAG,SAAS,GAAG,IAAI,CAO7F"}

package/dist/render/mesh-shadow.js

@@ -0,0 +1,19 @@
+import * as THREE from 'three';
+/**
+ * Apply the authored mesh-shadow contract to every renderable in a model.
+ *
+ * Primitive scene entities contain one Mesh, while glTF entities usually
+ * contain a Group with many Mesh/SkinnedMesh descendants. Keeping this walk
+ * shared prevents editor preview and runtime Play from disagreeing by source
+ * format.
+ */
+export function setMeshShadowEnabled(root, enabled) {
+    if (enabled === undefined)
+        return;
+    root.traverse((object) => {
+        if (!(object instanceof THREE.Mesh))
+            return;
+        object.castShadow = enabled;
+        object.receiveShadow = enabled;
+    });
+}

package/dist/render/particles-factory.d.ts

@@ -0,0 +1,99 @@
+/**
+ * Converts ParticlesDescriptor JSON → three.quarks ParticleSystem.
+ *
+ * Shared between the editor entity-factory and the runtime scene-loader.
+ * The schema mirrors quarks' native JSON format, so most fields pass through
+ * directly to quarks' fromJSON or constructor methods.
+ */
+import { type EmitterShape } from 'quarks.core';
+import * as THREE from 'three';
+import { type BatchedRenderer, ParticleSystem } from 'three.quarks';
+import type { ParticlesDescriptor } from '../asset-formats/particles';
+export interface ParticleSystemResult {
+    /** The emitter Object3D (add to scene for transform) */
+    emitter: THREE.Object3D;
+    /** The ParticleSystem instance (register with BatchedRenderer) */
+    system: ParticleSystem;
+}
+/**
+ * The non-JSON companion to a {@link ParticlesDescriptor} — the runtime objects
+ * a JSON document cannot carry, and an authoring toggle. Every field is
+ * optional and the whole argument is optional, so existing single-argument
+ * callers (the editor entity-factory, the runtime scene-loader) are unchanged.
+ *
+ * This is how a caller with fidelity a plain descriptor cannot express reaches
+ * the SAME factory instead of hand-building its own `new ParticleSystem(...)`:
+ * a foreign-engine carry (e.g. Godot CPUParticles) supplies its own
+ * `EmitterShape` and an instancing geometry here, and expresses everything
+ * else — lifecycle, start values, emission, behaviors, material — as descriptor
+ * JSON.
+ */
+export interface ParticleSystemObjects {
+    /**
+     * A pre-built emitter shape for a spawn distribution the JSON `shape` field
+     * cannot express (a `three.quarks` `EmitterShape` plugin instance). When
+     * present it REPLACES `data.shape`.
+     */
+    shape?: EmitterShape;
+    /**
+     * The geometry instanced per particle in `RenderMode.Mesh`. A
+     * `BufferGeometry` is not JSON-serializable, so `renderMode: 'mesh'` requires
+     * the caller to resolve and pass it here.
+     */
+    instancingGeometry?: THREE.BufferGeometry;
+    /**
+     * When the material has no texture `map`, the factory substitutes a soft
+     * radial default sprite so a freshly-authored billboard shows something.
+     * Pass `false` to keep the material's own (map-less) appearance — a faithful
+     * carry of a foreign engine whose particle draws a plain colored quad, and
+     * the way that carry avoids the default-sprite canvas entirely. Defaults to
+     * `true`.
+     */
+    defaultSprite?: boolean;
+}
+/**
+ * Create a three.quarks ParticleSystem from ParticlesDescriptor JSON data.
+ *
+ * `objects` carries the pieces a JSON descriptor cannot: a plugin emitter
+ * shape, a mesh-mode instancing geometry, and the default-sprite toggle. It is
+ * optional and additive — a call with only `data` behaves exactly as before.
+ */
+export declare function createParticleSystemFromData(data: ParticlesDescriptor, objects?: ParticleSystemObjects): ParticleSystemResult;
+/**
+ * Patch a RUNNING ParticleSystem in place from ParticlesDescriptor JSON — the
+ * editor's live-tune path (W1b). Unlike `createParticleSystemFromData`, this
+ * does NOT recreate the system: the particle pool, per-particle ages, and the
+ * emission clock all survive, so a curve-key drag reshapes the live emitter
+ * with no restart stutter.
+ *
+ * Covers the live-tunable subset: lifecycle scalars (duration/looping/
+ * prewarm), emitter shape, start-value generators, emission rates + bursts,
+ * and the behavior stack (behavior instances are rebuilt from JSON — quarks
+ * behaviors read their generators per-update, so existing particles pick the
+ * new curves up on the next frame).
+ *
+ * NOT covered (these change the render batch and must go through the normal
+ * teardown/rebuild path): material, renderMode, tiling/soft-particle render
+ * settings, worldSpace.
+ */
+export declare function applyParticlesDataLive(system: ParticleSystem, data: ParticlesDescriptor): void;
+/**
+ * Scrub a ParticleSystem to an absolute time by deterministic re-simulation:
+ * restart, then advance in fixed steps to `time`, then pause. Used by the
+ * editor's emitter-transport time scrub. `update` is TS-private on
+ * ParticleSystem but is exactly what BatchedRenderer.update calls per system.
+ */
+export declare function scrubParticleSystemTo(system: ParticleSystem, time: number, step?: number): void;
+/**
+ * Register a particle system with a BatchedRenderer.
+ */
+export declare function registerParticleSystem(batchedRenderer: BatchedRenderer, system: ParticleSystem): void;
+/**
+ * Unregister a particle system from a BatchedRenderer.
+ */
+export declare function unregisterParticleSystem(batchedRenderer: BatchedRenderer, system: ParticleSystem): void;
+/**
+ * Default particle data for creating a new particle emitter via AddSectionMenu.
+ */
+export declare function defaultParticlesData(): ParticlesDescriptor;
+//# sourceMappingURL=particles-factory.d.ts.map

package/dist/render/particles-factory.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"particles-factory.d.ts","sourceRoot":"","sources":["../../src/render/particles-factory.ts"],"names":[],"mappings":"AACA;;;;;;GAMG;AAEH,OAAO,EAQL,KAAK,YAAY,EAmBlB,MAAM,aAAa,CAAC;AACrB,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAC/B,OAAO,EAAE,KAAK,eAAe,EAAE,cAAc,EAAc,MAAM,cAAc,CAAC;AAChF,OAAO,KAAK,EAIV,mBAAmB,EAEpB,MAAM,4BAA4B,CAAC;AAyNpC,MAAM,WAAW,oBAAoB;IACnC,wDAAwD;IACxD,OAAO,EAAE,KAAK,CAAC,QAAQ,CAAC;IACxB,kEAAkE;IAClE,MAAM,EAAE,cAAc,CAAC;CACxB;AAED;;;;;;;;;;;;GAYG;AACH,MAAM,WAAW,qBAAqB;IACpC;;;;OAIG;IACH,KAAK,CAAC,EAAE,YAAY,CAAC;IACrB;;;;OAIG;IACH,kBAAkB,CAAC,EAAE,KAAK,CAAC,cAAc,CAAC;IAC1C;;;;;;;OAOG;IACH,aAAa,CAAC,EAAE,OAAO,CAAC;CACzB;AAED;;;;;;GAMG;AAEH,wBAAgB,4BAA4B,CAC1C,IAAI,EAAE,mBAAmB,EACzB,OAAO,CAAC,EAAE,qBAAqB,GAC9B,oBAAoB,CA6DtB;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,sBAAsB,CAAC,MAAM,EAAE,cAAc,EAAE,IAAI,EAAE,mBAAmB,GAAG,IAAI,CAsB9F;AAED;;;;;GAKG;AACH,wBAAgB,qBAAqB,CAAC,MAAM,EAAE,cAAc,EAAE,IAAI,EAAE,MAAM,EAAE,IAAI,SAAS,GAAG,IAAI,CAU/F;AAED;;GAEG;AACH,wBAAgB,sBAAsB,CACpC,eAAe,EAAE,eAAe,EAChC,MAAM,EAAE,cAAc,GACrB,IAAI,CAEN;AAED;;GAEG;AACH,wBAAgB,wBAAwB,CACtC,eAAe,EAAE,eAAe,EAChC,MAAM,EAAE,cAAc,GACrB,IAAI,CAEN;AAED;;GAEG;AACH,wBAAgB,oBAAoB,IAAI,mBAAmB,CA6B1D"}