@loaders.gl/math 3.1.0-alpha.5 → 3.1.0-beta.1

package/dist/geometry/attributes/compute-bounding-box.d.ts

@@ -7,3 +7,4 @@ export declare function computeBoundingBox(positions?: any): {
     min: number[];
     max: number[];
 };
+//# sourceMappingURL=compute-bounding-box.d.ts.map

package/dist/geometry/attributes/compute-bounding-box.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"compute-bounding-box.d.ts","sourceRoot":"","sources":["../../../src/geometry/attributes/compute-bounding-box.ts"],"names":[],"mappings":"AAUA;;;;GAIG;AACH,wBAAgB,kBAAkB,CAAC,SAAS,GAAE,GAAQ;;;EAqBrD"}

package/dist/geometry/attributes/compute-bounding-box.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.computeBoundingBox = void 0;
+const attribute_iterator_1 = require("../iterators/attribute-iterator");
+const assert_1 = require("../utils/assert");
+/**
+ * Getting bounding box geometry according to positions parameters
+ * @param positions
+ * @returns Bounding Box
+ */
+function computeBoundingBox(positions = []) {
+    const min = [Number(Infinity), Number(Infinity), Number(Infinity)];
+    const max = [-Infinity, -Infinity, -Infinity];
+    // @ts-ignore
+    for (const position of (0, attribute_iterator_1.makeAttributeIterator)(positions)) {
+        const x = position[0];
+        const y = position[1];
+        const z = position[2];
+        if (x < min[0])
+            min[0] = x;
+        if (y < min[1])
+            min[1] = y;
+        if (z < min[2])
+            min[2] = z;
+        if (x > max[0])
+            max[0] = x;
+        if (y > max[1])
+            max[1] = y;
+        if (z > max[2])
+            max[2] = z;
+    }
+    const boundingBox = { min, max };
+    validateBoundingBox(boundingBox);
+    return boundingBox;
+}
+exports.computeBoundingBox = computeBoundingBox;
+function validateBoundingBox(boundingBox) {
+    (0, assert_1.assert)(Number.isFinite(boundingBox.min[0]) &&
+        Number.isFinite(boundingBox.min[1]) &&
+        Number.isFinite(boundingBox.min[2]) &&
+        Number.isFinite(boundingBox.max[0]) &&
+        Number.isFinite(boundingBox.max[1]) &&
+        Number.isFinite(boundingBox.max[2]));
+}

package/dist/geometry/attributes/compute-bounding-sphere.d.ts

@@ -26,3 +26,4 @@ export function computeBoundingSphere(geometry: any, boundingBox: object, vector
   return {center, radius};
 }
 */
+//# sourceMappingURL=compute-bounding-sphere.d.ts.map

package/dist/geometry/attributes/compute-bounding-sphere.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"compute-bounding-sphere.d.ts","sourceRoot":"","sources":["../../../src/geometry/attributes/compute-bounding-sphere.ts"],"names":[],"mappings":"AACA;;;;;;;;;;;;;;;;;;;;;;;;;;;EA2BE"}

package/dist/geometry/attributes/compute-bounding-sphere.js

@@ -0,0 +1,30 @@
+"use strict";
+/* eslint-disable */
+/**
+import {getPositions} from './get-attribute-from-geometry.js';
+
+export function computeBoundingSphere(geometry: any, boundingBox: object, vector: Vector3 ) {
+  const positions = getPositions(geometry);
+
+  const center = getBoundingBox(center);
+  box.setFromBufferAttribute(position);
+  box.getCenter(center);
+
+  // hoping to find a boundingSphere with a radius smaller than the
+  // boundingSphere of the boundingBox: sqrt(3) smaller in the best case
+
+  var maxRadiusSq = 0;
+
+  for (const position of makeAttributeIterator(positions)) {
+    vector.x = position[0];
+    vector.y = position[1];
+    vector.z = position[2];
+    maxRadiusSq = Math.max(maxRadiusSq, center.distanceToSquared(vector));
+  }
+
+  const radius = Math.sqrt(maxRadiusSq);
+  assert(Number.isFinite(radius));
+
+  return {center, radius};
+}
+*/

package/dist/geometry/attributes/compute-tangents.d.ts

@@ -0,0 +1 @@
+//# sourceMappingURL=compute-tangents.d.ts.map

package/dist/geometry/attributes/compute-tangents.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"compute-tangents.d.ts","sourceRoot":"","sources":["../../../src/geometry/attributes/compute-tangents.ts"],"names":[],"mappings":""}

package/dist/geometry/attributes/compute-tangents.js

@@ -0,0 +1,146 @@
+"use strict";
+/*
+export function computeTangents({indices, positions, normals, uvs}) {
+  var index = geometry.index;
+  var attributes = geometry.attributes;
+
+  // based on http://www.terathon.com/code/tangent.html
+  // (per vertex tangents)
+
+  if (
+    index === null ||
+    attributes.position === undefined ||
+    attributes.normal === undefined ||
+    attributes.uv === undefined
+  ) {
+    console.warn(
+      'THREE.BufferGeometry: Missing required attributes (index, position, normal or uv) in BufferGeometry.computeTangents()'
+    );
+    return;
+  }
+
+  var nVertices = positions.length / 3;
+
+  var tangents = new Float32Array(4 * nVertices); // size: 4
+
+  var tan1 = [],
+    tan2 = [];
+
+  for (var k = 0; k < nVertices; k++) {
+    tan1[k] = new THREE.Vector3();
+    tan2[k] = new THREE.Vector3();
+  }
+
+  var vA = new THREE.Vector3(),
+    vB = new THREE.Vector3(),
+    vC = new THREE.Vector3(),
+    uvA = new THREE.Vector2(),
+    uvB = new THREE.Vector2(),
+    uvC = new THREE.Vector2(),
+    sdir = new THREE.Vector3(),
+    tdir = new THREE.Vector3();
+
+  function handleTriangle(a, b, c) {
+    vA.fromArray(positions, a * 3);
+    vB.fromArray(positions, b * 3);
+    vC.fromArray(positions, c * 3);
+
+    uvA.fromArray(uvs, a * 2);
+    uvB.fromArray(uvs, b * 2);
+    uvC.fromArray(uvs, c * 2);
+
+    var x1 = vB.x - vA.x;
+    var x2 = vC.x - vA.x;
+
+    var y1 = vB.y - vA.y;
+    var y2 = vC.y - vA.y;
+
+    var z1 = vB.z - vA.z;
+    var z2 = vC.z - vA.z;
+
+    var s1 = uvB.x - uvA.x;
+    var s2 = uvC.x - uvA.x;
+
+    var t1 = uvB.y - uvA.y;
+    var t2 = uvC.y - uvA.y;
+
+    var r = 1.0 / (s1 * t2 - s2 * t1);
+
+    sdir.set((t2 * x1 - t1 * x2) * r, (t2 * y1 - t1 * y2) * r, (t2 * z1 - t1 * z2) * r);
+
+    tdir.set((s1 * x2 - s2 * x1) * r, (s1 * y2 - s2 * y1) * r, (s1 * z2 - s2 * z1) * r);
+
+    tan1[a].add(sdir);
+    tan1[b].add(sdir);
+    tan1[c].add(sdir);
+
+    tan2[a].add(tdir);
+    tan2[b].add(tdir);
+    tan2[c].add(tdir);
+  }
+
+  var groups = geometry.groups;
+
+  if (groups.length === 0) {
+    groups = [
+      {
+        start: 0,
+        count: indices.length
+      }
+    ];
+  }
+
+  for (var j = 0, jl = groups.length; j < jl; ++j) {
+    var group = groups[j];
+
+    var start = group.start;
+    var count = group.count;
+
+    for (var i = start, il = start + count; i < il; i += 3) {
+      handleTriangle(indices[i + 0], indices[i + 1], indices[i + 2]);
+    }
+  }
+
+  var tmp = new THREE.Vector3(),
+    tmp2 = new THREE.Vector3();
+  var n = new THREE.Vector3(),
+    n2 = new THREE.Vector3();
+  var w, t, test;
+
+  function handleVertex(v) {
+    n.fromArray(normals, v * 3);
+    n2.copy(n);
+
+    t = tan1[v];
+
+    // Gram-Schmidt orthogonalize
+
+    tmp.copy(t);
+    tmp.sub(n.multiplyScalar(n.dot(t))).normalize();
+
+    // Calculate handedness
+
+    tmp2.crossVectors(n2, t);
+    test = tmp2.dot(tan2[v]);
+    w = test < 0.0 ? -1.0 : 1.0;
+
+    tangents[v * 4] = tmp.x;
+    tangents[v * 4 + 1] = tmp.y;
+    tangents[v * 4 + 2] = tmp.z;
+    tangents[v * 4 + 3] = w;
+  }
+
+  for (var j = 0, jl = groups.length; j < jl; ++j) {
+    var group = groups[j];
+
+    var start = group.start;
+    var count = group.count;
+
+    for (var i = start, il = start + count; i < il; i += 3) {
+      handleVertex(indices[i + 0]);
+      handleVertex(indices[i + 1]);
+      handleVertex(indices[i + 2]);
+    }
+  }
+}
+*/

package/dist/geometry/attributes/compute-vertex-normals.d.ts

@@ -14,3 +14,4 @@ declare type Geometry = {
  */
 export declare function computeVertexNormals(geometry: Geometry): Float32Array;
 export {};
+//# sourceMappingURL=compute-vertex-normals.d.ts.map

package/dist/geometry/attributes/compute-vertex-normals.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"compute-vertex-normals.d.ts","sourceRoot":"","sources":["../../../src/geometry/attributes/compute-vertex-normals.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,UAAU,EAAC,MAAM,UAAU,CAAC;AAQzC,aAAK,QAAQ,GAAG;IACd,IAAI,EAAE,GAAG,CAAC;IACV,OAAO,CAAC,EAAE;QAAC,IAAI,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,UAAU,CAAA;KAAC,CAAC;IAC7C,UAAU,CAAC,EAAE,EAAE,CAAC;CACjB,CAAC;AACF;;;;GAIG;AAEH,wBAAgB,oBAAoB,CAAC,QAAQ,EAAE,QAAQ,GAAG,YAAY,CAyCrE"}

package/dist/geometry/attributes/compute-vertex-normals.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.computeVertexNormals = void 0;
+const core_1 = require("@math.gl/core");
+const constants_1 = require("../constants");
+const assert_1 = require("../utils/assert");
+const primitive_iterator_1 = require("../iterators/primitive-iterator");
+const modes_1 = require("../primitives/modes");
+const get_attribute_from_geometry_1 = require("./get-attribute-from-geometry");
+/**
+ * Computes vertex normals for a geometry
+ * @param param0
+ * @returns
+ */
+// eslint-disable-next-line max-statements
+function computeVertexNormals(geometry) {
+    // Only support GL.TRIANGLES, GL.TRIANGLE_STRIP, GL.TRIANGLE_FAN
+    (0, assert_1.assert)((0, modes_1.getPrimitiveModeType)(geometry.mode) === constants_1.GL.TRIANGLES, 'TRIANGLES required');
+    const { values: positions } = (0, get_attribute_from_geometry_1.getPositions)(geometry);
+    const normals = new Float32Array(positions.length);
+    const vectorA = new core_1.Vector3();
+    const vectorB = new core_1.Vector3();
+    const vectorC = new core_1.Vector3();
+    const vectorCB = new core_1.Vector3();
+    const vectorAB = new core_1.Vector3();
+    for (const primitive of (0, primitive_iterator_1.makePrimitiveIterator)(geometry)) {
+        vectorA.fromArray(positions, primitive.i1 * 3);
+        vectorB.fromArray(positions, primitive.i2 * 3 + 3);
+        vectorC.fromArray(positions, primitive.i3 * 3 + 6);
+        vectorCB.subVectors(vectorC, vectorB);
+        vectorAB.subVectors(vectorA, vectorB);
+        const normal = vectorCB.cross(vectorAB);
+        normal.normalize();
+        // @ts-ignore
+        const { primitiveIndex } = primitive;
+        normals[primitiveIndex * 9 + 0] = normal.x;
+        normals[primitiveIndex * 9 + 1] = normal.y;
+        normals[primitiveIndex * 9 + 2] = normal.z;
+        normals[primitiveIndex * 9 + 3] = normal.x;
+        normals[primitiveIndex * 9 + 4] = normal.y;
+        normals[primitiveIndex * 9 + 5] = normal.z;
+        normals[primitiveIndex * 9 + 6] = normal.x;
+        normals[primitiveIndex * 9 + 7] = normal.y;
+        normals[primitiveIndex * 9 + 8] = normal.z;
+    }
+    return normals;
+}
+exports.computeVertexNormals = computeVertexNormals;

package/dist/geometry/attributes/convert-to-non-indexed.d.ts

@@ -8,3 +8,4 @@ export declare function convertBuffersToNonIndexed({ indices, attributes }: {
     indices: any;
     attributes: any;
 }): any;
+//# sourceMappingURL=convert-to-non-indexed.d.ts.map

package/dist/geometry/attributes/convert-to-non-indexed.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"convert-to-non-indexed.d.ts","sourceRoot":"","sources":["../../../src/geometry/attributes/convert-to-non-indexed.ts"],"names":[],"mappings":"AAEA;;;;;GAKG;AACH,wBAAgB,0BAA0B,CAAC,EAAC,OAAO,EAAE,UAAU,EAAC;;;CAAA,GAAG,GAAG,CA2BrE"}

package/dist/geometry/attributes/convert-to-non-indexed.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.convertBuffersToNonIndexed = void 0;
+/* eslint-disable */
+// @ts-nocheck
+/**
+ * Converts indices of geometry.
+ *
+ * @param param0
+ * @returns no indexed geometry
+ */
+function convertBuffersToNonIndexed({ indices, attributes }) {
+    const geometry2 = new BufferGeometry();
+    for (const name in attributes) {
+        const attribute = attributes[name];
+        const array = attribute.array;
+        const itemSize = attribute.itemSize;
+        const array2 = new array.constructor(indices.length * itemSize);
+        let index = 0, index2 = 0;
+        for (var i = 0, l = indices.length; i < l; i++) {
+            index = indices[i] * itemSize;
+            for (var j = 0; j < itemSize; j++) {
+                array2[index2++] = array[index++];
+            }
+        }
+        geometry2.addAttribute(name, new BufferAttribute(array2, itemSize));
+    }
+    for (const group of this.groups) {
+        geometry2.addGroup(group.start, group.count, group.materialIndex);
+    }
+    return geometry2;
+}
+exports.convertBuffersToNonIndexed = convertBuffersToNonIndexed;

package/dist/geometry/attributes/get-attribute-from-geometry.d.ts

@@ -5,3 +5,4 @@
  * @returns Position| New geometry |assert
  */
 export declare function getPositions(geometry: any): any;
+//# sourceMappingURL=get-attribute-from-geometry.d.ts.map

package/dist/geometry/attributes/get-attribute-from-geometry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"get-attribute-from-geometry.d.ts","sourceRoot":"","sources":["../../../src/geometry/attributes/get-attribute-from-geometry.ts"],"names":[],"mappings":"AAGA;;;;;GAKG;AAEH,wBAAgB,YAAY,CAAC,QAAQ,EAAE,GAAG,OAqBzC"}

package/dist/geometry/attributes/get-attribute-from-geometry.js

@@ -0,0 +1,34 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getPositions = void 0;
+const is_geometry_1 = __importDefault(require("../is-geometry"));
+const assert_1 = require("../utils/assert");
+/**
+ * analyze positions of geometry
+ *
+ * @param geometry
+ * @returns Position| New geometry |assert
+ */
+function getPositions(geometry) {
+    // If geometry, extract positions
+    if ((0, is_geometry_1.default)(geometry)) {
+        const { attributes } = geometry;
+        const position = attributes.POSITION || attributes.positions;
+        (0, assert_1.assert)(position);
+        return position;
+    }
+    // If arraybuffer, assume 3 components
+    if (ArrayBuffer.isView(geometry)) {
+        return { values: geometry, size: 3 };
+    }
+    // Else assume accessor object
+    if (geometry) {
+        (0, assert_1.assert)(geometry.values);
+        return geometry;
+    }
+    return (0, assert_1.assert)(false);
+}
+exports.getPositions = getPositions;

package/dist/geometry/attributes/normalize.d.ts

@@ -5,3 +5,4 @@ import { Vector3 } from '@math.gl/core';
  * @param vector
  */
 export declare function normalize(normals: any, vector: Vector3): void;
+//# sourceMappingURL=normalize.d.ts.map

package/dist/geometry/attributes/normalize.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"normalize.d.ts","sourceRoot":"","sources":["../../../src/geometry/attributes/normalize.ts"],"names":[],"mappings":"AACA,OAAO,EAAC,OAAO,EAAC,MAAM,eAAe,CAAC;AAEtC;;;;GAIG;AACH,wBAAgB,SAAS,CAAC,OAAO,KAAU,EAAE,MAAM,EAAE,OAAO,QAU3D"}

package/dist/geometry/attributes/normalize.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalize = void 0;
+/**
+ * Setting X, Y, Z for Vector
+ * @param normals
+ * @param vector
+ */
+function normalize(normals = {}, vector) {
+    //@ts-ignore
+    normals = this.attributes.normal;
+    for (let i = 0, il = normals.count; i < il; i++) {
+        vector.x = normals.getX(i);
+        vector.y = normals.getY(i);
+        vector.z = normals.getZ(i);
+        vector.normalize();
+        normals.setXYZ(i, vector.x, vector.y, vector.z);
+    }
+}
+exports.normalize = normalize;

package/dist/geometry/colors/rgb565.d.ts

@@ -11,3 +11,4 @@ export declare function decodeRGB565(rgb565: number, target?: number[]): number[
  * @returns color
  */
 export declare function encodeRGB565(rgb: number[]): number;
+//# sourceMappingURL=rgb565.d.ts.map

package/dist/geometry/colors/rgb565.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rgb565.d.ts","sourceRoot":"","sources":["../../../src/geometry/colors/rgb565.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,wBAAgB,YAAY,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,GAAE,MAAM,EAAc,GAAG,MAAM,EAAE,CAUnF;AAED;;;;GAIG;AACH,wBAAgB,YAAY,CAAC,GAAG,EAAE,MAAM,EAAE,GAAG,MAAM,CAKlD"}

package/dist/geometry/colors/rgb565.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.encodeRGB565 = exports.decodeRGB565 = void 0;
+/**
+ * Decode color values
+ * @param rgb565
+ * @param target
+ * @returns target
+ */
+function decodeRGB565(rgb565, target = [0, 0, 0]) {
+    const r5 = (rgb565 >> 11) & 31;
+    const g6 = (rgb565 >> 5) & 63;
+    const b5 = rgb565 & 31;
+    target[0] = r5 << 3;
+    target[1] = g6 << 2;
+    target[2] = b5 << 3;
+    return target;
+}
+exports.decodeRGB565 = decodeRGB565;
+/**
+ * Encode color values
+ * @param rgb
+ * @returns color
+ */
+function encodeRGB565(rgb) {
+    const r5 = Math.floor(rgb[0] / 8) + 4;
+    const g6 = Math.floor(rgb[1] / 4) + 2;
+    const b5 = Math.floor(rgb[2] / 8) + 4;
+    return r5 + (g6 << 5) + (b5 << 11);
+}
+exports.encodeRGB565 = encodeRGB565;

package/dist/geometry/compression/attribute-compression.d.ts

@@ -157,3 +157,4 @@ export declare function decompressTextureCoordinates(compressed: number, result:
  * @link https://github.com/AnalyticalGraphicsInc/quantized-mesh|quantized-mesh-1.0 terrain format
  */
 export declare function zigZagDeltaDecode(uBuffer: Uint16Array, vBuffer: Uint16Array, heightBuffer?: Uint16Array | number[]): void;
+//# sourceMappingURL=attribute-compression.d.ts.map

package/dist/geometry/compression/attribute-compression.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"attribute-compression.d.ts","sourceRoot":"","sources":["../../../src/geometry/compression/attribute-compression.ts"],"names":[],"mappings":"AAKA,OAAO,EAAC,OAAO,EAAE,OAAO,EAAoB,MAAM,eAAe,CAAC;AAClE,OAAO,EAAC,OAAO,EAAC,MAAM,UAAU,CAAC;AA8DjC;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,OAAO,EAAE,QAAQ,EAAE,MAAM,EAAE,MAAM,EAAE,OAAO,GAAG,OAAO,CAsB5F;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,SAAS,CAAC,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,OAAO,GAAG,OAAO,CAEnE;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,OAAO,GAAG,OAAO,CAO5E;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,gBAAgB,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,MAAM,EAAE,OAAO,GAAG,OAAO,CAiBjG;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,SAAS,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,MAAM,EAAE,OAAO,GAAG,OAAO,CAExE;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,oBAAoB,CAAC,OAAO,EAAE,OAAO,EAAE,MAAM,EAAE,OAAO,GAAG,OAAO,CAe/E;AAED;;;;;;GAMG;AACH,wBAAgB,YAAY,CAAC,OAAO,EAAE,OAAO,GAAG,MAAM,CAGrD;AAED;;;;;;;;GAQG;AACH,wBAAgB,cAAc,CAAC,MAAM,EAAE,OAAO,GAAG,MAAM,CAGtD;AAED;;;;;;;GAOG;AACH,wBAAgB,cAAc,CAAC,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,OAAO,GAAG,OAAO,CAQtE;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,OAAO,CAAC,EAAE,EAAE,OAAO,EAAE,EAAE,EAAE,OAAO,EAAE,EAAE,EAAE,OAAO,EAAE,MAAM,EAAE,OAAO,GAAG,OAAO,CAavF;AAED;;;;;;;GAOG;AACH,wBAAgB,SAAS,CAAC,MAAM,EAAE,OAAO,EAAE,EAAE,EAAE,OAAO,EAAE,EAAE,EAAE,OAAO,EAAE,EAAE,EAAE,OAAO,GAAG,IAAI,CAYtF;AAED;;;;;;GAMG;AACH,wBAAgB,0BAA0B,CAAC,kBAAkB,EAAE,OAAO,GAAG,MAAM,CAK9E;AAED;;;;;;;GAOG;AACH,wBAAgB,4BAA4B,CAAC,UAAU,EAAE,MAAM,EAAE,MAAM,EAAE,OAAO,GAAG,OAAO,CAMzF;AAED;;;;;;;;GAQG;AACH,wBAAgB,iBAAiB,CAC/B,OAAO,EAAE,WAAW,EACpB,OAAO,EAAE,WAAW,EACpB,YAAY,CAAC,EAAE,WAAW,GAAG,MAAM,EAAE,QA6BtC"}