@woosh/meep-engine 3.55.0 → 3.57.0

package/src/generation/foliage/config/BranchSpawnRule.d.ts

@@ -0,0 +1,118 @@
+/**
+ * Directed edge of the branch generator graph: every branch grown by generator `source` spawns lateral
+ * branches of generator `target` along `[attach_min, attach_max]` of its spine.
+ *
+ * Generators are indices into `TreeSpeciesConfig.branches`, and `target > source` always holds, so the
+ * graph is acyclic by construction and generator 0 (the trunk) is its only root.
+ */
+export class BranchSpawnRule {
+    /**
+     * @param {Partial<BranchSpawnRule>} [options]
+     * @returns {BranchSpawnRule}
+     */
+    static from(options?: Partial<BranchSpawnRule>): BranchSpawnRule;
+    /**
+     * Parent generator index.
+     * @type {number}
+     */
+    source: number;
+    /**
+     * Child generator index (`> source`).
+     * @type {number}
+     */
+    target: number;
+    /**
+     * Number of child branches spawned along a full-length parent.
+     * @type {number}
+     */
+    count: number;
+    /**
+     * Start of the attachment interval along the parent spine, normalized `t` in [0, 1].
+     * @type {number}
+     */
+    attach_min: number;
+    /**
+     * End of the attachment interval along the parent spine, normalized `t` in [0, 1].
+     * @type {number}
+     */
+    attach_max: number;
+    /**
+     * Phyllotactic arrangement of the spawned children.
+     * @type {PhyllotaxisMode|number}
+     */
+    phyllotaxis_mode: PhyllotaxisMode | number;
+    /**
+     * Children per whorl when `phyllotaxis_mode === PhyllotaxisMode.Whorled`.
+     * @type {number}
+     */
+    whorl_count: number;
+    /**
+     * Random azimuthal jitter in radians.
+     * @type {number}
+     */
+    azimuth_jitter: number;
+    /**
+     * Axillary insertion (polar divergence) angle in radians from the parent tangent.
+     * @type {number}
+     */
+    insertion_angle: number;
+    /**
+     * Random variation in insertion angle (radians).
+     * @type {number}
+     */
+    insertion_angle_variation: number;
+    /**
+     * 1D Hermite curve scaling the insertion angle along the parent's normalized position t in [0, 1].
+     * @type {AnimationCurve}
+     */
+    insertion_angle_profile: AnimationCurve;
+    /**
+     * 1D Hermite curve scaling the child's length along the parent's normalized position t in [0, 1].
+     * @type {AnimationCurve}
+     */
+    length_profile: AnimationCurve;
+    /**
+     * Weight [0, 1] of the sympodial recoil each emission imparts on the parent spine
+     * (scales the parent generator's `nodal_kink_strength`; 0 for whorls, roots and sprouts).
+     * @type {number}
+     */
+    parent_kink: number;
+    /**
+     * Whether the spawned children belong to the crown: their length follows the crown envelope at their height,
+     * and they are kept inside it (containment, space colonization). `false` for roots and trunk sprouts. Only crown rules self-prune (see
+     * `BranchGeneratorConfig.self_pruning`).
+     * @type {boolean}
+     */
+    crown_envelope: boolean;
+    /**
+     * @param {Partial<BranchSpawnRule>} [overrides]
+     * @returns {this}
+     */
+    applyOverrides(overrides?: Partial<BranchSpawnRule>): this;
+    /**
+     * @param {BranchSpawnRule} other
+     * @returns {this}
+     */
+    copy(other: BranchSpawnRule): this;
+    /**
+     * @returns {BranchSpawnRule}
+     */
+    clone(): BranchSpawnRule;
+    /**
+     * @param {BranchSpawnRule} other
+     * @returns {boolean}
+     */
+    equals(other: BranchSpawnRule): boolean;
+    /**
+     * @returns {number}
+     */
+    hash(): number;
+    /**
+     * @readonly
+     * @type {boolean}
+     */
+    readonly isBranchSpawnRule: boolean;
+}
+import { PhyllotaxisMode } from "./PhyllotaxisMode.js";
+import { AnimationCurve } from "../../../engine/animation/curve/AnimationCurve.js";
+//# sourceMappingURL=BranchSpawnRule.d.ts.map

package/src/generation/foliage/config/BranchSpawnRule.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"BranchSpawnRule.d.ts","sourceRoot":"","sources":["../../../../../src/generation/foliage/config/BranchSpawnRule.js"],"names":[],"mappings":"AAMA;;;;;;GAMG;AACH;IAwFI;;;OAGG;IACH,sBAHW,QAAQ,eAAe,CAAC,GACtB,eAAe,CAM3B;IA/FD;;;OAGG;IACH,QAFU,MAAM,CAEL;IAEX;;;OAGG;IACH,QAFU,MAAM,CAEL;IAEX;;;OAGG;IACH,OAFU,MAAM,CAEL;IAEX;;;OAGG;IACH,YAFU,MAAM,CAEE;IAElB;;;OAGG;IACH,YAFU,MAAM,CAEC;IAEjB;;;OAGG;IACH,kBAFU,eAAe,GAAC,MAAM,CAEgB;IAEhD;;;OAGG;IACH,aAFU,MAAM,CAEA;IAEhB;;;OAGG;IACH,gBAFU,MAAM,CAEM;IAEtB;;;OAGG;IACH,iBAFU,MAAM,CAEO;IAEvB;;;OAGG;IACH,2BAFU,MAAM,CAEiB;IAEjC;;;OAGG;IACH,yBAFU,cAAc,CAEyC;IAEjE;;;OAGG;IACH,gBAFU,cAAc,CAE0B;IAElD;;;;OAIG;IACH,aAFU,MAAM,CAEE;IAElB;;;;;OAKG;IACH,gBAFU,OAAO,CAEK;IAYtB;;;OAGG;IACH,2BAHW,QAAQ,eAAe,CAAC,GACtB,IAAI,CAqBhB;IAED;;;OAGG;IACH,YAHW,eAAe,GACb,IAAI,CAmBhB;IAED;;OAEG;IACH,SAFa,eAAe,CAM3B;IAED;;;OAGG;IACH,cAHW,eAAe,GACb,OAAO,CAmBnB;IAED;;OAEG;IACH,QAFa,MAAM,CAiBlB;IAGL;;;OAGG;IACH,4BAFU,OAAO,CAE0B;CAN1C;gCA9M+B,sBAAsB;+BADvB,mDAAmD"}

package/src/generation/foliage/config/BranchSpawnRule.js

@@ -0,0 +1,217 @@
+import { assert } from "../../../core/assert.js";
+import { hash_mix2 } from "../../../core/math/hash/hash_mix2.js";
+import { computeHashFloat } from "../../../core/primitives/numbers/computeHashFloat.js";
+import { AnimationCurve } from "../../../engine/animation/curve/AnimationCurve.js";
+import { PhyllotaxisMode } from "./PhyllotaxisMode.js";
+
+/**
+ * Directed edge of the branch generator graph: every branch grown by generator `source` spawns lateral
+ * branches of generator `target` along `[attach_min, attach_max]` of its spine.
+ *
+ * Generators are indices into `TreeSpeciesConfig.branches`, and `target > source` always holds, so the
+ * graph is acyclic by construction and generator 0 (the trunk) is its only root.
+ */
+export class BranchSpawnRule {
+    /**
+     * Parent generator index.
+     * @type {number}
+     */
+    source = 0;
+
+    /**
+     * Child generator index (`> source`).
+     * @type {number}
+     */
+    target = 1;
+
+    /**
+     * Number of child branches spawned along a full-length parent.
+     * @type {number}
+     */
+    count = 10;
+
+    /**
+     * Start of the attachment interval along the parent spine, normalized `t` in [0, 1].
+     * @type {number}
+     */
+    attach_min = 0.25;
+
+    /**
+     * End of the attachment interval along the parent spine, normalized `t` in [0, 1].
+     * @type {number}
+     */
+    attach_max = 1.0;
+
+    /**
+     * Phyllotactic arrangement of the spawned children.
+     * @type {PhyllotaxisMode|number}
+     */
+    phyllotaxis_mode = PhyllotaxisMode.SpiralGolden;
+
+    /**
+     * Children per whorl when `phyllotaxis_mode === PhyllotaxisMode.Whorled`.
+     * @type {number}
+     */
+    whorl_count = 3;
+
+    /**
+     * Random azimuthal jitter in radians.
+     * @type {number}
+     */
+    azimuth_jitter = 0.15;
+
+    /**
+     * Axillary insertion (polar divergence) angle in radians from the parent tangent.
+     * @type {number}
+     */
+    insertion_angle = 0.72;
+
+    /**
+     * Random variation in insertion angle (radians).
+     * @type {number}
+     */
+    insertion_angle_variation = 0.12;
+
+    /**
+     * 1D Hermite curve scaling the insertion angle along the parent's normalized position t in [0, 1].
+     * @type {AnimationCurve}
+     */
+    insertion_angle_profile = AnimationCurve.linear(0, 1.0, 1, 0.65);
+
+    /**
+     * 1D Hermite curve scaling the child's length along the parent's normalized position t in [0, 1].
+     * @type {AnimationCurve}
+     */
+    length_profile = AnimationCurve.constant(0, 1, 1);
+
+    /**
+     * Weight [0, 1] of the sympodial recoil each emission imparts on the parent spine
+     * (scales the parent generator's `nodal_kink_strength`; 0 for whorls, roots and sprouts).
+     * @type {number}
+     */
+    parent_kink = 1.0;
+
+    /**
+     * Whether the spawned children belong to the crown: their length follows the crown envelope at their height,
+     * and they are kept inside it (containment, space colonization). `false` for roots and trunk sprouts. Only crown rules self-prune (see
+     * `BranchGeneratorConfig.self_pruning`).
+     * @type {boolean}
+     */
+    crown_envelope = true;
+
+    /**
+     * @param {Partial<BranchSpawnRule>} [options]
+     * @returns {BranchSpawnRule}
+     */
+    static from(options = {}) {
+        const r = new BranchSpawnRule();
+        r.applyOverrides(options);
+        return r;
+    }
+
+    /**
+     * @param {Partial<BranchSpawnRule>} [overrides]
+     * @returns {this}
+     */
+    applyOverrides(overrides = {}) {
+        if (overrides === null || overrides === undefined) {
+            return this;
+        }
+        if (overrides.source !== undefined) this.source = overrides.source | 0;
+        if (overrides.target !== undefined) this.target = overrides.target | 0;
+        if (overrides.count !== undefined) this.count = Math.max(0, overrides.count | 0);
+        if (overrides.attach_min !== undefined) this.attach_min = overrides.attach_min;
+        if (overrides.attach_max !== undefined) this.attach_max = overrides.attach_max;
+        if (overrides.phyllotaxis_mode !== undefined) this.phyllotaxis_mode = overrides.phyllotaxis_mode;
+        if (overrides.whorl_count !== undefined) this.whorl_count = Math.max(1, overrides.whorl_count | 0);
+        if (overrides.azimuth_jitter !== undefined) this.azimuth_jitter = overrides.azimuth_jitter;
+        if (overrides.insertion_angle !== undefined) this.insertion_angle = overrides.insertion_angle;
+        if (overrides.insertion_angle_variation !== undefined) this.insertion_angle_variation = overrides.insertion_angle_variation;
+        if (overrides.insertion_angle_profile !== undefined) this.insertion_angle_profile.copy(overrides.insertion_angle_profile);
+        if (overrides.length_profile !== undefined) this.length_profile.copy(overrides.length_profile);
+        if (overrides.parent_kink !== undefined) this.parent_kink = overrides.parent_kink;
+        if (overrides.crown_envelope !== undefined) this.crown_envelope = Boolean(overrides.crown_envelope);
+        return this;
+    }
+
+    /**
+     * @param {BranchSpawnRule} other
+     * @returns {this}
+     */
+    copy(other) {
+        assert.defined(other, 'other');
+        this.source = other.source;
+        this.target = other.target;
+        this.count = other.count;
+        this.attach_min = other.attach_min;
+        this.attach_max = other.attach_max;
+        this.phyllotaxis_mode = other.phyllotaxis_mode;
+        this.whorl_count = other.whorl_count;
+        this.azimuth_jitter = other.azimuth_jitter;
+        this.insertion_angle = other.insertion_angle;
+        this.insertion_angle_variation = other.insertion_angle_variation;
+        this.insertion_angle_profile.copy(other.insertion_angle_profile);
+        this.length_profile.copy(other.length_profile);
+        this.parent_kink = other.parent_kink;
+        this.crown_envelope = other.crown_envelope;
+        return this;
+    }
+
+    /**
+     * @returns {BranchSpawnRule}
+     */
+    clone() {
+        const r = new BranchSpawnRule();
+        r.copy(this);
+        return r;
+    }
+
+    /**
+     * @param {BranchSpawnRule} other
+     * @returns {boolean}
+     */
+    equals(other) {
+        if (this === other) return true;
+        if (!other || !other.isBranchSpawnRule) return false;
+        return this.source === other.source
+            && this.target === other.target
+            && this.count === other.count
+            && this.attach_min === other.attach_min
+            && this.attach_max === other.attach_max
+            && this.phyllotaxis_mode === other.phyllotaxis_mode
+            && this.whorl_count === other.whorl_count
+            && this.azimuth_jitter === other.azimuth_jitter
+            && this.insertion_angle === other.insertion_angle
+            && this.insertion_angle_variation === other.insertion_angle_variation
+            && this.insertion_angle_profile.equals(other.insertion_angle_profile)
+            && this.length_profile.equals(other.length_profile)
+            && this.parent_kink === other.parent_kink
+            && this.crown_envelope === other.crown_envelope;
+    }
+
+    /**
+     * @returns {number}
+     */
+    hash() {
+        let h = hash_mix2(this.source, this.target);
+        h = hash_mix2(h, this.count);
+        h = hash_mix2(h, computeHashFloat(this.attach_min));
+        h = hash_mix2(h, computeHashFloat(this.attach_max));
+        h = hash_mix2(h, this.phyllotaxis_mode);
+        h = hash_mix2(h, this.whorl_count);
+        h = hash_mix2(h, computeHashFloat(this.azimuth_jitter));
+        h = hash_mix2(h, computeHashFloat(this.insertion_angle));
+        h = hash_mix2(h, computeHashFloat(this.insertion_angle_variation));
+        h = hash_mix2(h, this.insertion_angle_profile.hash());
+        h = hash_mix2(h, computeHashFloat(this.parent_kink));
+        h = hash_mix2(h, this.crown_envelope ? 1 : 0);
+        h = hash_mix2(h, this.length_profile.hash());
+        return h;
+    }
+}
+
+/**
+ * @readonly
+ * @type {boolean}
+ */
+BranchSpawnRule.prototype.isBranchSpawnRule = true;

package/src/generation/foliage/config/FoliageCardType.d.ts

@@ -7,6 +7,6 @@ export namespace FoliageCardType {
     let CrossCard: number;
     let TriStarCluster: number;
     let RibbedFrond: number;
-    let OctagonalCutoutHull: number;
+    let CutoutHull: number;
 }
 //# sourceMappingURL=FoliageCardType.d.ts.map

package/src/generation/foliage/config/FoliageCardType.js

@@ -13,6 +13,6 @@ export const FoliageCardType = {
     TriStarCluster: 2,
     /** Multi-segment curved Cubic Hermite ribbed frond (palms, ferns, weeping boughs) */
     RibbedFrond: 3,
-    /** Tight hexagonal/octagonal alpha-bound hull trimming empty corners */
-    OctagonalCutoutHull: 4,
+    /** Convex hull fitted to the atlas tile's leaf silhouette (`FoliageAtlasCutout`), folded along its midrib */
+    CutoutHull: 4,
 };

package/src/generation/foliage/config/FoliageConfig.d.ts

@@ -1,5 +1,8 @@
 /**
- * Configuration for phyllotactic leaf/frond placement, card topology, heliotropism, and canopy AO.
+ * Leaf card / frond geometry, heliotropism and canopy AO of a tree's foliage. Which branches carry it, is described
+ * by `TreeSpeciesConfig.foliage_rules`; how densely follows from the leaves the shoots bear, or on a branch not grown
+ * by annual units, from the card and the shoot (`foliage_cards_per_metre`). A card is the size of the leaf it draws
+ * (`foliage_tile_layout`).
  */
 export class FoliageConfig {
     /**
@@ -7,66 +10,42 @@ export class FoliageConfig {
      * @returns {FoliageConfig}
      */
     static from(options?: Partial<FoliageConfig>): FoliageConfig;
-    /**
-     * Whether foliage geometry is generated.
-     * @type {boolean}
-     */
-    enabled: boolean;
     /**
      * Leaf cluster card or frond mesh topology.
      * @type {FoliageCardType|number}
      */
     card_type: FoliageCardType | number;
     /**
-     * Minimum branch recursion level that carries foliage cards.
-     * @type {number}
-     */
-    attach_min_level: number;
-    /**
-     * Number of phyllotactic nodes along each qualifying carrier branch.
-     * @type {number}
-     */
-    cards_per_branch: number;
-    /**
-     * Number of terminal rosette cards clustered at the branch tip (t = 1).
-     * @type {number}
-     */
-    terminal_rosette_count: number;
-    /**
-     * Bare fraction [0, 0.9] at the base of a carrier branch without leaves.
-     * @type {number}
-     */
-    bare_ratio: number;
-    /**
-     * Phyllotactic arrangement mode for leaf attachments.
-     * @type {PhyllotaxisMode|number}
-     */
-    phyllotaxis_mode: PhyllotaxisMode | number;
-    /**
-     * Organs per node when `phyllotaxis_mode === PhyllotaxisMode.Whorled`.
+     * Relative random variance in card dimensions [0, 0.8].
      * @type {number}
      */
-    whorl_count: number;
+    size_variance: number;
     /**
-     * Petiole insertion angle (radians) relative to carrier branch tangent.
-     * @type {number}
+     * Share of an annual unit's leaves alive at each age in years, this year's unit first, on branches grown by annual
+     * units (`TreeSpeciesConfig.shoot_rules`): `[1]` keeps leaves one season, as a deciduous tree does; an
+     * evergreen's needle cohorts thin out over its list, and units older than it carry none.
+     * @type {number[]}
      */
-    insertion_angle: number;
+    leaf_survival: number[];
     /**
-     * Base width of a leaf cluster card or frond (meters).
+     * Leaves on an annual unit of no length, on branches grown by annual units; with {@link leaves_per_metre}, a unit
+     * `l` metres long bears `leaves_per_unit + leaves_per_metre * l`. The default is oak's: a leaf in the axil of each
+     * of the 4 subapical buds and of each median bud, `(l + 2.70) / 0.98` of them (cm) [Buck-Sorlin & Bell 2000,
+     * Forestry 73(1): 1-19, Table 5, footnote 3 p. 5]: 10.6 on a median 3.8 cm shoot, against 11.2 counted by
+     * Tree Physiology (2015).
      * @type {number}
      */
-    card_width: number;
+    leaves_per_unit: number;
     /**
-     * Base length of a leaf cluster card or frond from petiole pivot to tip (meters).
+     * Leaves an annual unit gains per metre of its length, see {@link leaves_per_unit}.
      * @type {number}
      */
-    card_length: number;
+    leaves_per_metre: number;
     /**
-     * Relative random variance in card dimensions [0, 0.8].
+     * Leaves a short shoot bears each year, crowded at its tip, on branches grown by annual units.
      * @type {number}
      */
-    size_variance: number;
+    leaves_per_short_shoot: number;
     /**
      * Transverse V-fold dihedral angle (radians) across the midrib.
      * @type {number}
@@ -118,10 +97,10 @@ export class FoliageConfig {
      */
     color_variation: number;
     /**
-     * @param {Partial<FoliageConfig>|boolean} [overrides]
+     * @param {Partial<FoliageConfig>} [overrides]
      * @returns {this}
      */
-    applyOverrides(overrides?: Partial<FoliageConfig> | boolean): this;
+    applyOverrides(overrides?: Partial<FoliageConfig>): this;
     /**
      * @param {FoliageConfig} other
      * @returns {this}
@@ -147,5 +126,4 @@ export class FoliageConfig {
     readonly isFoliageConfig: boolean;
 }
 import { FoliageCardType } from "./FoliageCardType.js";
-import { PhyllotaxisMode } from "./PhyllotaxisMode.js";
 //# sourceMappingURL=FoliageConfig.d.ts.map

package/src/generation/foliage/config/FoliageConfig.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"FoliageConfig.d.ts","sourceRoot":"","sources":["../../../../../src/generation/foliage/config/FoliageConfig.js"],"names":[],"mappings":"AAMA;;GAEG;AACH;IAqII;;;OAGG;IACH,sBAHW,QAAQ,aAAa,CAAC,GACpB,aAAa,CAMzB;IA5ID;;;OAGG;IACH,SAFU,OAAO,CAEF;IAEf;;;OAGG;IACH,WAFU,eAAe,GAAC,MAAM,CAEQ;IAExC;;;OAGG;IACH,kBAFU,MAAM,CAEK;IAErB;;;OAGG;IACH,kBAFU,MAAM,CAEM;IAEtB;;;OAGG;IACH,wBAFU,MAAM,CAEW;IAE3B;;;OAGG;IACH,YAFU,MAAM,CAEC;IAEjB;;;OAGG;IACH,kBAFU,eAAe,GAAC,MAAM,CAEgB;IAEhD;;;OAGG;IACH,aAFU,MAAM,CAEA;IAEhB;;;OAGG;IACH,iBAFU,MAAM,CAEO;IAEvB;;;OAGG;IACH,YAFU,MAAM,CAEE;IAElB;;;OAGG;IACH,aAFU,MAAM,CAEG;IAEnB;;;OAGG;IACH,eAFU,MAAM,CAEI;IAEpB;;;OAGG;IACH,YAFU,MAAM,CAEE;IAElB;;;OAGG;IACH,aAFU,MAAM,CAEG;IAEnB;;;OAGG;IACH,cAFU,MAAM,CAEG;IAEnB;;;OAGG;IACH,gBAFU,MAAM,CAEG;IAEnB;;;OAGG;IACH,cAFU,MAAM,CAEG;IAEnB;;;OAGG;IACH,cAFU,MAAM,CAEI;IAEpB;;;OAGG;IACH,gBAFU,MAAM,CAEM;IAEtB;;;OAGG;IACH,kBAFU,MAAM,CAEQ;IAExB;;;OAGG;IACH,mBAFU,MAAM,CAES;IAEzB;;;OAGG;IACH,iBAFU,MAAM,CAEO;IAYvB;;;OAGG;IACH,2BAHW,QAAQ,aAAa,CAAC,GAAC,OAAO,GAC5B,IAAI,CAiChB;IAED;;;OAGG;IACH,YAHW,aAAa,GACX,IAAI,CA2BhB;IAED;;OAEG;IACH,SAFa,aAAa,CAMzB;IAED;;;OAGG;IACH,cAHW,aAAa,GACX,OAAO,CA2BnB;IAED;;OAEG;IACH,QAFa,MAAM,CAclB;IAGL;;;OAGG;IACH,0BAFU,OAAO,CAEsB;CANtC;gCAjR+B,sBAAsB;gCACtB,sBAAsB"}
+{"version":3,"file":"FoliageConfig.d.ts","sourceRoot":"","sources":["../../../../../src/generation/foliage/config/FoliageConfig.js"],"names":[],"mappings":"AAOA;;;;;GAKG;AACH;IAuGI;;;OAGG;IACH,sBAHW,QAAQ,aAAa,CAAC,GACpB,aAAa,CAMzB;IA9GD;;;OAGG;IACH,WAFU,eAAe,GAAC,MAAM,CAEQ;IAExC;;;OAGG;IACH,eAFU,MAAM,CAEI;IAEpB;;;;;OAKG;IACH,eAFU,MAAM,EAAE,CAEE;IAEpB;;;;;;;OAOG;IACH,iBAFU,MAAM,CAEkB;IAElC;;;OAGG;IACH,kBAFU,MAAM,CAEc;IAE9B;;;OAGG;IACH,wBAFU,MAAM,CAEW;IAE3B;;;OAGG;IACH,YAFU,MAAM,CAEE;IAElB;;;OAGG;IACH,aAFU,MAAM,CAEG;IAEnB;;;OAGG;IACH,cAFU,MAAM,CAEG;IAEnB;;;OAGG;IACH,gBAFU,MAAM,CAEG;IAEnB;;;OAGG;IACH,cAFU,MAAM,CAEG;IAEnB;;;OAGG;IACH,cAFU,MAAM,CAEI;IAEpB;;;OAGG;IACH,gBAFU,MAAM,CAEM;IAEtB;;;OAGG;IACH,kBAFU,MAAM,CAEQ;IAExB;;;OAGG;IACH,mBAFU,MAAM,CAES;IAEzB;;;OAGG;IACH,iBAFU,MAAM,CAEO;IAYvB;;;OAGG;IACH,2BAHW,QAAQ,aAAa,CAAC,GACpB,IAAI,CA4BhB;IAED;;;OAGG;IACH,YAHW,aAAa,GACX,IAAI,CAqBhB;IAED;;OAEG;IACH,SAFa,aAAa,CAMzB;IAED;;;OAGG;IACH,cAHW,aAAa,GACX,OAAO,CAqBnB;IAED;;OAEG;IACH,QAFa,MAAM,CAWlB;IAGL;;;OAGG;IACH,0BAFU,OAAO,CAEsB;CANtC;gCAjO+B,sBAAsB"}