@math.gl/core 3.5.7 → 3.6.0-alpha.3

package/dist/classes/quaternion.d.ts

@@ -0,0 +1,63 @@
+import MathArray from './base/math-array';
+import { NumericArray } from '@math.gl/types';
+export default class Quaternion extends MathArray {
+    constructor(x?: number | Readonly<NumericArray>, y?: number, z?: number, w?: number);
+    copy(array: Readonly<NumericArray>): this;
+    set(x: number, y: number, z: number, w: number): this;
+    fromObject(object: {
+        x: number;
+        y: number;
+        z: number;
+        w: number;
+    }): this;
+    /**
+     * 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.
+     * @param m
+     * @returns
+     */
+    fromMatrix3(m: Readonly<NumericArray>): this;
+    fromAxisRotation(axis: Readonly<NumericArray>, rad: number): this;
+    /** Set a quat to the identity quaternion */
+    identity(): this;
+    setAxisAngle(axis: Readonly<NumericArray>, rad: number): this;
+    get ELEMENTS(): number;
+    get x(): number;
+    set x(value: number);
+    get y(): number;
+    set y(value: number);
+    get z(): number;
+    set z(value: number);
+    get w(): number;
+    set w(value: number);
+    len(): number;
+    lengthSquared(): number;
+    dot(a: Readonly<NumericArray>): number;
+    rotationTo(vectorA: NumericArray, vectorB: NumericArray): this;
+    add(a: Readonly<NumericArray>): this;
+    calculateW(): this;
+    conjugate(): this;
+    invert(): this;
+    lerp(a: Readonly<NumericArray>, b: Readonly<NumericArray> | number, t?: number): this;
+    multiplyRight(a: Readonly<NumericArray>): this;
+    multiplyLeft(a: Readonly<NumericArray>): this;
+    normalize(): this;
+    rotateX(rad: number): this;
+    rotateY(rad: number): this;
+    rotateZ(rad: number): this;
+    scale(b: number): this;
+    slerp(target: Readonly<NumericArray>, ratio: number): this;
+    slerp(start: Readonly<NumericArray>, target: Readonly<NumericArray>, ratio: number): this;
+    slerp(params: {
+        start: Readonly<NumericArray>;
+        target: Readonly<NumericArray>;
+        ratio: number;
+    }): this;
+    transformVector4(vector: Readonly<NumericArray>, result?: NumericArray): NumericArray;
+    lengthSq(): number;
+    setFromAxisAngle(axis: Readonly<NumericArray>, rad: number): this;
+    premultiply(a: Readonly<NumericArray>): this;
+    multiply(a: Readonly<NumericArray>): this;
+}
+//# sourceMappingURL=quaternion.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"quaternion.d.ts","sourceRoot":"","sources":["../../src/classes/quaternion.ts"],"names":[],"mappings":"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"}

package/dist/classes/quaternion.js

@@ -0,0 +1,262 @@
+// Copyright (c) 2017 Uber Technologies, Inc.
+// MIT License
+import MathArray from './base/math-array';
+import { checkNumber, checkVector } from '../lib/validators';
+import Vector4 from './vector4';
+import * as quat from 'gl-matrix/quat';
+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();
+    }
+    fromObject(object) {
+        this[0] = object.x;
+        this[1] = object.y;
+        this[2] = object.z;
+        this[3] = object.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.
+     * @param m
+     * @returns
+     */
+    fromMatrix3(m) {
+        quat.fromMat3(this, m);
+        return this.check();
+    }
+    fromAxisRotation(axis, rad) {
+        quat.setAxisAngle(this, axis, rad);
+        return this.check();
+    }
+    /** Set a quat to the identity quaternion */
+    identity() {
+        quat.identity(this);
+        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
+    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);
+    }
+    // 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) {
+        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) {
+        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) {
+        if (t === undefined) {
+            return this.lerp(this, a, b);
+        }
+        quat.lerp(this, a, b, t);
+        return this.check();
+    }
+    // Multiplies two quat's
+    multiplyRight(a) {
+        quat.multiply(this, this, a);
+        return this.check();
+    }
+    multiplyLeft(a) {
+        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(arg0, arg1, arg2) {
+        let start;
+        let target;
+        let 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
+                } = arg0);
+                break;
+            case 2: // THREE.js compatibility signature (target, ration)
+                start = this; // eslint-disable-line
+                target = arg0;
+                ratio = arg1;
+                break;
+            default:
+                // Default signature: (start, target, ratio)
+                start = arg0;
+                target = arg1;
+                ratio = arg2;
+        }
+        quat.slerp(this, start, target, ratio);
+        return this.check();
+    }
+    transformVector4(vector, result = new Vector4()) {
+        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) {
+        return this.multiplyLeft(a);
+    }
+    multiply(a) {
+        return this.multiplyRight(a);
+    }
+}

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

@@ -0,0 +1,60 @@
+import Vector3 from './vector3';
+import { NumericArray } from '@math.gl/types';
+declare type SphericalCoordinatesOptions = {
+    phi?: number;
+    theta?: number;
+    radius?: number;
+    bearing?: number;
+    pitch?: number;
+    altitude?: number;
+    radiusScale?: number;
+};
+declare type FormatOptions = {
+    printTypes?: boolean;
+};
+/**
+ * The poles (phi) are at the positive and negative y axis.
+ * The equator starts at positive z.
+ * @link https://en.wikipedia.org/wiki/Spherical_coordinate_system
+ */
+export default class SphericalCoordinates {
+    phi: number;
+    theta: number;
+    radius: number;
+    radiusScale: number;
+    /**
+     * Creates a new SphericalCoordinates object
+     * @param options
+     * @param [options.phi] =0 - rotation around X (latitude)
+     * @param [options.theta] =0 - rotation around Y (longitude)
+     * @param [options.radius] =1 - Distance from center
+     * @param [options.bearing]
+     * @param [options.pitch]
+     * @param [options.altitude]
+     * @param [options.radiusScale] =1
+     */
+    constructor({ phi, theta, radius, bearing, pitch, altitude, radiusScale }?: SphericalCoordinatesOptions);
+    toString(): string;
+    formatString({ printTypes }: FormatOptions): string;
+    equals(other: SphericalCoordinates): boolean;
+    exactEquals(other: SphericalCoordinates): boolean;
+    get bearing(): number;
+    set bearing(v: number);
+    get pitch(): number;
+    set pitch(v: number);
+    get longitude(): number;
+    get latitude(): number;
+    get lng(): number;
+    get lat(): number;
+    get z(): number;
+    set(radius: number, phi: number, theta: number): this;
+    clone(): SphericalCoordinates;
+    copy(other: SphericalCoordinates): this;
+    fromLngLatZ([lng, lat, z]: [number, number, number]): this;
+    fromVector3(v: Readonly<NumericArray>): this;
+    toVector3(): Vector3;
+    makeSafe(): this;
+    check(): this;
+}
+export {};
+//# 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.ts"],"names":[],"mappings":"AAGA,OAAO,OAAO,MAAM,WAAW,CAAC;AAIhC,OAAO,EAAC,YAAY,EAAC,MAAM,gBAAgB,CAAC;AAE5C,aAAK,2BAA2B,GAAG;IACjC,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB,CAAC;AAEF,aAAK,aAAa,GAAG;IACnB,UAAU,CAAC,EAAE,OAAO,CAAC;CACtB,CAAC;AAMF;;;;GAIG;AACH,MAAM,CAAC,OAAO,OAAO,oBAAoB;IACvC,GAAG,EAAE,MAAM,CAAC;IACZ,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;IACf,WAAW,EAAE,MAAM,CAAC;IAYpB;;;;;;;;;;OAUG;gBAES,EACV,GAAO,EACP,KAAS,EACT,MAAU,EACV,OAAO,EACP,KAAK,EACL,QAAQ,EACR,WAAiC,EAClC,GAAE,2BAAgC;IAenC,QAAQ,IAAI,MAAM;IAIlB,YAAY,CAAC,EAAC,UAAkB,EAAC,EAAE,aAAa,GAAG,MAAM;IAMzD,MAAM,CAAC,KAAK,EAAE,oBAAoB,GAAG,OAAO;IAQ5C,WAAW,CAAC,KAAK,EAAE,oBAAoB,GAAG,OAAO;IAMjD,IAAI,OAAO,IAAI,MAAM,CAEpB;IAED,IAAI,OAAO,CAAC,CAAC,EAAE,MAAM,EAEpB;IAED,IAAI,KAAK,IAAI,MAAM,CAElB;IAED,IAAI,KAAK,CAAC,CAAC,EAAE,MAAM,EAElB;IAMD,IAAI,SAAS,IAAI,MAAM,CAEtB;IAED,IAAI,QAAQ,IAAI,MAAM,CAErB;IAED,IAAI,GAAG,IAAI,MAAM,CAEhB;IAED,IAAI,GAAG,IAAI,MAAM,CAEhB;IAED,IAAI,CAAC,IAAI,MAAM,CAEd;IAGD,GAAG,CAAC,MAAM,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,IAAI;IAOrD,KAAK,IAAI,oBAAoB;IAI7B,IAAI,CAAC,KAAK,EAAE,oBAAoB,GAAG,IAAI;IAOvC,WAAW,CAAC,CAAC,GAAG,EAAE,GAAG,EAAE,CAAC,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,GAAG,IAAI;IAO1D,WAAW,CAAC,CAAC,EAAE,QAAQ,CAAC,YAAY,CAAC,GAAG,IAAI;IAS5C,SAAS,IAAI,OAAO;IAOpB,QAAQ,IAAI,IAAI;IAKhB,KAAK,IAAI,IAAI;CAOd"}

package/dist/classes/spherical-coordinates.js

@@ -0,0 +1,148 @@
+// Copyright (c) 2017 Uber Technologies, Inc.
+// MIT License
+// Adaptation of THREE.js Spherical class, under MIT license
+import Vector3 from './vector3';
+import { formatValue, equals, config } from '../lib/common';
+import { degrees, radians, clamp } from '../lib/common';
+import * as vec3 from 'gl-matrix/vec3';
+// TODO - import epsilon
+const EPSILON = 0.000001;
+const EARTH_RADIUS_METERS = 6371000;
+/**
+ * The poles (phi) are at the positive and negative y axis.
+ * The equator starts at positive z.
+ * @link https://en.wikipedia.org/wiki/Spherical_coordinate_system
+ */
+export default class SphericalCoordinates {
+    // bearing: number;
+    // pitch: number;
+    // altitude: number;
+    // lnglatZ coordinates
+    // longitude: number;
+    // latitude: number;
+    // lng: number;
+    // lat: number;
+    // z: number;
+    /**
+     * Creates a new SphericalCoordinates object
+     * @param options
+     * @param [options.phi] =0 - rotation around X (latitude)
+     * @param [options.theta] =0 - rotation around Y (longitude)
+     * @param [options.radius] =1 - Distance from center
+     * @param [options.bearing]
+     * @param [options.pitch]
+     * @param [options.altitude]
+     * @param [options.radiusScale] =1
+     */
+    // eslint-disable-next-line complexity
+    constructor({ phi = 0, theta = 0, radius = 1, bearing, pitch, altitude, 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);
+        return this.check();
+    }
+    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,55 @@
+import Vector from './base/vector';
+import { NumericArray } from '@math.gl/types';
+/**
+ * Two-element vector class.
+ * Subclass of Array<number>
+ */
+export default class Vector2 extends Vector {
+    constructor(x?: number | Readonly<NumericArray>, y?: number);
+    set(x: number, y: number): this;
+    copy(array: Readonly<NumericArray>): this;
+    fromObject(object: {
+        x: number;
+        y: number;
+    }): this;
+    toObject(object: {
+        x?: number;
+        y?: number;
+    }): {
+        x: number;
+        y: number;
+    };
+    get ELEMENTS(): number;
+    /**
+     * Returns angle from x axis
+     * @returns
+     */
+    horizontalAngle(): number;
+    /**
+     * Returns angle from y axis
+     * @returns
+     */
+    verticalAngle(): number;
+    /**
+     * Transforms as point
+     * @param matrix4
+     * @returns
+     */
+    transform(matrix4: Readonly<NumericArray>): this;
+    /**
+     * transforms as point (4th component is implicitly 1)
+     * @param matrix4
+     * @returns
+     */
+    transformAsPoint(matrix4: Readonly<NumericArray>): this;
+    /**
+     * transforms as vector (4th component is implicitly 0, ignores translation. slightly faster)
+     * @param matrix4
+     * @returns
+     */
+    transformAsVector(matrix4: Readonly<NumericArray>): this;
+    transformByMatrix3(matrix3: Readonly<NumericArray>): this;
+    transformByMatrix2x3(matrix2x3: Readonly<NumericArray>): this;
+    transformByMatrix2(matrix2: Readonly<NumericArray>): this;
+}
+//# 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.ts"],"names":[],"mappings":"AAEA,OAAO,MAAM,MAAM,eAAe,CAAC;AAMnC,OAAO,EAAC,YAAY,EAAC,MAAM,gBAAgB,CAAC;AAE5C;;;GAGG;AACH,MAAM,CAAC,OAAO,OAAO,OAAQ,SAAQ,MAAM;gBAE7B,CAAC,GAAE,MAAM,GAAG,QAAQ,CAAC,YAAY,CAAK,EAAE,CAAC,GAAE,MAAU;IAejE,GAAG,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,IAAI;IAM/B,IAAI,CAAC,KAAK,EAAE,QAAQ,CAAC,YAAY,CAAC,GAAG,IAAI;IAMzC,UAAU,CAAC,MAAM,EAAE;QAAC,CAAC,EAAE,MAAM,CAAC;QAAC,CAAC,EAAE,MAAM,CAAA;KAAC,GAAG,IAAI;IAUhD,QAAQ,CAAC,MAAM,EAAE;QAAC,CAAC,CAAC,EAAE,MAAM,CAAC;QAAC,CAAC,CAAC,EAAE,MAAM,CAAA;KAAC,GAAG;QAAC,CAAC,EAAE,MAAM,CAAC;QAAC,CAAC,EAAE,MAAM,CAAA;KAAC;IAQlE,IAAI,QAAQ,IAAI,MAAM,CAErB;IAED;;;OAGG;IACH,eAAe,IAAI,MAAM;IAIzB;;;OAGG;IACH,aAAa,IAAI,MAAM;IAMvB;;;;OAIG;IACH,SAAS,CAAC,OAAO,EAAE,QAAQ,CAAC,YAAY,CAAC,GAAG,IAAI;IAIhD;;;;OAIG;IACH,gBAAgB,CAAC,OAAO,EAAE,QAAQ,CAAC,YAAY,CAAC,GAAG,IAAI;IAKvD;;;;OAIG;IACH,iBAAiB,CAAC,OAAO,EAAE,QAAQ,CAAC,YAAY,CAAC,GAAG,IAAI;IAKxD,kBAAkB,CAAC,OAAO,EAAE,QAAQ,CAAC,YAAY,CAAC,GAAG,IAAI;IAKzD,oBAAoB,CAAC,SAAS,EAAE,QAAQ,CAAC,YAAY,CAAC,GAAG,IAAI;IAK7D,kBAAkB,CAAC,OAAO,EAAE,QAAQ,CAAC,YAAY,CAAC,GAAG,IAAI;CAI1D"}