@woosh/meep-engine 3.52.0 → 3.54.0

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

@@ -0,0 +1,109 @@
+/**
+ * Complete botanical, geometric, material, LOD, and wind configuration for a tree species.
+ */
+export class TreeSpeciesConfig {
+    /**
+     * Creates a default 3-level branch hierarchy (trunk, primary boughs, secondary branches).
+     * @returns {BranchLevelConfig[]}
+     */
+    static createDefaultLevels(): BranchLevelConfig[];
+    /**
+     * @param {Partial<TreeSpeciesConfig>} [options]
+     * @returns {TreeSpeciesConfig}
+     */
+    static from(options?: Partial<TreeSpeciesConfig>): TreeSpeciesConfig;
+    /**
+     * Species display/asset name.
+     * @type {string}
+     */
+    name: string;
+    /**
+     * Preset identifier (`TreePreset`).
+     * @type {TreePreset|string}
+     */
+    preset: TreePreset | string;
+    /**
+     * Deterministic integer random seed.
+     * @type {number}
+     */
+    seed: number;
+    /**
+     * Crown envelope, space colonization, and pipe-model parameters.
+     * @type {CrownConfig}
+     */
+    crown: CrownConfig;
+    /**
+     * Recursive branch level configurations (`levels[0]` = trunk, `levels[1]` = boughs, etc.).
+     * @type {BranchLevelConfig[]}
+     */
+    levels: BranchLevelConfig[];
+    /**
+     * Phyllotactic foliage card placement and geometry configuration.
+     * @type {FoliageConfig}
+     */
+    foliage: FoliageConfig;
+    /**
+     * Procedural bark PBR material configuration.
+     * @type {BarkMaterialConfig}
+     */
+    bark_material: BarkMaterialConfig;
+    /**
+     * Procedural cutout foliage PBR material configuration.
+     * @type {FoliageMaterialConfig}
+     */
+    foliage_material: FoliageMaterialConfig;
+    /**
+     * GPU skeletal wind and vertex flutter configuration.
+     * @type {TreeWindConfig}
+     */
+    wind: TreeWindConfig;
+    /**
+     * Multi-LOD chain configuration (`lods[0]` = highest detail).
+     * @type {TreeLODConfig[]}
+     */
+    lods: TreeLODConfig[];
+    /**
+     * Optional 3D guide curve for the trunk spine (`null` defaults to the vertical upward axis `(0, y, 0)`).
+     * Can be an array of `[x, y, z]` control points or a callable `(t_norm, out_xyz) => void`.
+     * @type {Array<ArrayLike<number>>|Function|null}
+     */
+    trunk_guide: Array<ArrayLike<number>> | Function | null;
+    /**
+     * Applies partial deep overrides onto this configuration.
+     * @param {Object} [overrides]
+     * @returns {this}
+     */
+    applyOverrides(overrides?: any): this;
+    /**
+     * @param {TreeSpeciesConfig} other
+     * @returns {this}
+     */
+    copy(other: TreeSpeciesConfig): this;
+    /**
+     * @returns {TreeSpeciesConfig}
+     */
+    clone(): TreeSpeciesConfig;
+    /**
+     * @param {TreeSpeciesConfig} other
+     * @returns {boolean}
+     */
+    equals(other: TreeSpeciesConfig): boolean;
+    /**
+     * @returns {number}
+     */
+    hash(): number;
+    /**
+     * @readonly
+     * @type {boolean}
+     */
+    readonly isTreeSpeciesConfig: boolean;
+}
+import { TreePreset } from "./TreePreset.js";
+import { CrownConfig } from "./CrownConfig.js";
+import { BranchLevelConfig } from "./BranchLevelConfig.js";
+import { FoliageConfig } from "./FoliageConfig.js";
+import { BarkMaterialConfig } from "./BarkMaterialConfig.js";
+import { FoliageMaterialConfig } from "./FoliageMaterialConfig.js";
+import { TreeWindConfig } from "./TreeWindConfig.js";
+import { TreeLODConfig } from "./TreeLODConfig.js";
+//# sourceMappingURL=TreeSpeciesConfig.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"TreeSpeciesConfig.d.ts","sourceRoot":"","sources":["../../../../../src/generation/foliage/config/TreeSpeciesConfig.js"],"names":[],"mappings":"AAaA;;GAEG;AACH;IAyEI;;;OAGG;IACH,8BAFa,iBAAiB,EAAE,CA2H/B;IAED;;;OAGG;IACH,sBAHW,QAAQ,iBAAiB,CAAC,GACxB,iBAAiB,CAS7B;IAlND;;;OAGG;IACH,MAFU,MAAM,CAEH;IAEb;;;OAGG;IACH,QAFU,UAAU,GAAC,MAAM,CAEH;IAExB;;;OAGG;IACH,MAFU,MAAM,CAEJ;IAEZ;;;OAGG;IACH,OAFU,WAAW,CAEK;IAE1B;;;OAGG;IACH,QAFU,iBAAiB,EAAE,CAEjB;IAEZ;;;OAGG;IACH,SAFU,aAAa,CAEO;IAE9B;;;OAGG;IACH,eAFU,kBAAkB,CAEa;IAEzC;;;OAGG;IACH,kBAFU,qBAAqB,CAEgB;IAE/C;;;OAGG;IACH,MAFU,cAAc,CAEI;IAE5B;;;OAGG;IACH,MAFU,aAAa,EAAE,CAEf;IAEV;;;;OAIG;IACH,aAFU,MAAM,UAAU,MAAM,CAAC,CAAC,cAAU,IAAI,CAE7B;IAmJnB;;;;OAIG;IACH,iCAFa,IAAI,CAuDhB;IAED;;;OAGG;IACH,YAHW,iBAAiB,GACf,IAAI,CAkBhB;IAED;;OAEG;IACH,SAFa,iBAAiB,CAM7B;IAED;;;OAGG;IACH,cAHW,iBAAiB,GACf,OAAO,CA0CnB;IAED;;OAEG;IACH,QAFa,MAAM,CAyBlB;IAGL;;;OAGG;IACH,8BAFU,OAAO,CAE8B;CAN9C;2BA/X0B,iBAAiB;4BAJhB,kBAAkB;kCADZ,wBAAwB;8BAE5B,oBAAoB;mCAHf,yBAAyB;sCAItB,4BAA4B;+BAGnC,qBAAqB;8BAFtB,oBAAoB"}

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

@@ -0,0 +1,400 @@
+import { assert } from "../../../core/assert.js";
+import { hash_mix2 } from "../../../core/math/hash/hash_mix2.js";
+import { computeStringHash } from "../../../core/primitives/strings/computeStringHash.js";
+import { AnimationCurve } from "../../../engine/animation/curve/AnimationCurve.js";
+import { BarkMaterialConfig } from "./BarkMaterialConfig.js";
+import { BranchLevelConfig } from "./BranchLevelConfig.js";
+import { CrownConfig } from "./CrownConfig.js";
+import { FoliageConfig } from "./FoliageConfig.js";
+import { FoliageMaterialConfig } from "./FoliageMaterialConfig.js";
+import { TreeLODConfig } from "./TreeLODConfig.js";
+import { TreePreset } from "./TreePreset.js";
+import { TreeWindConfig } from "./TreeWindConfig.js";
+
+/**
+ * Complete botanical, geometric, material, LOD, and wind configuration for a tree species.
+ */
+export class TreeSpeciesConfig {
+    /**
+     * Species display/asset name.
+     * @type {string}
+     */
+    name = "oak";
+
+    /**
+     * Preset identifier (`TreePreset`).
+     * @type {TreePreset|string}
+     */
+    preset = TreePreset.Oak;
+
+    /**
+     * Deterministic integer random seed.
+     * @type {number}
+     */
+    seed = 1337;
+
+    /**
+     * Crown envelope, space colonization, and pipe-model parameters.
+     * @type {CrownConfig}
+     */
+    crown = new CrownConfig();
+
+    /**
+     * Recursive branch level configurations (`levels[0]` = trunk, `levels[1]` = boughs, etc.).
+     * @type {BranchLevelConfig[]}
+     */
+    levels = [];
+
+    /**
+     * Phyllotactic foliage card placement and geometry configuration.
+     * @type {FoliageConfig}
+     */
+    foliage = new FoliageConfig();
+
+    /**
+     * Procedural bark PBR material configuration.
+     * @type {BarkMaterialConfig}
+     */
+    bark_material = new BarkMaterialConfig();
+
+    /**
+     * Procedural cutout foliage PBR material configuration.
+     * @type {FoliageMaterialConfig}
+     */
+    foliage_material = new FoliageMaterialConfig();
+
+    /**
+     * GPU skeletal wind and vertex flutter configuration.
+     * @type {TreeWindConfig}
+     */
+    wind = new TreeWindConfig();
+
+    /**
+     * Multi-LOD chain configuration (`lods[0]` = highest detail).
+     * @type {TreeLODConfig[]}
+     */
+    lods = [];
+
+    /**
+     * Optional 3D guide curve for the trunk spine (`null` defaults to the vertical upward axis `(0, y, 0)`).
+     * Can be an array of `[x, y, z]` control points or a callable `(t_norm, out_xyz) => void`.
+     * @type {Array<ArrayLike<number>>|Function|null}
+     */
+    trunk_guide = null;
+
+    constructor() {
+        this.levels = TreeSpeciesConfig.createDefaultLevels();
+        this.lods = TreeLODConfig.createDefaultChain(3);
+    }
+
+    /**
+     * Creates a default 3-level branch hierarchy (trunk, primary boughs, secondary branches).
+     * @returns {BranchLevelConfig[]}
+     */
+    static createDefaultLevels() {
+        return [
+            BranchLevelConfig.from({
+                level: 0,
+                segments: 12,
+                radial_segments_max: 14,
+                radial_segments_min: 8,
+                length: 9.0,
+                length_variance: 0.06,
+                radius_ratio: 0.058,
+                taper: 0.78,
+                bare_length_ratio: 0.30,
+                child_count: 11,
+                insertion_angle: 1.18,
+                insertion_angle_variation: 0.14,
+                insertion_angle_profile: AnimationCurve.linear(0, 1.05, 1, 0.52),
+                curvature: 0.22,
+                curve_back: -0.14,
+                spiral_twist: 0.35,
+                gravitropism: -0.05,
+                phototropism: 0.14,
+                gnarl_strength: 0.16,
+                gnarl_frequency: 0.38,
+                basal_lean: 0.025,
+                nodal_kink_strength: 0.52,
+                internode_zigzag: 0.07,
+                kink_sharpness: 0.68,
+                tip_upcurl: 0.12,
+                oval_eccentricity: 0.10,
+                bark_displacement: 0.10,
+                parent_collar_bulge: 0.34,
+                knot_count: 6,
+                knot_strength: 0.18,
+                split_probability: 0.32,
+                split_count: 2,
+                split_angle: 0.52,
+                flare_amplitude: 0.42,
+                flare_height_ratio: 0.20,
+                flare_lobes: 5,
+                flare_sharpness: 3.5,
+                flute_amplitude: 0.025,
+                flute_frequency: 4,
+                collar_weld_rings: 0
+            }),
+            BranchLevelConfig.from({
+                level: 1,
+                segments: 8,
+                radial_segments_max: 9,
+                radial_segments_min: 5,
+                length: 5.2,
+                length_variance: 0.14,
+                length_profile: AnimationCurve.linear(0, 1.0, 1, 0.52),
+                radius_ratio: 0.046,
+                taper: 0.82,
+                bare_length_ratio: 0.18,
+                child_count: 8,
+                insertion_angle: 0.82,
+                insertion_angle_variation: 0.16,
+                curvature: -0.22,
+                curve_back: 0.18,
+                spiral_twist: 0.28,
+                gravitropism: 0.16,
+                phototropism: 0.24,
+                gnarl_strength: 0.24,
+                gnarl_frequency: 0.52,
+                basal_lean: 0.0,
+                nodal_kink_strength: 0.78,
+                internode_zigzag: 0.15,
+                kink_sharpness: 0.72,
+                tip_upcurl: 0.28,
+                oval_eccentricity: 0.20,
+                bark_displacement: 0.08,
+                parent_collar_bulge: 0.28,
+                knot_count: 3,
+                knot_strength: 0.14,
+                split_probability: 0.26,
+                split_count: 2,
+                split_angle: 0.48,
+                flute_amplitude: 0.035,
+                flute_frequency: 4,
+                collar_weld_rings: 2,
+                collar_length_ratio: 0.1,
+                collar_spread_upper: 0.24,
+                collar_spread_lower: 0.45,
+                collar_normal_blend: 0.85
+            }),
+            BranchLevelConfig.from({
+                level: 2,
+                segments: 6,
+                radial_segments_max: 6,
+                radial_segments_min: 4,
+                length: 2.1,
+                length_variance: 0.18,
+                length_profile: AnimationCurve.linear(0, 0.9, 1, 0.5),
+                radius_ratio: 0.036,
+                taper: 0.88,
+                bare_length_ratio: 0.12,
+                child_count: 0,
+                insertion_angle: 0.68,
+                insertion_angle_variation: 0.18,
+                curvature: 0.22,
+                curve_back: -0.12,
+                gravitropism: 0.12,
+                phototropism: 0.34,
+                gnarl_strength: 0.22,
+                gnarl_frequency: 0.68,
+                nodal_kink_strength: 0.65,
+                internode_zigzag: 0.19,
+                kink_sharpness: 0.68,
+                tip_upcurl: 0.32,
+                oval_eccentricity: 0.12,
+                bark_displacement: 0.05,
+                knot_count: 1,
+                knot_strength: 0.08,
+                collar_weld_rings: 1,
+                collar_length_ratio: 0.12,
+                collar_spread_upper: 0.18,
+                collar_spread_lower: 0.3,
+                collar_normal_blend: 0.8
+            })
+        ];
+    }
+
+    /**
+     * @param {Partial<TreeSpeciesConfig>} [options]
+     * @returns {TreeSpeciesConfig}
+     */
+    static from(options = {}) {
+        if (options && options.isTreeSpeciesConfig) {
+            return options.clone();
+        }
+        const r = new TreeSpeciesConfig();
+        r.applyOverrides(options);
+        return r;
+    }
+
+    /**
+     * Applies partial deep overrides onto this configuration.
+     * @param {Object} [overrides]
+     * @returns {this}
+     */
+    applyOverrides(overrides = {}) {
+        if (overrides === null || overrides === undefined) {
+            return this;
+        }
+        if (overrides.name !== undefined) this.name = String(overrides.name);
+        if (overrides.preset !== undefined) this.preset = overrides.preset;
+        if (overrides.seed !== undefined) this.seed = overrides.seed | 0;
+        if (overrides.trunk_guide !== undefined) this.trunk_guide = overrides.trunk_guide;
+        if (overrides.crown !== undefined) this.crown.applyOverrides(overrides.crown);
+        if (overrides.foliage !== undefined) this.foliage.applyOverrides(overrides.foliage);
+        if (overrides.bark_material !== undefined) this.bark_material.applyOverrides(overrides.bark_material);
+        if (overrides.foliage_material !== undefined) this.foliage_material.applyOverrides(overrides.foliage_material);
+        if (overrides.wind !== undefined) this.wind.applyOverrides(overrides.wind);
+
+        if (Array.isArray(overrides.levels)) {
+            if (overrides.replace_levels === true) {
+                this.levels = overrides.levels.map((lvl, idx) => {
+                    const base = BranchLevelConfig.from(lvl);
+                    base.level = idx;
+                    return base;
+                });
+            } else if (overrides.levels.length !== this.levels.length) {
+                this.levels = overrides.levels.map((lvl, idx) => {
+                    const existing = this.levels[idx];
+                    const base = existing && existing.isBranchLevelConfig ? existing.clone() : new BranchLevelConfig();
+                    base.level = idx;
+                    base.applyOverrides(lvl);
+                    return base;
+                });
+            } else {
+                for (let i = 0; i < overrides.levels.length; i++) {
+                    if (overrides.levels[i]) {
+                        if (!this.levels[i] || !this.levels[i].isBranchLevelConfig) {
+                            this.levels[i] = new BranchLevelConfig();
+                        }
+                        this.levels[i].applyOverrides(overrides.levels[i]);
+                        this.levels[i].level = i;
+                    }
+                }
+            }
+        }
+
+        if (overrides.lod_count !== undefined && overrides.lods === undefined) {
+            this.lods = TreeLODConfig.createDefaultChain(overrides.lod_count);
+        } else if (Array.isArray(overrides.lods)) {
+            this.lods = overrides.lods.map((lod, idx) => {
+                const cfg = TreeLODConfig.from(lod);
+                cfg.level = idx;
+                return cfg;
+            });
+        }
+
+        return this;
+    }
+
+    /**
+     * @param {TreeSpeciesConfig} other
+     * @returns {this}
+     */
+    copy(other) {
+        assert.defined(other, 'other');
+        this.name = other.name;
+        this.preset = other.preset;
+        this.seed = other.seed;
+        this.trunk_guide = Array.isArray(other.trunk_guide)
+            ? other.trunk_guide.map(pt => [pt[0], pt[1], pt[2]])
+            : other.trunk_guide;
+        this.crown.copy(other.crown);
+        this.levels = other.levels.map(l => l.clone());
+        this.foliage.copy(other.foliage);
+        this.bark_material.copy(other.bark_material);
+        this.foliage_material.copy(other.foliage_material);
+        this.wind.copy(other.wind);
+        this.lods = other.lods.map(l => l.clone());
+        return this;
+    }
+
+    /**
+     * @returns {TreeSpeciesConfig}
+     */
+    clone() {
+        const r = new TreeSpeciesConfig();
+        r.copy(this);
+        return r;
+    }
+
+    /**
+     * @param {TreeSpeciesConfig} other
+     * @returns {boolean}
+     */
+    equals(other) {
+        if (this === other) return true;
+        if (!other || !other.isTreeSpeciesConfig) return false;
+        if (this.name !== other.name || this.preset !== other.preset || this.seed !== other.seed) {
+            return false;
+        }
+        if ((this.trunk_guide === null) !== (other.trunk_guide === null)) {
+            return false;
+        }
+        if (this.trunk_guide !== null && other.trunk_guide !== null) {
+            if (Array.isArray(this.trunk_guide) !== Array.isArray(other.trunk_guide)) return false;
+            if (Array.isArray(this.trunk_guide) && Array.isArray(other.trunk_guide)) {
+                if (this.trunk_guide.length !== other.trunk_guide.length) return false;
+                for (let i = 0; i < this.trunk_guide.length; i++) {
+                    const a = this.trunk_guide[i];
+                    const b = other.trunk_guide[i];
+                    if (a[0] !== b[0] || a[1] !== b[1] || a[2] !== b[2]) return false;
+                }
+            } else if (this.trunk_guide !== other.trunk_guide) {
+                return false;
+            }
+        }
+        if (!this.crown.equals(other.crown)
+            || !this.foliage.equals(other.foliage)
+            || !this.bark_material.equals(other.bark_material)
+            || !this.foliage_material.equals(other.foliage_material)
+            || !this.wind.equals(other.wind)
+        ) {
+            return false;
+        }
+        if (this.levels.length !== other.levels.length || this.lods.length !== other.lods.length) {
+            return false;
+        }
+        for (let i = 0; i < this.levels.length; i++) {
+            if (!this.levels[i].equals(other.levels[i])) return false;
+        }
+        for (let i = 0; i < this.lods.length; i++) {
+            if (!this.lods[i].equals(other.lods[i])) return false;
+        }
+        return true;
+    }
+
+    /**
+     * @returns {number}
+     */
+    hash() {
+        let h = hash_mix2(computeStringHash(this.name), this.seed);
+        if (Array.isArray(this.trunk_guide)) {
+            h = hash_mix2(h, this.trunk_guide.length);
+            for (let i = 0; i < this.trunk_guide.length; i++) {
+                const pt = this.trunk_guide[i];
+                h = hash_mix2(h, Math.imul(Math.round((pt[0] ?? 0) * 1000), 73856093)
+                    ^ Math.imul(Math.round((pt[1] ?? 0) * 1000), 19349663)
+                    ^ Math.imul(Math.round((pt[2] ?? 0) * 1000), 83492791));
+            }
+        }
+        h = hash_mix2(h, this.crown.hash());
+        h = hash_mix2(h, this.foliage.hash());
+        h = hash_mix2(h, this.bark_material.hash());
+        h = hash_mix2(h, this.foliage_material.hash());
+        h = hash_mix2(h, this.wind.hash());
+        for (let i = 0; i < this.levels.length; i++) {
+            h = hash_mix2(h, this.levels[i].hash());
+        }
+        for (let i = 0; i < this.lods.length; i++) {
+            h = hash_mix2(h, this.lods[i].hash());
+        }
+        return h;
+    }
+}
+
+/**
+ * @readonly
+ * @type {boolean}
+ */
+TreeSpeciesConfig.prototype.isTreeSpeciesConfig = true;

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

@@ -0,0 +1,84 @@
+/**
+ * Configuration for GPU fluid-driven skeletal wind animation (`Skin` + `FoliageWindRig`)
+ * and per-vertex wind attributes.
+ *
+ * Foliage bones are driven directly on the GPU by sampling Meep's 3D fluid dynamics
+ * wind field (`GPUSceneWind`: `GlobalFluidEffector` far-field + 3D MAC `GPUFluidCascadeStack`
+ * wakes/vortices/impulses) and stepping a 2nd-order damped spring-damper oscillator per joint.
+ */
+export class TreeWindConfig {
+    /**
+     * @param {Partial<TreeWindConfig>|boolean} [options]
+     * @returns {TreeWindConfig}
+     */
+    static from(options?: Partial<TreeWindConfig> | boolean): TreeWindConfig;
+    /**
+     * Whether GPU fluid-driven skeletal wind rig and joint attributes are generated.
+     * @type {boolean}
+     */
+    enabled: boolean;
+    /**
+     * Maximum number of structural skeleton joints extracted for `Skin` and `FoliageWindRig` (>= 1).
+     * @type {number}
+     */
+    max_joints: number;
+    /**
+     * Baseline aerodynamic compliance (rad / (m/s)^2) for level-0 trunk joints.
+     * @type {number}
+     */
+    trunk_compliance: number;
+    /**
+     * Baseline aerodynamic compliance (rad / (m/s)^2) for primary and secondary branch joints.
+     * @type {number}
+     */
+    branch_compliance: number;
+    /**
+     * Baseline natural angular frequency omega_0 (rad/s) for structural branches.
+     * @type {number}
+     */
+    natural_frequency: number;
+    /**
+     * Dimensionless viscous + structural damping ratio zeta (0 < zeta < 1 is underdamped).
+     * @type {number}
+     */
+    damping_ratio: number;
+    /**
+     * Cross-wind vortex-shedding & turbulent flutter amplitude ratio [0..1].
+     * @type {number}
+     */
+    turbulence: number;
+    /**
+     * Asymptotic elastic bend saturation limit (radians).
+     * @type {number}
+     */
+    max_bend_angle: number;
+    /**
+     * @param {Partial<TreeWindConfig>|boolean} [overrides]
+     * @returns {this}
+     */
+    applyOverrides(overrides?: Partial<TreeWindConfig> | boolean): this;
+    /**
+     * @param {TreeWindConfig} other
+     * @returns {this}
+     */
+    copy(other: TreeWindConfig): this;
+    /**
+     * @returns {TreeWindConfig}
+     */
+    clone(): TreeWindConfig;
+    /**
+     * @param {TreeWindConfig} other
+     * @returns {boolean}
+     */
+    equals(other: TreeWindConfig): boolean;
+    /**
+     * @returns {number}
+     */
+    hash(): number;
+    /**
+     * @readonly
+     * @type {boolean}
+     */
+    readonly isTreeWindConfig: boolean;
+}
+//# sourceMappingURL=TreeWindConfig.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"TreeWindConfig.d.ts","sourceRoot":"","sources":["../../../../../src/generation/foliage/config/TreeWindConfig.js"],"names":[],"mappings":"AAIA;;;;;;;GAOG;AACH;IAiDI;;;OAGG;IACH,sBAHW,QAAQ,cAAc,CAAC,GAAC,OAAO,GAC7B,cAAc,CAM1B;IAxDD;;;OAGG;IACH,SAFU,OAAO,CAEF;IAEf;;;OAGG;IACH,YAFU,MAAM,CAEA;IAEhB;;;OAGG;IACH,kBAFU,MAAM,CAES;IAEzB;;;OAGG;IACH,mBAFU,MAAM,CAEU;IAE1B;;;OAGG;IACH,mBAFU,MAAM,CAEQ;IAExB;;;OAGG;IACH,eAFU,MAAM,CAEK;IAErB;;;OAGG;IACH,YAFU,MAAM,CAEE;IAElB;;;OAGG;IACH,gBAFU,MAAM,CAEM;IAYtB;;;OAGG;IACH,2BAHW,QAAQ,cAAc,CAAC,GAAC,OAAO,GAC7B,IAAI,CAmBhB;IAED;;;OAGG;IACH,YAHW,cAAc,GACZ,IAAI,CAahB;IAED;;OAEG;IACH,SAFa,cAAc,CAM1B;IAED;;;OAGG;IACH,cAHW,cAAc,GACZ,OAAO,CAanB;IAED;;OAEG;IACH,QAFa,MAAM,CAWlB;IAGL;;;OAGG;IACH,2BAFU,OAAO,CAEwB;CANxC"}