@woosh/meep-engine 2.106.1 → 2.108.0

package/src/core/math/random/MersenneTwister.js

@@ -60,152 +60,153 @@
    email: m-mat @ math.sci.hiroshima-u.ac.jp (remove space)
 */
 
-export function MersenneTwister(seed) {
-    if (seed === undefined) {
-        seed = new Date().getTime();
+export class MersenneTwister {
+    constructor(seed = new Date().getTime()) {
+
+        /* Period parameters */
+        this.N = 624;
+        this.M = 397;
+        this.MATRIX_A = 0x9908b0df;
+        /* constant vector a */
+        this.UPPER_MASK = 0x80000000;
+        /* most significant w-r bits */
+        this.LOWER_MASK = 0x7fffffff;
+        /* least significant r bits */
+
+        this.mt = new Array(this.N);
+        /* the array for the state vector */
+        this.mti = this.N + 1;
+        /* mti==N+1 means mt[N] is not initialized */
+
+        this.init_genrand(seed);
     }
-    /* Period parameters */
-    this.N = 624;
-    this.M = 397;
-    this.MATRIX_A = 0x9908b0df;
-    /* constant vector a */
-    this.UPPER_MASK = 0x80000000;
-    /* most significant w-r bits */
-    this.LOWER_MASK = 0x7fffffff;
-    /* least significant r bits */
-
-    this.mt = new Array(this.N);
-    /* the array for the state vector */
-    this.mti = this.N + 1;
-    /* mti==N+1 means mt[N] is not initialized */
-
-    this.init_genrand(seed);
-}
 
-/* initializes mt[N] with a seed */
-MersenneTwister.prototype.init_genrand = function (s) {
-    this.mt[0] = s >>> 0;
-    for (this.mti = 1; this.mti < this.N; this.mti++) {
-        const s = this.mt[this.mti - 1] ^ (this.mt[this.mti - 1] >>> 30);
-        this.mt[this.mti] = (((((s & 0xffff0000) >>> 16) * 1812433253) << 16) + (s & 0x0000ffff) * 1812433253)
-            + this.mti;
-        /* See Knuth TAOCP Vol2. 3rd Ed. P.106 for multiplier. */
-        /* In the previous versions, MSBs of the seed affect   */
-        /* only MSBs of the array mt[].                        */
-        /* 2002/01/09 modified by Makoto Matsumoto             */
-        this.mt[this.mti] >>>= 0;
-        /* for >32 bit machines */
-    }
-};
-
-/* initialize by an array with array-length */
-/* init_key is the array for initializing keys */
-/* key_length is its length */
-/* slight change for C++, 2004/2/26 */
-MersenneTwister.prototype.init_by_array = function (init_key, key_length) {
-    let i, j, k;
-    this.init_genrand(19650218);
-    i = 1;
-    j = 0;
-    k = (this.N > key_length ? this.N : key_length);
-    for (; k; k--) {
-        const s = this.mt[i - 1] ^ (this.mt[i - 1] >>> 30)
-        this.mt[i] = (this.mt[i] ^ (((((s & 0xffff0000) >>> 16) * 1664525) << 16) + ((s & 0x0000ffff) * 1664525)))
-            + init_key[j] + j;
-        /* non linear */
-        this.mt[i] >>>= 0;
-        /* for WORDSIZE > 32 machines */
-        i++;
-        j++;
-        if (i >= this.N) {
-            this.mt[0] = this.mt[this.N - 1];
-            i = 1;
+    /* initializes mt[N] with a seed */
+    init_genrand(s) {
+        this.mt[0] = s >>> 0;
+        for (this.mti = 1; this.mti < this.N; this.mti++) {
+            const s = this.mt[this.mti - 1] ^ (this.mt[this.mti - 1] >>> 30);
+            this.mt[this.mti] = (((((s & 0xffff0000) >>> 16) * 1812433253) << 16) + (s & 0x0000ffff) * 1812433253)
+                + this.mti;
+            /* See Knuth TAOCP Vol2. 3rd Ed. P.106 for multiplier. */
+            /* In the previous versions, MSBs of the seed affect   */
+            /* only MSBs of the array mt[].                        */
+            /* 2002/01/09 modified by Makoto Matsumoto             */
+            this.mt[this.mti] >>>= 0;
+            /* for >32 bit machines */
         }
-        if (j >= key_length) j = 0;
     }
-    for (k = this.N - 1; k; k--) {
-        const s = this.mt[i - 1] ^ (this.mt[i - 1] >>> 30);
-        this.mt[i] = (this.mt[i] ^ (((((s & 0xffff0000) >>> 16) * 1566083941) << 16) + (s & 0x0000ffff) * 1566083941))
-            - i;
-        /* non linear */
-        this.mt[i] >>>= 0;
-        /* for WORDSIZE > 32 machines */
-        i++;
-        if (i >= this.N) {
-            this.mt[0] = this.mt[this.N - 1];
-            i = 1;
+
+    /* initialize by an array with array-length */
+    /* init_key is the array for initializing keys */
+    /* key_length is its length */
+
+    /* slight change for C++, 2004/2/26 */
+    init_by_array(init_key, key_length) {
+        let i, j, k;
+        this.init_genrand(19650218);
+        i = 1;
+        j = 0;
+        k = (this.N > key_length ? this.N : key_length);
+        for (; k; k--) {
+            const s = this.mt[i - 1] ^ (this.mt[i - 1] >>> 30)
+            this.mt[i] = (this.mt[i] ^ (((((s & 0xffff0000) >>> 16) * 1664525) << 16) + ((s & 0x0000ffff) * 1664525)))
+                + init_key[j] + j;
+            /* non linear */
+            this.mt[i] >>>= 0;
+            /* for WORDSIZE > 32 machines */
+            i++;
+            j++;
+            if (i >= this.N) {
+                this.mt[0] = this.mt[this.N - 1];
+                i = 1;
+            }
+            if (j >= key_length) j = 0;
+        }
+        for (k = this.N - 1; k; k--) {
+            const s = this.mt[i - 1] ^ (this.mt[i - 1] >>> 30);
+            this.mt[i] = (this.mt[i] ^ (((((s & 0xffff0000) >>> 16) * 1566083941) << 16) + (s & 0x0000ffff) * 1566083941))
+                - i;
+            /* non linear */
+            this.mt[i] >>>= 0;
+            /* for WORDSIZE > 32 machines */
+            i++;
+            if (i >= this.N) {
+                this.mt[0] = this.mt[this.N - 1];
+                i = 1;
+            }
         }
+
+        this.mt[0] = 0x80000000;
+        /* MSB is 1; assuring non-zero initial array */
     }
 
-    this.mt[0] = 0x80000000;
-    /* MSB is 1; assuring non-zero initial array */
-};
+    /* generates a random number on [0,0xffffffff]-interval */
+    genrand_int32() {
+        let y;
+        const mag01 = new Array(0x0, this.MATRIX_A);
+        /* mag01[x] = x * MATRIX_A  for x=0,1 */
+
+        if (this.mti >= this.N) { /* generate N words at one time */
+            let kk;
+
+            if (this.mti === this.N + 1)   /* if init_genrand() has not been called, */
+                this.init_genrand(5489);
+            /* a default initial seed is used */
+
+            for (kk = 0; kk < this.N - this.M; kk++) {
+                y = (this.mt[kk] & this.UPPER_MASK) | (this.mt[kk + 1] & this.LOWER_MASK);
+                this.mt[kk] = this.mt[kk + this.M] ^ (y >>> 1) ^ mag01[y & 0x1];
+            }
+            for (; kk < this.N - 1; kk++) {
+                y = (this.mt[kk] & this.UPPER_MASK) | (this.mt[kk + 1] & this.LOWER_MASK);
+                this.mt[kk] = this.mt[kk + (this.M - this.N)] ^ (y >>> 1) ^ mag01[y & 0x1];
+            }
+            y = (this.mt[this.N - 1] & this.UPPER_MASK) | (this.mt[0] & this.LOWER_MASK);
+            this.mt[this.N - 1] = this.mt[this.M - 1] ^ (y >>> 1) ^ mag01[y & 0x1];
+
+            this.mti = 0;
+        }
 
-/* generates a random number on [0,0xffffffff]-interval */
-MersenneTwister.prototype.genrand_int32 = function () {
-    let y;
-    const mag01 = new Array(0x0, this.MATRIX_A);
-    /* mag01[x] = x * MATRIX_A  for x=0,1 */
+        y = this.mt[this.mti++];
 
-    if (this.mti >= this.N) { /* generate N words at one time */
-        let kk;
+        /* Tempering */
+        y ^= (y >>> 11);
+        y ^= (y << 7) & 0x9d2c5680;
+        y ^= (y << 15) & 0xefc60000;
+        y ^= (y >>> 18);
 
-        if (this.mti === this.N + 1)   /* if init_genrand() has not been called, */
-            this.init_genrand(5489);
-        /* a default initial seed is used */
+        return y >>> 0;
+    }
 
-        for (kk = 0; kk < this.N - this.M; kk++) {
-            y = (this.mt[kk] & this.UPPER_MASK) | (this.mt[kk + 1] & this.LOWER_MASK);
-            this.mt[kk] = this.mt[kk + this.M] ^ (y >>> 1) ^ mag01[y & 0x1];
-        }
-        for (; kk < this.N - 1; kk++) {
-            y = (this.mt[kk] & this.UPPER_MASK) | (this.mt[kk + 1] & this.LOWER_MASK);
-            this.mt[kk] = this.mt[kk + (this.M - this.N)] ^ (y >>> 1) ^ mag01[y & 0x1];
-        }
-        y = (this.mt[this.N - 1] & this.UPPER_MASK) | (this.mt[0] & this.LOWER_MASK);
-        this.mt[this.N - 1] = this.mt[this.M - 1] ^ (y >>> 1) ^ mag01[y & 0x1];
+    /* generates a random number on [0,0x7fffffff]-interval */
+    genrand_int31() {
+        return (this.genrand_int32() >>> 1);
+    }
+
+    /* generates a random number on [0,1]-real-interval */
+    genrand_real1() {
+        return this.genrand_int32() * (1.0 / 4294967295.0);
+        /* divided by 2^32-1 */
+    }
 
-        this.mti = 0;
+    /* generates a random number on [0,1)-real-interval */
+    random() {
+        return this.genrand_int32() * (1.0 / 4294967296.0);
+        /* divided by 2^32 */
     }
 
-    y = this.mt[this.mti++];
-
-    /* Tempering */
-    y ^= (y >>> 11);
-    y ^= (y << 7) & 0x9d2c5680;
-    y ^= (y << 15) & 0xefc60000;
-    y ^= (y >>> 18);
-
-    return y >>> 0;
-};
-
-/* generates a random number on [0,0x7fffffff]-interval */
-MersenneTwister.prototype.genrand_int31 = function () {
-    return (this.genrand_int32() >>> 1);
-};
-
-/* generates a random number on [0,1]-real-interval */
-MersenneTwister.prototype.genrand_real1 = function () {
-    return this.genrand_int32() * (1.0 / 4294967295.0);
-    /* divided by 2^32-1 */
-};
-
-/* generates a random number on [0,1)-real-interval */
-MersenneTwister.prototype.random = function () {
-    return this.genrand_int32() * (1.0 / 4294967296.0);
-    /* divided by 2^32 */
-};
-
-/* generates a random number on (0,1)-real-interval */
-MersenneTwister.prototype.genrand_real3 = function () {
-    return (this.genrand_int32() + 0.5) * (1.0 / 4294967296.0);
-    /* divided by 2^32 */
-};
-
-/* generates a random number on [0,1) with 53-bit resolution*/
-MersenneTwister.prototype.genrand_res53 = function () {
-    const a = this.genrand_int32() >>> 5, b = this.genrand_int32() >>> 6;
-    return (a * 67108864.0 + b) * (1.0 / 9007199254740992.0);
-};
+    /* generates a random number on (0,1)-real-interval */
+    genrand_real3() {
+        return (this.genrand_int32() + 0.5) * (1.0 / 4294967296.0);
+        /* divided by 2^32 */
+    }
+
+    /* generates a random number on [0,1) with 53-bit resolution*/
+    genrand_res53() {
+        const a = this.genrand_int32() >>> 5, b = this.genrand_int32() >>> 6;
+        return (a * 67108864.0 + b) * (1.0 / 9007199254740992.0);
+    }
+}
 
 /* These real versions are due to Isaku Wada, 2002/01/09 added */

package/src/core/model/BooleanVector3.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"BooleanVector3.d.ts","sourceRoot":"","sources":["../../../../src/core/model/BooleanVector3.js"],"names":[],"mappings":"AAGA;;;;;;GAMG;AACH,mCALW,OAAO,MACP,OAAO,MACP,OAAO,QAqBjB;;IAzBD;;;;;;OAMG;IACH,gBALW,OAAO,MACP,OAAO,MACP,OAAO,EAqBjB;IAjBG;;;OAGG;IACH,GAFU,OAAO,CAEP;IACV;;;OAGG;IACH,GAFU,OAAO,CAEP;IACV;;;OAGG;IACH,GAFU,OAAO,CAEP;IAEV,0DAA6B;IAcjC;;;;;OAKG;IACH,OAJW,OAAO,KACP,OAAO,KACP,OAAO,QAoBjB;IAED;;;OAGG;IACH,QAFW,OAAO,QAIjB;IAED;;;OAGG;IACH,QAFW,OAAO,QAIjB;IAED;;;OAGG;IACH,QAFW,OAAO,QAIjB;IAED;;;OAGG;IACH,YAFW,cAAc,QAIxB;IAED;;;;MAMC;IAED,0BAEC;IAED;;;OAGG;IACH,2CAIC;IAED;;;OAGG;IACH,6CAQC;;;eArGS,cAAc;;gBAKd,cAAc;;;mBApCL,4BAA4B"}
+{"version":3,"file":"BooleanVector3.d.ts","sourceRoot":"","sources":["../../../../src/core/model/BooleanVector3.js"],"names":[],"mappings":"AAGA;IACI;;;;;;OAMG;IACH,gBALW,OAAO,MACP,OAAO,MACP,OAAO,EAqBjB;IAjBG;;;OAGG;IACH,GAFU,OAAO,CAEP;IACV;;;OAGG;IACH,GAFU,OAAO,CAEP;IACV;;;OAGG;IACH,GAFU,OAAO,CAEP;IAEV,0DAA6B;IAGjC;;;;;OAKG;IACH,OAJW,OAAO,KACP,OAAO,KACP,OAAO,QAoBjB;IAED;;;OAGG;IACH,QAFW,OAAO,QAIjB;IAED;;;OAGG;IACH,QAFW,OAAO,QAIjB;IAED;;;OAGG;IACH,QAFW,OAAO,QAIjB;IAED;;;OAGG;IACH,YAFW,cAAc,QAIxB;IAED;;;;MAMC;IAED,0BAEC;IAED;;;OAGG;IACH,2CAIC;IAED;;;OAGG;IACH,6CAQC;CACJ;;eAIS,cAAc;;gBAKd,cAAc;;;mBApIL,4BAA4B"}

package/src/core/model/BooleanVector3.js

@@ -1,136 +1,136 @@
 import { assert } from "../assert.js";
 import Signal from "../events/signal/Signal.js";
 
-/**
- *
- * @param {boolean} x
- * @param {boolean} y
- * @param {boolean} z
- * @constructor
- */
-function BooleanVector3(x = false, y = false, z = false) {
+export class BooleanVector3 {
     /**
      *
-     * @type {boolean}
+     * @param {boolean} x
+     * @param {boolean} y
+     * @param {boolean} z
+     * @constructor
      */
-    this.x = x;
+    constructor(x = false, y = false, z = false) {
+        /**
+         *
+         * @type {boolean}
+         */
+        this.x = x;
+        /**
+         *
+         * @type {boolean}
+         */
+        this.y = y;
+        /**
+         *
+         * @type {boolean}
+         */
+        this.z = z;
+
+        this.onChanged = new Signal();
+    }
+
     /**
      *
-     * @type {boolean}
+     * @param {boolean} x
+     * @param {boolean} y
+     * @param {boolean} z
      */
-    this.y = y;
+    set(x, y, z) {
+        assert.equal(typeof x, 'boolean', `expected x to be a boolean, instead was '${typeof x}'`);
+        assert.equal(typeof y, 'boolean', `expected y to be a boolean, instead was '${typeof y}'`);
+        assert.equal(typeof z, 'boolean', `expected z to be a boolean, instead was '${typeof z}'`);
+
+        const _x = this.x;
+        const _y = this.y;
+        const _z = this.z;
+
+        if (x !== _x || y !== _y || z !== _z) {
+            this.x = x;
+            this.y = y;
+            this.z = z;
+
+            if (this.onChanged.hasHandlers()) {
+                this.onChanged.send6(x, y, z, _x, _y, _z);
+            }
+        }
+    }
+
     /**
      *
-     * @type {boolean}
+     * @param {boolean} v
      */
-    this.z = z;
-
-    this.onChanged = new Signal();
-}
-
-/**
- * @readonly
- * @type {BooleanVector3}
- */
-BooleanVector3.true = Object.freeze(new BooleanVector3(true, true, true));
-/**
- * @readonly
- * @type {BooleanVector3}
- */
-BooleanVector3.false = Object.freeze(new BooleanVector3(false, false, false));
+    setX(v) {
+        this.set(v, this.y, this.z);
+    }
 
-/**
- *
- * @param {boolean} x
- * @param {boolean} y
- * @param {boolean} z
- */
-BooleanVector3.prototype.set = function (x, y, z) {
-    assert.equal(typeof x, 'boolean', `expected x to be a boolean, instead was '${typeof x}'`);
-    assert.equal(typeof y, 'boolean', `expected y to be a boolean, instead was '${typeof y}'`);
-    assert.equal(typeof z, 'boolean', `expected z to be a boolean, instead was '${typeof z}'`);
+    /**
+     *
+     * @param {boolean} v
+     */
+    setY(v) {
+        this.set(this.x, v, this.z);
+    }
 
-    const _x = this.x;
-    const _y = this.y;
-    const _z = this.z;
+    /**
+     *
+     * @param {boolean} v
+     */
+    setZ(v) {
+        this.set(this.x, this.y, v);
+    }
 
-    if (x !== _x || y !== _y || z !== _z) {
-        this.x = x;
-        this.y = y;
-        this.z = z;
+    /**
+     *
+     * @param {BooleanVector3} other
+     */
+    copy(other) {
+        this.set(other.x, other.y, other.z);
+    }
 
-        if (this.onChanged.hasHandlers()) {
-            this.onChanged.send6(x, y, z, _x, _y, _z);
-        }
+    toJSON() {
+        return {
+            x: this.x,
+            y: this.y,
+            z: this.z
+        };
     }
-};
 
-/**
- *
- * @param {boolean} v
- */
-BooleanVector3.prototype.setX = function (v) {
-    this.set(v, this.y, this.z);
-};
+    fromJSON(json) {
+        this.set(json.x, json.y, json.z);
+    }
 
-/**
- *
- * @param {boolean} v
- */
-BooleanVector3.prototype.setY = function (v) {
-    this.set(this.x, v, this.z);
-};
+    /**
+     *
+     * @param {BinaryBuffer} buffer
+     */
+    toBinaryBuffer(buffer) {
+        const v = (this.x ? 1 : 0) | (this.y ? 2 : 0) | (this.z ? 4 : 0);
 
-/**
- *
- * @param {boolean} v
- */
-BooleanVector3.prototype.setZ = function (v) {
-    this.set(this.x, this.y, v);
-};
+        buffer.writeUint8(v);
+    }
 
-/**
- *
- * @param {BooleanVector3} other
- */
-BooleanVector3.prototype.copy = function (other) {
-    this.set(other.x, other.y, other.z);
-}
+    /**
+     *
+     * @param {BinaryBuffer} buffer
+     */
+    fromBinaryBuffer(buffer) {
+        const value = buffer.readUint8();
 
-BooleanVector3.prototype.toJSON = function () {
-    return {
-        x: this.x,
-        y: this.y,
-        z: this.z
-    };
-};
+        const x = (value & 1) !== 0;
+        const y = (value & 2) !== 0;
+        const z = (value & 4) !== 0;
 
-BooleanVector3.prototype.fromJSON = function (json) {
-    this.set(json.x, json.y, json.z);
-};
+        this.set(x, y, z);
+    }
+}
 
 /**
- *
- * @param {BinaryBuffer} buffer
+ * @readonly
+ * @type {BooleanVector3}
  */
-BooleanVector3.prototype.toBinaryBuffer = function (buffer) {
-    const v = (this.x ? 1 : 0) | (this.y ? 2 : 0) | (this.z ? 4 : 0);
-
-    buffer.writeUint8(v);
-};
-
+BooleanVector3.true = Object.freeze(new BooleanVector3(true, true, true));
 /**
- *
- * @param {BinaryBuffer} buffer
+ * @readonly
+ * @type {BooleanVector3}
  */
-BooleanVector3.prototype.fromBinaryBuffer = function (buffer) {
-    const value = buffer.readUint8();
-
-    const x = (value & 1) !== 0;
-    const y = (value & 2) !== 0;
-    const z = (value & 4) !== 0;
-
-    this.set(x, y, z);
-};
-
-export { BooleanVector3 };
+BooleanVector3.false = Object.freeze(new BooleanVector3(false, false, false));

package/src/core/model/BoundedValue.d.ts

@@ -0,0 +1,116 @@
+export default BoundedValue;
+declare class BoundedValue {
+    /**
+     *
+     * @param {Number} currentValue
+     * @param {Number} upperLimit
+     * @param {Number} [lowerLimit=0]
+     * @constructor
+     */
+    constructor(currentValue: number, upperLimit: number, lowerLimit?: number);
+    /**
+     * @property {Number}
+     * @private
+     */
+    private __value;
+    /**
+     * @property {Number}
+     * @private
+     */
+    private __limitUpper;
+    /**
+     * @type {Number}
+     * @private
+     */
+    private __limitLower;
+    onChanged: Signal<any, any, any, any, any, any, any, any>;
+    onOverflow: Signal<any, any, any, any, any, any, any, any>;
+    onFilled: Signal<any, any, any, any, any, any, any, any>;
+    on: {
+        changed: Signal<any, any, any, any, any, any, any, any>;
+        overflow: Signal<any, any, any, any, any, any, any, any>;
+    };
+    /**
+     *
+     * @param {Number} v
+     */
+    setUpperLimit(v: number): void;
+    /**
+     *
+     * @returns {Number}
+     */
+    getUpperLimit(): number;
+    /**
+     *
+     * @returns {Number}
+     */
+    getLowerLimit(): number;
+    /**
+     *
+     * @param {Number} v
+     */
+    setLowerLimit(v: number): void;
+    /**
+     *
+     * @param {Number} v
+     */
+    setValue(v: number): void;
+    /**
+     *
+     * @returns {Number}
+     */
+    getValue(): number;
+    /**
+     *
+     * @returns {number}
+     */
+    getFraction(): number;
+    /**
+     *
+     */
+    setValueToLimit(): void;
+    /**
+     *
+     * @return {boolean}
+     */
+    isValueAtLimit(): boolean;
+    /**
+     *
+     * @param {Number} val
+     */
+    addValue(val: number): void;
+    /**
+     *
+     * @param {BoundedValue} other
+     * @returns {BoundedValue}
+     */
+    copy(other: BoundedValue): BoundedValue;
+    /**
+     *
+     * @param {BoundedValue} other
+     * @returns {boolean}
+     */
+    equals(other: BoundedValue): boolean;
+    /**
+     *
+     * @returns {number}
+     */
+    hash(): number;
+    toJSON(): {
+        value: number;
+        limit: number;
+    };
+    fromJSON(json: any): void;
+    /**
+     *
+     * @param {BinaryBuffer} buffer
+     */
+    toBinaryBuffer(buffer: BinaryBuffer): void;
+    /**
+     *
+     * @param {BinaryBuffer} buffer
+     */
+    fromBinaryBuffer(buffer: BinaryBuffer): void;
+}
+import Signal from "../events/signal/Signal.js";
+//# sourceMappingURL=BoundedValue.d.ts.map

package/src/core/model/BoundedValue.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"BoundedValue.d.ts","sourceRoot":"","sources":["../../../../src/core/model/BoundedValue.js"],"names":[],"mappings":";AAIA;IACI;;;;;;OAMG;IACH,2EA0BC;IAzBG;;;OAGG;IACH,gBAA4D;IAC5D;;;OAGG;IACH,qBAA6D;IAE7D;;;OAGG;IACH,qBAA6D;IAE7D,0DAA6B;IAC7B,2DAA8B;IAC9B,yDAA4B;IAE5B;;;MAGC;IAGL;;;OAGG;IACH,+BAQC;IAED;;;OAGG;IACH,wBAEC;IAED;;;OAGG;IACH,wBAEC;IAED;;;OAGG;IACH,+BAYC;IAED;;;OAGG;IACH,0BAiBC;IAED;;;OAGG;IACH,mBAEC;IAED;;;OAGG;IACH,eAFa,MAAM,CAIlB;IAED;;OAEG;IACH,wBAEC;IAED;;;OAGG;IACH,kBAFY,OAAO,CAIlB;IAED;;;OAGG;IACH,4BAEC;IAED;;;;OAIG;IACH,YAHW,YAAY,GACV,YAAY,CAMxB;IAED;;;;OAIG;IACH,cAHW,YAAY,GACV,OAAO,CAInB;IAED;;;OAGG;IACH,QAFa,MAAM,CAUlB;IAED;;;MAKC;IAED,0BAGC;IAED;;;OAGG;IACH,2CAGC;IAED;;;OAGG;IACH,6CAMC;CACJ;mBAxNkB,4BAA4B"}