@loaders.gl/math 4.0.0-beta.1 → 4.0.0-beta.3

package/dist/index.cjs

@@ -0,0 +1,545 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  GL: () => GL,
+  GLType: () => GLType,
+  GL_TYPE: () => GL_TYPE,
+  compressTextureCoordinates: () => compressTextureCoordinates,
+  computeVertexNormals: () => computeVertexNormals,
+  concatTypedArrays: () => concatTypedArrays,
+  decodeRGB565: () => decodeRGB565,
+  decompressTextureCoordinates: () => decompressTextureCoordinates,
+  emod: () => emod,
+  encodeRGB565: () => encodeRGB565,
+  isGeometry: () => isGeometry,
+  makeAttributeIterator: () => makeAttributeIterator,
+  makePrimitiveIterator: () => makePrimitiveIterator,
+  octDecode: () => octDecode,
+  octDecodeFloat: () => octDecodeFloat,
+  octDecodeFromVector4: () => octDecodeFromVector4,
+  octDecodeInRange: () => octDecodeInRange,
+  octEncode: () => octEncode,
+  octEncodeFloat: () => octEncodeFloat,
+  octEncodeInRange: () => octEncodeInRange,
+  octEncodeToVector4: () => octEncodeToVector4,
+  octPack: () => octPack,
+  octPackFloat: () => octPackFloat,
+  octUnpack: () => octUnpack,
+  zigZagDeltaDecode: () => zigZagDeltaDecode
+});
+module.exports = __toCommonJS(src_exports);
+
+// src/geometry/constants.ts
+var GL_PRIMITIVE_MODE = {
+  POINTS: 0,
+  // Points. single points.
+  LINES: 1,
+  // Lines. Each vertex connects to the one after it.
+  LINE_LOOP: 2,
+  // Lines. Each set of two vertices is treated as a separate line segment.
+  LINE_STRIP: 3,
+  // Lines/ a connected group of line segments from the first vertex to the last
+  TRIANGLES: 4,
+  // Triangles. Each set of three vertices creates a separate triangle.
+  TRIANGLE_STRIP: 5,
+  // Triangles. A connected group of triangles.
+  TRIANGLE_FAN: 6
+  // Triangles. A connected group of triangles.
+  // Each vertex connects to the previous and the first vertex in the fan.
+};
+var GL_TYPE = {
+  BYTE: 5120,
+  UNSIGNED_BYTE: 5121,
+  SHORT: 5122,
+  UNSIGNED_SHORT: 5123,
+  INT: 5124,
+  UNSIGNED_INT: 5125,
+  FLOAT: 5126,
+  DOUBLE: 5130
+};
+var GL = {
+  ...GL_PRIMITIVE_MODE,
+  ...GL_TYPE
+};
+
+// src/geometry/gl/gl-type.ts
+var GL_TYPE_TO_ARRAY_TYPE = {
+  [GL_TYPE.DOUBLE]: Float64Array,
+  [GL_TYPE.FLOAT]: Float32Array,
+  [GL_TYPE.UNSIGNED_SHORT]: Uint16Array,
+  [GL_TYPE.UNSIGNED_INT]: Uint32Array,
+  [GL_TYPE.UNSIGNED_BYTE]: Uint8Array,
+  [GL_TYPE.BYTE]: Int8Array,
+  [GL_TYPE.SHORT]: Int16Array,
+  [GL_TYPE.INT]: Int32Array
+};
+var NAME_TO_GL_TYPE = {
+  DOUBLE: GL_TYPE.DOUBLE,
+  FLOAT: GL_TYPE.FLOAT,
+  UNSIGNED_SHORT: GL_TYPE.UNSIGNED_SHORT,
+  UNSIGNED_INT: GL_TYPE.UNSIGNED_INT,
+  UNSIGNED_BYTE: GL_TYPE.UNSIGNED_BYTE,
+  BYTE: GL_TYPE.BYTE,
+  SHORT: GL_TYPE.SHORT,
+  INT: GL_TYPE.INT
+};
+var ERR_TYPE_CONVERSION = "Failed to convert GL type";
+var GLType = class {
+  // Signature: fromTypedArray(new Uint8Array())
+  // Signature: fromTypedArray(Uint8Array)
+  /**
+   * Returns the size, in bytes, of the corresponding datatype
+   * @param arrayOrType
+   * @returns glType a a string
+   */
+  static fromTypedArray(arrayOrType) {
+    arrayOrType = ArrayBuffer.isView(arrayOrType) ? arrayOrType.constructor : arrayOrType;
+    for (const glType in GL_TYPE_TO_ARRAY_TYPE) {
+      const ArrayType = GL_TYPE_TO_ARRAY_TYPE[glType];
+      if (ArrayType === arrayOrType) {
+        return glType;
+      }
+    }
+    throw new Error(ERR_TYPE_CONVERSION);
+  }
+  /**
+   * Extracts name for glType from array NAME_TO_GL_TYPE
+   * @param name
+   * @returns glType as a number
+   */
+  static fromName(name) {
+    const glType = NAME_TO_GL_TYPE[name];
+    if (!glType) {
+      throw new Error(ERR_TYPE_CONVERSION);
+    }
+    return glType;
+  }
+  // Converts GL constant to corresponding typed array type
+  // eslint-disable-next-line complexity
+  static getArrayType(glType) {
+    switch (glType) {
+      case GL_TYPE.UNSIGNED_SHORT_5_6_5:
+      case GL_TYPE.UNSIGNED_SHORT_4_4_4_4:
+      case GL_TYPE.UNSIGNED_SHORT_5_5_5_1:
+        return Uint16Array;
+      default:
+        const ArrayType = GL_TYPE_TO_ARRAY_TYPE[glType];
+        if (!ArrayType) {
+          throw new Error(ERR_TYPE_CONVERSION);
+        }
+        return ArrayType;
+    }
+  }
+  /**
+   * Returns the size in bytes of one element of the provided WebGL type
+   * @param glType
+   * @returns size of glType
+   */
+  static getByteSize(glType) {
+    const ArrayType = GLType.getArrayType(glType);
+    return ArrayType.BYTES_PER_ELEMENT;
+  }
+  /**
+   * Returns `true` if `glType` is a valid WebGL data type.
+   * @param glType
+   * @returns boolean
+   */
+  static validate(glType) {
+    return Boolean(GLType.getArrayType(glType));
+  }
+  /**
+   * Creates a typed view of an array of bytes
+   * @param glType The type of typed array (ArrayBuffer view) to create
+   * @param buffer The buffer storage to use for the view.
+   * @param byteOffset The offset, in bytes, to the first element in the view
+   * @param length The number of elements in the view. Defaults to buffer length
+   * @returns A typed array view of the buffer
+   */
+  static createTypedArray(glType, buffer, byteOffset = 0, length) {
+    if (length === void 0) {
+      length = (buffer.byteLength - byteOffset) / GLType.getByteSize(glType);
+    }
+    const ArrayType = GLType.getArrayType(glType);
+    return new ArrayType(buffer, byteOffset, length);
+  }
+};
+
+// src/geometry/is-geometry.ts
+function isGeometry(geometry) {
+  return geometry && typeof geometry === "object" && geometry.mode && geometry.attributes && typeof geometry.attributes === "object";
+}
+
+// src/geometry/iterators/attribute-iterator.ts
+function* makeAttributeIterator(values, size) {
+  const ArrayType = values.constructor;
+  const element = new ArrayType(size);
+  for (let i = 0; i < values.length; i += size) {
+    for (let j = 0; j < size; j++) {
+      element[j] = element[i + j];
+    }
+    yield element;
+  }
+}
+
+// src/geometry/primitives/modes.ts
+function getPrimitiveModeType(mode) {
+  switch (mode) {
+    case GL.POINTS:
+      return GL.POINTS;
+    case GL.LINES:
+    case GL.LINE_STRIP:
+    case GL.LINE_LOOP:
+      return GL.LINES;
+    case GL.TRIANGLES:
+    case GL.TRIANGLE_STRIP:
+    case GL.TRIANGLE_FAN:
+      return GL.TRIANGLES;
+    default:
+      throw new Error("Unknown primitive mode");
+  }
+}
+
+// src/geometry/iterators/primitive-iterator.ts
+var import_loader_utils = require("@loaders.gl/loader-utils");
+function* makePrimitiveIterator(indices, attributes = {}, mode, start = 0, end) {
+  if (indices) {
+    indices = indices.values || indices.value || indices;
+  }
+  if (end === void 0) {
+    end = indices ? indices.length : start;
+  }
+  const info = {
+    attributes,
+    type: getPrimitiveModeType(mode),
+    i1: 0,
+    i2: 0,
+    i3: 0
+  };
+  let i = start;
+  while (i < end) {
+    switch (mode) {
+      case GL.POINTS:
+        info.i1 = i;
+        i += 1;
+        break;
+      case GL.LINES:
+        info.i1 = i;
+        info.i2 = i + 1;
+        i += 2;
+        break;
+      case GL.LINE_STRIP:
+        info.i1 = i;
+        info.i2 = i + 1;
+        i += 1;
+        break;
+      case GL.LINE_LOOP:
+        info.i1 = i;
+        info.i2 = i + 1;
+        i += 1;
+        break;
+      case GL.TRIANGLES:
+        info.i1 = i;
+        info.i2 = i + 1;
+        info.i3 = i + 2;
+        i += 3;
+        break;
+      case GL.TRIANGLE_STRIP:
+        info.i1 = i;
+        info.i2 = i + 1;
+        i += 1;
+        break;
+      case GL.TRIANGLE_FAN:
+        info.i1 = 1;
+        info.i2 = i;
+        info.i3 = i + 1;
+        i += 1;
+        break;
+      default:
+        (0, import_loader_utils.assert)(false);
+    }
+    if (indices) {
+      if ("i1" in info) {
+        info.i1 = indices[info.i1];
+        info.i2 = indices[info.i2];
+        info.i3 = indices[info.i3];
+      }
+    }
+    yield info;
+  }
+}
+
+// src/geometry/attributes/compute-vertex-normals.ts
+var import_core = require("@math.gl/core");
+
+// src/geometry/utils/assert.ts
+function assert2(condition, message) {
+  if (!condition) {
+    throw new Error(`math.gl assertion failed. ${message}`);
+  }
+}
+
+// src/geometry/attributes/get-attribute-from-geometry.ts
+function getPositions(geometry) {
+  if (isGeometry(geometry)) {
+    const { attributes } = geometry;
+    const position = attributes.POSITION || attributes.positions;
+    assert2(position);
+    return position;
+  }
+  if (ArrayBuffer.isView(geometry)) {
+    return { values: geometry, size: 3 };
+  }
+  if (geometry) {
+    assert2(geometry.values);
+    return geometry;
+  }
+  return assert2(false);
+}
+
+// src/geometry/attributes/compute-vertex-normals.ts
+function computeVertexNormals(geometry) {
+  assert2(getPrimitiveModeType(geometry.mode) === GL.TRIANGLES, "TRIANGLES required");
+  const { values: positions } = getPositions(geometry);
+  const normals = new Float32Array(positions.length);
+  const vectorA = new import_core.Vector3();
+  const vectorB = new import_core.Vector3();
+  const vectorC = new import_core.Vector3();
+  const vectorCB = new import_core.Vector3();
+  const vectorAB = new import_core.Vector3();
+  for (const primitive of 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();
+    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;
+}
+
+// src/geometry/colors/rgb565.ts
+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;
+}
+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);
+}
+
+// src/geometry/typed-arrays/typed-array-utils.ts
+function concatTypedArrays(arrays = []) {
+  let byteLength = 0;
+  for (let i = 0; i < arrays.length; ++i) {
+    byteLength += arrays[i].byteLength;
+  }
+  const buffer = new Uint8Array(byteLength);
+  let byteOffset = 0;
+  for (let i = 0; i < arrays.length; ++i) {
+    const data = new Uint8Array(arrays[i].buffer);
+    byteLength = data.length;
+    for (let j = 0; j < byteLength; ++j) {
+      buffer[byteOffset++] = data[j];
+    }
+  }
+  return buffer;
+}
+
+// src/geometry/compression/attribute-compression.ts
+var import_core2 = require("@math.gl/core");
+var RIGHT_SHIFT = 1 / 256;
+var LEFT_SHIFT = 256;
+var scratchVector2 = new import_core2.Vector2();
+var scratchVector3 = new import_core2.Vector3();
+var scratchEncodeVector2 = new import_core2.Vector2();
+var octEncodeScratch = new import_core2.Vector2();
+var uint8ForceArray = new Uint8Array(1);
+function forceUint8(value) {
+  uint8ForceArray[0] = value;
+  return uint8ForceArray[0];
+}
+function fromSNorm(value, rangeMaximum = 255) {
+  return (0, import_core2.clamp)(value, 0, rangeMaximum) / rangeMaximum * 2 - 1;
+}
+function toSNorm(value, rangeMaximum = 255) {
+  return Math.round(((0, import_core2.clamp)(value, -1, 1) * 0.5 + 0.5) * rangeMaximum);
+}
+function signNotZero(value) {
+  return value < 0 ? -1 : 1;
+}
+function octEncodeInRange(vector, rangeMax, result) {
+  assert2(vector);
+  assert2(result);
+  const vector3 = scratchVector3.from(vector);
+  assert2(Math.abs(vector3.magnitudeSquared() - 1) <= import_core2._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 - Math.abs(y)) * signNotZero(x);
+    result.y = (1 - Math.abs(x)) * signNotZero(y);
+  }
+  result.x = toSNorm(result.x, rangeMax);
+  result.y = toSNorm(result.y, rangeMax);
+  return result;
+}
+function octEncode(vector, result) {
+  return octEncodeInRange(vector, 255, result);
+}
+function octEncodeToVector4(vector, result) {
+  octEncodeInRange(vector, 65535, octEncodeScratch);
+  result.x = forceUint8(octEncodeScratch.x * RIGHT_SHIFT);
+  result.y = forceUint8(octEncodeScratch.x);
+  result.z = forceUint8(octEncodeScratch.y * RIGHT_SHIFT);
+  result.w = forceUint8(octEncodeScratch.y);
+  return result;
+}
+function octDecodeInRange(x, y, rangeMax, result) {
+  assert2(result);
+  if (x < 0 || x > rangeMax || y < 0 || y > rangeMax) {
+    throw new Error(`x and y must be unsigned normalized integers between 0 and ${rangeMax}`);
+  }
+  result.x = fromSNorm(x, rangeMax);
+  result.y = fromSNorm(y, rangeMax);
+  result.z = 1 - (Math.abs(result.x) + Math.abs(result.y));
+  if (result.z < 0) {
+    const oldVX = result.x;
+    result.x = (1 - Math.abs(result.y)) * signNotZero(oldVX);
+    result.y = (1 - Math.abs(oldVX)) * signNotZero(result.y);
+  }
+  return result.normalize();
+}
+function octDecode(x, y, result) {
+  return octDecodeInRange(x, y, 255, result);
+}
+function octDecodeFromVector4(encoded, result) {
+  assert2(encoded);
+  assert2(result);
+  const x = encoded.x;
+  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);
+}
+function octPackFloat(encoded) {
+  const vector2 = scratchVector2.from(encoded);
+  return 256 * vector2.x + vector2.y;
+}
+function octEncodeFloat(vector) {
+  octEncode(vector, scratchEncodeVector2);
+  return octPackFloat(scratchEncodeVector2);
+}
+function octDecodeFloat(value, result) {
+  assert2(Number.isFinite(value));
+  const temp = value / 256;
+  const x = Math.floor(temp);
+  const y = (temp - x) * 256;
+  return octDecode(x, y, result);
+}
+function octPack(v1, v2, v3, result) {
+  assert2(v1);
+  assert2(v2);
+  assert2(v3);
+  assert2(result);
+  const encoded1 = octEncodeFloat(v1);
+  const encoded2 = octEncodeFloat(v2);
+  const encoded3 = octEncode(v3, scratchEncodeVector2);
+  result.x = 65536 * encoded3.x + encoded1;
+  result.y = 65536 * encoded3.y + encoded2;
+  return result;
+}
+function octUnpack(packed, v1, v2, v3) {
+  let temp = packed.x / 65536;
+  const x = Math.floor(temp);
+  const encodedFloat1 = (temp - x) * 65536;
+  temp = packed.y / 65536;
+  const y = Math.floor(temp);
+  const encodedFloat2 = (temp - y) * 65536;
+  octDecodeFloat(encodedFloat1, v1);
+  octDecodeFloat(encodedFloat2, v2);
+  octDecode(x, y, v3);
+}
+function compressTextureCoordinates(textureCoordinates) {
+  const x = textureCoordinates.x * 4095 | 0;
+  const y = textureCoordinates.y * 4095 | 0;
+  return 4096 * x + y;
+}
+function decompressTextureCoordinates(compressed, result) {
+  const temp = compressed / 4096;
+  const xZeroTo4095 = Math.floor(temp);
+  result.x = xZeroTo4095 / 4095;
+  result.y = (compressed - xZeroTo4095 * 4096) / 4095;
+  return result;
+}
+function zigZagDeltaDecode(uBuffer, vBuffer, heightBuffer) {
+  assert2(uBuffer);
+  assert2(vBuffer);
+  assert2(uBuffer.length === vBuffer.length);
+  if (heightBuffer) {
+    assert2(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;
+    }
+  }
+}
+
+// src/geometry/utils/coordinates.ts
+function emod(n) {
+  return (n % 1 + 1) % 1;
+}

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-export type TypedArrayConstructor = Int8ArrayConstructor | Uint8ArrayConstructor | Int16ArrayConstructor | Uint16ArrayConstructor | Int32ArrayConstructor | Uint32ArrayConstructor | Int32ArrayConstructor | Uint32ArrayConstructor | Float32ArrayConstructor | Float64ArrayConstructor;
+export type TypedArrayConstructor = Int8ArrayConstructor | Uint8ArrayConstructor | Int16ArrayConstructor | Uint16ArrayConstructor | Int32ArrayConstructor | Uint32ArrayConstructor | Float32ArrayConstructor | Float64ArrayConstructor;
 export { GL } from './geometry/constants';
 export { GL_TYPE } from './geometry/constants';
 export { default as GLType } from './geometry/gl/gl-type';

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;AAEtD,OAAO,EAAC,IAAI,EAAC,MAAM,8BAA8B,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,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/dist/index.js

@@ -0,0 +1,12 @@
+export { GL } from "./geometry/constants.js";
+export { GL_TYPE } from "./geometry/constants.js";
+export { default as GLType } from "./geometry/gl/gl-type.js";
+export { default as isGeometry } from "./geometry/is-geometry.js";
+export { makeAttributeIterator } from "./geometry/iterators/attribute-iterator.js";
+export { makePrimitiveIterator } from "./geometry/iterators/primitive-iterator.js";
+export { computeVertexNormals } from "./geometry/attributes/compute-vertex-normals.js";
+export { encodeRGB565, decodeRGB565 } from "./geometry/colors/rgb565.js";
+export { concatTypedArrays } from "./geometry/typed-arrays/typed-array-utils.js";
+export { octEncodeInRange, octEncode, octEncodeToVector4, octDecodeInRange, octDecode, octDecodeFromVector4, octPackFloat, octEncodeFloat, octDecodeFloat, octPack, octUnpack, compressTextureCoordinates, decompressTextureCoordinates, zigZagDeltaDecode } from "./geometry/compression/attribute-compression.js";
+export { emod } from "./geometry/utils/coordinates.js";
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +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","emod"],"sources":["../src/index.ts"],"sourcesContent":["export type TypedArrayConstructor =\n  | Int8ArrayConstructor\n  | Uint8ArrayConstructor\n  | Int16ArrayConstructor\n  | Uint16ArrayConstructor\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":"SAUQA,EAAE;AAAA,SAGFC,OAAO;AAAA,SACPC,OAAO,IAAIC,MAAM;AAAA,SAGjBD,OAAO,IAAIE,UAAU;AAAA,SAGrBC,qBAAqB;AAAA,SACrBC,qBAAqB;AAAA,SAGrBC,oBAAoB;AAAA,SAEpBC,YAAY,EAAEC,YAAY;AAAA,SAG1BC,iBAAiB;AAAA,SAIvBC,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;AAAA,SAGXC,IAAI"}

package/dist/utils/assert.js.map

@@ -0,0 +1 @@
+{"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":"AAGA,OAAO,SAASA,MAAMA,CAACC,SAAkB,EAAEC,OAAgB,EAAQ;EACjE,IAAI,CAACD,SAAS,EAAE;IACd,MAAM,IAAIE,KAAK,CAACD,OAAO,IAAI,mCAAmC,CAAC;EACjE;AACF"}

package/package.json

@@ -1,8 +1,9 @@
 {
   "name": "@loaders.gl/math",
-  "version": "4.0.0-beta.1",
+  "version": "4.0.0-beta.3",
   "description": "Experimental math classes for loaders.gl",
   "license": "MIT",
+  "type": "module",
   "publishConfig": {
     "access": "public"
   },
@@ -18,8 +19,15 @@
     "glTF"
   ],
   "types": "dist/index.d.ts",
-  "main": "dist/es5/index.js",
-  "module": "dist/esm/index.js",
+  "main": "dist/index.cjs",
+  "module": "dist/index.js",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "require": "./dist/index.cjs",
+      "types": "./dist/index.d.ts"
+    }
+  },
   "sideEffects": false,
   "files": [
     "src",
@@ -31,9 +39,9 @@
     "pre-build": "echo \"Nothing to build in @loaders.gl/math\""
   },
   "dependencies": {
-    "@loaders.gl/images": "4.0.0-beta.1",
-    "@loaders.gl/loader-utils": "4.0.0-beta.1",
-    "@math.gl/core": "^3.5.1"
+    "@loaders.gl/images": "4.0.0-beta.3",
+    "@loaders.gl/loader-utils": "4.0.0-beta.3",
+    "@math.gl/core": "^4.0.0"
   },
-  "gitHead": "35c625e67132b0784e597d9ddabae8aefea29ff2"
+  "gitHead": "7ba9621cc51c7a26c407086ac86171f35b8712af"
 }

package/src/index.ts

@@ -5,8 +5,6 @@ export type TypedArrayConstructor =
   | Uint16ArrayConstructor
   | Int32ArrayConstructor
   | Uint32ArrayConstructor
-  | Int32ArrayConstructor
-  | Uint32ArrayConstructor
   | Float32ArrayConstructor
   | Float64ArrayConstructor;
 

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

@@ -1,46 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.computeBoundingBox = computeBoundingBox;
-var _attributeIterator = require("../iterators/attribute-iterator");
-var _assert = require("../utils/assert");
-function _createForOfIteratorHelper(o, allowArrayLike) { var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"]; if (!it) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = it.call(o); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it.return != null) it.return(); } finally { if (didErr) throw err; } } }; }
-function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
-function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i]; return arr2; }
-function computeBoundingBox() {
-  var positions = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];
-  var min = [Number(Infinity), Number(Infinity), Number(Infinity)];
-  var max = [-Infinity, -Infinity, -Infinity];
-  var _iterator = _createForOfIteratorHelper((0, _attributeIterator.makeAttributeIterator)(positions)),
-    _step;
-  try {
-    for (_iterator.s(); !(_step = _iterator.n()).done;) {
-      var position = _step.value;
-      var x = position[0];
-      var y = position[1];
-      var 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;
-    }
-  } catch (err) {
-    _iterator.e(err);
-  } finally {
-    _iterator.f();
-  }
-  var boundingBox = {
-    min: min,
-    max: max
-  };
-  validateBoundingBox(boundingBox);
-  return boundingBox;
-}
-function validateBoundingBox(boundingBox) {
-  (0, _assert.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]));
-}
-//# sourceMappingURL=compute-bounding-box.js.map