@math.gl/geometry 5.0.0-alpha.2 → 5.0.0-alpha.20

package/dist/utils/index.cjs

@@ -0,0 +1,965 @@
+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);
+
+// dist/utils/index.js
+var index_exports = {};
+__export(index_exports, {
+  GL: () => GL,
+  GLType: () => GLType,
+  GL_PRIMITIVE: () => GL_PRIMITIVE,
+  GL_PRIMITIVE_MODE: () => GL_PRIMITIVE_MODE,
+  GL_TYPE: () => GL_TYPE,
+  compressTextureCoordinates: () => compressTextureCoordinates,
+  computeVertexNormals: () => computeVertexNormals,
+  concatTypedArrays: () => concatTypedArrays,
+  decodeRGB565: () => decodeRGB565,
+  decompressTextureCoordinates: () => decompressTextureCoordinates,
+  emod: () => emod,
+  encodeRGB565: () => encodeRGB565,
+  getDegenerateTriangles: () => getDegenerateTriangles,
+  interpolatePackedAttributes: () => interpolatePackedAttributes,
+  isGeometry: () => isGeometry,
+  makeAttributeIterator: () => makeAttributeIterator,
+  makePrimitiveIterator: () => makePrimitiveIterator,
+  mergeGeometries: () => mergeGeometries,
+  octDecode: () => octDecode,
+  octDecodeFloat: () => octDecodeFloat,
+  octDecodeFromVector4: () => octDecodeFromVector4,
+  octDecodeInRange: () => octDecodeInRange,
+  octEncode: () => octEncode,
+  octEncodeFloat: () => octEncodeFloat,
+  octEncodeInRange: () => octEncodeInRange,
+  octEncodeToVector4: () => octEncodeToVector4,
+  octPack: () => octPack,
+  octPackFloat: () => octPackFloat,
+  octUnpack: () => octUnpack,
+  transformGeometry: () => transformGeometry,
+  weldGeometry: () => weldGeometry,
+  zigZagDeltaDecode: () => zigZagDeltaDecode
+});
+module.exports = __toCommonJS(index_exports);
+
+// dist/utils/constants.js
+var GL_PRIMITIVE = {
+  POINTS: 0,
+  LINES: 1,
+  TRIANGLES: 4
+};
+var GL_PRIMITIVE_MODE = {
+  POINTS: 0,
+  LINES: 1,
+  LINE_LOOP: 2,
+  LINE_STRIP: 3,
+  TRIANGLES: 4,
+  TRIANGLE_STRIP: 5,
+  TRIANGLE_FAN: 6
+};
+var GL_TYPE = {
+  BYTE: 5120,
+  UNSIGNED_BYTE: 5121,
+  SHORT: 5122,
+  UNSIGNED_SHORT: 5123,
+  INT: 5124,
+  UNSIGNED_INT: 5125,
+  FLOAT: 5126,
+  DOUBLE: 5130,
+  UNSIGNED_SHORT_4_4_4_4: 32819,
+  UNSIGNED_SHORT_5_5_5_1: 32820,
+  UNSIGNED_SHORT_5_6_5: 33635
+};
+var GL = {
+  ...GL_PRIMITIVE_MODE,
+  ...GL_TYPE
+};
+
+// dist/utils/gl-type.js
+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,
+  [GL_TYPE.UNSIGNED_SHORT_4_4_4_4]: Uint16Array,
+  [GL_TYPE.UNSIGNED_SHORT_5_5_5_1]: Uint16Array,
+  [GL_TYPE.UNSIGNED_SHORT_5_6_5]: Uint16Array
+};
+var NAME_TO_GL_TYPE = Object.fromEntries(Object.entries(GL_TYPE).map(([name, glType]) => [name, glType]));
+var TYPE_CONVERSION_ERROR = "Failed to convert GL type";
+var GLType = class _GLType {
+  /** Returns the WebGL component constant for a typed array or typed-array constructor. */
+  static fromTypedArray(arrayOrType) {
+    const arrayType = ArrayBuffer.isView(arrayOrType) ? arrayOrType.constructor : arrayOrType;
+    if (arrayType === Uint8ClampedArray) {
+      return GL_TYPE.UNSIGNED_BYTE;
+    }
+    for (const [glType, candidateArrayType] of Object.entries(GL_TYPE_TO_ARRAY_TYPE)) {
+      if (candidateArrayType === arrayType) {
+        return Number(glType);
+      }
+    }
+    throw new Error(TYPE_CONVERSION_ERROR);
+  }
+  /** Returns a WebGL component constant from its uppercase name. */
+  static fromName(name) {
+    const glType = NAME_TO_GL_TYPE[name];
+    if (glType === void 0) {
+      throw new Error(TYPE_CONVERSION_ERROR);
+    }
+    return glType;
+  }
+  /** Returns the typed-array constructor for a WebGL component constant. */
+  static getArrayType(glType) {
+    const ArrayType = GL_TYPE_TO_ARRAY_TYPE[glType];
+    if (!ArrayType) {
+      throw new Error(TYPE_CONVERSION_ERROR);
+    }
+    return ArrayType;
+  }
+  /** Returns the size in bytes of one element of a WebGL component type. */
+  static getByteSize(glType) {
+    return _GLType.getArrayType(glType).BYTES_PER_ELEMENT;
+  }
+  /** Returns whether a value is a supported WebGL component type. */
+  static validate(glType) {
+    return Boolean(GL_TYPE_TO_ARRAY_TYPE[glType]);
+  }
+  /** Creates a typed view over an ArrayBuffer or an existing ArrayBuffer view. */
+  static createTypedArray(glType, buffer, byteOffset = 0, length) {
+    const ArrayType = _GLType.getArrayType(glType);
+    const arrayBuffer = ArrayBuffer.isView(buffer) ? buffer.buffer : buffer;
+    const viewByteOffset = ArrayBuffer.isView(buffer) ? buffer.byteOffset : 0;
+    const resolvedByteOffset = viewByteOffset + byteOffset;
+    const resolvedLength = length ?? Math.floor((buffer.byteLength - byteOffset) / ArrayType.BYTES_PER_ELEMENT);
+    return new ArrayType(arrayBuffer, resolvedByteOffset, resolvedLength);
+  }
+};
+
+// dist/utils/geometry.js
+function isGeometry(value) {
+  if (!value || typeof value !== "object") {
+    return false;
+  }
+  const geometry = value;
+  return typeof geometry.mode === "number" && Boolean(geometry.attributes);
+}
+function getAttributeValues(attribute) {
+  if (ArrayBuffer.isView(attribute)) {
+    return attribute;
+  }
+  const values = attribute.value || attribute.values;
+  if (!values) {
+    throw new Error("Geometry attribute does not contain typed-array values");
+  }
+  return values;
+}
+function getPositionAttribute(geometry) {
+  const position = geometry.attributes["POSITION"] || geometry.attributes["positions"];
+  if (!position) {
+    throw new Error("Geometry does not contain a position attribute");
+  }
+  return position;
+}
+
+// dist/utils/attribute-iterator.js
+function* makeAttributeIterator(values, size) {
+  if (!Number.isInteger(size) || size <= 0) {
+    throw new Error("Attribute size must be a positive integer");
+  }
+  if (values.length % size !== 0) {
+    throw new Error("Attribute length must be divisible by its size");
+  }
+  const ArrayType = values.constructor;
+  const element = new ArrayType(size);
+  for (let index = 0; index < values.length; index += size) {
+    for (let componentIndex = 0; componentIndex < size; componentIndex++) {
+      element[componentIndex] = values[index + componentIndex];
+    }
+    yield element;
+  }
+}
+
+// dist/utils/primitive-iterator.js
+function* makePrimitiveIterator(geometryOrIndices, attributes = {}, mode, start = 0, end) {
+  let indices;
+  if (isGeometry(geometryOrIndices)) {
+    const geometry = geometryOrIndices;
+    indices = geometry.indices ? getAttributeValues(geometry.indices) : void 0;
+    attributes = geometry.attributes;
+    mode = geometry.mode;
+    if (end === void 0) {
+      const position = getPositionAttribute(geometry);
+      end = (indices == null ? void 0 : indices.length) ?? getAttributeValues(position).length / (position.size || 3);
+    }
+  } else if (geometryOrIndices) {
+    indices = getAttributeValues(geometryOrIndices);
+  }
+  if (mode === void 0) {
+    throw new Error("Primitive mode is required");
+  }
+  end ?? (end = (indices == null ? void 0 : indices.length) ?? start);
+  const dereference = (index) => Number(indices ? indices[index] : index);
+  let primitiveIndex = 0;
+  switch (mode) {
+    case GL.POINTS:
+      for (let index = start; index < end; index++) {
+        yield {
+          attributes,
+          type: GL.POINTS,
+          i1: dereference(index),
+          primitiveIndex: primitiveIndex++
+        };
+      }
+      return;
+    case GL.LINES:
+      for (let index = start; index + 1 < end; index += 2) {
+        yield {
+          attributes,
+          type: GL.LINES,
+          i1: dereference(index),
+          i2: dereference(index + 1),
+          primitiveIndex: primitiveIndex++
+        };
+      }
+      return;
+    case GL.LINE_STRIP:
+      for (let index = start; index + 1 < end; index++) {
+        yield {
+          attributes,
+          type: GL.LINES,
+          i1: dereference(index),
+          i2: dereference(index + 1),
+          primitiveIndex: primitiveIndex++
+        };
+      }
+      return;
+    case GL.LINE_LOOP:
+      for (let index = start; index < end; index++) {
+        yield {
+          attributes,
+          type: GL.LINES,
+          i1: dereference(index),
+          i2: dereference(index + 1 < end ? index + 1 : start),
+          primitiveIndex: primitiveIndex++
+        };
+      }
+      return;
+    case GL.TRIANGLES:
+      for (let index = start; index + 2 < end; index += 3) {
+        yield {
+          attributes,
+          type: GL.TRIANGLES,
+          i1: dereference(index),
+          i2: dereference(index + 1),
+          i3: dereference(index + 2),
+          primitiveIndex: primitiveIndex++
+        };
+      }
+      return;
+    case GL.TRIANGLE_STRIP:
+      for (let index = start; index + 2 < end; index++) {
+        const odd = (index - start) % 2 === 1;
+        yield {
+          attributes,
+          type: GL.TRIANGLES,
+          i1: dereference(odd ? index + 1 : index),
+          i2: dereference(odd ? index : index + 1),
+          i3: dereference(index + 2),
+          primitiveIndex: primitiveIndex++
+        };
+      }
+      return;
+    case GL.TRIANGLE_FAN:
+      for (let index = start + 1; index + 1 < end; index++) {
+        yield {
+          attributes,
+          type: GL.TRIANGLES,
+          i1: dereference(start),
+          i2: dereference(index),
+          i3: dereference(index + 1),
+          primitiveIndex: primitiveIndex++
+        };
+      }
+      return;
+    default:
+      throw new Error(`Unknown primitive mode ${mode}`);
+  }
+}
+
+// dist/utils/compute-vertex-normals.js
+var import_core = require("@math.gl/core");
+function computeVertexNormals(geometry) {
+  if (geometry.mode !== GL.TRIANGLES && geometry.mode !== GL.TRIANGLE_STRIP && geometry.mode !== GL.TRIANGLE_FAN) {
+    throw new Error("Triangle geometry is required");
+  }
+  const position = getPositionAttribute(geometry);
+  const positions = getAttributeValues(position);
+  const positionSize = position.size || 3;
+  if (positionSize < 3) {
+    throw new Error("Position attributes must have at least three components");
+  }
+  const vertexCount = positions.length / positionSize;
+  const normals = new Float32Array(vertexCount * 3);
+  const vectorA = new import_core.Vector3();
+  const vectorB = new import_core.Vector3();
+  const vectorC = new import_core.Vector3();
+  const edgeCB = new import_core.Vector3();
+  const edgeAB = new import_core.Vector3();
+  for (const primitive of makePrimitiveIterator(geometry)) {
+    const { i1, i2, i3 } = primitive;
+    if (i2 === void 0 || i3 === void 0) {
+      continue;
+    }
+    vectorA.fromArray(positions, i1 * positionSize);
+    vectorB.fromArray(positions, i2 * positionSize);
+    vectorC.fromArray(positions, i3 * positionSize);
+    const faceNormal = edgeCB.subVectors(vectorC, vectorB).cross(edgeAB.subVectors(vectorA, vectorB));
+    for (const vertexIndex of [i1, i2, i3]) {
+      normals[vertexIndex * 3] += faceNormal.x;
+      normals[vertexIndex * 3 + 1] += faceNormal.y;
+      normals[vertexIndex * 3 + 2] += faceNormal.z;
+    }
+  }
+  const normal = new import_core.Vector3();
+  for (let vertexIndex = 0; vertexIndex < vertexCount; vertexIndex++) {
+    normal.fromArray(normals, vertexIndex * 3);
+    if (normal.magnitudeSquared() > 0) {
+      normal.normalize().toArray(normals, vertexIndex * 3);
+    }
+  }
+  return normals;
+}
+
+// dist/utils/rgb565.js
+function decodeRGB565(rgb565, target = [0, 0, 0]) {
+  const red = rgb565 >> 11 & 31;
+  const green = rgb565 >> 5 & 63;
+  const blue = rgb565 & 31;
+  target[0] = red << 3 | red >> 2;
+  target[1] = green << 2 | green >> 4;
+  target[2] = blue << 3 | blue >> 2;
+  return target;
+}
+function encodeRGB565(rgb) {
+  const red = Math.round(clampByte(rgb[0] ?? 0) * (31 / 255));
+  const green = Math.round(clampByte(rgb[1] ?? 0) * (63 / 255));
+  const blue = Math.round(clampByte(rgb[2] ?? 0) * (31 / 255));
+  return red << 11 | green << 5 | blue;
+}
+function clampByte(value) {
+  return Math.max(0, Math.min(255, value));
+}
+
+// dist/utils/typed-array-utils.js
+function concatTypedArrays(arrays = []) {
+  const byteLength = arrays.reduce((length, array) => length + array.byteLength, 0);
+  const result = new Uint8Array(byteLength);
+  let byteOffset = 0;
+  for (const array of arrays) {
+    const bytes = new Uint8Array(array.buffer, array.byteOffset, array.byteLength);
+    result.set(bytes, byteOffset);
+    byteOffset += bytes.byteLength;
+  }
+  return result;
+}
+
+// dist/utils/attribute-compression.js
+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, rangeMaximum, result) {
+  (0, import_core2.assert)(vector);
+  (0, import_core2.assert)(result);
+  scratchVector3.from(vector);
+  (0, import_core2.assert)(Math.abs(scratchVector3.magnitudeSquared() - 1) <= import_core2._MathUtils.EPSILON6);
+  const denominator = Math.abs(vector.x) + Math.abs(vector.y) + Math.abs(vector.z);
+  result.x = vector.x / denominator;
+  result.y = vector.y / denominator;
+  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, rangeMaximum);
+  result.y = toSNorm(result.y, rangeMaximum);
+  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, rangeMaximum, result) {
+  (0, import_core2.assert)(result);
+  if (x < 0 || x > rangeMaximum || y < 0 || y > rangeMaximum) {
+    throw new Error(`x and y must be unsigned normalized integers between 0 and ${rangeMaximum}`);
+  }
+  result.x = fromSNorm(x, rangeMaximum);
+  result.y = fromSNorm(y, rangeMaximum);
+  result.z = 1 - (Math.abs(result.x) + Math.abs(result.y));
+  if (result.z < 0) {
+    const oldX = result.x;
+    result.x = (1 - Math.abs(result.y)) * signNotZero(oldX);
+    result.y = (1 - Math.abs(oldX)) * signNotZero(result.y);
+  }
+  return result.normalize();
+}
+function octDecode(x, y, result) {
+  return octDecodeInRange(x, y, 255, result);
+}
+function octDecodeFromVector4(encoded, result) {
+  (0, import_core2.assert)(encoded);
+  (0, import_core2.assert)(result);
+  const { x, y, z, w } = encoded;
+  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");
+  }
+  return octDecodeInRange(x * LEFT_SHIFT + y, z * LEFT_SHIFT + w, 65535, result);
+}
+function octPackFloat(encoded) {
+  scratchVector2.from(encoded);
+  return 256 * scratchVector2.x + scratchVector2.y;
+}
+function octEncodeFloat(vector) {
+  octEncode(vector, scratchEncodeVector2);
+  return octPackFloat(scratchEncodeVector2);
+}
+function octDecodeFloat(value, result) {
+  (0, import_core2.assert)(Number.isFinite(value));
+  const temporary = value / 256;
+  const x = Math.floor(temporary);
+  const y = (temporary - x) * 256;
+  return octDecode(x, y, result);
+}
+function octPack(vector1, vector2, vector3, result) {
+  (0, import_core2.assert)(vector1);
+  (0, import_core2.assert)(vector2);
+  (0, import_core2.assert)(vector3);
+  (0, import_core2.assert)(result);
+  const encoded1 = octEncodeFloat(vector1);
+  const encoded2 = octEncodeFloat(vector2);
+  const encoded3 = octEncode(vector3, scratchEncodeVector2);
+  result.x = 65536 * encoded3.x + encoded1;
+  result.y = 65536 * encoded3.y + encoded2;
+  return result;
+}
+function octUnpack(packed, vector1, vector2, vector3) {
+  let temporary = packed.x / 65536;
+  const x = Math.floor(temporary);
+  const encodedFloat1 = (temporary - x) * 65536;
+  temporary = packed.y / 65536;
+  const y = Math.floor(temporary);
+  const encodedFloat2 = (temporary - y) * 65536;
+  octDecodeFloat(encodedFloat1, vector1);
+  octDecodeFloat(encodedFloat2, vector2);
+  octDecode(x, y, vector3);
+}
+function compressTextureCoordinates(textureCoordinates) {
+  const x = textureCoordinates.x * 4095 | 0;
+  const y = textureCoordinates.y * 4095 | 0;
+  return 4096 * x + y;
+}
+function decompressTextureCoordinates(compressed, result) {
+  const temporary = compressed / 4096;
+  const x = Math.floor(temporary);
+  result.x = x / 4095;
+  result.y = (compressed - x * 4096) / 4095;
+  return result;
+}
+function zigZagDeltaDecode(uBuffer, vBuffer, heightBuffer) {
+  (0, import_core2.assert)(uBuffer);
+  (0, import_core2.assert)(vBuffer);
+  (0, import_core2.assert)(uBuffer.length === vBuffer.length);
+  if (heightBuffer) {
+    (0, import_core2.assert)(uBuffer.length === heightBuffer.length);
+  }
+  let u = 0;
+  let v = 0;
+  let height = 0;
+  for (let index = 0; index < uBuffer.length; index++) {
+    u += zigZagDecode(uBuffer[index]);
+    v += zigZagDecode(vBuffer[index]);
+    uBuffer[index] = u;
+    vBuffer[index] = v;
+    if (heightBuffer) {
+      height += zigZagDecode(heightBuffer[index]);
+      heightBuffer[index] = height;
+    }
+  }
+}
+function zigZagDecode(value) {
+  return value >> 1 ^ -(value & 1);
+}
+
+// dist/utils/coordinates.js
+function emod(value) {
+  return (value % 1 + 1) % 1;
+}
+
+// dist/utils/mesh-processing.js
+var import_core3 = require("@math.gl/core");
+function transformGeometry(geometry, matrix) {
+  const mesh = readMesh(geometry);
+  if (matrix.length !== 16 || Array.from(matrix).some((v) => !Number.isFinite(v)) || matrix[3] !== 0 || matrix[7] !== 0 || matrix[11] !== 0 || matrix[15] !== 1) {
+    throw new RangeError("Transform must be a finite affine column-major matrix");
+  }
+  const transform = new import_core3.Matrix4(Array.from(matrix));
+  const columns = [0, 4, 8].map((offset) => Array.from(matrix).slice(offset, offset + 3));
+  const scales = columns.map((column) => Math.max(...column.map(Math.abs)));
+  const basis = columns.map((column, i) => column.map((v) => scales[i] ? v / scales[i] : 0));
+  const cofactors = [
+    cross(basis[1], basis[2]),
+    cross(basis[2], basis[0]),
+    cross(basis[0], basis[1])
+  ];
+  const determinant = basis[0].reduce((sum, v, i) => sum + v * cofactors[0][i], 0);
+  const attributes = copyAttributes(mesh.attributes);
+  const normalName = attributes["NORMAL"] ? "NORMAL" : attributes["normals"] ? "normals" : null;
+  const tangentName = attributes["TANGENT"] ? "TANGENT" : null;
+  if ((normalName || tangentName) && (!Number.isFinite(determinant) || determinant === 0))
+    throw new RangeError("Normals and tangents require an invertible transform");
+  const positions = new Float64Array(mesh.count * 3);
+  const source = mesh.attributes[mesh.position].value;
+  for (let i = 0; i < mesh.count; i++) {
+    const point = transform.transformAsPoint([source[i * 3], source[i * 3 + 1], source[i * 3 + 2]]);
+    positions.set(point, i * 3);
+  }
+  attributes[mesh.position] = { size: 3, value: positions };
+  if (normalName) {
+    const input = mesh.attributes[normalName];
+    if (input.size !== 3)
+      throw new RangeError("Normals must have size 3");
+    const output = new Float64Array(mesh.count * 3);
+    for (let i = 0; i < mesh.count; i++) {
+      const value = normalizedLinearCombination(cofactors, Array.from(input.value.slice(i * 3, i * 3 + 3)), scales.map((v) => -Math.log(v)));
+      output.set(value.map((v) => determinant < 0 ? -v : v), i * 3);
+    }
+    attributes[normalName] = { size: 3, value: output };
+  }
+  if (tangentName) {
+    const input = mesh.attributes[tangentName];
+    if (input.size !== 4)
+      throw new RangeError("Tangents must have size 4");
+    const output = new Float64Array(mesh.count * 4);
+    for (let i = 0; i < mesh.count; i++) {
+      const value = normalizedLinearCombination(basis, Array.from(input.value.slice(i * 4, i * 4 + 3)), scales.map(Math.log));
+      if (normalName) {
+        const n = attributes[normalName].value.slice(i * 3, i * 3 + 3);
+        const projection = value[0] * n[0] + value[1] * n[1] + value[2] * n[2];
+        for (let axis = 0; axis < 3; axis++)
+          value[axis] -= projection * n[axis];
+      }
+      const length = Math.hypot(...value);
+      output.set(value.map((v) => length ? v / length : 0), i * 4);
+      output[i * 4 + 3] = input.value[i * 4 + 3] * (determinant < 0 ? -1 : 1);
+    }
+    attributes[tangentName] = { size: 4, value: output };
+  }
+  const indices = mesh.indices.slice();
+  if (determinant < 0)
+    for (let i = 0; i < indices.length; i += 3)
+      [indices[i + 1], indices[i + 2]] = [indices[i + 2], indices[i + 1]];
+  return { mode: GL.TRIANGLES, attributes, indices };
+}
+function mergeGeometries(geometries) {
+  if (!geometries.length)
+    throw new RangeError("At least one geometry is required");
+  const meshes = geometries.map(readMesh), first = meshes[0], names = Object.keys(first.attributes).sort();
+  let count = 0, indexCount = 0;
+  for (const mesh of meshes) {
+    if (mesh.position !== first.position || Object.keys(mesh.attributes).length !== names.length || names.some((name) => !Object.prototype.hasOwnProperty.call(mesh.attributes, name)))
+      throw new RangeError("Attribute names must match");
+    for (const name of names) {
+      if (mesh.attributes[name].size !== first.attributes[name].size || mesh.attributes[name].value.constructor !== first.attributes[name].value.constructor) {
+        throw new RangeError("Attribute sizes and storage types must match");
+      }
+    }
+    count += mesh.count;
+    indexCount += mesh.indices.length;
+  }
+  if (count > 4294967295)
+    throw new RangeError("Geometry exceeds 32-bit indexing");
+  const attributes = {};
+  for (const name of names) {
+    const attribute = first.attributes[name], Constructor = attribute.value.constructor;
+    const value = new Constructor(count * attribute.size);
+    let offset = 0;
+    for (const mesh of meshes) {
+      value.set(mesh.attributes[name].value, offset);
+      offset += mesh.attributes[name].value.length;
+    }
+    attributes[name] = { size: attribute.size, value };
+  }
+  const indices = new Uint32Array(indexCount);
+  let vertexOffset = 0, indexOffset = 0;
+  for (const mesh of meshes) {
+    for (const index of mesh.indices)
+      indices[indexOffset++] = index + vertexOffset;
+    vertexOffset += mesh.count;
+  }
+  return { mode: GL.TRIANGLES, attributes, indices };
+}
+function weldGeometry(geometry, options = {}) {
+  const mesh = readMesh(geometry), grid = options.positionGridSize ?? 0;
+  if (!Number.isFinite(grid) || grid < 0)
+    throw new RangeError("positionGridSize must be finite and nonnegative");
+  const names = Object.keys(mesh.attributes).sort(), keys = /* @__PURE__ */ new Map(), rows = [], vertexMap = new Uint32Array(mesh.count);
+  for (let i = 0; i < mesh.count; i++) {
+    const tuple = [];
+    for (const name of names) {
+      const attribute = mesh.attributes[name];
+      for (let component = 0; component < attribute.size; component++) {
+        const value = attribute.value[i * attribute.size + component];
+        const quantized = name === mesh.position && grid ? Math.round(value / grid) : value;
+        if (!Number.isFinite(quantized))
+          throw new RangeError("Position quantization overflow");
+        tuple.push(quantized);
+      }
+    }
+    const key = tuple.join(",");
+    let row = keys.get(key);
+    if (row === void 0) {
+      row = rows.length;
+      keys.set(key, row);
+      rows.push(i);
+    }
+    vertexMap[i] = row;
+  }
+  const attributes = {};
+  for (const name of names) {
+    const attribute = mesh.attributes[name], Constructor = attribute.value.constructor;
+    const value = new Constructor(rows.length * attribute.size);
+    rows.forEach((row, i) => value.set(attribute.value.subarray(row * attribute.size, (row + 1) * attribute.size), i * attribute.size));
+    attributes[name] = { size: attribute.size, value };
+  }
+  return {
+    geometry: {
+      mode: GL.TRIANGLES,
+      attributes,
+      indices: Uint32Array.from(mesh.indices, (index) => vertexMap[index])
+    },
+    vertexMap,
+    removedVertices: mesh.count - rows.length
+  };
+}
+function getDegenerateTriangles(geometry, areaEpsilon = 0) {
+  if (!Number.isFinite(areaEpsilon) || areaEpsilon < 0)
+    throw new RangeError("Area epsilon must be finite and nonnegative");
+  const mesh = readMesh(geometry), positions = mesh.attributes[mesh.position].value, result = [];
+  for (let i = 0; i < mesh.indices.length; i += 3) {
+    const [a, b, c] = Array.from(mesh.indices.subarray(i, i + 3), (index) => index * 3);
+    const ab = [
+      positions[b] - positions[a],
+      positions[b + 1] - positions[a + 1],
+      positions[b + 2] - positions[a + 2]
+    ];
+    const ac = [
+      positions[c] - positions[a],
+      positions[c + 1] - positions[a + 1],
+      positions[c + 2] - positions[a + 2]
+    ];
+    const scaleAB = Math.max(...ab.map(Math.abs));
+    const scaleAC = Math.max(...ac.map(Math.abs));
+    const normalizedAB = ab.map((v) => scaleAB ? v / scaleAB : 0);
+    const normalizedAC = ac.map((v) => scaleAC ? v / scaleAC : 0);
+    const crossLength = Math.hypot(...cross(normalizedAB, normalizedAC));
+    const lostComponent = [ab, ac].some((edge, i2) => edge.some((v, axis) => v !== 0 && (i2 ? normalizedAC : normalizedAB)[axis] === 0));
+    if (!Number.isFinite(crossLength) || crossLength === 0 || lostComponent) {
+      if (exactAreaAtMost(positions, a, b, c, areaEpsilon))
+        result.push(i / 3);
+    } else {
+      const logArea = Math.log(crossLength) + Math.log(scaleAB) + Math.log(scaleAC) - Math.log(2);
+      if (areaEpsilon > 0 && logArea <= Math.log(areaEpsilon))
+        result.push(i / 3);
+    }
+  }
+  return Uint32Array.from(result);
+}
+function readMesh(geometry) {
+  if (geometry.mode !== GL.TRIANGLES)
+    throw new RangeError("Packed triangle-list geometry is required");
+  const position = geometry.attributes["POSITION"] ? "POSITION" : geometry.attributes["positions"] ? "positions" : null;
+  if (!position)
+    throw new RangeError("POSITION or positions is required");
+  const attributes = {};
+  let count;
+  for (const [name, attribute] of Object.entries(geometry.attributes)) {
+    const value = getAttributeValues(attribute), size = attribute.size ?? (name === position ? 3 : void 0);
+    if (!Number.isSafeInteger(size) || size < 1 || value.length % size)
+      throw new RangeError("Attributes need explicit packed sizes");
+    const length = value.length / size;
+    if (name === position) {
+      if (size !== 3)
+        throw new RangeError("Positions must have size 3");
+      count = length;
+    }
+    for (const component of value)
+      if (!Number.isFinite(component))
+        throw new RangeError("Attributes must be finite");
+    attributes[name] = { value, size };
+  }
+  for (const attribute of Object.values(attributes))
+    if (attribute.value.length / attribute.size !== count)
+      throw new RangeError("Attribute vertex counts must match");
+  if (count > 4294967295)
+    throw new RangeError("Geometry exceeds 32-bit indexing");
+  const input = geometry.indices ? getAttributeValues(geometry.indices) : Uint32Array.from({ length: count }, (_, i) => i);
+  if (input.length % 3)
+    throw new RangeError("Indices must form triangles");
+  for (const index of input)
+    if (!Number.isSafeInteger(index) || index < 0 || index >= count)
+      throw new RangeError("Vertex index is out of bounds");
+  return { attributes, position, count, indices: Uint32Array.from(input) };
+}
+function copyAttributes(attributes) {
+  return Object.fromEntries(Object.entries(attributes).map(([name, attribute]) => [
+    name,
+    { size: attribute.size, value: attribute.value.slice() }
+  ]));
+}
+function cross(a, b) {
+  return [a[1] * b[2] - a[2] * b[1], a[2] * b[0] - a[0] * b[2], a[0] * b[1] - a[1] * b[0]];
+}
+function normalizedLinearCombination(columns, vector, logScales) {
+  const logs = vector.map((v, i) => v ? Math.log(Math.abs(v)) + logScales[i] : -Infinity);
+  const largest = Math.max(...logs);
+  if (largest === -Infinity)
+    return [0, 0, 0];
+  const weights = logs.map((v, i) => Math.sign(vector[i]) * Math.exp(v - largest));
+  const result = [0, 1, 2].map((axis) => columns.reduce((sum, column, i) => sum + column[axis] * weights[i], 0));
+  const length = Math.hypot(...result);
+  return result.map((v) => length ? v / length : 0);
+}
+function exactAreaAtMost(positions, a, b, c, epsilon) {
+  const edge = (end) => [0, 1, 2].map((axis) => subtractDyadic(toDyadic(positions[end + axis]), toDyadic(positions[a + axis])));
+  const ab = edge(b), ac = edge(c);
+  const components = [0, 1, 2].map((axis) => {
+    const j = (axis + 1) % 3, k = (axis + 2) % 3;
+    return subtractDyadic(multiplyDyadic(ab[j], ac[k]), multiplyDyadic(ab[k], ac[j]));
+  });
+  if (epsilon === 0)
+    return components.every((v) => v.n === 0n);
+  const squared = components.map((v) => multiplyDyadic(v, v));
+  const sum = squared.reduce((total, v) => subtractDyadic(total, { ...v, n: -v.n }), {
+    n: 0n,
+    exponent: 0
+  });
+  const threshold = multiplyDyadic(toDyadic(epsilon), toDyadic(epsilon));
+  threshold.exponent += 2;
+  return subtractDyadic(sum, threshold).n <= 0n;
+}
+function toDyadic(value) {
+  const bits = new DataView(new ArrayBuffer(8));
+  bits.setFloat64(0, value);
+  const high = bits.getUint32(0), low = bits.getUint32(4);
+  const exponentBits = high >>> 20 & 2047;
+  const fraction = BigInt(high & 1048575) << 32n | BigInt(low);
+  const n = exponentBits ? 1n << 52n | fraction : fraction;
+  return { n: high >>> 31 ? -n : n, exponent: exponentBits ? exponentBits - 1075 : -1074 };
+}
+function subtractDyadic(a, b) {
+  const exponent = Math.min(a.exponent, b.exponent);
+  return {
+    n: (a.n << BigInt(a.exponent - exponent)) - (b.n << BigInt(b.exponent - exponent)),
+    exponent
+  };
+}
+function multiplyDyadic(a, b) {
+  return { n: a.n * b.n, exponent: a.exponent + b.exponent };
+}
+
+// dist/utils/interpolate-packed-attributes.js
+var BYTE_SIZES = {
+  int8: 1,
+  uint8: 1,
+  int16: 2,
+  uint16: 2,
+  int32: 4,
+  uint32: 4,
+  float32: 4,
+  float64: 8
+};
+function interpolatePackedAttributes(source, provenance, options) {
+  const { byteStride, attributes, littleEndian = true, maxOutputBytes = 64 * 1024 * 1024 } = options;
+  const { sourceVertexIndices, sourceVertexWeights } = provenance;
+  if (!Number.isSafeInteger(byteStride) || byteStride <= 0 || source.byteLength % byteStride || !Array.isArray(options.attributes) || typeof littleEndian !== "boolean" || !Number.isSafeInteger(maxOutputBytes) || maxOutputBytes < 0 || !Number.isSafeInteger(sourceVertexIndices.length) || sourceVertexIndices.length < 0 || sourceVertexIndices.length % 3 || sourceVertexIndices.length !== sourceVertexWeights.length) {
+    throw new RangeError("Invalid packed attribute layout or provenance lengths");
+  }
+  const outputCount = sourceVertexIndices.length / 3;
+  const outputBytes = outputCount * byteStride;
+  if (!Number.isSafeInteger(outputBytes) || outputBytes > maxOutputBytes) {
+    throw new RangeError("Packed attribute interpolation exceeded maxOutputBytes");
+  }
+  const ranges = [];
+  for (const attribute of attributes) {
+    if (!attribute || typeof attribute !== "object" || !Object.prototype.hasOwnProperty.call(BYTE_SIZES, attribute.type) || !Number.isSafeInteger(attribute.size) || attribute.size <= 0 || !Number.isSafeInteger(attribute.byteOffset) || attribute.byteOffset < 0) {
+      throw new RangeError("Invalid packed attribute descriptor");
+    }
+    const end = attribute.byteOffset + attribute.size * BYTE_SIZES[attribute.type];
+    if (!Number.isSafeInteger(end) || end > byteStride || ranges.some(([start, previousEnd]) => attribute.byteOffset < previousEnd && end > start)) {
+      throw new RangeError("Packed attribute ranges must fit the stride and not overlap");
+    }
+    ranges.push([attribute.byteOffset, end]);
+    if (typeof attribute.interpolation === "string") {
+      validateInterpolation(attribute.interpolation);
+    } else {
+      if (!Array.isArray(attribute.interpolation) || attribute.interpolation.length !== attribute.size) {
+        throw new RangeError("Expected one interpolation policy per component");
+      }
+      for (let component = 0; component < attribute.size; component++) {
+        validateInterpolation(attribute.interpolation[component]);
+      }
+    }
+  }
+  const sourceCount = source.byteLength / byteStride;
+  const input = new DataView(source.buffer, source.byteOffset, source.byteLength);
+  const output = new Uint8Array(outputBytes);
+  const result = new DataView(output.buffer);
+  for (let vertex = 0; vertex < outputCount; vertex++) {
+    let sum = 0;
+    let firstSource = -1;
+    let contributors = 0;
+    for (let slot = 0; slot < 3; slot++) {
+      const weight = sourceVertexWeights[vertex * 3 + slot];
+      const index = sourceVertexIndices[vertex * 3 + slot];
+      if (!Number.isFinite(weight) || weight < 0 || weight > 1 || weight > 0 && (!Number.isSafeInteger(index) || index < 0 || index >= sourceCount)) {
+        throw new RangeError("Invalid contributing source index or interpolation weight");
+      }
+      if (weight > 0) {
+        contributors++;
+        if (firstSource < 0)
+          firstSource = index;
+      }
+      sum += weight;
+    }
+    if (firstSource < 0 || Math.abs(sum - 1) > 1e-10) {
+      throw new RangeError("Interpolation weights must sum to one");
+    }
+    output.set(source.subarray(firstSource * byteStride, (firstSource + 1) * byteStride), vertex * byteStride);
+    for (const attribute of attributes) {
+      for (let component = 0; component < attribute.size; component++) {
+        const offset = attribute.byteOffset + component * BYTE_SIZES[attribute.type];
+        const policy = typeof attribute.interpolation === "string" ? attribute.interpolation : attribute.interpolation[component];
+        const firstValue = readComponent(input, firstSource * byteStride + offset, attribute.type, littleEndian);
+        let value = 0;
+        for (let slot = 0; slot < 3; slot++) {
+          const weight = sourceVertexWeights[vertex * 3 + slot];
+          if (weight === 0)
+            continue;
+          const sourceValue = readComponent(input, sourceVertexIndices[vertex * 3 + slot] * byteStride + offset, attribute.type, littleEndian);
+          if (!Number.isFinite(sourceValue))
+            throw new RangeError("Packed attributes must be finite");
+          if (policy === "flat" && sourceValue !== firstValue) {
+            throw new RangeError("Flat attribute contributors must agree");
+          }
+          value += sourceValue * weight;
+        }
+        if (policy === "linear") {
+          if (!Number.isFinite(value))
+            throw new RangeError("Interpolated attributes must be finite");
+          if (contributors !== 1 || sum !== 1) {
+            writeComponent(result, vertex * byteStride + offset, attribute.type, value, littleEndian);
+          }
+        }
+      }
+    }
+  }
+  return output;
+}
+function validateInterpolation(interpolation) {
+  if (interpolation !== "linear" && interpolation !== "flat") {
+    throw new RangeError("Expected linear or flat interpolation");
+  }
+}
+function readComponent(view, offset, type, littleEndian) {
+  switch (type) {
+    case "int8":
+      return view.getInt8(offset);
+    case "uint8":
+      return view.getUint8(offset);
+    case "int16":
+      return view.getInt16(offset, littleEndian);
+    case "uint16":
+      return view.getUint16(offset, littleEndian);
+    case "int32":
+      return view.getInt32(offset, littleEndian);
+    case "uint32":
+      return view.getUint32(offset, littleEndian);
+    case "float32":
+      return view.getFloat32(offset, littleEndian);
+    case "float64":
+      return view.getFloat64(offset, littleEndian);
+  }
+}
+function writeComponent(view, offset, type, value, littleEndian) {
+  const integer = Math.round(value);
+  switch (type) {
+    case "int8":
+      view.setInt8(offset, integer);
+      break;
+    case "uint8":
+      view.setUint8(offset, integer);
+      break;
+    case "int16":
+      view.setInt16(offset, integer, littleEndian);
+      break;
+    case "uint16":
+      view.setUint16(offset, integer, littleEndian);
+      break;
+    case "int32":
+      view.setInt32(offset, integer, littleEndian);
+      break;
+    case "uint32":
+      view.setUint32(offset, integer, littleEndian);
+      break;
+    case "float32":
+      view.setFloat32(offset, value, littleEndian);
+      break;
+    case "float64":
+      view.setFloat64(offset, value, littleEndian);
+      break;
+  }
+}
+//# sourceMappingURL=index.cjs.map