@loaders.gl/math 4.0.0-alpha.9 → 4.0.0-beta.2

package/dist/es5/geometry/utils/coordinates.js

@@ -0,0 +1,10 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.emod = emod;
+function emod(n) {
+  return (n % 1 + 1) % 1;
+}
+//# sourceMappingURL=coordinates.js.map

package/dist/es5/geometry/utils/coordinates.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"coordinates.js","names":["emod","n"],"sources":["../../../../src/geometry/utils/coordinates.ts"],"sourcesContent":["/**\n * Handle UVs if they are out of range [0,1].\n * @param n\n */\nexport function emod(n: number): number {\n  return ((n % 1) + 1) % 1;\n}\n"],"mappings":";;;;;;AAIO,SAASA,IAAIA,CAACC,CAAS,EAAU;EACtC,OAAO,CAAEA,CAAC,GAAG,CAAC,GAAI,CAAC,IAAI,CAAC;AAC1B"}

package/dist/es5/index.js

@@ -52,6 +52,12 @@ Object.defineProperty(exports, "decompressTextureCoordinates", {
     return _attributeCompression.decompressTextureCoordinates;
   }
 });
+Object.defineProperty(exports, "emod", {
+  enumerable: true,
+  get: function get() {
+    return _coordinates.emod;
+  }
+});
 Object.defineProperty(exports, "encodeRGB565", {
   enumerable: true,
   get: function get() {
@@ -157,4 +163,5 @@ var _computeVertexNormals = require("./geometry/attributes/compute-vertex-normal
 var _rgb = require("./geometry/colors/rgb565");
 var _typedArrayUtils = require("./geometry/typed-arrays/typed-array-utils");
 var _attributeCompression = require("./geometry/compression/attribute-compression");
+var _coordinates = require("./geometry/utils/coordinates");
 //# sourceMappingURL=index.js.map

package/dist/es5/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","names":["_constants","require","_glType","_interopRequireDefault","_isGeometry","_attributeIterator","_primitiveIterator","_computeVertexNormals","_rgb","_typedArrayUtils","_attributeCompression"],"sources":["../../src/index.ts"],"sourcesContent":["export type TypedArrayConstructor =\n  | Int8ArrayConstructor\n  | Uint8ArrayConstructor\n  | Int16ArrayConstructor\n  | Uint16ArrayConstructor\n  | Int32ArrayConstructor\n  | Uint32ArrayConstructor\n  | Int32ArrayConstructor\n  | Uint32ArrayConstructor\n  | Float32ArrayConstructor\n  | Float64ArrayConstructor;\n\nexport {GL} from './geometry/constants';\n\n// GL support\nexport {GL_TYPE} from './geometry/constants';\nexport {default as GLType} from './geometry/gl/gl-type';\n\n// Geometry\nexport {default as isGeometry} from './geometry/is-geometry';\n\n// Iterators\nexport {makeAttributeIterator} from './geometry/iterators/attribute-iterator';\nexport {makePrimitiveIterator} from './geometry/iterators/primitive-iterator';\n\n// Helper methods\nexport {computeVertexNormals} from './geometry/attributes/compute-vertex-normals';\n\nexport {encodeRGB565, decodeRGB565} from './geometry/colors/rgb565';\n\n// Typed array utils\nexport {concatTypedArrays} from './geometry/typed-arrays/typed-array-utils';\n\n// Compression\nexport {\n  octEncodeInRange,\n  octEncode,\n  octEncodeToVector4,\n  octDecodeInRange,\n  octDecode,\n  octDecodeFromVector4,\n  octPackFloat,\n  octEncodeFloat,\n  octDecodeFloat,\n  octPack,\n  octUnpack,\n  compressTextureCoordinates,\n  decompressTextureCoordinates,\n  zigZagDeltaDecode\n} from './geometry/compression/attribute-compression';\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAYA,IAAAA,UAAA,GAAAC,OAAA;AAIA,IAAAC,OAAA,GAAAC,sBAAA,CAAAF,OAAA;AAGA,IAAAG,WAAA,GAAAD,sBAAA,CAAAF,OAAA;AAGA,IAAAI,kBAAA,GAAAJ,OAAA;AACA,IAAAK,kBAAA,GAAAL,OAAA;AAGA,IAAAM,qBAAA,GAAAN,OAAA;AAEA,IAAAO,IAAA,GAAAP,OAAA;AAGA,IAAAQ,gBAAA,GAAAR,OAAA;AAGA,IAAAS,qBAAA,GAAAT,OAAA"}
+{"version":3,"file":"index.js","names":["_constants","require","_glType","_interopRequireDefault","_isGeometry","_attributeIterator","_primitiveIterator","_computeVertexNormals","_rgb","_typedArrayUtils","_attributeCompression","_coordinates"],"sources":["../../src/index.ts"],"sourcesContent":["export type TypedArrayConstructor =\n  | Int8ArrayConstructor\n  | Uint8ArrayConstructor\n  | Int16ArrayConstructor\n  | Uint16ArrayConstructor\n  | Int32ArrayConstructor\n  | Uint32ArrayConstructor\n  | Int32ArrayConstructor\n  | Uint32ArrayConstructor\n  | Float32ArrayConstructor\n  | Float64ArrayConstructor;\n\nexport {GL} from './geometry/constants';\n\n// GL support\nexport {GL_TYPE} from './geometry/constants';\nexport {default as GLType} from './geometry/gl/gl-type';\n\n// Geometry\nexport {default as isGeometry} from './geometry/is-geometry';\n\n// Iterators\nexport {makeAttributeIterator} from './geometry/iterators/attribute-iterator';\nexport {makePrimitiveIterator} from './geometry/iterators/primitive-iterator';\n\n// Helper methods\nexport {computeVertexNormals} from './geometry/attributes/compute-vertex-normals';\n\nexport {encodeRGB565, decodeRGB565} from './geometry/colors/rgb565';\n\n// Typed array utils\nexport {concatTypedArrays} from './geometry/typed-arrays/typed-array-utils';\n\n// Compression\nexport {\n  octEncodeInRange,\n  octEncode,\n  octEncodeToVector4,\n  octDecodeInRange,\n  octDecode,\n  octDecodeFromVector4,\n  octPackFloat,\n  octEncodeFloat,\n  octDecodeFloat,\n  octPack,\n  octUnpack,\n  compressTextureCoordinates,\n  decompressTextureCoordinates,\n  zigZagDeltaDecode\n} from './geometry/compression/attribute-compression';\n\nexport {emod} from './geometry/utils/coordinates';\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAYA,IAAAA,UAAA,GAAAC,OAAA;AAIA,IAAAC,OAAA,GAAAC,sBAAA,CAAAF,OAAA;AAGA,IAAAG,WAAA,GAAAD,sBAAA,CAAAF,OAAA;AAGA,IAAAI,kBAAA,GAAAJ,OAAA;AACA,IAAAK,kBAAA,GAAAL,OAAA;AAGA,IAAAM,qBAAA,GAAAN,OAAA;AAEA,IAAAO,IAAA,GAAAP,OAAA;AAGA,IAAAQ,gBAAA,GAAAR,OAAA;AAGA,IAAAS,qBAAA,GAAAT,OAAA;AAiBA,IAAAU,YAAA,GAAAV,OAAA"}

package/dist/esm/geometry/utils/coordinates.js

@@ -0,0 +1,4 @@
+export function emod(n) {
+  return (n % 1 + 1) % 1;
+}
+//# sourceMappingURL=coordinates.js.map

package/dist/esm/geometry/utils/coordinates.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"coordinates.js","names":["emod","n"],"sources":["../../../../src/geometry/utils/coordinates.ts"],"sourcesContent":["/**\n * Handle UVs if they are out of range [0,1].\n * @param n\n */\nexport function emod(n: number): number {\n  return ((n % 1) + 1) % 1;\n}\n"],"mappings":"AAIA,OAAO,SAASA,IAAIA,CAACC,CAAS,EAAU;EACtC,OAAO,CAAEA,CAAC,GAAG,CAAC,GAAI,CAAC,IAAI,CAAC;AAC1B"}

package/dist/esm/index.js

@@ -8,4 +8,5 @@ export { computeVertexNormals } from './geometry/attributes/compute-vertex-norma
 export { encodeRGB565, decodeRGB565 } from './geometry/colors/rgb565';
 export { concatTypedArrays } from './geometry/typed-arrays/typed-array-utils';
 export { octEncodeInRange, octEncode, octEncodeToVector4, octDecodeInRange, octDecode, octDecodeFromVector4, octPackFloat, octEncodeFloat, octDecodeFloat, octPack, octUnpack, compressTextureCoordinates, decompressTextureCoordinates, zigZagDeltaDecode } from './geometry/compression/attribute-compression';
+export { emod } from './geometry/utils/coordinates';
 //# sourceMappingURL=index.js.map

package/dist/esm/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","names":["GL","GL_TYPE","default","GLType","isGeometry","makeAttributeIterator","makePrimitiveIterator","computeVertexNormals","encodeRGB565","decodeRGB565","concatTypedArrays","octEncodeInRange","octEncode","octEncodeToVector4","octDecodeInRange","octDecode","octDecodeFromVector4","octPackFloat","octEncodeFloat","octDecodeFloat","octPack","octUnpack","compressTextureCoordinates","decompressTextureCoordinates","zigZagDeltaDecode"],"sources":["../../src/index.ts"],"sourcesContent":["export type TypedArrayConstructor =\n  | Int8ArrayConstructor\n  | Uint8ArrayConstructor\n  | Int16ArrayConstructor\n  | Uint16ArrayConstructor\n  | Int32ArrayConstructor\n  | Uint32ArrayConstructor\n  | Int32ArrayConstructor\n  | Uint32ArrayConstructor\n  | Float32ArrayConstructor\n  | Float64ArrayConstructor;\n\nexport {GL} from './geometry/constants';\n\n// GL support\nexport {GL_TYPE} from './geometry/constants';\nexport {default as GLType} from './geometry/gl/gl-type';\n\n// Geometry\nexport {default as isGeometry} from './geometry/is-geometry';\n\n// Iterators\nexport {makeAttributeIterator} from './geometry/iterators/attribute-iterator';\nexport {makePrimitiveIterator} from './geometry/iterators/primitive-iterator';\n\n// Helper methods\nexport {computeVertexNormals} from './geometry/attributes/compute-vertex-normals';\n\nexport {encodeRGB565, decodeRGB565} from './geometry/colors/rgb565';\n\n// Typed array utils\nexport {concatTypedArrays} from './geometry/typed-arrays/typed-array-utils';\n\n// Compression\nexport {\n  octEncodeInRange,\n  octEncode,\n  octEncodeToVector4,\n  octDecodeInRange,\n  octDecode,\n  octDecodeFromVector4,\n  octPackFloat,\n  octEncodeFloat,\n  octDecodeFloat,\n  octPack,\n  octUnpack,\n  compressTextureCoordinates,\n  decompressTextureCoordinates,\n  zigZagDeltaDecode\n} from './geometry/compression/attribute-compression';\n"],"mappings":"AAYA,SAAQA,EAAE,QAAO,sBAAsB;AAGvC,SAAQC,OAAO,QAAO,sBAAsB;AAC5C,SAAQC,OAAO,IAAIC,MAAM,QAAO,uBAAuB;AAGvD,SAAQD,OAAO,IAAIE,UAAU,QAAO,wBAAwB;AAG5D,SAAQC,qBAAqB,QAAO,yCAAyC;AAC7E,SAAQC,qBAAqB,QAAO,yCAAyC;AAG7E,SAAQC,oBAAoB,QAAO,8CAA8C;AAEjF,SAAQC,YAAY,EAAEC,YAAY,QAAO,0BAA0B;AAGnE,SAAQC,iBAAiB,QAAO,2CAA2C;AAG3E,SACEC,gBAAgB,EAChBC,SAAS,EACTC,kBAAkB,EAClBC,gBAAgB,EAChBC,SAAS,EACTC,oBAAoB,EACpBC,YAAY,EACZC,cAAc,EACdC,cAAc,EACdC,OAAO,EACPC,SAAS,EACTC,0BAA0B,EAC1BC,4BAA4B,EAC5BC,iBAAiB,QACZ,8CAA8C"}
+{"version":3,"file":"index.js","names":["GL","GL_TYPE","default","GLType","isGeometry","makeAttributeIterator","makePrimitiveIterator","computeVertexNormals","encodeRGB565","decodeRGB565","concatTypedArrays","octEncodeInRange","octEncode","octEncodeToVector4","octDecodeInRange","octDecode","octDecodeFromVector4","octPackFloat","octEncodeFloat","octDecodeFloat","octPack","octUnpack","compressTextureCoordinates","decompressTextureCoordinates","zigZagDeltaDecode","emod"],"sources":["../../src/index.ts"],"sourcesContent":["export type TypedArrayConstructor =\n  | Int8ArrayConstructor\n  | Uint8ArrayConstructor\n  | Int16ArrayConstructor\n  | Uint16ArrayConstructor\n  | Int32ArrayConstructor\n  | Uint32ArrayConstructor\n  | Int32ArrayConstructor\n  | Uint32ArrayConstructor\n  | Float32ArrayConstructor\n  | Float64ArrayConstructor;\n\nexport {GL} from './geometry/constants';\n\n// GL support\nexport {GL_TYPE} from './geometry/constants';\nexport {default as GLType} from './geometry/gl/gl-type';\n\n// Geometry\nexport {default as isGeometry} from './geometry/is-geometry';\n\n// Iterators\nexport {makeAttributeIterator} from './geometry/iterators/attribute-iterator';\nexport {makePrimitiveIterator} from './geometry/iterators/primitive-iterator';\n\n// Helper methods\nexport {computeVertexNormals} from './geometry/attributes/compute-vertex-normals';\n\nexport {encodeRGB565, decodeRGB565} from './geometry/colors/rgb565';\n\n// Typed array utils\nexport {concatTypedArrays} from './geometry/typed-arrays/typed-array-utils';\n\n// Compression\nexport {\n  octEncodeInRange,\n  octEncode,\n  octEncodeToVector4,\n  octDecodeInRange,\n  octDecode,\n  octDecodeFromVector4,\n  octPackFloat,\n  octEncodeFloat,\n  octDecodeFloat,\n  octPack,\n  octUnpack,\n  compressTextureCoordinates,\n  decompressTextureCoordinates,\n  zigZagDeltaDecode\n} from './geometry/compression/attribute-compression';\n\nexport {emod} from './geometry/utils/coordinates';\n"],"mappings":"AAYA,SAAQA,EAAE,QAAO,sBAAsB;AAGvC,SAAQC,OAAO,QAAO,sBAAsB;AAC5C,SAAQC,OAAO,IAAIC,MAAM,QAAO,uBAAuB;AAGvD,SAAQD,OAAO,IAAIE,UAAU,QAAO,wBAAwB;AAG5D,SAAQC,qBAAqB,QAAO,yCAAyC;AAC7E,SAAQC,qBAAqB,QAAO,yCAAyC;AAG7E,SAAQC,oBAAoB,QAAO,8CAA8C;AAEjF,SAAQC,YAAY,EAAEC,YAAY,QAAO,0BAA0B;AAGnE,SAAQC,iBAAiB,QAAO,2CAA2C;AAG3E,SACEC,gBAAgB,EAChBC,SAAS,EACTC,kBAAkB,EAClBC,gBAAgB,EAChBC,SAAS,EACTC,oBAAoB,EACpBC,YAAY,EACZC,cAAc,EACdC,cAAc,EACdC,OAAO,EACPC,SAAS,EACTC,0BAA0B,EAC1BC,4BAA4B,EAC5BC,iBAAiB,QACZ,8CAA8C;AAErD,SAAQC,IAAI,QAAO,8BAA8B"}

package/dist/geometry/utils/coordinates.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Handle UVs if they are out of range [0,1].
+ * @param n
+ */
+export declare function emod(n: number): number;
+//# sourceMappingURL=coordinates.d.ts.map

package/dist/geometry/utils/coordinates.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"coordinates.d.ts","sourceRoot":"","sources":["../../../src/geometry/utils/coordinates.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,wBAAgB,IAAI,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM,CAEtC"}

package/dist/index.d.ts

@@ -9,4 +9,5 @@ export { computeVertexNormals } from './geometry/attributes/compute-vertex-norma
 export { encodeRGB565, decodeRGB565 } from './geometry/colors/rgb565';
 export { concatTypedArrays } from './geometry/typed-arrays/typed-array-utils';
 export { octEncodeInRange, octEncode, octEncodeToVector4, octDecodeInRange, octDecode, octDecodeFromVector4, octPackFloat, octEncodeFloat, octDecodeFloat, octPack, octUnpack, compressTextureCoordinates, decompressTextureCoordinates, zigZagDeltaDecode } from './geometry/compression/attribute-compression';
+export { emod } from './geometry/utils/coordinates';
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,qBAAqB,GAC7B,oBAAoB,GACpB,qBAAqB,GACrB,qBAAqB,GACrB,sBAAsB,GACtB,qBAAqB,GACrB,sBAAsB,GACtB,qBAAqB,GACrB,sBAAsB,GACtB,uBAAuB,GACvB,uBAAuB,CAAC;AAE5B,OAAO,EAAC,EAAE,EAAC,MAAM,sBAAsB,CAAC;AAGxC,OAAO,EAAC,OAAO,EAAC,MAAM,sBAAsB,CAAC;AAC7C,OAAO,EAAC,OAAO,IAAI,MAAM,EAAC,MAAM,uBAAuB,CAAC;AAGxD,OAAO,EAAC,OAAO,IAAI,UAAU,EAAC,MAAM,wBAAwB,CAAC;AAG7D,OAAO,EAAC,qBAAqB,EAAC,MAAM,yCAAyC,CAAC;AAC9E,OAAO,EAAC,qBAAqB,EAAC,MAAM,yCAAyC,CAAC;AAG9E,OAAO,EAAC,oBAAoB,EAAC,MAAM,8CAA8C,CAAC;AAElF,OAAO,EAAC,YAAY,EAAE,YAAY,EAAC,MAAM,0BAA0B,CAAC;AAGpE,OAAO,EAAC,iBAAiB,EAAC,MAAM,2CAA2C,CAAC;AAG5E,OAAO,EACL,gBAAgB,EAChB,SAAS,EACT,kBAAkB,EAClB,gBAAgB,EAChB,SAAS,EACT,oBAAoB,EACpB,YAAY,EACZ,cAAc,EACd,cAAc,EACd,OAAO,EACP,SAAS,EACT,0BAA0B,EAC1B,4BAA4B,EAC5B,iBAAiB,EAClB,MAAM,8CAA8C,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,qBAAqB,GAC7B,oBAAoB,GACpB,qBAAqB,GACrB,qBAAqB,GACrB,sBAAsB,GACtB,qBAAqB,GACrB,sBAAsB,GACtB,qBAAqB,GACrB,sBAAsB,GACtB,uBAAuB,GACvB,uBAAuB,CAAC;AAE5B,OAAO,EAAC,EAAE,EAAC,MAAM,sBAAsB,CAAC;AAGxC,OAAO,EAAC,OAAO,EAAC,MAAM,sBAAsB,CAAC;AAC7C,OAAO,EAAC,OAAO,IAAI,MAAM,EAAC,MAAM,uBAAuB,CAAC;AAGxD,OAAO,EAAC,OAAO,IAAI,UAAU,EAAC,MAAM,wBAAwB,CAAC;AAG7D,OAAO,EAAC,qBAAqB,EAAC,MAAM,yCAAyC,CAAC;AAC9E,OAAO,EAAC,qBAAqB,EAAC,MAAM,yCAAyC,CAAC;AAG9E,OAAO,EAAC,oBAAoB,EAAC,MAAM,8CAA8C,CAAC;AAElF,OAAO,EAAC,YAAY,EAAE,YAAY,EAAC,MAAM,0BAA0B,CAAC;AAGpE,OAAO,EAAC,iBAAiB,EAAC,MAAM,2CAA2C,CAAC;AAG5E,OAAO,EACL,gBAAgB,EAChB,SAAS,EACT,kBAAkB,EAClB,gBAAgB,EAChB,SAAS,EACT,oBAAoB,EACpB,YAAY,EACZ,cAAc,EACd,cAAc,EACd,OAAO,EACP,SAAS,EACT,0BAA0B,EAC1B,4BAA4B,EAC5B,iBAAiB,EAClB,MAAM,8CAA8C,CAAC;AAEtD,OAAO,EAAC,IAAI,EAAC,MAAM,8BAA8B,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@loaders.gl/math",
-  "version": "4.0.0-alpha.9",
+  "version": "4.0.0-beta.2",
   "description": "Experimental math classes for loaders.gl",
   "license": "MIT",
   "publishConfig": {
@@ -31,9 +31,9 @@
     "pre-build": "echo \"Nothing to build in @loaders.gl/math\""
   },
   "dependencies": {
-    "@loaders.gl/images": "4.0.0-alpha.9",
-    "@loaders.gl/loader-utils": "4.0.0-alpha.9",
+    "@loaders.gl/images": "4.0.0-beta.2",
+    "@loaders.gl/loader-utils": "4.0.0-beta.2",
     "@math.gl/core": "^3.5.1"
   },
-  "gitHead": "03ff81ab468f20f3bddeec787aa88d477a7e1c72"
+  "gitHead": "79c2033f755e88e11bc30a04428e3666b177b8fc"
 }

package/src/geometry/utils/coordinates.ts

@@ -0,0 +1,7 @@
+/**
+ * Handle UVs if they are out of range [0,1].
+ * @param n
+ */
+export function emod(n: number): number {
+  return ((n % 1) + 1) % 1;
+}

package/src/index.ts

@@ -48,3 +48,5 @@ export {
   decompressTextureCoordinates,
   zigZagDeltaDecode
 } from './geometry/compression/attribute-compression';
+
+export {emod} from './geometry/utils/coordinates';

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

@@ -1,44 +0,0 @@
-"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.js

@@ -1,30 +0,0 @@
-"use strict";
-/* eslint-disable */
-/**
-import {getPositions} from './get-attribute-from-geometry';
-
-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.js

@@ -1,146 +0,0 @@
-"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.js

@@ -1,48 +0,0 @@
-"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.js

@@ -1,33 +0,0 @@
-"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.js

@@ -1,34 +0,0 @@
-"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.js

@@ -1,20 +0,0 @@
-"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.js

@@ -1,31 +0,0 @@
-"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;