@math.gl/core 3.5.3 → 3.6.0-alpha.1

package/dist/classes/quaternion.js

@@ -0,0 +1,266 @@
+// Copyright (c) 2017 Uber Technologies, Inc.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+// THE SOFTWARE.
+import MathArray from './base/math-array';
+import { checkNumber, checkVector } from '../lib/validators';
+import assert from '../lib/assert';
+// @ts-ignore: error TS2307: Cannot find module 'gl-matrix/...'.
+import * as quat from 'gl-matrix/quat';
+// @ts-ignore: error TS2307: Cannot find module 'gl-matrix/...'.
+import * as vec4 from 'gl-matrix/vec4';
+const IDENTITY_QUATERNION = [0, 0, 0, 1];
+export default class Quaternion extends MathArray {
+    constructor(x = 0, y = 0, z = 0, w = 1) {
+        // PERF NOTE: initialize elements as double precision numbers
+        super(-0, -0, -0, -0);
+        // eslint-disable-next-line prefer-rest-params
+        if (Array.isArray(x) && arguments.length === 1) {
+            this.copy(x);
+        }
+        else {
+            this.set(x, y, z, w);
+        }
+    }
+    copy(array) {
+        this[0] = array[0];
+        this[1] = array[1];
+        this[2] = array[2];
+        this[3] = array[3];
+        return this.check();
+    }
+    set(x, y, z, w) {
+        this[0] = x;
+        this[1] = y;
+        this[2] = z;
+        this[3] = w;
+        return this.check();
+    }
+    // Creates a quaternion from the given 3x3 rotation matrix.
+    // NOTE: The resultant quaternion is not normalized, so you should
+    // be sure to renormalize the quaternion yourself where necessary.
+    fromMatrix3(m) {
+        quat.fromMat3(this, m);
+        return this.check();
+    }
+    // Set a quat to the identity quaternion
+    identity() {
+        quat.identity(this);
+        return this.check();
+    }
+    fromAxisRotation(axis, rad) {
+        quat.setAxisAngle(this, axis, rad);
+        return this.check();
+    }
+    // Set the components of a quat to the given values
+    // set(i, j, k, l) {
+    //   quat.set(this, i, j, k, l);
+    //   return this.check();
+    // }
+    // Sets a quat from the given angle and rotation axis, then returns it.
+    setAxisAngle(axis, rad) {
+        return this.fromAxisRotation(axis, rad);
+    }
+    // Getters/setters
+    /* eslint-disable no-multi-spaces, brace-style, no-return-assign */
+    get ELEMENTS() {
+        return 4;
+    }
+    get x() {
+        return this[0];
+    }
+    set x(value) {
+        this[0] = checkNumber(value);
+    }
+    get y() {
+        return this[1];
+    }
+    set y(value) {
+        this[1] = checkNumber(value);
+    }
+    get z() {
+        return this[2];
+    }
+    set z(value) {
+        this[2] = checkNumber(value);
+    }
+    get w() {
+        return this[3];
+    }
+    set w(value) {
+        this[3] = checkNumber(value);
+    }
+    /* eslint-enable no-multi-spaces, brace-style, no-return-assign */
+    // Calculates the length of a quat
+    len() {
+        return quat.length(this);
+    }
+    // Calculates the squared length of a quat
+    lengthSquared() {
+        return quat.squaredLength(this);
+    }
+    // Calculates the dot product of two quat's
+    // @return {Number}
+    dot(a, b) {
+        if (b !== undefined) {
+            throw new Error('Quaternion.dot only takes one argument');
+        }
+        return quat.dot(this, a);
+    }
+    // Gets the rotation axis and angle for a given quaternion.
+    // If a quaternion is created with setAxisAngle, this method will
+    // return the same values as providied in the original parameter
+    // list OR functionally equivalent values.
+    // Example: The quaternion formed by axis [0, 0, 1] and angle -90
+    // is the same as the quaternion formed by [0, 0, 1] and 270.
+    // This method favors the latter.
+    // @return {{[x,y,z], Number}}
+    // getAxisAngle() {
+    //   const axis = [];
+    //   const angle = quat.getAxisAngle(axis, this);
+    //   return {axis, angle};
+    // }
+    // MODIFIERS
+    // Sets a quaternion to represent the shortest rotation from one vector
+    // to another. Both vectors are assumed to be unit length.
+    rotationTo(vectorA, vectorB) {
+        quat.rotationTo(this, vectorA, vectorB);
+        return this.check();
+    }
+    // Sets the specified quaternion with values corresponding to the given axes.
+    // Each axis is a vec3 and is expected to be unit length and perpendicular
+    // to all other specified axes.
+    // setAxes() {
+    //   Number
+    // }
+    // Performs a spherical linear interpolation with two control points
+    // sqlerp() {
+    //   Number;
+    // }
+    // Adds two quat's
+    add(a, b) {
+        if (b !== undefined) {
+            throw new Error('Quaternion.add only takes one argument');
+        }
+        quat.add(this, this, a);
+        return this.check();
+    }
+    // Calculates the W component of a quat from the X, Y, and Z components.
+    // Any existing W component will be ignored.
+    calculateW() {
+        quat.calculateW(this, this);
+        return this.check();
+    }
+    // Calculates the conjugate of a quat If the quaternion is normalized,
+    // this function is faster than quat.inverse and produces the same result.
+    conjugate() {
+        quat.conjugate(this, this);
+        return this.check();
+    }
+    // Calculates the inverse of a quat
+    invert() {
+        quat.invert(this, this);
+        return this.check();
+    }
+    // Performs a linear interpolation between two quat's
+    lerp(a, b, t) {
+        quat.lerp(this, a, b, t);
+        return this.check();
+    }
+    // Multiplies two quat's
+    multiplyRight(a, b) {
+        assert(!b); // Quaternion.multiply only takes one argument
+        quat.multiply(this, this, a);
+        return this.check();
+    }
+    multiplyLeft(a, b) {
+        assert(!b); // Quaternion.multiply only takes one argument
+        quat.multiply(this, a, this);
+        return this.check();
+    }
+    // Normalize a quat
+    normalize() {
+        // Handle 0 case
+        const length = this.len();
+        const l = length > 0 ? 1 / length : 0;
+        this[0] = this[0] * l;
+        this[1] = this[1] * l;
+        this[2] = this[2] * l;
+        this[3] = this[3] * l;
+        // Set to [0, 0, 0, 1] if length is 0
+        if (length === 0) {
+            this[3] = 1;
+        }
+        return this.check();
+    }
+    // Rotates a quaternion by the given angle about the X axis
+    rotateX(rad) {
+        quat.rotateX(this, this, rad);
+        return this.check();
+    }
+    // Rotates a quaternion by the given angle about the Y axis
+    rotateY(rad) {
+        quat.rotateY(this, this, rad);
+        return this.check();
+    }
+    // Rotates a quaternion by the given angle about the Z axis
+    rotateZ(rad) {
+        quat.rotateZ(this, this, rad);
+        return this.check();
+    }
+    // Scales a quat by a scalar number
+    scale(b) {
+        quat.scale(this, this, b);
+        return this.check();
+    }
+    // Performs a spherical linear interpolation between two quat
+    slerp(start, target, ratio) {
+        // eslint-disable-next-line prefer-rest-params
+        switch (arguments.length) {
+            case 1: // Deprecated signature ({start, target, ratio})
+                // eslint-disable-next-line prefer-rest-params
+                ({ start = IDENTITY_QUATERNION, target, ratio } = arguments[0]);
+                break;
+            case 2: // THREE.js compatibility signature (target, ration)
+                // eslint-disable-next-line prefer-rest-params
+                [target, ratio] = arguments;
+                start = this; // eslint-disable-line
+                break;
+            default: // Default signature: (start, target, ratio)
+        }
+        quat.slerp(this, start, target, ratio);
+        return this.check();
+    }
+    transformVector4(vector, result = vector) {
+        vec4.transformQuat(result, vector, this);
+        return checkVector(result, 4);
+    }
+    // THREE.js Math API compatibility
+    lengthSq() {
+        return this.lengthSquared();
+    }
+    setFromAxisAngle(axis, rad) {
+        return this.setAxisAngle(axis, rad);
+    }
+    premultiply(a, b) {
+        return this.multiplyLeft(a, b);
+    }
+    multiply(a, b) {
+        return this.multiplyRight(a, b);
+    }
+}

package/dist/classes/spherical-coordinates.d.ts

@@ -0,0 +1,40 @@
+export default class SphericalCoordinates {
+    constructor({ phi, theta, radius, bearing, pitch, altitude, radiusScale }?: {
+        phi?: number;
+        theta?: number;
+        radius?: number;
+        bearing?: any;
+        pitch?: any;
+        altitude?: any;
+        radiusScale?: number;
+    });
+    phi: number;
+    theta: number;
+    radius: any;
+    radiusScale: number;
+    set bearing(arg: number);
+    get bearing(): number;
+    set pitch(arg: number);
+    get pitch(): number;
+    toString(): string;
+    formatString({ printTypes }: {
+        printTypes?: boolean;
+    }): string;
+    equals(other: any): boolean;
+    exactEquals(other: any): boolean;
+    get longitude(): number;
+    get latitude(): number;
+    get lng(): number;
+    get lat(): number;
+    get z(): number;
+    set(radius: any, phi: any, theta: any): SphericalCoordinates;
+    clone(): SphericalCoordinates;
+    copy(other: any): SphericalCoordinates;
+    fromLngLatZ([lng, lat, z]: [any, any, any]): void;
+    fromVector3(v: any): SphericalCoordinates;
+    toVector3(): Vector3;
+    makeSafe(): SphericalCoordinates;
+    check(): SphericalCoordinates;
+}
+import Vector3 from "./vector3";
+//# sourceMappingURL=spherical-coordinates.d.ts.map

package/dist/classes/spherical-coordinates.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"spherical-coordinates.d.ts","sourceRoot":"","sources":["../../src/classes/spherical-coordinates.js"],"names":[],"mappings":"AAkCA;IAGE;;;;;;;;OAsBC;IAbC,YAAc;IACd,cAAkB;IAElB,YAAqC;IACrC,oBAAmC;IAsCrC,yBAEC;IALD,sBAEC;IAOD,uBAEC;IALD,oBAEC;IAhCD,mBAEC;IAED;;eAIC;IAED,4BAMC;IAED,iCAEC;IAqBD,wBAEC;IACD,uBAEC;IACD,kBAEC;IACD,kBAEC;IACD,gBAEC;IAGD,6DAKC;IAED,8BAEC;IAED,uCAKC;IAED,kDAIC;IAED,0CAOC;IAED,qBAIC;IAGD,iCAGC;IAED,8BAMC;CACF"}

package/dist/classes/spherical-coordinates.js

@@ -0,0 +1,142 @@
+// Copyright (c) 2017 Uber Technologies, Inc.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+// THE SOFTWARE.
+// Adaptation of THREE.js Spherical class, under MIT license
+import { formatValue, equals, config } from '../lib/common';
+import { degrees, radians, clamp } from '../lib/common';
+import Vector3 from './vector3';
+// @ts-ignore: error TS2307: Cannot find module 'gl-matrix/...'.
+import * as vec3 from 'gl-matrix/vec3';
+// TODO - import epsilon
+const EPSILON = 0.000001;
+const EARTH_RADIUS_METERS = 6.371e6;
+// Todo [rho, theta, phi] ?
+export default class SphericalCoordinates {
+    // @ts-ignore TS2740: Type '{}' is missing the following properties from type
+    // eslint-disable-next-line complexity
+    constructor({ phi = 0, theta = 0, radius = 1, bearing = undefined, pitch = undefined, altitude = undefined, radiusScale = EARTH_RADIUS_METERS } = {}) {
+        this.phi = phi;
+        this.theta = theta;
+        // TODO - silently accepts illegal 0
+        this.radius = radius || altitude || 1; // radial distance from center
+        this.radiusScale = radiusScale || 1; // Used by lngLatZ
+        if (bearing !== undefined) {
+            this.bearing = bearing; // up / down towards top and bottom pole
+        }
+        if (pitch !== undefined) {
+            this.pitch = pitch; // around the equator of the sphere
+        }
+        this.check();
+    }
+    toString() {
+        return this.formatString(config);
+    }
+    formatString({ printTypes = false }) {
+        const f = formatValue;
+        return `${printTypes ? 'Spherical' : ''}\
+[rho:${f(this.radius)},theta:${f(this.theta)},phi:${f(this.phi)}]`;
+    }
+    equals(other) {
+        return (equals(this.radius, other.radius) &&
+            equals(this.theta, other.theta) &&
+            equals(this.phi, other.phi));
+    }
+    exactEquals(other) {
+        return this.radius === other.radius && this.theta === other.theta && this.phi === other.phi;
+    }
+    /* eslint-disable brace-style */
+    // Cartographic (bearing 0 north, pitch 0 look from above)
+    get bearing() {
+        return 180 - degrees(this.phi);
+    }
+    set bearing(v) {
+        this.phi = Math.PI - radians(v);
+    }
+    get pitch() {
+        return degrees(this.theta);
+    }
+    set pitch(v) {
+        this.theta = radians(v);
+    }
+    // get pitch() { return 90 - degrees(this.phi); }
+    // set pitch(v) { this.phi = radians(v) + Math.PI / 2; }
+    // get altitude() { return this.radius - 1; } // relative altitude
+    // lnglatZ coordinates
+    get longitude() {
+        return degrees(this.phi);
+    }
+    get latitude() {
+        return degrees(this.theta);
+    }
+    get lng() {
+        return degrees(this.phi);
+    }
+    get lat() {
+        return degrees(this.theta);
+    }
+    get z() {
+        return (this.radius - 1) * this.radiusScale;
+    }
+    /* eslint-enable brace-style */
+    set(radius, phi, theta) {
+        this.radius = radius;
+        this.phi = phi;
+        this.theta = theta;
+        return this.check();
+    }
+    clone() {
+        return new SphericalCoordinates().copy(this);
+    }
+    copy(other) {
+        this.radius = other.radius;
+        this.phi = other.phi;
+        this.theta = other.theta;
+        return this.check();
+    }
+    fromLngLatZ([lng, lat, z]) {
+        this.radius = 1 + z / this.radiusScale;
+        this.phi = radians(lat);
+        this.theta = radians(lng);
+    }
+    fromVector3(v) {
+        this.radius = vec3.length(v);
+        if (this.radius > 0) {
+            this.theta = Math.atan2(v[0], v[1]); // equator angle around y-up axis
+            this.phi = Math.acos(clamp(v[2] / this.radius, -1, 1)); // polar angle
+        }
+        return this.check();
+    }
+    toVector3() {
+        return new Vector3(0, 0, this.radius)
+            .rotateX({ radians: this.theta })
+            .rotateZ({ radians: this.phi });
+    }
+    // restrict phi to be betwee EPS and PI-EPS
+    makeSafe() {
+        this.phi = Math.max(EPSILON, Math.min(Math.PI - EPSILON, this.phi));
+        return this;
+    }
+    check() {
+        // this.makeSafe();
+        if (!Number.isFinite(this.phi) || !Number.isFinite(this.theta) || !(this.radius > 0)) {
+            throw new Error('SphericalCoordinates: some fields set to invalid numbers');
+        }
+        return this;
+    }
+}

package/dist/classes/vector2.d.ts

@@ -0,0 +1,19 @@
+export default class Vector2 extends Vector<any> {
+    constructor(x?: number, y?: number, ...args: any[]);
+    0: number;
+    1: number;
+    set(x: any, y: any): any;
+    copy(array: any): any;
+    fromObject(object: any): any;
+    toObject(object: any): any;
+    horizontalAngle(): number;
+    verticalAngle(): number;
+    transform(matrix4: any): any;
+    transformAsPoint(matrix4: any): any;
+    transformAsVector(matrix4: any): any;
+    transformByMatrix3(matrix3: any): any;
+    transformByMatrix2x3(matrix2x3: any): any;
+    transformByMatrix2(matrix2: any): any;
+}
+import Vector from "./base/vector";
+//# sourceMappingURL=vector2.d.ts.map

package/dist/classes/vector2.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"vector2.d.ts","sourceRoot":"","sources":["../../src/classes/vector2.js"],"names":[],"mappings":"AA6BA;IAEE,oDAaC;IAHG,UAAW;IACX,UAAW;IAIf,yBAIC;IAED,sBAIC;IAED,6BAQC;IAED,2BAIC;IASD,0BAEC;IAED,wBAEC;IAID,6BAEC;IAGD,oCAGC;IAGD,qCAGC;IAED,sCAGC;IAED,0CAGC;IAED,sCAGC;CACF"}

package/dist/classes/vector2.js

@@ -0,0 +1,105 @@
+// Copyright (c) 2017 Uber Technologies, Inc.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+// THE SOFTWARE.
+import Vector from './base/vector';
+import { config, isArray } from '../lib/common';
+import { checkNumber } from '../lib/validators';
+// @ts-ignore: error TS2307: Cannot find module 'gl-matrix/...'.
+import * as vec2 from 'gl-matrix/vec2';
+// eslint-disable-next-line camelcase
+import { vec2_transformMat4AsVector } from '../lib/gl-matrix-extras';
+export default class Vector2 extends Vector {
+    // Creates a new, empty vec2
+    constructor(x = 0, y = 0) {
+        // PERF NOTE: initialize elements as double precision numbers
+        super(2); // -0, -0);
+        if (isArray(x) && arguments.length === 1) {
+            this.copy(x);
+        }
+        else {
+            if (config.debug) {
+                checkNumber(x);
+                checkNumber(y);
+            }
+            this[0] = x;
+            this[1] = y;
+        }
+    }
+    set(x, y) {
+        this[0] = x;
+        this[1] = y;
+        return this.check();
+    }
+    copy(array) {
+        this[0] = array[0];
+        this[1] = array[1];
+        return this.check();
+    }
+    fromObject(object) {
+        if (config.debug) {
+            checkNumber(object.x);
+            checkNumber(object.y);
+        }
+        this[0] = object.x;
+        this[1] = object.y;
+        return this.check();
+    }
+    toObject(object) {
+        object.x = this[0];
+        object.y = this[1];
+        return object;
+    }
+    // Getters/setters
+    get ELEMENTS() {
+        return 2;
+    }
+    // x,y inherited from Vector
+    horizontalAngle() {
+        return Math.atan2(this.y, this.x);
+    }
+    verticalAngle() {
+        return Math.atan2(this.x, this.y);
+    }
+    // Transforms
+    transform(matrix4) {
+        return this.transformAsPoint(matrix4);
+    }
+    // transforms as point (4th component is implicitly 1)
+    transformAsPoint(matrix4) {
+        vec2.transformMat4(this, this, matrix4);
+        return this.check();
+    }
+    // transforms as vector  (4th component is implicitly 0, ignores translation. slightly faster)
+    transformAsVector(matrix4) {
+        vec2_transformMat4AsVector(this, this, matrix4);
+        return this.check();
+    }
+    transformByMatrix3(matrix3) {
+        vec2.transformMat3(this, this, matrix3);
+        return this.check();
+    }
+    transformByMatrix2x3(matrix2x3) {
+        vec2.transformMat2d(this, this, matrix2x3);
+        return this.check();
+    }
+    transformByMatrix2(matrix2) {
+        vec2.transformMat2(this, this, matrix2);
+        return this.check();
+    }
+}

package/dist/classes/vector3.d.ts

@@ -0,0 +1,41 @@
+export default class Vector3 extends Vector<any> {
+    static get ZERO(): any;
+    /**
+     * @class
+     * @param {Number | [Number, Number, Number]} x
+     * @param {Number} y - rotation around X (latitude)
+     * @param {Number} z - rotation around X (latitude)
+     */
+    constructor(x?: number | [number, number, number], y?: number, z?: number, ...args: any[]);
+    0: number | [number, number, number];
+    1: number;
+    2: number;
+    set(x: any, y: any, z: any): any;
+    copy(array: any): any;
+    fromObject(object: any): any;
+    toObject(object: any): any;
+    set z(arg: number);
+    get z(): number;
+    angle(vector: any): any;
+    cross(vector: any): any;
+    rotateX({ radians, origin }: {
+        radians: any;
+        origin?: number[];
+    }): any;
+    rotateY({ radians, origin }: {
+        radians: any;
+        origin?: number[];
+    }): any;
+    rotateZ({ radians, origin }: {
+        radians: any;
+        origin?: number[];
+    }): any;
+    transform(matrix4: any): any;
+    transformAsPoint(matrix4: any): any;
+    transformAsVector(matrix4: any): any;
+    transformByMatrix3(matrix3: any): any;
+    transformByMatrix2(matrix2: any): any;
+    transformByQuaternion(quaternion: any): any;
+}
+import Vector from "./base/vector";
+//# sourceMappingURL=vector3.d.ts.map

package/dist/classes/vector3.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"vector3.d.ts","sourceRoot":"","sources":["../../src/classes/vector3.js"],"names":[],"mappings":"AAgCA;IACE,uBAEC;IAED;;;;;OAKG;IACH,gBAJW,SAAS,wBAAwB,0CAqB3C;IAJG,qCAAW;IACX,UAAW;IACX,UAAW;IAIf,iCAKC;IAED,sBAKC;IAED,6BAUC;IAED,2BAKC;IAaD,mBAEC;IALD,gBAEC;IAMD,wBAEC;IAID,wBAGC;IAED;;;YAGC;IAED;;;YAGC;IAED;;;YAGC;IAKD,6BAEC;IAGD,oCAGC;IAGD,qCAGC;IAED,sCAGC;IAED,sCAGC;IAED,4CAGC;CACF"}