@woosh/meep-engine 3.55.0 → 3.57.0

package/src/core/geom/ConicRay.js

@@ -1,237 +1,230 @@
-import { assert } from "../assert.js";
-import { hash_mix2 } from "../math/hash/hash_mix2.js";
-import { EPSILON } from "../math/EPSILON.js";
-import { epsilonEquals } from "../math/epsilonEquals.js";
-import { PI2 } from "../math/PI2.js";
-import { computeHashFloat } from "../primitives/numbers/computeHashFloat.js";
-import Vector3 from "./Vector3.js";
-
-
-/**
- * Represents a direction vector+angle
- * Mainly used inside particle systems for pick a motion direction at spawn
- *
- * @author Alex Goldring
- * @copyright Company Named Limited (c) 2026
- */
-export class ConicRay {
-
-    /**
-     * Must be normalized
-     * @readonly
-     * @type {Vector3}
-     */
-    direction = new Vector3(0, 1, 0);
-
-    /**
-     * Half-angle of the cone that is the angle between the center axis and the edge of the cone
-     *
-     * @type {number} In radians
-     */
-    angle = 0;
-
-    toJSON() {
-        return {
-            direction: this.direction.toJSON(),
-            angle: this.angle
-        };
-    }
-
-    fromJSON(json) {
-        this.direction.fromJSON(json.direction);
-        this.angle = json.angle;
-    }
-
-    /**
-     *
-     * @param {BinaryBuffer} buffer
-     */
-    toBinaryBuffer(buffer) {
-        buffer.writeFloat64(this.angle);
-        this.direction.toBinaryBufferFloat32(buffer);
-    }
-
-    /**
-     *
-     * @param {BinaryBuffer} buffer
-     */
-    fromBinaryBuffer(buffer) {
-        this.angle = buffer.readFloat64();
-        this.direction.fromBinaryBufferFloat32(buffer);
-
-        //normalize direction
-        this.direction.normalize();
-    }
-
-    /**
-     *
-     * @param {ConicRay} other
-     * @returns {boolean}
-     */
-    equals(other) {
-        return this.angle === other.angle
-            && this.direction.equals(other.direction)
-            ;
-    }
-
-    /**
-     *
-     * @param {ConicRay} other
-     * @param {number} [tolerance]
-     * @returns {boolean}
-     */
-    roughlyEquals(other, tolerance = EPSILON) {
-        return epsilonEquals(this.angle, other.angle, tolerance)
-            && this.direction.roughlyEquals(other.direction, tolerance);
-    }
-
-    /**
-     *
-     * @return {number}
-     */
-    hash() {
-        return hash_mix2(
-            computeHashFloat(this.angle),
-            this.direction.hash()
-        );
-    }
-
-    /**
-     *
-     * @param {ConicRay} other
-     */
-    copy(other) {
-        this.direction.copy(other.direction);
-        this.angle = other.angle;
-    }
-
-    /**
-     * Includes boundary matches
-     * @param {Vector3} v3
-     * @returns {boolean}
-     */
-    containsDirectionVector(v3) {
-        const angular_distance = this.direction.angleTo(v3);
-
-        return angular_distance <= this.angle;
-    }
-
-    /**
-     * NOTE: Heavily based on a stackoverflow answer
-     * @see https://stackoverflow.com/questions/38997302/create-random-unit-vector-inside-a-defined-conical-region/39003745#39003745
-     * @param {function} random
-     * @param {Vector3} result
-     */
-    sampleRandomDirection(random, result) {
-        const coneAngle = this.angle;
-
-        if (coneAngle === 0) {
-            //fast path, just copy ray direction
-            result.copy(this.direction);
-            return;
-        }
-
-        // Generate points on the spherical cap around the north pole [1].
-        // [1] See https://math.stackexchange.com/a/205589/81266
-        const angleCosine = Math.cos(coneAngle);
-
-        const z = random() * (1 - angleCosine) + angleCosine;
-
-        const phi = random() * PI2;
-
-        const zSqr = z * z;
-
-        const zSqrtNeg = Math.sqrt(1 - zSqr);
-
-        const x = zSqrtNeg * Math.cos(phi);
-        const y = zSqrtNeg * Math.sin(phi);
-
-        // If the spherical cap is centered around the north pole, we're done.
-        const direction = this.direction;
-        if (direction._equals(0, 0, 1)) {
-            result.set(x, y, z);
-            return;
-        }
-
-        // The antipode (0,0,-1) is the singularity of the k = 1/(1+dZ) rotation below (dZ === -1 -> k = Infinity).
-        // Map the cap onto the south pole with a 180 degree rotation about the X axis: (x, y, z) -> (x, -y, -z).
-        if (direction._equals(0, 0, -1)) {
-            result.set(x, -y, -z);
-            return;
-        }
-
-        assert.ok(direction.isNormalized(), 'direction vector must be normalized');
-
-        // Find the rotation axis `u` and rotation angle `rot` [1]
-
-        const dX = direction.x;
-        const dY = direction.y;
-        const dZ = direction.z;
-
-        // Build the rotation that maps the north pole (0,0,1) onto `direction`, expressed as a 3x3 matrix.
-        // This uses the k = 1/(1+dZ) form of that rotation. The previous code used t = 1 - dZ together with
-        // spurious sin() factors on the off-diagonal terms, producing a non-orthonormal matrix that did not
-        // actually rotate (0,0,1) to `direction`.
-
-        //write matrix
-        const c = dZ;
-        // Singular at dZ === -1 (the antipode); both the (0,0,1) and (0,0,-1) poles are handled by the early
-        // returns above, so dZ is strictly in (-1, 1) here.
-        const k = 1 / (1 + dZ);
-        const tx = -k * dY;
-        const ty = k * dX;
-
-        //build relevant terms of the matrix
-        const n11 = c - tx * dY;
-        const n12 = tx * dX;
-        const n22 = ty * dX + c;
-        const n13 = dX;
-        const n32 = -dY;
-
-
-        // Rotate [x; y; z] from north pole to `coneDir`.
-        const _x = n11 * x + n12 * y + n13 * z;
-        const _y = n12 * x + n22 * y + -n32 * z;
-        const _z = -n13 * x + n32 * y + c * z;
-
-        result.set(_x, _y, _z);
-    }
-
-    /**
-     *
-     * @param {number} x
-     * @param {number} y
-     * @param {number} z
-     * @param {number} half_angle
-     * @returns {ConicRay}
-     */
-    static fromScalars(
-        x,
-        y,
-        z,
-        half_angle
-    ) {
-        assert.isNumber(half_angle, 'angle');
-        assert.greaterThanOrEqual(half_angle, 0, 'half_angle must be non-negative');
-
-        const r = new ConicRay();
-
-        r.angle = half_angle;
-        r.direction.set(x, y, z);
-        r.direction.normalize();
-
-        return r;
-    }
-}
-
-/**
- * @readonly
- * @type {boolean}
- */
-ConicRay.prototype.isConicRay = true;
-
-/**
- * @readonly
- * @type {string}
- */
-ConicRay.typeName = "ConicRay";
+import { assert } from "../assert.js";
+import { EPSILON } from "../math/EPSILON.js";
+import { epsilonEquals } from "../math/epsilonEquals.js";
+import { hash_mix2 } from "../math/hash/hash_mix2.js";
+import { computeHashFloat } from "../primitives/numbers/computeHashFloat.js";
+import { v3_uniform_sample_cone } from "./vec3/v3_uniform_sample_cone.js";
+import Vector3 from "./Vector3.js";
+
+const scratch_sample = [0, 0, 0];
+
+/**
+ * Represents a direction vector+angle
+ * Mainly used inside particle systems for pick a motion direction at spawn
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export class ConicRay {
+
+    /**
+     * Must be normalized
+     * @readonly
+     * @type {Vector3}
+     */
+    direction = new Vector3(0, 1, 0);
+
+    /**
+     * Half-angle of the cone that is the angle between the center axis and the edge of the cone
+     *
+     * @type {number} In radians
+     */
+    angle = 0;
+
+    toJSON() {
+        return {
+            direction: this.direction.toJSON(),
+            angle: this.angle
+        };
+    }
+
+    fromJSON(json) {
+        this.direction.fromJSON(json.direction);
+        this.angle = json.angle;
+    }
+
+    /**
+     *
+     * @param {BinaryBuffer} buffer
+     */
+    toBinaryBuffer(buffer) {
+        buffer.writeFloat64(this.angle);
+        this.direction.toBinaryBufferFloat32(buffer);
+    }
+
+    /**
+     *
+     * @param {BinaryBuffer} buffer
+     */
+    fromBinaryBuffer(buffer) {
+        this.angle = buffer.readFloat64();
+        this.direction.fromBinaryBufferFloat32(buffer);
+
+        //normalize direction
+        this.direction.normalize();
+    }
+
+    /**
+     *
+     * @param {ConicRay} other
+     * @returns {boolean}
+     */
+    equals(other) {
+        return this.angle === other.angle
+            && this.direction.equals(other.direction)
+            ;
+    }
+
+    /**
+     *
+     * @param {ConicRay} other
+     * @param {number} [tolerance]
+     * @returns {boolean}
+     */
+    roughlyEquals(other, tolerance = EPSILON) {
+        return epsilonEquals(this.angle, other.angle, tolerance)
+            && this.direction.roughlyEquals(other.direction, tolerance);
+    }
+
+    /**
+     *
+     * @return {number}
+     */
+    hash() {
+        return hash_mix2(
+            computeHashFloat(this.angle),
+            this.direction.hash()
+        );
+    }
+
+    /**
+     *
+     * @param {ConicRay} other
+     */
+    copy(other) {
+        this.direction.copy(other.direction);
+        this.angle = other.angle;
+    }
+
+    /**
+     * Includes boundary matches
+     * @param {Vector3} v3
+     * @returns {boolean}
+     */
+    containsDirectionVector(v3) {
+        const angular_distance = this.direction.angleTo(v3);
+
+        return angular_distance <= this.angle;
+    }
+
+    /**
+     * NOTE: Heavily based on a stackoverflow answer
+     * @see https://stackoverflow.com/questions/38997302/create-random-unit-vector-inside-a-defined-conical-region/39003745#39003745
+     * @param {function} random
+     * @param {Vector3} result
+     */
+    sampleRandomDirection(random, result) {
+        const coneAngle = this.angle;
+
+        if (coneAngle === 0) {
+            //fast path, just copy ray direction
+            result.copy(this.direction);
+            return;
+        }
+
+        // Generate points on the spherical cap around the north pole [1].
+        // [1] See https://math.stackexchange.com/a/205589/81266
+        v3_uniform_sample_cone(scratch_sample, 0, 1 - random(), random(), Math.cos(coneAngle));
+        const x = scratch_sample[0];
+        const y = scratch_sample[1];
+        const z = scratch_sample[2];
+
+        // If the spherical cap is centered around the north pole, we're done.
+        const direction = this.direction;
+        if (direction._equals(0, 0, 1)) {
+            result.set(x, y, z);
+            return;
+        }
+
+        // The antipode (0,0,-1) is the singularity of the k = 1/(1+dZ) rotation below (dZ === -1 -> k = Infinity).
+        // Map the cap onto the south pole with a 180 degree rotation about the X axis: (x, y, z) -> (x, -y, -z).
+        if (direction._equals(0, 0, -1)) {
+            result.set(x, -y, -z);
+            return;
+        }
+
+        assert.ok(direction.isNormalized(), 'direction vector must be normalized');
+
+        // Find the rotation axis `u` and rotation angle `rot` [1]
+
+        const dX = direction.x;
+        const dY = direction.y;
+        const dZ = direction.z;
+
+        // Build the rotation that maps the north pole (0,0,1) onto `direction`, expressed as a 3x3 matrix.
+        // This uses the k = 1/(1+dZ) form of that rotation. The previous code used t = 1 - dZ together with
+        // spurious sin() factors on the off-diagonal terms, producing a non-orthonormal matrix that did not
+        // actually rotate (0,0,1) to `direction`.
+
+        //write matrix
+        const c = dZ;
+        // Singular at dZ === -1 (the antipode); both the (0,0,1) and (0,0,-1) poles are handled by the early
+        // returns above, so dZ is strictly in (-1, 1) here.
+        const k = 1 / (1 + dZ);
+        const tx = -k * dY;
+        const ty = k * dX;
+
+        //build relevant terms of the matrix
+        const n11 = c - tx * dY;
+        const n12 = tx * dX;
+        const n22 = ty * dX + c;
+        const n13 = dX;
+        const n32 = -dY;
+
+
+        // Rotate [x; y; z] from north pole to `coneDir`.
+        const _x = n11 * x + n12 * y + n13 * z;
+        const _y = n12 * x + n22 * y + -n32 * z;
+        const _z = -n13 * x + n32 * y + c * z;
+
+        result.set(_x, _y, _z);
+    }
+
+    /**
+     *
+     * @param {number} x
+     * @param {number} y
+     * @param {number} z
+     * @param {number} half_angle
+     * @returns {ConicRay}
+     */
+    static fromScalars(
+        x,
+        y,
+        z,
+        half_angle
+    ) {
+        assert.isNumber(half_angle, 'angle');
+        assert.greaterThanOrEqual(half_angle, 0, 'half_angle must be non-negative');
+
+        const r = new ConicRay();
+
+        r.angle = half_angle;
+        r.direction.set(x, y, z);
+        r.direction.normalize();
+
+        return r;
+    }
+}
+
+/**
+ * @readonly
+ * @type {boolean}
+ */
+ConicRay.prototype.isConicRay = true;
+
+/**
+ * @readonly
+ * @type {string}
+ */
+ConicRay.typeName = "ConicRay";

package/src/core/localization/LocaleDataset.d.ts

@@ -15,6 +15,12 @@ export class LocaleDataset {
      * @returns {string|Object|undefined}
      */
     get(key: string): string | any | undefined;
+    /**
+     *
+     * @param {string} key
+     * @param {string|Object} value
+     */
+    set(key: string, value: string | any): void;
     #private;
 }
 //# sourceMappingURL=LocaleDataset.d.ts.map

package/src/core/localization/LocaleDataset.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"LocaleDataset.d.ts","sourceRoot":"","sources":["../../../../src/core/localization/LocaleDataset.js"],"names":[],"mappings":"AAIA;;GAEG;AACH;IAQI;;;;;OAKG;IACH,YAHW,MAAM,GACL,OAAO,CAMlB;IAED;;;;OAIG;IACH,SAHW,MAAM,GACJ,MAAM,SAAQ,SAAS,CAInC;;CAEJ"}
+{"version":3,"file":"LocaleDataset.d.ts","sourceRoot":"","sources":["../../../../src/core/localization/LocaleDataset.js"],"names":[],"mappings":"AAIA;;GAEG;AACH;IAQI;;;;;OAKG;IACH,YAHW,MAAM,GACL,OAAO,CAMlB;IAED;;;;OAIG;IACH,SAHW,MAAM,GACJ,MAAM,SAAQ,SAAS,CAInC;IAED;;;;OAIG;IACH,SAHW,MAAM,SACN,MAAM,MAAO,QAMvB;;CAEJ"}

package/src/core/localization/LocaleDataset.js

@@ -1,37 +1,48 @@
-//
-
-import { assert } from "../assert.js";
-
-/**
- * Represents data for a single localization
- */
-export class LocaleDataset {
-    /**
-     * Localized objects, identified by localization key
-     * @type {Object<Object|string>}
-     * @private
-     */
-    #map = {}
-
-    /**
-     *
-     * Does a given key exist?
-     * @param {string} key
-     * @return {boolean}
-     */
-    hasKey(key) {
-        assert.isString(key, 'key');
-
-        return this.#map[key] !== undefined;
-    }
-
-    /**
-     *
-     * @param {string} key
-     * @returns {string|Object|undefined}
-     */
-    get(key) {
-        return this.#map[key];
-    }
-
-}
+//
+
+import { assert } from "../assert.js";
+
+/**
+ * Represents data for a single localization
+ */
+export class LocaleDataset {
+    /**
+     * Localized objects, identified by localization key
+     * @type {Object<Object|string>}
+     * @private
+     */
+    #map = {}
+
+    /**
+     *
+     * Does a given key exist?
+     * @param {string} key
+     * @return {boolean}
+     */
+    hasKey(key) {
+        assert.isString(key, 'key');
+
+        return this.#map[key] !== undefined;
+    }
+
+    /**
+     *
+     * @param {string} key
+     * @returns {string|Object|undefined}
+     */
+    get(key) {
+        return this.#map[key];
+    }
+
+    /**
+     *
+     * @param {string} key
+     * @param {string|Object} value
+     */
+    set(key, value) {
+        assert.isString(key, 'key');
+
+        this.#map[key] = value;
+    }
+
+}

package/src/core/localization/LocalizationEngine.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"LocalizationEngine.d.ts","sourceRoot":"","sources":["../../../../src/core/localization/LocalizationEngine.js"],"names":[],"mappings":"AAKA;IAaI;;;;OAIG;IACH,sBAHW,MAAM,gCAQhB;IAED;;;OAGG;IACH,sDAQC;IAED;;;;;;;OAOG;IACH,sBAJW,MAAM,gBACN,MAAM,GACJ,MAAO,MAAM,GAAC,SAAS,CAiDnC;;CAEJ"}
+{"version":3,"file":"LocalizationEngine.d.ts","sourceRoot":"","sources":["../../../../src/core/localization/LocalizationEngine.js"],"names":[],"mappings":"AAKA;IAaI;;;;OAIG;IACH,sBAHW,MAAM,gCAQhB;IAED;;;OAGG;IACH,sDAQC;IAED;;;;;;;OAOG;IACH,sBAJW,MAAM,gBACN,MAAM,GACJ,MAAO,MAAM,GAAC,SAAS,CAkDnC;;CAEJ"}

package/src/core/localization/LocalizationEngine.js

@@ -62,10 +62,11 @@ export class LocalizationEngine {
 
             const locale = this.#locales[lang];
 
-            if (locale !== undefined && locale[fragment_key] !== undefined) {
+            const value = locale !== undefined ? (typeof locale.get === 'function' ? locale.get(fragment_key) : locale[fragment_key]) : undefined;
+            if (value !== undefined) {
 
                 // found a hit
-                return locale[fragment_key];
+                return value;
 
             } else {
 

package/src/core/math/lookup/ParameterLookupTable.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ParameterLookupTable.d.ts","sourceRoot":"","sources":["../../../../../src/core/math/lookup/ParameterLookupTable.js"],"names":[],"mappings":"AAWA;IAsbI;;;;;OAKG;IACH,sBAJW,MAAM,UACN,MAAM,EAAE,cACR,MAAM,EAAE,wBAQlB;IAED;;;;OAIG;IACH,8CAFa,oBAAoB,CA0BhC;IAjcD;;;;OAIG;IACH,uBAHW,MAAM,EAYhB;IA5CD;;;OAGG;IACH,MAFU,MAAM,EAAE,GAAC,YAAY,CAErB;IAEV;;;OAGG;IACH,WAFU,MAAM,EAAE,GAAC,YAAY,CAEhB;IAEf;;;OAGG;IACH,UAFU,MAAM,CAEH;IAEb;;;OAGG;IACH,UAFU,MAAM,CAEH;IAEb;;;OAGG;IACH,cAA4C;IAUxC;;;OAGG;IACH,UAFU,MAAM,CAEQ;IAI5B;;;OAGG;IACH,WAFW,yBAAyB,QAInC;IAED;;;OAGG;IACH,aAFW,yBAAyB,GAAC,MAAM,QAI1C;IAED;;;;OAIG;IACH,WAHW,yBAAyB,GACvB,OAAO,CAInB;IAED,yBAEC;IAED,0BAGC;IAED;;;;MAMC;IAED;;;;OAIG;IACH,2CAgDC;IAED;;;OAGG;IACH,6CAkCC;IAED;;;;OAIG;IACH,iBAHW,MAAM,UACN,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,QA0D5C;IAED,gCAUC;IAED;;;;OAIG;IACH,cAHW,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,GAAC,UAAU,cAC7C,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,QA4B5C;IAED;;;;OAIG;IACH,mBAHW,MAAM,SACN,MAAM,EAAE,QAqClB;IAED;;OAEG;IACH,0BAkBC;IAED,eAgBC;IAED;;;;OAIG;IACH,cAHW,oBAAoB,GAClB,OAAO,CAenB;IAED,oBAwCC;IAgDL;;;OAGG;IACH,iCAFU,OAAO,CAEoC;CANpD;0CAreyC,gCAAgC"}
+{"version":3,"file":"ParameterLookupTable.d.ts","sourceRoot":"","sources":["../../../../../src/core/math/lookup/ParameterLookupTable.js"],"names":[],"mappings":"AAWA;IAwbI;;;;;OAKG;IACH,sBAJW,MAAM,UACN,MAAM,EAAE,cACR,MAAM,EAAE,wBAQlB;IAED;;;;OAIG;IACH,8CAFa,oBAAoB,CA0BhC;IAncD;;;;OAIG;IACH,uBAHW,MAAM,EAYhB;IA5CD;;;OAGG;IACH,MAFU,MAAM,EAAE,GAAC,YAAY,CAErB;IAEV;;;OAGG;IACH,WAFU,MAAM,EAAE,GAAC,YAAY,CAEhB;IAEf;;;OAGG;IACH,UAFU,MAAM,CAEH;IAEb;;;OAGG;IACH,UAFU,MAAM,CAEH;IAEb;;;OAGG;IACH,cAA4C;IAUxC;;;OAGG;IACH,UAFU,MAAM,CAEQ;IAI5B;;;OAGG;IACH,WAFW,yBAAyB,QAInC;IAED;;;OAGG;IACH,aAFW,yBAAyB,GAAC,MAAM,QAI1C;IAED;;;;OAIG;IACH,WAHW,yBAAyB,GACvB,OAAO,CAInB;IAED,yBAEC;IAED,0BAGC;IAED;;;;MAMC;IAED;;;;OAIG;IACH,2CAgDC;IAED;;;OAGG;IACH,6CAkCC;IAED;;;;OAIG;IACH,iBAHW,MAAM,UACN,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,QA0D5C;IAED,gCAUC;IAED;;;;OAIG;IACH,cAHW,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,GAAC,UAAU,cAC7C,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,QA4B5C;IAED;;;;OAIG;IACH,mBAHW,MAAM,SACN,MAAM,EAAE,QAuClB;IAED;;OAEG;IACH,0BAkBC;IAED,eAgBC;IAED;;;;OAIG;IACH,cAHW,oBAAoB,GAClB,OAAO,CAenB;IAED,oBAwCC;IAgDL;;;OAGG;IACH,iCAFU,OAAO,CAEoC;CANpD;0CAveyC,gCAAgC"}

package/src/core/math/lookup/ParameterLookupTable.js

@@ -341,7 +341,9 @@ export class ParameterLookupTable {
         const spliceArgs = value.slice();
         spliceArgs.unshift(i * this.itemSize, 0);
 
-        Array.prototype.splice.apply(this.data, spliceArgs);
+        Array.prototype.splice.apply(this.data, spliceArgs);
+
+        this.computeStatistics();
     }
 
     /**

package/src/core/math/spline/spline3_hermite_intersection_spline3_hermite_nd.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"spline3_hermite_intersection_spline3_hermite_nd.d.ts","sourceRoot":"","sources":["../../../../../src/core/math/spline/spline3_hermite_intersection_spline3_hermite_nd.js"],"names":[],"mappings":"AAiSA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,mEAPW,YAAY,GAAC,MAAM,EAAE,KACrB,YAAY,GAAC,MAAM,EAAE,OACrB,MAAM,UACN,YAAY,GAAC,MAAM,EAAE,iBACrB,MAAM,GACJ,MAAM,CAoFlB;AAxHD;;;;;;;GAOG;AACH,2BAFU,MAAM,CAEsC"}
+{"version":3,"file":"spline3_hermite_intersection_spline3_hermite_nd.d.ts","sourceRoot":"","sources":["../../../../../src/core/math/spline/spline3_hermite_intersection_spline3_hermite_nd.js"],"names":[],"mappings":"AA+NA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,mEAPW,YAAY,GAAC,MAAM,EAAE,KACrB,YAAY,GAAC,MAAM,EAAE,OACrB,MAAM,UACN,YAAY,GAAC,MAAM,EAAE,iBACrB,MAAM,GACJ,MAAM,CAgFlB;AApHD;;;;;;;GAOG;AACH,2BAFU,MAAM,CAEsC"}