@woosh/meep-engine 3.51.0 → 3.53.0

package/src/generation/foliage/skeleton/TreeSkeleton.d.ts

@@ -0,0 +1,443 @@
+/**
+ * Directed botanical tree skeleton backed by Meep's {@link Graph}, {@link Transform64}, and {@link Attribute}s.
+ *
+ * - **Topology (`this.graph: Graph<number>`)**:
+ *   A single connected directed tree (`EdgeDirectionType.Forward`) of skeleton node IDs `0 .. node_count - 1`.
+ *   Intra-branch edges represent Cubic Hermite spine segments; inter-branch edges connect each lateral branch's
+ *   root node to its parent attachment node on the supporting branch.
+ * - **Spatial Frame & Radius (`this.node_transforms: Transform64[]`)**:
+ *   Each node `v` owns a {@link Transform64} storing:
+ *   - `translation` (`[12..14]`): 3D position $\mathbf{p}_v = (x, y, z)$ in tree space ($+Y$ up).
+ *   - `rotation` (`[16..19]`): Orthonormal Rotation-Minimizing Frame (RMF) quaternion where
+ *     local $+X$ (`right`) $= \mathbf{R}_v$, local $+Y$ (`up`) $= \mathbf{S}_v = \mathbf{T}_v \times \mathbf{R}_v$,
+ *     and local $+Z$ (`forward`) $= \mathbf{T}_v$ (unit spine tangent).
+ *   - `scale` (`[20..22]`): Uniform cross-sectional radius $R_v$.
+ * - **Node & Segment Data (`Attribute`)**:
+ *   Per-node and per-segment attributes are packed into typed {@link Attribute} buffers.
+ */
+export class TreeSkeleton {
+    /**
+     * Directed topological graph of node IDs (`0 .. node_count - 1`).
+     * @type {Graph<number>}
+     */
+    graph: Graph<number>;
+    /**
+     * Per-node 3D transforms (translation = position, rotation = RMF basis `[R, S, T]`, scale = radius).
+     * @type {Transform64[]}
+     */
+    node_transforms: Transform64[];
+    /**
+     * Number of active skeleton nodes.
+     * @type {number}
+     */
+    node_count: number;
+    /**
+     * Number of active Cubic Hermite spine segments.
+     * @type {number}
+     */
+    segment_count: number;
+    /**
+     * Number of active branches.
+     * @type {number}
+     */
+    branch_count: number;
+    /**
+     * Int32x4 per node: `[branch_id, level, parent_branch_id, in_segment_id]`
+     * @type {Attribute}
+     */
+    attr_node_branch_info: Attribute;
+    /**
+     * Float32x3 per node: `[t_norm, arc_s, phase_hash]`
+     * @type {Attribute}
+     */
+    attr_node_spine_param: Attribute;
+    /**
+     * Uint16x2 per node: `[primary_joint_index, parent_joint_index]`
+     * @type {Attribute}
+     */
+    attr_node_joint: Attribute;
+    /**
+     * Int32x2 per Cubic Hermite segment: `[v0, v1]`
+     * @type {Attribute}
+     */
+    attr_segment_endpoints: Attribute;
+    /**
+     * Float32x3 per Cubic Hermite segment: `[m0x, m0y, m0z]` (outgoing tangent at `v0`)
+     * @type {Attribute}
+     */
+    attr_segment_hermite_m0: Attribute;
+    /**
+     * Float32x3 per Cubic Hermite segment: `[m1x, m1y, m1z]` (incoming tangent at `v1`)
+     * @type {Attribute}
+     */
+    attr_segment_hermite_m1: Attribute;
+    /**
+     * Float32x2 per Cubic Hermite segment: `[length, parent_attach_t]`
+     * @type {Attribute}
+     */
+    attr_segment_metrics: Attribute;
+    /**
+     * Root node ID of each branch.
+     * @type {Int32Array}
+     */
+    branch_root_vertex: Int32Array;
+    /**
+     * Terminal tip node ID of each branch.
+     * @type {Int32Array}
+     */
+    branch_tip_vertex: Int32Array;
+    /**
+     * Recursion level of each branch (0 = trunk).
+     * @type {Uint8Array}
+     */
+    branch_level: Uint8Array;
+    /**
+     * Parent branch ID (-1 for trunk).
+     * @type {Int32Array}
+     */
+    branch_parent: Int32Array;
+    /**
+     * Parent Hermite segment ID where this branch attaches (-1 for trunk).
+     * @type {Int32Array}
+     */
+    branch_parent_edge: Int32Array;
+    /**
+     * Normalized position t in [0, 1] along the parent branch where this branch attaches.
+     * @type {Float32Array}
+     */
+    branch_parent_attach_t: Float32Array;
+    /**
+     * Total arc length of each branch in meters.
+     * @type {Float32Array}
+     */
+    branch_length: Float32Array;
+    /**
+     * Base radius of each branch in meters.
+     * @type {Float32Array}
+     */
+    branch_base_radius: Float32Array;
+    /**
+     * Per-branch random phase hash in [0, 1).
+     * @type {Float32Array}
+     */
+    branch_phase_hash: Float32Array;
+    /**
+     * Crown center `[cx, cy, cz]` in tree local space (Y-up).
+     * @type {Float32Array}
+     */
+    crown_center: Float32Array;
+    /**
+     * Crown ellipsoid semi-axes `[rx, ry, rz]`.
+     * @type {Float32Array}
+     */
+    crown_radii: Float32Array;
+    /**
+     * Resets the skeleton to empty state while retaining allocated attribute buffers and `Transform64` instances.
+     */
+    clear(): void;
+    /**
+     * Registers a new branch in the branch table and returns its `branch_id`.
+     *
+     * @param {number} root_vertex
+     * @param {number} level
+     * @param {number} parent_branch_id
+     * @param {number} parent_edge_id
+     * @param {number} parent_attach_t
+     * @param {number} length
+     * @param {number} base_radius
+     * @param {number} [phase_hash=0]
+     * @returns {number} branch_id
+     */
+    add_branch(root_vertex: number, level: number, parent_branch_id: number, parent_edge_id: number, parent_attach_t: number, length: number, base_radius: number, phase_hash?: number): number;
+    /**
+     * Allocates and initializes a new skeleton node in `this.graph`, storing its 3D position,
+     * orthonormal RMF basis `[R, S, T]`, and radius in a {@link Transform64}, and its metadata in {@link Attribute}s.
+     *
+     * @param {number} px
+     * @param {number} py
+     * @param {number} pz
+     * @param {number} tx unit spine tangent X
+     * @param {number} ty unit spine tangent Y
+     * @param {number} tz unit spine tangent Z
+     * @param {number} rx unit radial normal X
+     * @param {number} ry unit radial normal Y
+     * @param {number} rz unit radial normal Z
+     * @param {number} radius cross-sectional radius
+     * @param {number} branch_id
+     * @param {number} level
+     * @param {number} parent_branch_id
+     * @param {number} t_norm
+     * @param {number} arc_s
+     * @param {number} phase_hash
+     * @returns {number} node ID
+     */
+    add_node(px: number, py: number, pz: number, tx: number, ty: number, tz: number, rx: number, ry: number, rz: number, radius: number, branch_id: number, level: number, parent_branch_id: number, t_norm: number, arc_s: number, phase_hash: number): number;
+    /**
+     * Connects `parent_v -> child_v` with a directed `EdgeDirectionType.Forward` edge in `this.graph`
+     * if not already connected. Used both by `add_segment` and to link lateral branch root nodes to their
+     * parent attachment node so `this.graph` forms a single connected arborescence.
+     *
+     * @param {number} parent_v
+     * @param {number} child_v
+     */
+    connect_nodes(parent_v: number, child_v: number): void;
+    /**
+     * Creates a directed Cubic Hermite spine segment `(v0 -> v1)` and adds the corresponding
+     * `EdgeDirectionType.Forward` edge to `this.graph`.
+     *
+     * @param {number} v0 parent node ID
+     * @param {number} v1 child node ID
+     * @param {number} m0x outgoing tangent X at v0
+     * @param {number} m0y outgoing tangent Y at v0
+     * @param {number} m0z outgoing tangent Z at v0
+     * @param {number} m1x incoming tangent X at v1
+     * @param {number} m1y incoming tangent Y at v1
+     * @param {number} m1z incoming tangent Z at v1
+     * @param {number} length chord/arc length of the segment
+     * @param {number} [parent_attach_t=0] normalized position along parent branch
+     * @returns {number} segment ID
+     */
+    add_segment(v0: number, v1: number, m0x: number, m0y: number, m0z: number, m1x: number, m1y: number, m1z: number, length: number, parent_attach_t?: number): number;
+    /**
+     * Reads node `v`'s 3D position from its {@link Transform64}.
+     *
+     * @param {number[]|Float32Array|Float64Array} out
+     * @param {number} out_offset
+     * @param {number} v
+     */
+    node_read_position(out: number[] | Float32Array | Float64Array, out_offset: number, v: number): void;
+    /**
+     * Writes node `v`'s 3D position into its {@link Transform64}.
+     *
+     * @param {number} v
+     * @param {number} px
+     * @param {number} py
+     * @param {number} pz
+     */
+    node_write_position(v: number, px: number, py: number, pz: number): void;
+    /**
+     * Reads node `v`'s unit spine tangent $\mathbf{T}_v$ (local $+Z$ of its {@link Transform64}).
+     *
+     * @param {number[]|Float32Array|Float64Array} out
+     * @param {number} out_offset
+     * @param {number} v
+     */
+    node_read_tangent(out: number[] | Float32Array | Float64Array, out_offset: number, v: number): void;
+    /**
+     * Reads node `v`'s unit RMF radial normal $\mathbf{R}_v$ (local $+X$ of its {@link Transform64}).
+     *
+     * @param {number[]|Float32Array|Float64Array} out
+     * @param {number} out_offset
+     * @param {number} v
+     */
+    node_read_frame_r(out: number[] | Float32Array | Float64Array, out_offset: number, v: number): void;
+    /**
+     * Reads node `v`'s unit RMF binormal $\mathbf{S}_v = \mathbf{T}_v \times \mathbf{R}_v$ (local $+Y$ of its {@link Transform64}).
+     *
+     * @param {number[]|Float32Array|Float64Array} out
+     * @param {number} out_offset
+     * @param {number} v
+     */
+    node_read_frame_s(out: number[] | Float32Array | Float64Array, out_offset: number, v: number): void;
+    /**
+     * Updates node `v`'s {@link Transform64} rotation from tangent $\mathbf{T}$ and radial vector $\mathbf{R}$.
+     *
+     * @param {number} v
+     * @param {number} tx
+     * @param {number} ty
+     * @param {number} tz
+     * @param {number} rx
+     * @param {number} ry
+     * @param {number} rz
+     */
+    node_write_frame(v: number, tx: number, ty: number, tz: number, rx: number, ry: number, rz: number): void;
+    /**
+     * Updates node `v`'s tangent $\mathbf{T}_v$ while orthogonalizing its existing radial vector $\mathbf{R}_v$.
+     *
+     * @param {number} v
+     * @param {number} tx
+     * @param {number} ty
+     * @param {number} tz
+     */
+    node_write_tangent(v: number, tx: number, ty: number, tz: number): void;
+    /**
+     * Returns node `v`'s cross-sectional radius stored in its {@link Transform64} scale.
+     *
+     * @param {number} v
+     * @returns {number}
+     */
+    node_read_radius(v: number): number;
+    /**
+     * Writes node `v`'s cross-sectional radius into its {@link Transform64} scale.
+     *
+     * @param {number} v
+     * @param {number} radius
+     */
+    node_write_radius(v: number, radius: number): void;
+    /**
+     * @param {number} v
+     * @returns {number}
+     */
+    node_branch_id(v: number): number;
+    /**
+     * @param {number} v
+     * @returns {number}
+     */
+    node_level(v: number): number;
+    /**
+     * @param {number} v
+     * @returns {number}
+     */
+    node_parent_branch_id(v: number): number;
+    /**
+     * @param {number} v
+     * @returns {number} incoming Hermite segment ID, or -1 if none
+     */
+    node_in_segment(v: number): number;
+    /**
+     * Reads `[t_norm, arc_s, phase_hash]` for node `v`.
+     *
+     * @param {number[]|Float32Array} out
+     * @param {number} out_offset
+     * @param {number} v
+     */
+    node_read_spine_param(out: number[] | Float32Array, out_offset: number, v: number): void;
+    /**
+     * @param {number} v
+     * @returns {number}
+     */
+    node_t_norm(v: number): number;
+    /**
+     * @param {number} v
+     * @returns {number}
+     */
+    node_arc_s(v: number): number;
+    /**
+     * @param {number} v
+     * @returns {number}
+     */
+    node_phase_hash(v: number): number;
+    /**
+     * @param {number} v
+     * @param {number} component 0 for primary joint, 1 for parent joint
+     * @returns {number}
+     */
+    node_read_joint(v: number, component: number): number;
+    /**
+     * @param {number} v
+     * @param {number} primary_joint
+     * @param {number} parent_joint
+     */
+    node_write_joint(v: number, primary_joint: number, parent_joint: number): void;
+    /**
+     * Queries `this.graph` for the parent node of `v` along its incoming directed edge (`EdgeDirectionType.Forward`).
+     * Returns `-1` if `v` is a root node.
+     *
+     * @param {number} v
+     * @returns {number}
+     */
+    node_parent_vertex(v: number): number;
+    /**
+     * @param {number} edge_id
+     * @returns {number}
+     */
+    segment_v0(edge_id: number): number;
+    /**
+     * @param {number} edge_id
+     * @returns {number}
+     */
+    segment_v1(edge_id: number): number;
+    /**
+     * @param {number} edge_id
+     * @returns {number}
+     */
+    segment_length(edge_id: number): number;
+    /**
+     * @param {number} edge_id
+     * @returns {number}
+     */
+    segment_parent_attach_t(edge_id: number): number;
+    /**
+     * @param {number[]|Float32Array} out
+     * @param {number} out_offset
+     * @param {number} edge_id
+     */
+    segment_read_m0(out: number[] | Float32Array, out_offset: number, edge_id: number): void;
+    /**
+     * @param {number} edge_id
+     * @param {number} mx
+     * @param {number} my
+     * @param {number} mz
+     */
+    segment_write_m0(edge_id: number, mx: number, my: number, mz: number): void;
+    /**
+     * @param {number[]|Float32Array} out
+     * @param {number} out_offset
+     * @param {number} edge_id
+     */
+    segment_read_m1(out: number[] | Float32Array, out_offset: number, edge_id: number): void;
+    /**
+     * @param {number} edge_id
+     * @param {number} mx
+     * @param {number} my
+     * @param {number} mz
+     */
+    segment_write_m1(edge_id: number, mx: number, my: number, mz: number): void;
+    /**
+     * Evaluates the 3D position along Cubic Hermite segment `edge_id` at parameter `u` in `[0, 1]`.
+     *
+     * @param {number[]|Float32Array} out
+     * @param {number} out_offset
+     * @param {number} edge_id
+     * @param {number} u
+     */
+    evaluate_segment_position(out: number[] | Float32Array, out_offset: number, edge_id: number, u: number): void;
+    /**
+     * Evaluates the unnormalized 3D derivative along Cubic Hermite segment `edge_id` at parameter `u` in `[0, 1]`.
+     *
+     * @param {number[]|Float32Array} out
+     * @param {number} out_offset
+     * @param {number} edge_id
+     * @param {number} u
+     */
+    evaluate_segment_derivative(out: number[] | Float32Array, out_offset: number, edge_id: number, u: number): void;
+    /**
+     * Evaluates the unit 3D tangent vector along Cubic Hermite segment `edge_id` at parameter `u` in `[0, 1]`.
+     *
+     * @param {number[]|Float32Array} out
+     * @param {number} out_offset
+     * @param {number} edge_id
+     * @param {number} u
+     */
+    evaluate_segment_tangent(out: number[] | Float32Array, out_offset: number, edge_id: number, u: number): void;
+    /**
+     * Collects the ordered node IDs and Hermite segment IDs along branch `branch_id` by traversing
+     * outgoing edges of `this.graph` that belong to `branch_id`.
+     *
+     * @param {number} branch_id
+     * @param {number[]} out_nodes
+     * @param {number[]} out_segments
+     */
+    collect_branch_chain(branch_id: number, out_nodes: number[], out_segments: number[]): void;
+    /**
+     * Deep copies another `TreeSkeleton` into this instance (`Graph`, `Transform64[]`, and `Attribute`s).
+     *
+     * @param {TreeSkeleton} other
+     * @returns {this}
+     */
+    copy(other: TreeSkeleton): this;
+    /**
+     * @returns {TreeSkeleton}
+     */
+    clone(): TreeSkeleton;
+    /**
+     * @readonly
+     * @type {boolean}
+     */
+    readonly isTreeSkeleton: boolean;
+    #private;
+}
+import { Graph } from "../../../core/graph/v2/Graph.js";
+import { Transform64 } from "../../../engine/ecs/transform/Transform64.js";
+import { Attribute } from "../../../shade/renderer/geometry/Attribute.js";
+//# sourceMappingURL=TreeSkeleton.d.ts.map

package/src/generation/foliage/skeleton/TreeSkeleton.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"TreeSkeleton.d.ts","sourceRoot":"","sources":["../../../../../src/generation/foliage/skeleton/TreeSkeleton.js"],"names":[],"mappings":"AAuCA;;;;;;;;;;;;;;;;GAgBG;AACH;IACI;;;OAGG;IACH,OAFU,MAAM,MAAM,CAAC,CAEH;IAEpB;;;OAGG;IACH,iBAFU,WAAW,EAAE,CAEF;IAErB;;;OAGG;IACH,YAFU,MAAM,CAED;IAEf;;;OAGG;IACH,eAFU,MAAM,CAEE;IAElB;;;OAGG;IACH,cAFU,MAAM,CAEC;IAiBjB;;;OAGG;IACH,uBAFU,SAAS,CAEsF;IAEzG;;;OAGG;IACH,uBAFU,SAAS,CAEwF;IAE3G;;;OAGG;IACH,iBAFU,SAAS,CAE2E;IAE9F;;;OAGG;IACH,wBAFU,SAAS,CAE2F;IAE9G;;;OAGG;IACH,yBAFU,SAAS,CAE+F;IAElH;;;OAGG;IACH,yBAFU,SAAS,CAE+F;IAElH;;;OAGG;IACH,sBAFU,SAAS,CAEyF;IAE5G;;;OAGG;IACH,oBAFU,UAAU,CAEyC;IAE7D;;;OAGG;IACH,mBAFU,UAAU,CAEwC;IAE5D;;;OAGG;IACH,cAFU,UAAU,CAEmC;IAEvD;;;OAGG;IACH,eAFU,UAAU,CAEoC;IAExD;;;OAGG;IACH,oBAFU,UAAU,CAEyC;IAE7D;;;OAGG;IACH,wBAFU,YAAY,CAE6C;IAEnE;;;OAGG;IACH,eAFU,YAAY,CAEoC;IAE1D;;;OAGG;IACH,oBAFU,YAAY,CAEyC;IAE/D;;;OAGG;IACH,mBAFU,YAAY,CAEwC;IAE9D;;;OAGG;IACH,cAFU,YAAY,CAEqB;IAE3C;;;OAGG;IACH,aAFU,YAAY,CAE0B;IAYhD;;OAEG;IACH,cAYC;IA6ED;;;;;;;;;;;;OAYG;IACH,wBAVW,MAAM,SACN,MAAM,oBACN,MAAM,kBACN,MAAM,mBACN,MAAM,UACN,MAAM,eACN,MAAM,eACN,MAAM,GACJ,MAAM,CA2BlB;IAED;;;;;;;;;;;;;;;;;;;;;OAqBG;IACH,aAlBW,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,UACN,MAAM,aACN,MAAM,SACN,MAAM,oBACN,MAAM,UACN,MAAM,SACN,MAAM,cACN,MAAM,GACJ,MAAM,CA2DlB;IAED;;;;;;;OAOG;IACH,wBAHW,MAAM,WACN,MAAM,QAQhB;IAED;;;;;;;;;;;;;;;OAeG;IACH,gBAZW,MAAM,MACN,MAAM,OACN,MAAM,OACN,MAAM,OACN,MAAM,OACN,MAAM,OACN,MAAM,OACN,MAAM,UACN,MAAM,oBACN,MAAM,GACJ,MAAM,CAwClB;IAED;;;;;;OAMG;IACH,wBAJW,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,cAClC,MAAM,KACN,MAAM,QAOhB;IAED;;;;;;;OAOG;IACH,uBALW,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,QAIhB;IAED;;;;;;OAMG;IACH,uBAJW,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,cAClC,MAAM,KACN,MAAM,QAYhB;IAED;;;;;;OAMG;IACH,uBAJW,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,cAClC,MAAM,KACN,MAAM,QAYhB;IAED;;;;;;OAMG;IACH,uBAJW,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,cAClC,MAAM,KACN,MAAM,QAYhB;IAED;;;;;;;;;;OAUG;IACH,oBARW,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,QAShB;IAED;;;;;;;OAOG;IACH,sBALW,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,QAsBhB;IAED;;;;;OAKG;IACH,oBAHW,MAAM,GACJ,MAAM,CAIlB;IAED;;;;;OAKG;IACH,qBAHW,MAAM,UACN,MAAM,QAMhB;IAED;;;OAGG;IACH,kBAHW,MAAM,GACJ,MAAM,CAIlB;IAED;;;OAGG;IACH,cAHW,MAAM,GACJ,MAAM,CAIlB;IAED;;;OAGG;IACH,yBAHW,MAAM,GACJ,MAAM,CAIlB;IAED;;;OAGG;IACH,mBAHW,MAAM,GACJ,MAAM,CAIlB;IAED;;;;;;OAMG;IACH,2BAJW,MAAM,EAAE,GAAC,YAAY,cACrB,MAAM,KACN,MAAM,QAQhB;IAED;;;OAGG;IACH,eAHW,MAAM,GACJ,MAAM,CAIlB;IAED;;;OAGG;IACH,cAHW,MAAM,GACJ,MAAM,CAIlB;IAED;;;OAGG;IACH,mBAHW,MAAM,GACJ,MAAM,CAIlB;IAED;;;;OAIG;IACH,mBAJW,MAAM,aACN,MAAM,GACJ,MAAM,CAIlB;IAED;;;;OAIG;IACH,oBAJW,MAAM,iBACN,MAAM,gBACN,MAAM,QAOhB;IAED;;;;;;OAMG;IACH,sBAHW,MAAM,GACJ,MAAM,CAelB;IAED;;;OAGG;IACH,oBAHW,MAAM,GACJ,MAAM,CAIlB;IAED;;;OAGG;IACH,oBAHW,MAAM,GACJ,MAAM,CAIlB;IAED;;;OAGG;IACH,wBAHW,MAAM,GACJ,MAAM,CAIlB;IAED;;;OAGG;IACH,iCAHW,MAAM,GACJ,MAAM,CAIlB;IAED;;;;OAIG;IACH,qBAJW,MAAM,EAAE,GAAC,YAAY,cACrB,MAAM,WACN,MAAM,QAQhB;IAED;;;;;OAKG;IACH,0BALW,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,QAQhB;IAED;;;;OAIG;IACH,qBAJW,MAAM,EAAE,GAAC,YAAY,cACrB,MAAM,WACN,MAAM,QAQhB;IAED;;;;;OAKG;IACH,0BALW,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,QAQhB;IAED;;;;;;;OAOG;IACH,+BALW,MAAM,EAAE,GAAC,YAAY,cACrB,MAAM,WACN,MAAM,KACN,MAAM,QAkChB;IAED;;;;;;;OAOG;IACH,iCALW,MAAM,EAAE,GAAC,YAAY,cACrB,MAAM,WACN,MAAM,KACN,MAAM,QAkChB;IAED;;;;;;;OAOG;IACH,8BALW,MAAM,EAAE,GAAC,YAAY,cACrB,MAAM,WACN,MAAM,KACN,MAAM,QAiBhB;IAED;;;;;;;OAOG;IACH,gCAJW,MAAM,aACN,MAAM,EAAE,gBACR,MAAM,EAAE,QA2ClB;IAED;;;;;OAKG;IACH,YAHW,YAAY,GACV,IAAI,CA2DhB;IAED;;OAEG;IACH,SAFa,YAAY,CAMxB;IAGL;;;OAGG;IACH,yBAFU,OAAO,CAEoB;;CANpC;sBAlkCqB,iCAAiC;4BAShD,8CAA8C;0BAC3B,+CAA+C"}