@loaders.gl/math 3.3.0-alpha.5 → 3.3.0-alpha.7

package/dist/es5/index.js

@@ -1,7 +1,6 @@
 "use strict";
 
 var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
-
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
@@ -11,34 +10,22 @@ Object.defineProperty(exports, "GL", {
     return _constants.GL;
   }
 });
-Object.defineProperty(exports, "GL_TYPE", {
-  enumerable: true,
-  get: function get() {
-    return _constants.GL_TYPE;
-  }
-});
 Object.defineProperty(exports, "GLType", {
   enumerable: true,
   get: function get() {
     return _glType.default;
   }
 });
-Object.defineProperty(exports, "isGeometry", {
-  enumerable: true,
-  get: function get() {
-    return _isGeometry.default;
-  }
-});
-Object.defineProperty(exports, "makeAttributeIterator", {
+Object.defineProperty(exports, "GL_TYPE", {
   enumerable: true,
   get: function get() {
-    return _attributeIterator.makeAttributeIterator;
+    return _constants.GL_TYPE;
   }
 });
-Object.defineProperty(exports, "makePrimitiveIterator", {
+Object.defineProperty(exports, "compressTextureCoordinates", {
   enumerable: true,
   get: function get() {
-    return _primitiveIterator.makePrimitiveIterator;
+    return _attributeCompression.compressTextureCoordinates;
   }
 });
 Object.defineProperty(exports, "computeVertexNormals", {
@@ -47,10 +34,10 @@ Object.defineProperty(exports, "computeVertexNormals", {
     return _computeVertexNormals.computeVertexNormals;
   }
 });
-Object.defineProperty(exports, "encodeRGB565", {
+Object.defineProperty(exports, "concatTypedArrays", {
   enumerable: true,
   get: function get() {
-    return _rgb.encodeRGB565;
+    return _typedArrayUtils.concatTypedArrays;
   }
 });
 Object.defineProperty(exports, "decodeRGB565", {
@@ -59,34 +46,34 @@ Object.defineProperty(exports, "decodeRGB565", {
     return _rgb.decodeRGB565;
   }
 });
-Object.defineProperty(exports, "concatTypedArrays", {
+Object.defineProperty(exports, "decompressTextureCoordinates", {
   enumerable: true,
   get: function get() {
-    return _typedArrayUtils.concatTypedArrays;
+    return _attributeCompression.decompressTextureCoordinates;
   }
 });
-Object.defineProperty(exports, "octEncodeInRange", {
+Object.defineProperty(exports, "encodeRGB565", {
   enumerable: true,
   get: function get() {
-    return _attributeCompression.octEncodeInRange;
+    return _rgb.encodeRGB565;
   }
 });
-Object.defineProperty(exports, "octEncode", {
+Object.defineProperty(exports, "isGeometry", {
   enumerable: true,
   get: function get() {
-    return _attributeCompression.octEncode;
+    return _isGeometry.default;
   }
 });
-Object.defineProperty(exports, "octEncodeToVector4", {
+Object.defineProperty(exports, "makeAttributeIterator", {
   enumerable: true,
   get: function get() {
-    return _attributeCompression.octEncodeToVector4;
+    return _attributeIterator.makeAttributeIterator;
   }
 });
-Object.defineProperty(exports, "octDecodeInRange", {
+Object.defineProperty(exports, "makePrimitiveIterator", {
   enumerable: true,
   get: function get() {
-    return _attributeCompression.octDecodeInRange;
+    return _primitiveIterator.makePrimitiveIterator;
   }
 });
 Object.defineProperty(exports, "octDecode", {
@@ -95,16 +82,28 @@ Object.defineProperty(exports, "octDecode", {
     return _attributeCompression.octDecode;
   }
 });
+Object.defineProperty(exports, "octDecodeFloat", {
+  enumerable: true,
+  get: function get() {
+    return _attributeCompression.octDecodeFloat;
+  }
+});
 Object.defineProperty(exports, "octDecodeFromVector4", {
   enumerable: true,
   get: function get() {
     return _attributeCompression.octDecodeFromVector4;
   }
 });
-Object.defineProperty(exports, "octPackFloat", {
+Object.defineProperty(exports, "octDecodeInRange", {
   enumerable: true,
   get: function get() {
-    return _attributeCompression.octPackFloat;
+    return _attributeCompression.octDecodeInRange;
+  }
+});
+Object.defineProperty(exports, "octEncode", {
+  enumerable: true,
+  get: function get() {
+    return _attributeCompression.octEncode;
   }
 });
 Object.defineProperty(exports, "octEncodeFloat", {
@@ -113,34 +112,34 @@ Object.defineProperty(exports, "octEncodeFloat", {
     return _attributeCompression.octEncodeFloat;
   }
 });
-Object.defineProperty(exports, "octDecodeFloat", {
+Object.defineProperty(exports, "octEncodeInRange", {
   enumerable: true,
   get: function get() {
-    return _attributeCompression.octDecodeFloat;
+    return _attributeCompression.octEncodeInRange;
   }
 });
-Object.defineProperty(exports, "octPack", {
+Object.defineProperty(exports, "octEncodeToVector4", {
   enumerable: true,
   get: function get() {
-    return _attributeCompression.octPack;
+    return _attributeCompression.octEncodeToVector4;
   }
 });
-Object.defineProperty(exports, "octUnpack", {
+Object.defineProperty(exports, "octPack", {
   enumerable: true,
   get: function get() {
-    return _attributeCompression.octUnpack;
+    return _attributeCompression.octPack;
   }
 });
-Object.defineProperty(exports, "compressTextureCoordinates", {
+Object.defineProperty(exports, "octPackFloat", {
   enumerable: true,
   get: function get() {
-    return _attributeCompression.compressTextureCoordinates;
+    return _attributeCompression.octPackFloat;
   }
 });
-Object.defineProperty(exports, "decompressTextureCoordinates", {
+Object.defineProperty(exports, "octUnpack", {
   enumerable: true,
   get: function get() {
-    return _attributeCompression.decompressTextureCoordinates;
+    return _attributeCompression.octUnpack;
   }
 });
 Object.defineProperty(exports, "zigZagDeltaDecode", {
@@ -149,22 +148,13 @@ Object.defineProperty(exports, "zigZagDeltaDecode", {
     return _attributeCompression.zigZagDeltaDecode;
   }
 });
-
 var _constants = require("./geometry/constants");
-
 var _glType = _interopRequireDefault(require("./geometry/gl/gl-type"));
-
 var _isGeometry = _interopRequireDefault(require("./geometry/is-geometry"));
-
 var _attributeIterator = require("./geometry/iterators/attribute-iterator");
-
 var _primitiveIterator = require("./geometry/iterators/primitive-iterator");
-
 var _computeVertexNormals = require("./geometry/attributes/compute-vertex-normals");
-
 var _rgb = require("./geometry/colors/rgb565");
-
 var _typedArrayUtils = require("./geometry/typed-arrays/typed-array-utils");
-
 var _attributeCompression = require("./geometry/compression/attribute-compression");
 //# sourceMappingURL=index.js.map

package/dist/es5/index.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../src/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;;AAIA;;AAGA;;AAGA;;AACA;;AAGA;;AAEA;;AAGA;;AAGA","sourcesContent":["export {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"],"file":"index.js"}
+{"version":3,"file":"index.js","names":[],"sources":["../../src/index.ts"],"sourcesContent":["export {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":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAIA;AAGA;AAGA;AACA;AAGA;AAEA;AAGA;AAGA"}

package/dist/es5/utils/assert.js

@@ -4,7 +4,6 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.assert = assert;
-
 function assert(condition, message) {
   if (!condition) {
     throw new Error(message || '3d-tile loader: assertion failed.');

package/dist/es5/utils/assert.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../src/utils/assert.ts"],"names":["assert","condition","message","Error"],"mappings":";;;;;;;AAGO,SAASA,MAAT,CAAgBC,SAAhB,EAAoCC,OAApC,EAA4D;AACjE,MAAI,CAACD,SAAL,EAAgB;AACd,UAAM,IAAIE,KAAJ,CAAUD,OAAO,IAAI,mCAArB,CAAN;AACD;AACF","sourcesContent":["// Replacement for the external assert method to reduce bundle size\n// Note: We don't use the second \"message\" argument in calling code,\n// so no need to support it here\nexport function assert(condition: Boolean, message?: string): void {\n  if (!condition) {\n    throw new Error(message || '3d-tile loader: assertion failed.');\n  }\n}\n"],"file":"assert.js"}
+{"version":3,"file":"assert.js","names":["assert","condition","message","Error"],"sources":["../../../src/utils/assert.ts"],"sourcesContent":["// Replacement for the external assert method to reduce bundle size\n// Note: We don't use the second \"message\" argument in calling code,\n// so no need to support it here\nexport function assert(condition: Boolean, message?: string): void {\n  if (!condition) {\n    throw new Error(message || '3d-tile loader: assertion failed.');\n  }\n}\n"],"mappings":";;;;;;AAGO,SAASA,MAAM,CAACC,SAAkB,EAAEC,OAAgB,EAAQ;EACjE,IAAI,CAACD,SAAS,EAAE;IACd,MAAM,IAAIE,KAAK,CAACD,OAAO,IAAI,mCAAmC,CAAC;EACjE;AACF"}

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

@@ -1,9 +1,10 @@
 import { makeAttributeIterator } from '../iterators/attribute-iterator';
 import { assert } from '../utils/assert';
-export function computeBoundingBox(positions = []) {
+
+export function computeBoundingBox() {
+  let positions = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];
   const min = [Number(Infinity), Number(Infinity), Number(Infinity)];
   const max = [-Infinity, -Infinity, -Infinity];
-
   for (const position of makeAttributeIterator(positions)) {
     const x = position[0];
     const y = position[1];
@@ -15,7 +16,6 @@ export function computeBoundingBox(positions = []) {
     if (y > max[1]) max[1] = y;
     if (z > max[2]) max[2] = z;
   }
-
   const boundingBox = {
     min,
     max
@@ -23,7 +23,6 @@ export function computeBoundingBox(positions = []) {
   validateBoundingBox(boundingBox);
   return boundingBox;
 }
-
 function validateBoundingBox(boundingBox) {
   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/esm/geometry/attributes/compute-bounding-box.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../../src/geometry/attributes/compute-bounding-box.ts"],"names":["makeAttributeIterator","assert","computeBoundingBox","positions","min","Number","Infinity","max","position","x","y","z","boundingBox","validateBoundingBox","isFinite"],"mappings":"AAAA,SAAQA,qBAAR,QAAoC,iCAApC;AACA,SAAQC,MAAR,QAAqB,iBAArB;AAcA,OAAO,SAASC,kBAAT,CAA4BC,SAAc,GAAG,EAA7C,EAAiD;AACtD,QAAMC,GAAG,GAAG,CAACC,MAAM,CAACC,QAAD,CAAP,EAAmBD,MAAM,CAACC,QAAD,CAAzB,EAAqCD,MAAM,CAACC,QAAD,CAA3C,CAAZ;AACA,QAAMC,GAAG,GAAG,CAAC,CAACD,QAAF,EAAY,CAACA,QAAb,EAAuB,CAACA,QAAxB,CAAZ;;AAEA,OAAK,MAAME,QAAX,IAAuBR,qBAAqB,CAACG,SAAD,CAA5C,EAAyD;AACvD,UAAMM,CAAC,GAAGD,QAAQ,CAAC,CAAD,CAAlB;AACA,UAAME,CAAC,GAAGF,QAAQ,CAAC,CAAD,CAAlB;AACA,UAAMG,CAAC,GAAGH,QAAQ,CAAC,CAAD,CAAlB;AAEA,QAAIC,CAAC,GAAGL,GAAG,CAAC,CAAD,CAAX,EAAgBA,GAAG,CAAC,CAAD,CAAH,GAASK,CAAT;AAChB,QAAIC,CAAC,GAAGN,GAAG,CAAC,CAAD,CAAX,EAAgBA,GAAG,CAAC,CAAD,CAAH,GAASM,CAAT;AAChB,QAAIC,CAAC,GAAGP,GAAG,CAAC,CAAD,CAAX,EAAgBA,GAAG,CAAC,CAAD,CAAH,GAASO,CAAT;AAEhB,QAAIF,CAAC,GAAGF,GAAG,CAAC,CAAD,CAAX,EAAgBA,GAAG,CAAC,CAAD,CAAH,GAASE,CAAT;AAChB,QAAIC,CAAC,GAAGH,GAAG,CAAC,CAAD,CAAX,EAAgBA,GAAG,CAAC,CAAD,CAAH,GAASG,CAAT;AAChB,QAAIC,CAAC,GAAGJ,GAAG,CAAC,CAAD,CAAX,EAAgBA,GAAG,CAAC,CAAD,CAAH,GAASI,CAAT;AACjB;;AAED,QAAMC,WAAW,GAAG;AAACR,IAAAA,GAAD;AAAMG,IAAAA;AAAN,GAApB;AACAM,EAAAA,mBAAmB,CAACD,WAAD,CAAnB;AACA,SAAOA,WAAP;AACD;;AAED,SAASC,mBAAT,CAA6BD,WAA7B,EAAuD;AACrDX,EAAAA,MAAM,CACJI,MAAM,CAACS,QAAP,CAAgBF,WAAW,CAACR,GAAZ,CAAgB,CAAhB,CAAhB,KACEC,MAAM,CAACS,QAAP,CAAgBF,WAAW,CAACR,GAAZ,CAAgB,CAAhB,CAAhB,CADF,IAEEC,MAAM,CAACS,QAAP,CAAgBF,WAAW,CAACR,GAAZ,CAAgB,CAAhB,CAAhB,CAFF,IAGEC,MAAM,CAACS,QAAP,CAAgBF,WAAW,CAACL,GAAZ,CAAgB,CAAhB,CAAhB,CAHF,IAIEF,MAAM,CAACS,QAAP,CAAgBF,WAAW,CAACL,GAAZ,CAAgB,CAAhB,CAAhB,CAJF,IAKEF,MAAM,CAACS,QAAP,CAAgBF,WAAW,CAACL,GAAZ,CAAgB,CAAhB,CAAhB,CANE,CAAN;AAQD","sourcesContent":["import {makeAttributeIterator} from '../iterators/attribute-iterator';\nimport {assert} from '../utils/assert';\n\n/**\n * Type for Bounding Box computing\n */\ntype BoundingBox = {\n  min: number[];\n  max: number[];\n};\n/**\n * Getting bounding box geometry according to positions parameters\n * @param positions\n * @returns Bounding Box\n */\nexport function computeBoundingBox(positions: any = []) {\n  const min = [Number(Infinity), Number(Infinity), Number(Infinity)];\n  const max = [-Infinity, -Infinity, -Infinity];\n  // @ts-ignore\n  for (const position of makeAttributeIterator(positions)) {\n    const x = position[0];\n    const y = position[1];\n    const z = position[2];\n\n    if (x < min[0]) min[0] = x;\n    if (y < min[1]) min[1] = y;\n    if (z < min[2]) min[2] = z;\n\n    if (x > max[0]) max[0] = x;\n    if (y > max[1]) max[1] = y;\n    if (z > max[2]) max[2] = z;\n  }\n\n  const boundingBox = {min, max};\n  validateBoundingBox(boundingBox);\n  return boundingBox;\n}\n\nfunction validateBoundingBox(boundingBox: BoundingBox) {\n  assert(\n    Number.isFinite(boundingBox.min[0]) &&\n      Number.isFinite(boundingBox.min[1]) &&\n      Number.isFinite(boundingBox.min[2]) &&\n      Number.isFinite(boundingBox.max[0]) &&\n      Number.isFinite(boundingBox.max[1]) &&\n      Number.isFinite(boundingBox.max[2])\n  );\n}\n"],"file":"compute-bounding-box.js"}
+{"version":3,"file":"compute-bounding-box.js","names":["makeAttributeIterator","assert","computeBoundingBox","positions","min","Number","Infinity","max","position","x","y","z","boundingBox","validateBoundingBox","isFinite"],"sources":["../../../../src/geometry/attributes/compute-bounding-box.ts"],"sourcesContent":["import {makeAttributeIterator} from '../iterators/attribute-iterator';\nimport {assert} from '../utils/assert';\n\n/**\n * Type for Bounding Box computing\n */\ntype BoundingBox = {\n  min: number[];\n  max: number[];\n};\n/**\n * Getting bounding box geometry according to positions parameters\n * @param positions\n * @returns Bounding Box\n */\nexport function computeBoundingBox(positions: any = []) {\n  const min = [Number(Infinity), Number(Infinity), Number(Infinity)];\n  const max = [-Infinity, -Infinity, -Infinity];\n  // @ts-ignore\n  for (const position of makeAttributeIterator(positions)) {\n    const x = position[0];\n    const y = position[1];\n    const z = position[2];\n\n    if (x < min[0]) min[0] = x;\n    if (y < min[1]) min[1] = y;\n    if (z < min[2]) min[2] = z;\n\n    if (x > max[0]) max[0] = x;\n    if (y > max[1]) max[1] = y;\n    if (z > max[2]) max[2] = z;\n  }\n\n  const boundingBox = {min, max};\n  validateBoundingBox(boundingBox);\n  return boundingBox;\n}\n\nfunction validateBoundingBox(boundingBox: BoundingBox) {\n  assert(\n    Number.isFinite(boundingBox.min[0]) &&\n      Number.isFinite(boundingBox.min[1]) &&\n      Number.isFinite(boundingBox.min[2]) &&\n      Number.isFinite(boundingBox.max[0]) &&\n      Number.isFinite(boundingBox.max[1]) &&\n      Number.isFinite(boundingBox.max[2])\n  );\n}\n"],"mappings":"AAAA,SAAQA,qBAAqB,QAAO,iCAAiC;AACrE,SAAQC,MAAM,QAAO,iBAAiB;;AActC,OAAO,SAASC,kBAAkB,GAAsB;EAAA,IAArBC,SAAc,uEAAG,EAAE;EACpD,MAAMC,GAAG,GAAG,CAACC,MAAM,CAACC,QAAQ,CAAC,EAAED,MAAM,CAACC,QAAQ,CAAC,EAAED,MAAM,CAACC,QAAQ,CAAC,CAAC;EAClE,MAAMC,GAAG,GAAG,CAAC,CAACD,QAAQ,EAAE,CAACA,QAAQ,EAAE,CAACA,QAAQ,CAAC;EAE7C,KAAK,MAAME,QAAQ,IAAIR,qBAAqB,CAACG,SAAS,CAAC,EAAE;IACvD,MAAMM,CAAC,GAAGD,QAAQ,CAAC,CAAC,CAAC;IACrB,MAAME,CAAC,GAAGF,QAAQ,CAAC,CAAC,CAAC;IACrB,MAAMG,CAAC,GAAGH,QAAQ,CAAC,CAAC,CAAC;IAErB,IAAIC,CAAC,GAAGL,GAAG,CAAC,CAAC,CAAC,EAAEA,GAAG,CAAC,CAAC,CAAC,GAAGK,CAAC;IAC1B,IAAIC,CAAC,GAAGN,GAAG,CAAC,CAAC,CAAC,EAAEA,GAAG,CAAC,CAAC,CAAC,GAAGM,CAAC;IAC1B,IAAIC,CAAC,GAAGP,GAAG,CAAC,CAAC,CAAC,EAAEA,GAAG,CAAC,CAAC,CAAC,GAAGO,CAAC;IAE1B,IAAIF,CAAC,GAAGF,GAAG,CAAC,CAAC,CAAC,EAAEA,GAAG,CAAC,CAAC,CAAC,GAAGE,CAAC;IAC1B,IAAIC,CAAC,GAAGH,GAAG,CAAC,CAAC,CAAC,EAAEA,GAAG,CAAC,CAAC,CAAC,GAAGG,CAAC;IAC1B,IAAIC,CAAC,GAAGJ,GAAG,CAAC,CAAC,CAAC,EAAEA,GAAG,CAAC,CAAC,CAAC,GAAGI,CAAC;EAC5B;EAEA,MAAMC,WAAW,GAAG;IAACR,GAAG;IAAEG;EAAG,CAAC;EAC9BM,mBAAmB,CAACD,WAAW,CAAC;EAChC,OAAOA,WAAW;AACpB;AAEA,SAASC,mBAAmB,CAACD,WAAwB,EAAE;EACrDX,MAAM,CACJI,MAAM,CAACS,QAAQ,CAACF,WAAW,CAACR,GAAG,CAAC,CAAC,CAAC,CAAC,IACjCC,MAAM,CAACS,QAAQ,CAACF,WAAW,CAACR,GAAG,CAAC,CAAC,CAAC,CAAC,IACnCC,MAAM,CAACS,QAAQ,CAACF,WAAW,CAACR,GAAG,CAAC,CAAC,CAAC,CAAC,IACnCC,MAAM,CAACS,QAAQ,CAACF,WAAW,CAACL,GAAG,CAAC,CAAC,CAAC,CAAC,IACnCF,MAAM,CAACS,QAAQ,CAACF,WAAW,CAACL,GAAG,CAAC,CAAC,CAAC,CAAC,IACnCF,MAAM,CAACS,QAAQ,CAACF,WAAW,CAACL,GAAG,CAAC,CAAC,CAAC,CAAC,CACtC;AACH"}

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

@@ -1 +1 @@
-{"version":3,"sources":[],"names":[],"mappings":"","sourcesContent":[],"file":"compute-bounding-sphere.js"}
+{"version":3,"file":"compute-bounding-sphere.js","names":[],"sources":["../../../../src/geometry/attributes/compute-bounding-sphere.ts"],"sourcesContent":["/* eslint-disable */\n/**\nimport {getPositions} from './get-attribute-from-geometry';\n\nexport function computeBoundingSphere(geometry: any, boundingBox: object, vector: Vector3 ) {\n  const positions = getPositions(geometry);\n\n  const center = getBoundingBox(center);\n  box.setFromBufferAttribute(position);\n  box.getCenter(center);\n\n  // hoping to find a boundingSphere with a radius smaller than the\n  // boundingSphere of the boundingBox: sqrt(3) smaller in the best case\n\n  var maxRadiusSq = 0;\n\n  for (const position of makeAttributeIterator(positions)) {\n    vector.x = position[0];\n    vector.y = position[1];\n    vector.z = position[2];\n    maxRadiusSq = Math.max(maxRadiusSq, center.distanceToSquared(vector));\n  }\n\n  const radius = Math.sqrt(maxRadiusSq);\n  assert(Number.isFinite(radius));\n\n  return {center, radius};\n}\n*/\n"],"mappings":""}

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

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

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

@@ -15,7 +15,6 @@ export function computeVertexNormals(geometry) {
   const vectorC = new Vector3();
   const vectorCB = new Vector3();
   const vectorAB = new Vector3();
-
   for (const primitive of makePrimitiveIterator(geometry)) {
     vectorA.fromArray(positions, primitive.i1 * 3);
     vectorB.fromArray(positions, primitive.i2 * 3 + 3);
@@ -37,7 +36,6 @@ export function computeVertexNormals(geometry) {
     normals[primitiveIndex * 9 + 7] = normal.y;
     normals[primitiveIndex * 9 + 8] = normal.z;
   }
-
   return normals;
 }
 //# sourceMappingURL=compute-vertex-normals.js.map

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

@@ -1 +1 @@
-{"version":3,"sources":["../../../../src/geometry/attributes/compute-vertex-normals.ts"],"names":["Vector3","GL","assert","makePrimitiveIterator","getPrimitiveModeType","getPositions","computeVertexNormals","geometry","mode","TRIANGLES","values","positions","normals","Float32Array","length","vectorA","vectorB","vectorC","vectorCB","vectorAB","primitive","fromArray","i1","i2","i3","subVectors","normal","cross","normalize","primitiveIndex","x","y","z"],"mappings":"AACA,SAAQA,OAAR,QAAsB,eAAtB;AACA,SAAQC,EAAR,QAAiB,cAAjB;AACA,SAAQC,MAAR,QAAqB,iBAArB;AACA,SAAQC,qBAAR,QAAoC,iCAApC;AACA,SAAQC,oBAAR,QAAmC,qBAAnC;AACA,SAAQC,YAAR,QAA2B,+BAA3B;AAaA,OAAO,SAASC,oBAAT,CAA8BC,QAA9B,EAAgE;AAErEL,EAAAA,MAAM,CAACE,oBAAoB,CAACG,QAAQ,CAACC,IAAV,CAApB,KAAwCP,EAAE,CAACQ,SAA5C,EAAuD,oBAAvD,CAAN;AAEA,QAAM;AAACC,IAAAA,MAAM,EAAEC;AAAT,MAAsBN,YAAY,CAACE,QAAD,CAAxC;AAEA,QAAMK,OAAO,GAAG,IAAIC,YAAJ,CAAiBF,SAAS,CAACG,MAA3B,CAAhB;AAEA,QAAMC,OAAO,GAAG,IAAIf,OAAJ,EAAhB;AACA,QAAMgB,OAAO,GAAG,IAAIhB,OAAJ,EAAhB;AACA,QAAMiB,OAAO,GAAG,IAAIjB,OAAJ,EAAhB;AAEA,QAAMkB,QAAQ,GAAG,IAAIlB,OAAJ,EAAjB;AACA,QAAMmB,QAAQ,GAAG,IAAInB,OAAJ,EAAjB;;AAEA,OAAK,MAAMoB,SAAX,IAAwBjB,qBAAqB,CAACI,QAAD,CAA7C,EAAyD;AACvDQ,IAAAA,OAAO,CAACM,SAAR,CAAkBV,SAAlB,EAA6BS,SAAS,CAACE,EAAV,GAAe,CAA5C;AACAN,IAAAA,OAAO,CAACK,SAAR,CAAkBV,SAAlB,EAA6BS,SAAS,CAACG,EAAV,GAAe,CAAf,GAAmB,CAAhD;AACAN,IAAAA,OAAO,CAACI,SAAR,CAAkBV,SAAlB,EAA6BS,SAAS,CAACI,EAAV,GAAe,CAAf,GAAmB,CAAhD;AAEAN,IAAAA,QAAQ,CAACO,UAAT,CAAoBR,OAApB,EAA6BD,OAA7B;AACAG,IAAAA,QAAQ,CAACM,UAAT,CAAoBV,OAApB,EAA6BC,OAA7B;AACA,UAAMU,MAAM,GAAGR,QAAQ,CAACS,KAAT,CAAeR,QAAf,CAAf;AACAO,IAAAA,MAAM,CAACE,SAAP;AAEA,UAAM;AAACC,MAAAA;AAAD,QAAmBT,SAAzB;AAEAR,IAAAA,OAAO,CAACiB,cAAc,GAAG,CAAjB,GAAqB,CAAtB,CAAP,GAAkCH,MAAM,CAACI,CAAzC;AACAlB,IAAAA,OAAO,CAACiB,cAAc,GAAG,CAAjB,GAAqB,CAAtB,CAAP,GAAkCH,MAAM,CAACK,CAAzC;AACAnB,IAAAA,OAAO,CAACiB,cAAc,GAAG,CAAjB,GAAqB,CAAtB,CAAP,GAAkCH,MAAM,CAACM,CAAzC;AAEApB,IAAAA,OAAO,CAACiB,cAAc,GAAG,CAAjB,GAAqB,CAAtB,CAAP,GAAkCH,MAAM,CAACI,CAAzC;AACAlB,IAAAA,OAAO,CAACiB,cAAc,GAAG,CAAjB,GAAqB,CAAtB,CAAP,GAAkCH,MAAM,CAACK,CAAzC;AACAnB,IAAAA,OAAO,CAACiB,cAAc,GAAG,CAAjB,GAAqB,CAAtB,CAAP,GAAkCH,MAAM,CAACM,CAAzC;AAEApB,IAAAA,OAAO,CAACiB,cAAc,GAAG,CAAjB,GAAqB,CAAtB,CAAP,GAAkCH,MAAM,CAACI,CAAzC;AACAlB,IAAAA,OAAO,CAACiB,cAAc,GAAG,CAAjB,GAAqB,CAAtB,CAAP,GAAkCH,MAAM,CAACK,CAAzC;AACAnB,IAAAA,OAAO,CAACiB,cAAc,GAAG,CAAjB,GAAqB,CAAtB,CAAP,GAAkCH,MAAM,CAACM,CAAzC;AACD;;AAED,SAAOpB,OAAP;AACD","sourcesContent":["import type {TypedArray} from '@math.gl/core';\nimport {Vector3} from '@math.gl/core';\nimport {GL} from '../constants';\nimport {assert} from '../utils/assert';\nimport {makePrimitiveIterator} from '../iterators/primitive-iterator';\nimport {getPrimitiveModeType} from '../primitives/modes';\nimport {getPositions} from './get-attribute-from-geometry';\n\ntype Geometry = {\n  mode: any;\n  indices?: {size: number; values: TypedArray};\n  attributes?: {};\n};\n/**\n * Computes vertex normals for a geometry\n * @param param0\n * @returns\n */\n// eslint-disable-next-line max-statements\nexport function computeVertexNormals(geometry: Geometry): Float32Array {\n  // Only support GL.TRIANGLES, GL.TRIANGLE_STRIP, GL.TRIANGLE_FAN\n  assert(getPrimitiveModeType(geometry.mode) === GL.TRIANGLES, 'TRIANGLES required');\n\n  const {values: positions} = getPositions(geometry);\n\n  const normals = new Float32Array(positions.length);\n\n  const vectorA = new Vector3();\n  const vectorB = new Vector3();\n  const vectorC = new Vector3();\n\n  const vectorCB = new Vector3();\n  const vectorAB = new Vector3();\n\n  for (const primitive of makePrimitiveIterator(geometry)) {\n    vectorA.fromArray(positions, primitive.i1 * 3);\n    vectorB.fromArray(positions, primitive.i2 * 3 + 3);\n    vectorC.fromArray(positions, primitive.i3 * 3 + 6);\n\n    vectorCB.subVectors(vectorC, vectorB);\n    vectorAB.subVectors(vectorA, vectorB);\n    const normal = vectorCB.cross(vectorAB);\n    normal.normalize();\n    // @ts-ignore\n    const {primitiveIndex} = primitive;\n\n    normals[primitiveIndex * 9 + 0] = normal.x;\n    normals[primitiveIndex * 9 + 1] = normal.y;\n    normals[primitiveIndex * 9 + 2] = normal.z;\n\n    normals[primitiveIndex * 9 + 3] = normal.x;\n    normals[primitiveIndex * 9 + 4] = normal.y;\n    normals[primitiveIndex * 9 + 5] = normal.z;\n\n    normals[primitiveIndex * 9 + 6] = normal.x;\n    normals[primitiveIndex * 9 + 7] = normal.y;\n    normals[primitiveIndex * 9 + 8] = normal.z;\n  }\n\n  return normals;\n}\n"],"file":"compute-vertex-normals.js"}
+{"version":3,"file":"compute-vertex-normals.js","names":["Vector3","GL","assert","makePrimitiveIterator","getPrimitiveModeType","getPositions","computeVertexNormals","geometry","mode","TRIANGLES","values","positions","normals","Float32Array","length","vectorA","vectorB","vectorC","vectorCB","vectorAB","primitive","fromArray","i1","i2","i3","subVectors","normal","cross","normalize","primitiveIndex","x","y","z"],"sources":["../../../../src/geometry/attributes/compute-vertex-normals.ts"],"sourcesContent":["import type {TypedArray} from '@math.gl/core';\nimport {Vector3} from '@math.gl/core';\nimport {GL} from '../constants';\nimport {assert} from '../utils/assert';\nimport {makePrimitiveIterator} from '../iterators/primitive-iterator';\nimport {getPrimitiveModeType} from '../primitives/modes';\nimport {getPositions} from './get-attribute-from-geometry';\n\ntype Geometry = {\n  mode: any;\n  indices?: {size: number; values: TypedArray};\n  attributes?: {};\n};\n/**\n * Computes vertex normals for a geometry\n * @param param0\n * @returns\n */\n// eslint-disable-next-line max-statements\nexport function computeVertexNormals(geometry: Geometry): Float32Array {\n  // Only support GL.TRIANGLES, GL.TRIANGLE_STRIP, GL.TRIANGLE_FAN\n  assert(getPrimitiveModeType(geometry.mode) === GL.TRIANGLES, 'TRIANGLES required');\n\n  const {values: positions} = getPositions(geometry);\n\n  const normals = new Float32Array(positions.length);\n\n  const vectorA = new Vector3();\n  const vectorB = new Vector3();\n  const vectorC = new Vector3();\n\n  const vectorCB = new Vector3();\n  const vectorAB = new Vector3();\n\n  for (const primitive of makePrimitiveIterator(geometry)) {\n    vectorA.fromArray(positions, primitive.i1 * 3);\n    vectorB.fromArray(positions, primitive.i2 * 3 + 3);\n    vectorC.fromArray(positions, primitive.i3 * 3 + 6);\n\n    vectorCB.subVectors(vectorC, vectorB);\n    vectorAB.subVectors(vectorA, vectorB);\n    const normal = vectorCB.cross(vectorAB);\n    normal.normalize();\n    // @ts-ignore\n    const {primitiveIndex} = primitive;\n\n    normals[primitiveIndex * 9 + 0] = normal.x;\n    normals[primitiveIndex * 9 + 1] = normal.y;\n    normals[primitiveIndex * 9 + 2] = normal.z;\n\n    normals[primitiveIndex * 9 + 3] = normal.x;\n    normals[primitiveIndex * 9 + 4] = normal.y;\n    normals[primitiveIndex * 9 + 5] = normal.z;\n\n    normals[primitiveIndex * 9 + 6] = normal.x;\n    normals[primitiveIndex * 9 + 7] = normal.y;\n    normals[primitiveIndex * 9 + 8] = normal.z;\n  }\n\n  return normals;\n}\n"],"mappings":"AACA,SAAQA,OAAO,QAAO,eAAe;AACrC,SAAQC,EAAE,QAAO,cAAc;AAC/B,SAAQC,MAAM,QAAO,iBAAiB;AACtC,SAAQC,qBAAqB,QAAO,iCAAiC;AACrE,SAAQC,oBAAoB,QAAO,qBAAqB;AACxD,SAAQC,YAAY,QAAO,+BAA+B;AAa1D,OAAO,SAASC,oBAAoB,CAACC,QAAkB,EAAgB;EAErEL,MAAM,CAACE,oBAAoB,CAACG,QAAQ,CAACC,IAAI,CAAC,KAAKP,EAAE,CAACQ,SAAS,EAAE,oBAAoB,CAAC;EAElF,MAAM;IAACC,MAAM,EAAEC;EAAS,CAAC,GAAGN,YAAY,CAACE,QAAQ,CAAC;EAElD,MAAMK,OAAO,GAAG,IAAIC,YAAY,CAACF,SAAS,CAACG,MAAM,CAAC;EAElD,MAAMC,OAAO,GAAG,IAAIf,OAAO,EAAE;EAC7B,MAAMgB,OAAO,GAAG,IAAIhB,OAAO,EAAE;EAC7B,MAAMiB,OAAO,GAAG,IAAIjB,OAAO,EAAE;EAE7B,MAAMkB,QAAQ,GAAG,IAAIlB,OAAO,EAAE;EAC9B,MAAMmB,QAAQ,GAAG,IAAInB,OAAO,EAAE;EAE9B,KAAK,MAAMoB,SAAS,IAAIjB,qBAAqB,CAACI,QAAQ,CAAC,EAAE;IACvDQ,OAAO,CAACM,SAAS,CAACV,SAAS,EAAES,SAAS,CAACE,EAAE,GAAG,CAAC,CAAC;IAC9CN,OAAO,CAACK,SAAS,CAACV,SAAS,EAAES,SAAS,CAACG,EAAE,GAAG,CAAC,GAAG,CAAC,CAAC;IAClDN,OAAO,CAACI,SAAS,CAACV,SAAS,EAAES,SAAS,CAACI,EAAE,GAAG,CAAC,GAAG,CAAC,CAAC;IAElDN,QAAQ,CAACO,UAAU,CAACR,OAAO,EAAED,OAAO,CAAC;IACrCG,QAAQ,CAACM,UAAU,CAACV,OAAO,EAAEC,OAAO,CAAC;IACrC,MAAMU,MAAM,GAAGR,QAAQ,CAACS,KAAK,CAACR,QAAQ,CAAC;IACvCO,MAAM,CAACE,SAAS,EAAE;IAElB,MAAM;MAACC;IAAc,CAAC,GAAGT,SAAS;IAElCR,OAAO,CAACiB,cAAc,GAAG,CAAC,GAAG,CAAC,CAAC,GAAGH,MAAM,CAACI,CAAC;IAC1ClB,OAAO,CAACiB,cAAc,GAAG,CAAC,GAAG,CAAC,CAAC,GAAGH,MAAM,CAACK,CAAC;IAC1CnB,OAAO,CAACiB,cAAc,GAAG,CAAC,GAAG,CAAC,CAAC,GAAGH,MAAM,CAACM,CAAC;IAE1CpB,OAAO,CAACiB,cAAc,GAAG,CAAC,GAAG,CAAC,CAAC,GAAGH,MAAM,CAACI,CAAC;IAC1ClB,OAAO,CAACiB,cAAc,GAAG,CAAC,GAAG,CAAC,CAAC,GAAGH,MAAM,CAACK,CAAC;IAC1CnB,OAAO,CAACiB,cAAc,GAAG,CAAC,GAAG,CAAC,CAAC,GAAGH,MAAM,CAACM,CAAC;IAE1CpB,OAAO,CAACiB,cAAc,GAAG,CAAC,GAAG,CAAC,CAAC,GAAGH,MAAM,CAACI,CAAC;IAC1ClB,OAAO,CAACiB,cAAc,GAAG,CAAC,GAAG,CAAC,CAAC,GAAGH,MAAM,CAACK,CAAC;IAC1CnB,OAAO,CAACiB,cAAc,GAAG,CAAC,GAAG,CAAC,CAAC,GAAGH,MAAM,CAACM,CAAC;EAC5C;EAEA,OAAOpB,OAAO;AAChB"}

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

@@ -1,32 +1,28 @@
-export function convertBuffersToNonIndexed({
-  indices,
-  attributes
-}) {
-  const geometry2 = new BufferGeometry();
 
+export function convertBuffersToNonIndexed(_ref) {
+  let {
+    indices,
+    attributes
+  } = _ref;
+  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;
-
+      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;
 }
 //# sourceMappingURL=convert-to-non-indexed.js.map

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

@@ -1 +1 @@
-{"version":3,"sources":["../../../../src/geometry/attributes/convert-to-non-indexed.ts"],"names":["convertBuffersToNonIndexed","indices","attributes","geometry2","BufferGeometry","name","attribute","array","itemSize","array2","constructor","length","index","index2","i","l","j","addAttribute","BufferAttribute","group","groups","addGroup","start","count","materialIndex"],"mappings":"AAQA,OAAO,SAASA,0BAAT,CAAoC;AAACC,EAAAA,OAAD;AAAUC,EAAAA;AAAV,CAApC,EAAgE;AACrE,QAAMC,SAAS,GAAG,IAAIC,cAAJ,EAAlB;;AAEA,OAAK,MAAMC,IAAX,IAAmBH,UAAnB,EAA+B;AAC7B,UAAMI,SAAS,GAAGJ,UAAU,CAACG,IAAD,CAA5B;AAEA,UAAME,KAAK,GAAGD,SAAS,CAACC,KAAxB;AACA,UAAMC,QAAQ,GAAGF,SAAS,CAACE,QAA3B;AAEA,UAAMC,MAAM,GAAG,IAAIF,KAAK,CAACG,WAAV,CAAsBT,OAAO,CAACU,MAAR,GAAiBH,QAAvC,CAAf;AACA,QAAII,KAAK,GAAG,CAAZ;AAAA,QACEC,MAAM,GAAG,CADX;;AAGA,SAAK,IAAIC,CAAC,GAAG,CAAR,EAAWC,CAAC,GAAGd,OAAO,CAACU,MAA5B,EAAoCG,CAAC,GAAGC,CAAxC,EAA2CD,CAAC,EAA5C,EAAgD;AAC9CF,MAAAA,KAAK,GAAGX,OAAO,CAACa,CAAD,CAAP,GAAaN,QAArB;;AACA,WAAK,IAAIQ,CAAC,GAAG,CAAb,EAAgBA,CAAC,GAAGR,QAApB,EAA8BQ,CAAC,EAA/B,EAAmC;AACjCP,QAAAA,MAAM,CAACI,MAAM,EAAP,CAAN,GAAmBN,KAAK,CAACK,KAAK,EAAN,CAAxB;AACD;AACF;;AACDT,IAAAA,SAAS,CAACc,YAAV,CAAuBZ,IAAvB,EAA6B,IAAIa,eAAJ,CAAoBT,MAApB,EAA4BD,QAA5B,CAA7B;AACD;;AAED,OAAK,MAAMW,KAAX,IAAoB,KAAKC,MAAzB,EAAiC;AAC/BjB,IAAAA,SAAS,CAACkB,QAAV,CAAmBF,KAAK,CAACG,KAAzB,EAAgCH,KAAK,CAACI,KAAtC,EAA6CJ,KAAK,CAACK,aAAnD;AACD;;AAED,SAAOrB,SAAP;AACD","sourcesContent":["/* eslint-disable */\n// @ts-nocheck\n/**\n * Converts indices of geometry.\n *\n * @param param0\n * @returns no indexed geometry\n */\nexport function convertBuffersToNonIndexed({indices, attributes}): any {\n  const geometry2 = new BufferGeometry();\n\n  for (const name in attributes) {\n    const attribute = attributes[name];\n\n    const array = attribute.array;\n    const itemSize = attribute.itemSize;\n\n    const array2 = new array.constructor(indices.length * itemSize);\n    let index = 0,\n      index2 = 0;\n\n    for (var i = 0, l = indices.length; i < l; i++) {\n      index = indices[i] * itemSize;\n      for (var j = 0; j < itemSize; j++) {\n        array2[index2++] = array[index++];\n      }\n    }\n    geometry2.addAttribute(name, new BufferAttribute(array2, itemSize));\n  }\n\n  for (const group of this.groups) {\n    geometry2.addGroup(group.start, group.count, group.materialIndex);\n  }\n\n  return geometry2;\n}\n"],"file":"convert-to-non-indexed.js"}
+{"version":3,"file":"convert-to-non-indexed.js","names":["convertBuffersToNonIndexed","indices","attributes","geometry2","BufferGeometry","name","attribute","array","itemSize","array2","constructor","length","index","index2","i","l","j","addAttribute","BufferAttribute","group","groups","addGroup","start","count","materialIndex"],"sources":["../../../../src/geometry/attributes/convert-to-non-indexed.ts"],"sourcesContent":["/* eslint-disable */\n// @ts-nocheck\n/**\n * Converts indices of geometry.\n *\n * @param param0\n * @returns no indexed geometry\n */\nexport function convertBuffersToNonIndexed({indices, attributes}): any {\n  const geometry2 = new BufferGeometry();\n\n  for (const name in attributes) {\n    const attribute = attributes[name];\n\n    const array = attribute.array;\n    const itemSize = attribute.itemSize;\n\n    const array2 = new array.constructor(indices.length * itemSize);\n    let index = 0,\n      index2 = 0;\n\n    for (var i = 0, l = indices.length; i < l; i++) {\n      index = indices[i] * itemSize;\n      for (var j = 0; j < itemSize; j++) {\n        array2[index2++] = array[index++];\n      }\n    }\n    geometry2.addAttribute(name, new BufferAttribute(array2, itemSize));\n  }\n\n  for (const group of this.groups) {\n    geometry2.addGroup(group.start, group.count, group.materialIndex);\n  }\n\n  return geometry2;\n}\n"],"mappings":";AAQA,OAAO,SAASA,0BAA0B,OAA6B;EAAA,IAA5B;IAACC,OAAO;IAAEC;EAAU,CAAC;EAC9D,MAAMC,SAAS,GAAG,IAAIC,cAAc,EAAE;EAEtC,KAAK,MAAMC,IAAI,IAAIH,UAAU,EAAE;IAC7B,MAAMI,SAAS,GAAGJ,UAAU,CAACG,IAAI,CAAC;IAElC,MAAME,KAAK,GAAGD,SAAS,CAACC,KAAK;IAC7B,MAAMC,QAAQ,GAAGF,SAAS,CAACE,QAAQ;IAEnC,MAAMC,MAAM,GAAG,IAAIF,KAAK,CAACG,WAAW,CAACT,OAAO,CAACU,MAAM,GAAGH,QAAQ,CAAC;IAC/D,IAAII,KAAK,GAAG,CAAC;MACXC,MAAM,GAAG,CAAC;IAEZ,KAAK,IAAIC,CAAC,GAAG,CAAC,EAAEC,CAAC,GAAGd,OAAO,CAACU,MAAM,EAAEG,CAAC,GAAGC,CAAC,EAAED,CAAC,EAAE,EAAE;MAC9CF,KAAK,GAAGX,OAAO,CAACa,CAAC,CAAC,GAAGN,QAAQ;MAC7B,KAAK,IAAIQ,CAAC,GAAG,CAAC,EAAEA,CAAC,GAAGR,QAAQ,EAAEQ,CAAC,EAAE,EAAE;QACjCP,MAAM,CAACI,MAAM,EAAE,CAAC,GAAGN,KAAK,CAACK,KAAK,EAAE,CAAC;MACnC;IACF;IACAT,SAAS,CAACc,YAAY,CAACZ,IAAI,EAAE,IAAIa,eAAe,CAACT,MAAM,EAAED,QAAQ,CAAC,CAAC;EACrE;EAEA,KAAK,MAAMW,KAAK,IAAI,IAAI,CAACC,MAAM,EAAE;IAC/BjB,SAAS,CAACkB,QAAQ,CAACF,KAAK,CAACG,KAAK,EAAEH,KAAK,CAACI,KAAK,EAAEJ,KAAK,CAACK,aAAa,CAAC;EACnE;EAEA,OAAOrB,SAAS;AAClB"}

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

@@ -1,5 +1,6 @@
 import isGeometry from '../is-geometry';
 import { assert } from '../utils/assert';
+
 export function getPositions(geometry) {
   if (isGeometry(geometry)) {
     const {
@@ -21,7 +22,6 @@ export function getPositions(geometry) {
     assert(geometry.values);
     return geometry;
   }
-
   return assert(false);
 }
 //# sourceMappingURL=get-attribute-from-geometry.js.map

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

@@ -1 +1 @@
-{"version":3,"sources":["../../../../src/geometry/attributes/get-attribute-from-geometry.ts"],"names":["isGeometry","assert","getPositions","geometry","attributes","position","POSITION","positions","ArrayBuffer","isView","values","size"],"mappings":"AAAA,OAAOA,UAAP,MAAuB,gBAAvB;AACA,SAAQC,MAAR,QAAqB,iBAArB;AASA,OAAO,SAASC,YAAT,CAAsBC,QAAtB,EAAqC;AAE1C,MAAIH,UAAU,CAACG,QAAD,CAAd,EAA0B;AACxB,UAAM;AAACC,MAAAA;AAAD,QAAeD,QAArB;AACA,UAAME,QAAQ,GAAGD,UAAU,CAACE,QAAX,IAAuBF,UAAU,CAACG,SAAnD;AACAN,IAAAA,MAAM,CAACI,QAAD,CAAN;AACA,WAAOA,QAAP;AACD;;AAGD,MAAIG,WAAW,CAACC,MAAZ,CAAmBN,QAAnB,CAAJ,EAAkC;AAChC,WAAO;AAACO,MAAAA,MAAM,EAAEP,QAAT;AAAmBQ,MAAAA,IAAI,EAAE;AAAzB,KAAP;AACD;;AAGD,MAAIR,QAAJ,EAAc;AACZF,IAAAA,MAAM,CAACE,QAAQ,CAACO,MAAV,CAAN;AACA,WAAOP,QAAP;AACD;;AAED,SAAOF,MAAM,CAAC,KAAD,CAAb;AACD","sourcesContent":["import isGeometry from '../is-geometry';\nimport {assert} from '../utils/assert';\n\n/**\n * analyze positions of geometry\n *\n * @param geometry\n * @returns Position| New geometry |assert\n */\n\nexport function getPositions(geometry: any) {\n  // If geometry, extract positions\n  if (isGeometry(geometry)) {\n    const {attributes} = geometry;\n    const position = attributes.POSITION || attributes.positions;\n    assert(position);\n    return position;\n  }\n\n  // If arraybuffer, assume 3 components\n  if (ArrayBuffer.isView(geometry)) {\n    return {values: geometry, size: 3};\n  }\n\n  // Else assume accessor object\n  if (geometry) {\n    assert(geometry.values);\n    return geometry;\n  }\n\n  return assert(false);\n}\n"],"file":"get-attribute-from-geometry.js"}
+{"version":3,"file":"get-attribute-from-geometry.js","names":["isGeometry","assert","getPositions","geometry","attributes","position","POSITION","positions","ArrayBuffer","isView","values","size"],"sources":["../../../../src/geometry/attributes/get-attribute-from-geometry.ts"],"sourcesContent":["import isGeometry from '../is-geometry';\nimport {assert} from '../utils/assert';\n\n/**\n * analyze positions of geometry\n *\n * @param geometry\n * @returns Position| New geometry |assert\n */\n\nexport function getPositions(geometry: any) {\n  // If geometry, extract positions\n  if (isGeometry(geometry)) {\n    const {attributes} = geometry;\n    const position = attributes.POSITION || attributes.positions;\n    assert(position);\n    return position;\n  }\n\n  // If arraybuffer, assume 3 components\n  if (ArrayBuffer.isView(geometry)) {\n    return {values: geometry, size: 3};\n  }\n\n  // Else assume accessor object\n  if (geometry) {\n    assert(geometry.values);\n    return geometry;\n  }\n\n  return assert(false);\n}\n"],"mappings":"AAAA,OAAOA,UAAU,MAAM,gBAAgB;AACvC,SAAQC,MAAM,QAAO,iBAAiB;;AAStC,OAAO,SAASC,YAAY,CAACC,QAAa,EAAE;EAE1C,IAAIH,UAAU,CAACG,QAAQ,CAAC,EAAE;IACxB,MAAM;MAACC;IAAU,CAAC,GAAGD,QAAQ;IAC7B,MAAME,QAAQ,GAAGD,UAAU,CAACE,QAAQ,IAAIF,UAAU,CAACG,SAAS;IAC5DN,MAAM,CAACI,QAAQ,CAAC;IAChB,OAAOA,QAAQ;EACjB;;EAGA,IAAIG,WAAW,CAACC,MAAM,CAACN,QAAQ,CAAC,EAAE;IAChC,OAAO;MAACO,MAAM,EAAEP,QAAQ;MAAEQ,IAAI,EAAE;IAAC,CAAC;EACpC;;EAGA,IAAIR,QAAQ,EAAE;IACZF,MAAM,CAACE,QAAQ,CAACO,MAAM,CAAC;IACvB,OAAOP,QAAQ;EACjB;EAEA,OAAOF,MAAM,CAAC,KAAK,CAAC;AACtB"}

package/dist/esm/geometry/attributes/normalize.js

@@ -1,6 +1,9 @@
-export function normalize(normals = {}, vector) {
-  normals = this.attributes.normal;
 
+
+export function normalize() {
+  let normals = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+  let vector = arguments.length > 1 ? arguments[1] : undefined;
+  normals = this.attributes.normal;
   for (let i = 0, il = normals.count; i < il; i++) {
     vector.x = normals.getX(i);
     vector.y = normals.getY(i);

package/dist/esm/geometry/attributes/normalize.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../../src/geometry/attributes/normalize.ts"],"names":["normalize","normals","vector","attributes","normal","i","il","count","x","getX","y","getY","z","getZ","setXYZ"],"mappings":"AAQA,OAAO,SAASA,SAAT,CAAmBC,OAAY,GAAG,EAAlC,EAAsCC,MAAtC,EAAuD;AAE5DD,EAAAA,OAAO,GAAG,KAAKE,UAAL,CAAgBC,MAA1B;;AACA,OAAK,IAAIC,CAAC,GAAG,CAAR,EAAWC,EAAE,GAAGL,OAAO,CAACM,KAA7B,EAAoCF,CAAC,GAAGC,EAAxC,EAA4CD,CAAC,EAA7C,EAAiD;AAC/CH,IAAAA,MAAM,CAACM,CAAP,GAAWP,OAAO,CAACQ,IAAR,CAAaJ,CAAb,CAAX;AACAH,IAAAA,MAAM,CAACQ,CAAP,GAAWT,OAAO,CAACU,IAAR,CAAaN,CAAb,CAAX;AACAH,IAAAA,MAAM,CAACU,CAAP,GAAWX,OAAO,CAACY,IAAR,CAAaR,CAAb,CAAX;AACAH,IAAAA,MAAM,CAACF,SAAP;AACAC,IAAAA,OAAO,CAACa,MAAR,CAAeT,CAAf,EAAkBH,MAAM,CAACM,CAAzB,EAA4BN,MAAM,CAACQ,CAAnC,EAAsCR,MAAM,CAACU,CAA7C;AACD;AACF","sourcesContent":["/* eslint-disable */\nimport {Vector3} from '@math.gl/core';\n\n/**\n * Setting X, Y, Z for Vector\n * @param normals\n * @param vector\n */\nexport function normalize(normals: any = {}, vector: Vector3) {\n  //@ts-ignore\n  normals = this.attributes.normal;\n  for (let i = 0, il = normals.count; i < il; i++) {\n    vector.x = normals.getX(i);\n    vector.y = normals.getY(i);\n    vector.z = normals.getZ(i);\n    vector.normalize();\n    normals.setXYZ(i, vector.x, vector.y, vector.z);\n  }\n}\n"],"file":"normalize.js"}
+{"version":3,"file":"normalize.js","names":["normalize","normals","vector","attributes","normal","i","il","count","x","getX","y","getY","z","getZ","setXYZ"],"sources":["../../../../src/geometry/attributes/normalize.ts"],"sourcesContent":["/* eslint-disable */\nimport {Vector3} from '@math.gl/core';\n\n/**\n * Setting X, Y, Z for Vector\n * @param normals\n * @param vector\n */\nexport function normalize(normals: any = {}, vector: Vector3) {\n  //@ts-ignore\n  normals = this.attributes.normal;\n  for (let i = 0, il = normals.count; i < il; i++) {\n    vector.x = normals.getX(i);\n    vector.y = normals.getY(i);\n    vector.z = normals.getZ(i);\n    vector.normalize();\n    normals.setXYZ(i, vector.x, vector.y, vector.z);\n  }\n}\n"],"mappings":";;AAQA,OAAO,SAASA,SAAS,GAAqC;EAAA,IAApCC,OAAY,uEAAG,CAAC,CAAC;EAAA,IAAEC,MAAe;EAE1DD,OAAO,GAAG,IAAI,CAACE,UAAU,CAACC,MAAM;EAChC,KAAK,IAAIC,CAAC,GAAG,CAAC,EAAEC,EAAE,GAAGL,OAAO,CAACM,KAAK,EAAEF,CAAC,GAAGC,EAAE,EAAED,CAAC,EAAE,EAAE;IAC/CH,MAAM,CAACM,CAAC,GAAGP,OAAO,CAACQ,IAAI,CAACJ,CAAC,CAAC;IAC1BH,MAAM,CAACQ,CAAC,GAAGT,OAAO,CAACU,IAAI,CAACN,CAAC,CAAC;IAC1BH,MAAM,CAACU,CAAC,GAAGX,OAAO,CAACY,IAAI,CAACR,CAAC,CAAC;IAC1BH,MAAM,CAACF,SAAS,EAAE;IAClBC,OAAO,CAACa,MAAM,CAACT,CAAC,EAAEH,MAAM,CAACM,CAAC,EAAEN,MAAM,CAACQ,CAAC,EAAER,MAAM,CAACU,CAAC,CAAC;EACjD;AACF"}

package/dist/esm/geometry/colors/rgb565.js

@@ -1,4 +1,6 @@
-export function decodeRGB565(rgb565, target = [0, 0, 0]) {
+
+export function decodeRGB565(rgb565) {
+  let target = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : [0, 0, 0];
   const r5 = rgb565 >> 11 & 31;
   const g6 = rgb565 >> 5 & 63;
   const b5 = rgb565 & 31;
@@ -7,6 +9,7 @@ export function decodeRGB565(rgb565, target = [0, 0, 0]) {
   target[2] = b5 << 3;
   return target;
 }
+
 export function encodeRGB565(rgb) {
   const r5 = Math.floor(rgb[0] / 8) + 4;
   const g6 = Math.floor(rgb[1] / 4) + 2;

package/dist/esm/geometry/colors/rgb565.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../../src/geometry/colors/rgb565.ts"],"names":["decodeRGB565","rgb565","target","r5","g6","b5","encodeRGB565","rgb","Math","floor"],"mappings":"AAMA,OAAO,SAASA,YAAT,CAAsBC,MAAtB,EAAsCC,MAAgB,GAAG,CAAC,CAAD,EAAI,CAAJ,EAAO,CAAP,CAAzD,EAA8E;AACnF,QAAMC,EAAE,GAAIF,MAAM,IAAI,EAAX,GAAiB,EAA5B;AACA,QAAMG,EAAE,GAAIH,MAAM,IAAI,CAAX,GAAgB,EAA3B;AACA,QAAMI,EAAE,GAAGJ,MAAM,GAAG,EAApB;AAEAC,EAAAA,MAAM,CAAC,CAAD,CAAN,GAAYC,EAAE,IAAI,CAAlB;AACAD,EAAAA,MAAM,CAAC,CAAD,CAAN,GAAYE,EAAE,IAAI,CAAlB;AACAF,EAAAA,MAAM,CAAC,CAAD,CAAN,GAAYG,EAAE,IAAI,CAAlB;AAEA,SAAOH,MAAP;AACD;AAOD,OAAO,SAASI,YAAT,CAAsBC,GAAtB,EAA6C;AAClD,QAAMJ,EAAE,GAAGK,IAAI,CAACC,KAAL,CAAWF,GAAG,CAAC,CAAD,CAAH,GAAS,CAApB,IAAyB,CAApC;AACA,QAAMH,EAAE,GAAGI,IAAI,CAACC,KAAL,CAAWF,GAAG,CAAC,CAAD,CAAH,GAAS,CAApB,IAAyB,CAApC;AACA,QAAMF,EAAE,GAAGG,IAAI,CAACC,KAAL,CAAWF,GAAG,CAAC,CAAD,CAAH,GAAS,CAApB,IAAyB,CAApC;AACA,SAAOJ,EAAE,IAAIC,EAAE,IAAI,CAAV,CAAF,IAAkBC,EAAE,IAAI,EAAxB,CAAP;AACD","sourcesContent":["/**\n * Decode color values\n * @param rgb565\n * @param target\n * @returns target\n */\nexport function decodeRGB565(rgb565: number, target: number[] = [0, 0, 0]): number[] {\n  const r5 = (rgb565 >> 11) & 31;\n  const g6 = (rgb565 >> 5) & 63;\n  const b5 = rgb565 & 31;\n\n  target[0] = r5 << 3;\n  target[1] = g6 << 2;\n  target[2] = b5 << 3;\n\n  return target;\n}\n\n/**\n * Encode color values\n * @param rgb\n * @returns color\n */\nexport function encodeRGB565(rgb: number[]): number {\n  const r5 = Math.floor(rgb[0] / 8) + 4;\n  const g6 = Math.floor(rgb[1] / 4) + 2;\n  const b5 = Math.floor(rgb[2] / 8) + 4;\n  return r5 + (g6 << 5) + (b5 << 11);\n}\n"],"file":"rgb565.js"}
+{"version":3,"file":"rgb565.js","names":["decodeRGB565","rgb565","target","r5","g6","b5","encodeRGB565","rgb","Math","floor"],"sources":["../../../../src/geometry/colors/rgb565.ts"],"sourcesContent":["/**\n * Decode color values\n * @param rgb565\n * @param target\n * @returns target\n */\nexport function decodeRGB565(rgb565: number, target: number[] = [0, 0, 0]): number[] {\n  const r5 = (rgb565 >> 11) & 31;\n  const g6 = (rgb565 >> 5) & 63;\n  const b5 = rgb565 & 31;\n\n  target[0] = r5 << 3;\n  target[1] = g6 << 2;\n  target[2] = b5 << 3;\n\n  return target;\n}\n\n/**\n * Encode color values\n * @param rgb\n * @returns color\n */\nexport function encodeRGB565(rgb: number[]): number {\n  const r5 = Math.floor(rgb[0] / 8) + 4;\n  const g6 = Math.floor(rgb[1] / 4) + 2;\n  const b5 = Math.floor(rgb[2] / 8) + 4;\n  return r5 + (g6 << 5) + (b5 << 11);\n}\n"],"mappings":";AAMA,OAAO,SAASA,YAAY,CAACC,MAAc,EAA0C;EAAA,IAAxCC,MAAgB,uEAAG,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC;EACvE,MAAMC,EAAE,GAAIF,MAAM,IAAI,EAAE,GAAI,EAAE;EAC9B,MAAMG,EAAE,GAAIH,MAAM,IAAI,CAAC,GAAI,EAAE;EAC7B,MAAMI,EAAE,GAAGJ,MAAM,GAAG,EAAE;EAEtBC,MAAM,CAAC,CAAC,CAAC,GAAGC,EAAE,IAAI,CAAC;EACnBD,MAAM,CAAC,CAAC,CAAC,GAAGE,EAAE,IAAI,CAAC;EACnBF,MAAM,CAAC,CAAC,CAAC,GAAGG,EAAE,IAAI,CAAC;EAEnB,OAAOH,MAAM;AACf;;AAOA,OAAO,SAASI,YAAY,CAACC,GAAa,EAAU;EAClD,MAAMJ,EAAE,GAAGK,IAAI,CAACC,KAAK,CAACF,GAAG,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,GAAG,CAAC;EACrC,MAAMH,EAAE,GAAGI,IAAI,CAACC,KAAK,CAACF,GAAG,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,GAAG,CAAC;EACrC,MAAMF,EAAE,GAAGG,IAAI,CAACC,KAAK,CAACF,GAAG,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,GAAG,CAAC;EACrC,OAAOJ,EAAE,IAAIC,EAAE,IAAI,CAAC,CAAC,IAAIC,EAAE,IAAI,EAAE,CAAC;AACpC"}

package/dist/esm/geometry/compression/attribute-compression.js

@@ -1,3 +1,5 @@
+
+
 import { Vector2, Vector3, clamp, _MathUtils } from '@math.gl/core';
 import { assert } from '../utils/assert';
 const RIGHT_SHIFT = 1.0 / 256.0;
@@ -13,11 +15,13 @@ function forceUint8(value) {
   return uint8ForceArray[0];
 }
 
-function fromSNorm(value, rangeMaximum = 255) {
+function fromSNorm(value) {
+  let rangeMaximum = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 255;
   return clamp(value, 0.0, rangeMaximum) / rangeMaximum * 2.0 - 1.0;
 }
 
-function toSNorm(value, rangeMaximum = 255) {
+function toSNorm(value) {
+  let rangeMaximum = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 255;
   return Math.round((clamp(value, -1.0, 1.0) * 0.5 + 0.5) * rangeMaximum);
 }
 
@@ -32,21 +36,21 @@ export function octEncodeInRange(vector, rangeMax, result) {
   assert(Math.abs(vector3.magnitudeSquared() - 1.0) <= _MathUtils.EPSILON6);
   result.x = vector.x / (Math.abs(vector.x) + Math.abs(vector.y) + Math.abs(vector.z));
   result.y = vector.y / (Math.abs(vector.x) + Math.abs(vector.y) + Math.abs(vector.z));
-
   if (vector.z < 0) {
     const x = result.x;
     const y = result.y;
     result.x = (1.0 - Math.abs(y)) * signNotZero(x);
     result.y = (1.0 - Math.abs(x)) * signNotZero(y);
   }
-
   result.x = toSNorm(result.x, rangeMax);
   result.y = toSNorm(result.y, rangeMax);
   return result;
 }
+
 export function octEncode(vector, result) {
   return octEncodeInRange(vector, 255, result);
 }
+
 export function octEncodeToVector4(vector, result) {
   octEncodeInRange(vector, 65535, octEncodeScratch);
   result.x = forceUint8(octEncodeScratch.x * RIGHT_SHIFT);
@@ -55,28 +59,27 @@ export function octEncodeToVector4(vector, result) {
   result.w = forceUint8(octEncodeScratch.y);
   return result;
 }
+
 export function octDecodeInRange(x, y, rangeMax, result) {
   assert(result);
-
   if (x < 0 || x > rangeMax || y < 0 || y > rangeMax) {
     throw new Error("x and y must be unsigned normalized integers between 0 and ".concat(rangeMax));
   }
-
   result.x = fromSNorm(x, rangeMax);
   result.y = fromSNorm(y, rangeMax);
   result.z = 1.0 - (Math.abs(result.x) + Math.abs(result.y));
-
   if (result.z < 0.0) {
     const oldVX = result.x;
     result.x = (1.0 - Math.abs(result.y)) * signNotZero(oldVX);
     result.y = (1.0 - Math.abs(oldVX)) * signNotZero(result.y);
   }
-
   return result.normalize();
 }
+
 export function octDecode(x, y, result) {
   return octDecodeInRange(x, y, 255, result);
 }
+
 export function octDecodeFromVector4(encoded, result) {
   assert(encoded);
   assert(result);
@@ -84,23 +87,24 @@ export function octDecodeFromVector4(encoded, result) {
   const y = encoded.y;
   const z = encoded.z;
   const w = encoded.w;
-
   if (x < 0 || x > 255 || y < 0 || y > 255 || z < 0 || z > 255 || w < 0 || w > 255) {
     throw new Error('x, y, z, and w must be unsigned normalized integers between 0 and 255');
   }
-
   const xOct16 = x * LEFT_SHIFT + y;
   const yOct16 = z * LEFT_SHIFT + w;
   return octDecodeInRange(xOct16, yOct16, 65535, result);
 }
+
 export function octPackFloat(encoded) {
   const vector2 = scratchVector2.from(encoded);
   return 256.0 * vector2.x + vector2.y;
 }
+
 export function octEncodeFloat(vector) {
   octEncode(vector, scratchEncodeVector2);
   return octPackFloat(scratchEncodeVector2);
 }
+
 export function octDecodeFloat(value, result) {
   assert(Number.isFinite(value));
   const temp = value / 256.0;
@@ -108,6 +112,7 @@ export function octDecodeFloat(value, result) {
   const y = (temp - x) * 256.0;
   return octDecode(x, y, result);
 }
+
 export function octPack(v1, v2, v3, result) {
   assert(v1);
   assert(v2);
@@ -120,6 +125,7 @@ export function octPack(v1, v2, v3, result) {
   result.y = 65536.0 * encoded3.y + encoded2;
   return result;
 }
+
 export function octUnpack(packed, v1, v2, v3) {
   let temp = packed.x / 65536.0;
   const x = Math.floor(temp);
@@ -131,11 +137,13 @@ export function octUnpack(packed, v1, v2, v3) {
   octDecodeFloat(encodedFloat2, v2);
   octDecode(x, y, v3);
 }
+
 export function compressTextureCoordinates(textureCoordinates) {
   const x = textureCoordinates.x * 4095.0 | 0;
   const y = textureCoordinates.y * 4095.0 | 0;
   return 4096.0 * x + y;
 }
+
 export function decompressTextureCoordinates(compressed, result) {
   const temp = compressed / 4096.0;
   const xZeroTo4095 = Math.floor(temp);
@@ -143,29 +151,25 @@ export function decompressTextureCoordinates(compressed, result) {
   result.y = (compressed - xZeroTo4095 * 4096) / 4095;
   return result;
 }
+
 export function zigZagDeltaDecode(uBuffer, vBuffer, heightBuffer) {
   assert(uBuffer);
   assert(vBuffer);
   assert(uBuffer.length === vBuffer.length);
-
   if (heightBuffer) {
     assert(uBuffer.length === heightBuffer.length);
   }
-
   function zigZagDecode(value) {
     return value >> 1 ^ -(value & 1);
   }
-
   let u = 0;
   let v = 0;
   let height = 0;
-
   for (let i = 0; i < uBuffer.length; ++i) {
     u += zigZagDecode(uBuffer[i]);
     v += zigZagDecode(vBuffer[i]);
     uBuffer[i] = u;
     vBuffer[i] = v;
-
     if (heightBuffer) {
       height += zigZagDecode(heightBuffer[i]);
       heightBuffer[i] = height;