@math.gl/geometry-utils 4.2.0-alpha.5

package/dist/index.cjs

@@ -0,0 +1,535 @@
+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/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,
+  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(index_exports);
+
+// dist/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/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/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/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/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/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/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/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/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/coordinates.js
+function emod(value) {
+  return (value % 1 + 1) % 1;
+}
+//# sourceMappingURL=index.cjs.map

package/dist/index.cjs.map

@@ -0,0 +1,6 @@
+{
+  "version": 3,
+  "sources": ["../src/index.ts", "../src/constants.ts", "../src/gl-type.ts", "../src/geometry.ts", "../src/attribute-iterator.ts", "../src/primitive-iterator.ts", "../src/compute-vertex-normals.ts", "../src/rgb565.ts", "../src/typed-array-utils.ts", "../src/attribute-compression.ts", "../src/coordinates.ts"],
+  "mappings": "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",
+  "names": ["import_core"]
+}

package/dist/index.d.ts

@@ -0,0 +1,14 @@
+export type { TypedArray, TypedArrayConstructor } from '@math.gl/types';
+export { GL, GL_TYPE, GL_PRIMITIVE, GL_PRIMITIVE_MODE } from "./constants.js";
+export { default as GLType } from "./gl-type.js";
+export type { Geometry, GeometryAttribute } from "./geometry.js";
+export { isGeometry } from "./geometry.js";
+export type { Primitive } from "./primitive-iterator.js";
+export { makeAttributeIterator } from "./attribute-iterator.js";
+export { makePrimitiveIterator } from "./primitive-iterator.js";
+export { computeVertexNormals } from "./compute-vertex-normals.js";
+export { encodeRGB565, decodeRGB565 } from "./rgb565.js";
+export { concatTypedArrays } from "./typed-array-utils.js";
+export { octEncodeInRange, octEncode, octEncodeToVector4, octDecodeInRange, octDecode, octDecodeFromVector4, octPackFloat, octEncodeFloat, octDecodeFloat, octPack, octUnpack, compressTextureCoordinates, decompressTextureCoordinates, zigZagDeltaDecode } from "./attribute-compression.js";
+export { emod } from "./coordinates.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAIA,YAAY,EAAC,UAAU,EAAE,qBAAqB,EAAC,MAAM,gBAAgB,CAAC;AAEtE,OAAO,EAAC,EAAE,EAAE,OAAO,EAAE,YAAY,EAAE,iBAAiB,EAAC,uBAAoB;AACzE,OAAO,EAAC,OAAO,IAAI,MAAM,EAAC,qBAAkB;AAE5C,YAAY,EAAC,QAAQ,EAAE,iBAAiB,EAAC,sBAAmB;AAC5D,OAAO,EAAC,UAAU,EAAC,sBAAmB;AAEtC,YAAY,EAAC,SAAS,EAAC,gCAA6B;AACpD,OAAO,EAAC,qBAAqB,EAAC,gCAA6B;AAC3D,OAAO,EAAC,qBAAqB,EAAC,gCAA6B;AAC3D,OAAO,EAAC,oBAAoB,EAAC,oCAAiC;AAE9D,OAAO,EAAC,YAAY,EAAE,YAAY,EAAC,oBAAiB;AACpD,OAAO,EAAC,iBAAiB,EAAC,+BAA4B;AAEtD,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,mCAAgC;AAEjC,OAAO,EAAC,IAAI,EAAC,yBAAsB"}

package/dist/index.js

@@ -0,0 +1,14 @@
+// math.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+export { GL, GL_TYPE, GL_PRIMITIVE, GL_PRIMITIVE_MODE } from "./constants.js";
+export { default as GLType } from "./gl-type.js";
+export { isGeometry } from "./geometry.js";
+export { makeAttributeIterator } from "./attribute-iterator.js";
+export { makePrimitiveIterator } from "./primitive-iterator.js";
+export { computeVertexNormals } from "./compute-vertex-normals.js";
+export { encodeRGB565, decodeRGB565 } from "./rgb565.js";
+export { concatTypedArrays } from "./typed-array-utils.js";
+export { octEncodeInRange, octEncode, octEncodeToVector4, octDecodeInRange, octDecode, octDecodeFromVector4, octPackFloat, octEncodeFloat, octDecodeFloat, octPack, octUnpack, compressTextureCoordinates, decompressTextureCoordinates, zigZagDeltaDecode } from "./attribute-compression.js";
+export { emod } from "./coordinates.js";
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,UAAU;AACV,+BAA+B;AAC/B,oCAAoC;AAIpC,OAAO,EAAC,EAAE,EAAE,OAAO,EAAE,YAAY,EAAE,iBAAiB,EAAC,uBAAoB;AACzE,OAAO,EAAC,OAAO,IAAI,MAAM,EAAC,qBAAkB;AAG5C,OAAO,EAAC,UAAU,EAAC,sBAAmB;AAGtC,OAAO,EAAC,qBAAqB,EAAC,gCAA6B;AAC3D,OAAO,EAAC,qBAAqB,EAAC,gCAA6B;AAC3D,OAAO,EAAC,oBAAoB,EAAC,oCAAiC;AAE9D,OAAO,EAAC,YAAY,EAAE,YAAY,EAAC,oBAAiB;AACpD,OAAO,EAAC,iBAAiB,EAAC,+BAA4B;AAEtD,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,mCAAgC;AAEjC,OAAO,EAAC,IAAI,EAAC,yBAAsB"}

package/dist/primitive-iterator.d.ts

@@ -0,0 +1,21 @@
+import type { TypedArray } from '@math.gl/types';
+import type { Geometry } from "./geometry.js";
+/** One dereferenced point, line, or triangle primitive. */
+export type Primitive = {
+    attributes: object;
+    type: number;
+    i1: number;
+    i2?: number;
+    i3?: number;
+    primitiveIndex: number;
+};
+/**
+ * Iterates through a geometry's primitives and dereferences optional indices.
+ *
+ * The legacy argument form `(indices, attributes, mode, start, end)` is also supported.
+ */
+export declare function makePrimitiveIterator(geometryOrIndices?: Geometry | TypedArray | {
+    value?: TypedArray;
+    values?: TypedArray;
+}, attributes?: object, mode?: number, start?: number, end?: number): Iterable<Primitive>;
+//# sourceMappingURL=primitive-iterator.d.ts.map

package/dist/primitive-iterator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"primitive-iterator.d.ts","sourceRoot":"","sources":["../src/primitive-iterator.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAC,UAAU,EAAC,MAAM,gBAAgB,CAAC;AAE/C,OAAO,KAAK,EAAC,QAAQ,EAAC,sBAAmB;AAGzC,2DAA2D;AAC3D,MAAM,MAAM,SAAS,GAAG;IACtB,UAAU,EAAE,MAAM,CAAC;IACnB,IAAI,EAAE,MAAM,CAAC;IACb,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,CAAC,EAAE,MAAM,CAAC;IACZ,EAAE,CAAC,EAAE,MAAM,CAAC;IACZ,cAAc,EAAE,MAAM,CAAC;CACxB,CAAC;AAEF;;;;GAIG;AACH,wBAAiB,qBAAqB,CACpC,iBAAiB,CAAC,EAAE,QAAQ,GAAG,UAAU,GAAG;IAAC,KAAK,CAAC,EAAE,UAAU,CAAC;IAAC,MAAM,CAAC,EAAE,UAAU,CAAA;CAAC,EACrF,UAAU,GAAE,MAAW,EACvB,IAAI,CAAC,EAAE,MAAM,EACb,KAAK,SAAI,EACT,GAAG,CAAC,EAAE,MAAM,GACX,QAAQ,CAAC,SAAS,CAAC,CAkHrB"}