@woosh/meep-engine 3.11.2 → 3.12.0

package/src/engine/graphics3/LightSystem.d.ts

@@ -0,0 +1,40 @@
+/**
+ * Mirrors light entities into Shade's scene.
+ *
+ * The same shape as {@link MeshSystem} and for the same reason: the ECS says what exists and where,
+ * and this keeps the renderer's own objects in step. A Shade light **is** a `Node3D`, so `Scene.add`
+ * routes it into the light collection on its own and placement is the same transform copy meshes
+ * get — which for a directional light is also what aims it, since the engine's convention is that a
+ * light shines along its forward.
+ *
+ * **Ambient lights are deliberately not carried over.** Shade lights indirect from the environment
+ * by default, and that environment is the ambient term — a separate flat ambient light would be
+ * double-counting it. An entity asking for one is served better by the environment it already has.
+ */
+export class LightSystem extends System<any> {
+    /**
+     * @param {GraphicsEngine} graphics
+     * @param {Scene} scene
+     */
+    constructor(graphics: GraphicsEngine, scene: Scene);
+    dependencies: (typeof Transform | typeof Light)[];
+    startup(entityManager: any): Promise<void>;
+    shutdown(entityManager: any): Promise<void>;
+    /**
+     * @param {Light} component
+     * @param {Transform} transform
+     * @param {number} entity
+     */
+    link(component: Light, transform: Transform, entity: number): void;
+    /**
+     * @param {Light} component
+     * @param {Transform} transform
+     * @param {number} entity
+     */
+    unlink(component: Light, transform: Transform, entity: number): void;
+    #private;
+}
+import { System } from "../ecs/System.js";
+import { Transform } from "../ecs/transform/Transform.js";
+import { Light } from "../graphics/ecs/light/Light.js";
+//# sourceMappingURL=LightSystem.d.ts.map

package/src/engine/graphics3/LightSystem.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"LightSystem.d.ts","sourceRoot":"","sources":["../../../../src/engine/graphics3/LightSystem.js"],"names":[],"mappings":"AAWA;;;;;;;;;;;;GAYG;AACH;IAgBI;;;OAGG;IACH,oDAUC;IADG,kDAAsC;IAG1C,2CAIC;IAED,4CAIC;IAED;;;;OAIG;IACH,gBAJW,KAAK,aACL,SAAS,UACT,MAAM,QAqEhB;IAED;;;;OAIG;IACH,kBAJW,KAAK,aACL,SAAS,UACT,MAAM,QAIhB;;CAoBJ;uBApKsB,kBAAkB;0BACf,+BAA+B;sBAEnC,gCAAgC"}

package/src/engine/graphics3/LightSystem.js

@@ -0,0 +1,211 @@
+import { assert } from "../../core/assert.js";
+import { SignalBinding } from "../../core/events/signal/SignalBinding.js";
+import { DirectionalLight } from "../../shade/renderer/light/model/DirectionalLight.js";
+import { PointLight } from "../../shade/renderer/light/model/PointLight.js";
+import { SpotLight } from "../../shade/renderer/light/model/SpotLight.js";
+import { System } from "../ecs/System.js";
+import { Transform } from "../ecs/transform/Transform.js";
+import { t64_copy_from_transform } from "../ecs/transform/t64_copy_from_transform.js";
+import { Light } from "../graphics/ecs/light/Light.js";
+import { LightType } from "../graphics/ecs/light/LightType.js";
+
+/**
+ * Mirrors light entities into Shade's scene.
+ *
+ * The same shape as {@link MeshSystem} and for the same reason: the ECS says what exists and where,
+ * and this keeps the renderer's own objects in step. A Shade light **is** a `Node3D`, so `Scene.add`
+ * routes it into the light collection on its own and placement is the same transform copy meshes
+ * get — which for a directional light is also what aims it, since the engine's convention is that a
+ * light shines along its forward.
+ *
+ * **Ambient lights are deliberately not carried over.** Shade lights indirect from the environment
+ * by default, and that environment is the ambient term — a separate flat ambient light would be
+ * double-counting it. An entity asking for one is served better by the environment it already has.
+ */
+export class LightSystem extends System {
+    /**
+     * @type {GraphicsEngine}
+     */
+    #graphics;
+
+    /**
+     * @type {Scene}
+     */
+    #scene;
+
+    /**
+     * @type {Map<number, {light: Light, bindings: SignalBinding[]}>}
+     */
+    #entries = new Map();
+
+    /**
+     * @param {GraphicsEngine} graphics
+     * @param {Scene} scene
+     */
+    constructor(graphics, scene) {
+        super();
+
+        assert.defined(graphics, 'graphics');
+        assert.equal(scene.isScene, true, 'scene.isScene !== true');
+
+        this.#graphics = graphics;
+        this.#scene = scene;
+
+        this.dependencies = [Light, Transform];
+    }
+
+    async startup(entityManager) {
+        this.entityManager = entityManager;
+
+        this.#graphics.set_scene(this.#scene);
+    }
+
+    async shutdown(entityManager) {
+        for (const entity of Array.from(this.#entries.keys())) {
+            this.#drop(entity);
+        }
+    }
+
+    /**
+     * @param {Light} component
+     * @param {Transform} transform
+     * @param {number} entity
+     */
+    link(component, transform, entity) {
+        const light = make_shade_light(component.type.getValue());
+
+        if (light === null) {
+            // ambient, or a type Shade has no object for — see the class note
+            return;
+        }
+
+        apply_light_properties(light, component);
+
+        t64_copy_from_transform(light.transform_local, transform);
+        light.updateMatrices();
+
+        this.#scene.add(light);
+
+        const entry = { light, bindings: [] };
+
+        this.#entries.set(entity, entry);
+
+        /*
+         Adding and removing a light invalidates the collection on its own, but **changing one in
+         place does not** — the GPU light table is rebuilt only when the collection's version moves,
+         so a light that is recoloured, re-aimed or dimmed keeps rendering with the values it was
+         uploaded with. `needsUpdate` is what says otherwise, and both paths below go through it.
+
+         Worth knowing because it is invisible from the CPU side: the light object holds the new
+         value, everything reads back correctly, and only the picture is stale.
+         */
+        const place = () => {
+            t64_copy_from_transform(light.transform_local, transform);
+            light.updateMatrices();
+
+            this.#scene.lights.needsUpdate = true;
+        };
+
+        const refresh = () => {
+            apply_light_properties(light, component);
+
+            this.#scene.lights.needsUpdate = true;
+        };
+
+        for (const component_value of [transform.position, transform.rotation, transform.scale]) {
+            const binding = new SignalBinding(component_value.onChanged, place);
+
+            binding.link();
+
+            entry.bindings.push(binding);
+        }
+
+        // A light's properties are gameplay-driven — a torch guttering, a spell charging, a
+        // searchlight narrowing — so they are followed rather than sampled once at spawn.
+        const observed_properties = [
+            component.color,
+            component.intensity,
+            component.castShadow,
+            component.angle,
+            component.penumbra,
+            component.distance
+        ];
+
+        for (const observed of observed_properties) {
+            const binding = new SignalBinding(observed.onChanged, refresh);
+
+            binding.link();
+
+            entry.bindings.push(binding);
+        }
+    }
+
+    /**
+     * @param {Light} component
+     * @param {Transform} transform
+     * @param {number} entity
+     */
+    unlink(component, transform, entity) {
+        this.#drop(entity);
+    }
+
+    /**
+     * @param {number} entity
+     */
+    #drop(entity) {
+        const entry = this.#entries.get(entity);
+
+        if (entry === undefined) {
+            return;
+        }
+
+        for (let i = 0; i < entry.bindings.length; i++) {
+            entry.bindings[i].unlink();
+        }
+
+        this.#scene.remove(entry.light);
+
+        this.#entries.delete(entity);
+    }
+}
+
+/**
+ * @param {LightType} type
+ * @returns {Light|null} null when Shade has no object for it
+ */
+function make_shade_light(type) {
+    switch (type) {
+        case LightType.DIRECTION:
+            return new DirectionalLight();
+        case LightType.SPOT:
+            return new SpotLight();
+        case LightType.POINT:
+            return new PointLight();
+        default:
+            // AMBIENT: the environment is the ambient term
+            return null;
+    }
+}
+
+/**
+ * Copy what the component says onto the light Shade will render.
+ *
+ * `maxShadowDistance` has no counterpart here on purpose: it caps the frustum the legacy renderer
+ * fits a cascade against, and Shade fits its own shadows.
+ *
+ * @param {Light} light Shade's
+ * @param {Light} component meep's
+ */
+function apply_light_properties(light, component) {
+    light.color.copy(component.color);
+    light.intensity = component.intensity.getValue();
+    light.casts_shadow = component.castShadow.getValue();
+
+    if (light.isSpotLight === true) {
+        light.angle = component.angle.getValue();
+        light.penumbra = component.penumbra.getValue();
+        light.distance = component.distance.getValue();
+    } else if (light.isPointLight === true) {
+        light.distance = component.distance.getValue();
+    }
+}

package/src/engine/graphics3/LightSystem3.d.ts

@@ -1,40 +1,10 @@
 /**
- * Mirrors light entities into Shade's scene.
+ * @deprecated Renamed to {@link LightSystem}. The trailing `3` marked the 2.x → 3.x renderer transition;
+ * the 2.x name it disambiguated against is gone, so the suffix no longer distinguishes anything.
  *
- * The same shape as {@link MeshSystem3} and for the same reason: the ECS says what exists and where,
- * and this keeps the renderer's own objects in step. A Shade light **is** a `Node3D`, so `Scene.add`
- * routes it into the light collection on its own and placement is the same transform copy meshes
- * get — which for a directional light is also what aims it, since the engine's convention is that a
- * light shines along its forward.
- *
- * **Ambient lights are deliberately not carried over.** Shade lights indirect from the environment
- * by default, and that environment is the ambient term — a separate flat ambient light would be
- * double-counting it. An entity asking for one is served better by the environment it already has.
+ * Kept as a re-export rather than removed: this is a library, and an import path is as much a
+ * published interface as a class name.
  */
-export class LightSystem3 extends System<any> {
-    /**
-     * @param {GraphicsEngine3} graphics
-     * @param {Scene} scene
-     */
-    constructor(graphics: GraphicsEngine3, scene: Scene);
-    dependencies: (typeof Transform | typeof Light)[];
-    startup(entityManager: any): Promise<void>;
-    shutdown(entityManager: any): Promise<void>;
-    /**
-     * @param {Light} component
-     * @param {Transform} transform
-     * @param {number} entity
-     */
-    link(component: Light, transform: Transform, entity: number): void;
-    /**
-     * @param {Light} component
-     * @param {Transform} transform
-     * @param {number} entity
-     */
-    unlink(component: Light, transform: Transform, entity: number): void;
-    #private;
-}
-import { System } from "../ecs/System.js";
-import { Transform } from "../ecs/transform/Transform.js";
-import { Light } from "../graphics/ecs/light/Light.js";
+export const LightSystem3: typeof LightSystem;
+import { LightSystem } from "./LightSystem.js";
 //# sourceMappingURL=LightSystem3.d.ts.map

package/src/engine/graphics3/LightSystem3.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"LightSystem3.d.ts","sourceRoot":"","sources":["../../../../src/engine/graphics3/LightSystem3.js"],"names":[],"mappings":"AAWA;;;;;;;;;;;;GAYG;AACH;IAgBI;;;OAGG;IACH,qDAUC;IADG,kDAAsC;IAG1C,2CAIC;IAED,4CAIC;IAED;;;;OAIG;IACH,gBAJW,KAAK,aACL,SAAS,UACT,MAAM,QAqEhB;IAED;;;;OAIG;IACH,kBAJW,KAAK,aACL,SAAS,UACT,MAAM,QAIhB;;CAoBJ;uBApKsB,kBAAkB;0BACf,+BAA+B;sBAEnC,gCAAgC"}
+{"version":3,"file":"LightSystem3.d.ts","sourceRoot":"","sources":["../../../../src/engine/graphics3/LightSystem3.js"],"names":[],"mappings":"AAEA;;;;;;GAMG;AACH,8CAAwC;4BATZ,kBAAkB"}

package/src/engine/graphics3/LightSystem3.js

@@ -1,211 +1,10 @@
-import { assert } from "../../core/assert.js";
-import { SignalBinding } from "../../core/events/signal/SignalBinding.js";
-import { DirectionalLight } from "../../shade/renderer/light/model/DirectionalLight.js";
-import { PointLight } from "../../shade/renderer/light/model/PointLight.js";
-import { SpotLight } from "../../shade/renderer/light/model/SpotLight.js";
-import { System } from "../ecs/System.js";
-import { Transform } from "../ecs/transform/Transform.js";
-import { t64_copy_from_transform } from "../ecs/transform/t64_copy_from_transform.js";
-import { Light } from "../graphics/ecs/light/Light.js";
-import { LightType } from "../graphics/ecs/light/LightType.js";
+import { LightSystem } from "./LightSystem.js";
 
 /**
- * Mirrors light entities into Shade's scene.
+ * @deprecated Renamed to {@link LightSystem}. The trailing `3` marked the 2.x → 3.x renderer transition;
+ * the 2.x name it disambiguated against is gone, so the suffix no longer distinguishes anything.
  *
- * The same shape as {@link MeshSystem3} and for the same reason: the ECS says what exists and where,
- * and this keeps the renderer's own objects in step. A Shade light **is** a `Node3D`, so `Scene.add`
- * routes it into the light collection on its own and placement is the same transform copy meshes
- * get — which for a directional light is also what aims it, since the engine's convention is that a
- * light shines along its forward.
- *
- * **Ambient lights are deliberately not carried over.** Shade lights indirect from the environment
- * by default, and that environment is the ambient term — a separate flat ambient light would be
- * double-counting it. An entity asking for one is served better by the environment it already has.
- */
-export class LightSystem3 extends System {
-    /**
-     * @type {GraphicsEngine3}
-     */
-    #graphics;
-
-    /**
-     * @type {Scene}
-     */
-    #scene;
-
-    /**
-     * @type {Map<number, {light: Light, bindings: SignalBinding[]}>}
-     */
-    #entries = new Map();
-
-    /**
-     * @param {GraphicsEngine3} graphics
-     * @param {Scene} scene
-     */
-    constructor(graphics, scene) {
-        super();
-
-        assert.defined(graphics, 'graphics');
-        assert.equal(scene.isScene, true, 'scene.isScene !== true');
-
-        this.#graphics = graphics;
-        this.#scene = scene;
-
-        this.dependencies = [Light, Transform];
-    }
-
-    async startup(entityManager) {
-        this.entityManager = entityManager;
-
-        this.#graphics.set_scene(this.#scene);
-    }
-
-    async shutdown(entityManager) {
-        for (const entity of Array.from(this.#entries.keys())) {
-            this.#drop(entity);
-        }
-    }
-
-    /**
-     * @param {Light} component
-     * @param {Transform} transform
-     * @param {number} entity
-     */
-    link(component, transform, entity) {
-        const light = make_shade_light(component.type.getValue());
-
-        if (light === null) {
-            // ambient, or a type Shade has no object for — see the class note
-            return;
-        }
-
-        apply_light_properties(light, component);
-
-        t64_copy_from_transform(light.transform_local, transform);
-        light.updateMatrices();
-
-        this.#scene.add(light);
-
-        const entry = { light, bindings: [] };
-
-        this.#entries.set(entity, entry);
-
-        /*
-         Adding and removing a light invalidates the collection on its own, but **changing one in
-         place does not** — the GPU light table is rebuilt only when the collection's version moves,
-         so a light that is recoloured, re-aimed or dimmed keeps rendering with the values it was
-         uploaded with. `needsUpdate` is what says otherwise, and both paths below go through it.
-
-         Worth knowing because it is invisible from the CPU side: the light object holds the new
-         value, everything reads back correctly, and only the picture is stale.
-         */
-        const place = () => {
-            t64_copy_from_transform(light.transform_local, transform);
-            light.updateMatrices();
-
-            this.#scene.lights.needsUpdate = true;
-        };
-
-        const refresh = () => {
-            apply_light_properties(light, component);
-
-            this.#scene.lights.needsUpdate = true;
-        };
-
-        for (const component_value of [transform.position, transform.rotation, transform.scale]) {
-            const binding = new SignalBinding(component_value.onChanged, place);
-
-            binding.link();
-
-            entry.bindings.push(binding);
-        }
-
-        // A light's properties are gameplay-driven — a torch guttering, a spell charging, a
-        // searchlight narrowing — so they are followed rather than sampled once at spawn.
-        const observed_properties = [
-            component.color,
-            component.intensity,
-            component.castShadow,
-            component.angle,
-            component.penumbra,
-            component.distance
-        ];
-
-        for (const observed of observed_properties) {
-            const binding = new SignalBinding(observed.onChanged, refresh);
-
-            binding.link();
-
-            entry.bindings.push(binding);
-        }
-    }
-
-    /**
-     * @param {Light} component
-     * @param {Transform} transform
-     * @param {number} entity
-     */
-    unlink(component, transform, entity) {
-        this.#drop(entity);
-    }
-
-    /**
-     * @param {number} entity
-     */
-    #drop(entity) {
-        const entry = this.#entries.get(entity);
-
-        if (entry === undefined) {
-            return;
-        }
-
-        for (let i = 0; i < entry.bindings.length; i++) {
-            entry.bindings[i].unlink();
-        }
-
-        this.#scene.remove(entry.light);
-
-        this.#entries.delete(entity);
-    }
-}
-
-/**
- * @param {LightType} type
- * @returns {Light|null} null when Shade has no object for it
+ * Kept as a re-export rather than removed: this is a library, and an import path is as much a
+ * published interface as a class name.
  */
-function make_shade_light(type) {
-    switch (type) {
-        case LightType.DIRECTION:
-            return new DirectionalLight();
-        case LightType.SPOT:
-            return new SpotLight();
-        case LightType.POINT:
-            return new PointLight();
-        default:
-            // AMBIENT: the environment is the ambient term
-            return null;
-    }
-}
-
-/**
- * Copy what the component says onto the light Shade will render.
- *
- * `maxShadowDistance` has no counterpart here on purpose: it caps the frustum the legacy renderer
- * fits a cascade against, and Shade fits its own shadows.
- *
- * @param {Light} light Shade's
- * @param {Light} component meep's
- */
-function apply_light_properties(light, component) {
-    light.color.copy(component.color);
-    light.intensity = component.intensity.getValue();
-    light.casts_shadow = component.castShadow.getValue();
-
-    if (light.isSpotLight === true) {
-        light.angle = component.angle.getValue();
-        light.penumbra = component.penumbra.getValue();
-        light.distance = component.distance.getValue();
-    } else if (light.isPointLight === true) {
-        light.distance = component.distance.getValue();
-    }
-}
+export const LightSystem3 = LightSystem;

package/src/engine/graphics3/MeshSystem.d.ts

@@ -0,0 +1,106 @@
+/**
+ * Puts entities into Shade's scene and keeps them where the ECS says they are.
+ *
+ * **It owns the scene and tells the facade to draw it**, rather than the facade handing a graph out
+ * for anyone to write into — that coupling is what §2.1 retires along with `GraphicsEngine.scene`.
+ *
+ * Placement is a `Transform` copied into `Node3D.transform_local`, through
+ * {@link t64_copy_from_transform} because the node's transform is a `Transform64` since S2 and the
+ * two types stay deliberately distinct. `transform_global` is **derived** — `updateMatrices`
+ * recomputes it from the local transform and the parent chain — so writing it directly would be
+ * undone by the next refresh, and the entity is placed through the local one.
+ *
+ * What makes this affordable is S1: the scene database takes row-level updates, so moving one
+ * entity writes one row. Nothing here rebuilds anything.
+ *
+ * **It also hands each instance to the GPU's animation manager** ({@link update}), because it is
+ * what builds instances and therefore the only thing that knows when one exists. Driving those
+ * clips is not its business — that is the animation systems' — but a clip nothing has registered
+ * cannot be driven by anyone.
+ */
+export class MeshSystem extends System<any> {
+    /**
+     * @param {GraphicsEngine} graphics
+     * @param {Scene} scene
+     * @param {function(string): Promise<SceneBundle>} load
+     */
+    constructor(graphics: GraphicsEngine, scene: Scene, load: (arg0: string) => Promise<SceneBundle>);
+    dependencies: (typeof Transform | typeof SGMesh)[];
+    /**
+     * @returns {Scene}
+     */
+    get scene(): Scene;
+    /**
+     * Visit every node of an entity's model that carries geometry.
+     *
+     * The nodes are what the scene database keys on, so anything that has to say something about a
+     * particular entity's meshes — which rows they occupy, which of them the visibility buffer will
+     * name — starts here. A grouping node is skipped, because it has no geometry and therefore no
+     * row of its own.
+     *
+     * @param {number} entity
+     * @param {function(SGMesh): void} visitor
+     * @returns {boolean} `false` when the entity has nothing in the scene — never seen, or still
+     * loading, and neither is an error
+     */
+    traverse_meshes(entity: number, visitor: (arg0: SGMesh) => void): boolean;
+    /**
+     * The private copy of the model an entity is showing — its clips among other things, which is
+     * where their names and their durations come from.
+     *
+     * Handed out rather than copied because an animation driver has to know *which* instance it is
+     * bound to: a model swap builds a new one, and a driver still holding the old one would be
+     * driving nodes that left the scene. The object's identity is the only signal that says so.
+     *
+     * @param {number} entity
+     * @returns {SceneBundleInstance|null} `null` for an entity this system has never seen, or one
+     * whose model has not finished loading
+     */
+    instance_of(entity: number): SceneBundleInstance | null;
+    /**
+     * What the GPU's animation manager gave back for that instance — the skin and clip ids, in the
+     * instance's own order.
+     *
+     * Same reasoning as {@link instance_of} and a stronger version of it: these ids belong to one
+     * renderer, and a restart voids every one of them. The object is replaced when that happens, so
+     * a driver that compares it against what it bound against notices in the same frame.
+     *
+     * @param {number} entity
+     * @returns {InstanceAnimationRegistration|null} `null` while there is nothing registered — no
+     * model yet, no device yet, or a renderer restart that has not been drained
+     */
+    animation_of(entity: number): InstanceAnimationRegistration | null;
+    /**
+     * Where an entity's model is, in world space.
+     *
+     * This is what makes picking possible without a second copy of the geometry: Shade already keeps
+     * a world bounding box per mesh, refreshed as part of the `updateMatrices` that places it, so the
+     * answer is a walk over what the entity has in the scene and nothing is recomputed.
+     *
+     * @param {ArrayLike<number>|number[]|Float32Array} target aabb3, order `x0,y0,z0,x1,y1,z1`
+     * @param {number} entity
+     * @returns {boolean} `false` when the entity has nothing in the scene — it may be an entity this
+     * system has never seen, or one whose model is still loading, and neither is an error
+     */
+    compute_world_bounds(target: ArrayLike<number> | number[] | Float32Array, entity: number): boolean;
+    startup(entityManager: any): Promise<void>;
+    shutdown(entityManager: any): Promise<void>;
+    /**
+     * @param {SGMesh} model
+     * @param {Transform} transform
+     * @param {number} entity
+     */
+    link(model: SGMesh, transform: Transform, entity: number): void;
+    /**
+     * @param {SGMesh} model
+     * @param {Transform} transform
+     * @param {number} entity
+     */
+    unlink(model: SGMesh, transform: Transform, entity: number): void;
+    #private;
+}
+import { System } from "../ecs/System.js";
+import { Transform } from "../ecs/transform/Transform.js";
+import { SGMesh } from "../graphics/ecs/mesh-v2/aggregate/SGMesh.js";
+import { Scene } from "../../shade/renderer/scene/Scene.js";
+//# sourceMappingURL=MeshSystem.d.ts.map

package/src/engine/graphics3/MeshSystem.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"MeshSystem.d.ts","sourceRoot":"","sources":["../../../../src/engine/graphics3/MeshSystem.js"],"names":[],"mappings":"AAiBA;;;;;;;;;;;;;;;;;;;GAmBG;AACH;IAmFI;;;;OAIG;IACH,6CAHW,KAAK,eACI,MAAM,KAAG,oBAAoB,EAchD;IADG,mDAAuC;IAG3C;;OAEG;IACH,mBAEC;IAED;;;;;;;;;;;;OAYG;IACH,wBALW,MAAM,kBACG,MAAM,KAAG,IAAI,GACpB,OAAO,CAqBnB;IAoCD;;;;;;;;;;;OAWG;IACH,oBAJW,MAAM,GACJ,sBAAoB,IAAI,CAWpC;IAED;;;;;;;;;;;OAWG;IACH,qBAJW,MAAM,GACJ,gCAA8B,IAAI,CAW9C;IAED;;;;;;;;;;;OAWG;IACH,6BALW,UAAU,MAAM,CAAC,GAAC,MAAM,EAAE,GAAC,YAAY,UACvC,MAAM,GACJ,OAAO,CAuCnB;IAED,2CAIC;IAED,4CASC;IA6GD;;;;OAIG;IACH,YAJW,MAAM,aACN,SAAS,UACT,MAAM,QA2BhB;IAED;;;;OAIG;IACH,cAJW,MAAM,aACN,SAAS,UACT,MAAM,QAIhB;;CAgLJ;uBA7nBsB,kBAAkB;0BACf,+BAA+B;uBAIlC,6CAA6C;sBAX9C,qCAAqC"}