@loaders.gl/tile-converter 5.0.0-alpha.7 → 5.0.0-alpha.8

package/dist/v5/browser.js

@@ -0,0 +1,1927 @@
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res, err) => function __init() {
+  if (err) throw err[0];
+  try {
+    return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+  } catch (e) {
+    throw err = [e], e;
+  }
+};
+
+// ../../modules/loader-utils/src/lib/env-utils/assert.ts
+function assert(condition, message) {
+  if (!condition) {
+    throw new Error(message || "loader assertion failed.");
+  }
+}
+var init_assert = __esm({
+  "../../modules/loader-utils/src/lib/env-utils/assert.ts"() {
+    "use strict";
+  }
+});
+
+// ../../modules/loader-utils/src/lib/binary-utils/memory-copy-utils.ts
+function padToNBytes(byteLength, padding) {
+  assert(byteLength >= 0);
+  assert(padding > 0);
+  return byteLength + (padding - 1) & ~(padding - 1);
+}
+var init_memory_copy_utils = __esm({
+  "../../modules/loader-utils/src/lib/binary-utils/memory-copy-utils.ts"() {
+    "use strict";
+    init_assert();
+  }
+});
+
+// ../../modules/loader-utils/src/lib/binary-utils/dataview-copy-utils.ts
+function padStringToByteAlignment(string, byteAlignment) {
+  const length = string.length;
+  const paddedLength = Math.ceil(length / byteAlignment) * byteAlignment;
+  const padding = paddedLength - length;
+  let whitespace = "";
+  for (let i = 0; i < padding; ++i) {
+    whitespace += " ";
+  }
+  return string + whitespace;
+}
+function copyStringToDataView(dataView, byteOffset, string, byteLength) {
+  if (dataView) {
+    for (let i = 0; i < byteLength; i++) {
+      dataView.setUint8(byteOffset + i, string.charCodeAt(i));
+    }
+  }
+  return byteOffset + byteLength;
+}
+function copyBinaryToDataView(dataView, byteOffset, binary, byteLength) {
+  if (dataView) {
+    for (let i = 0; i < byteLength; i++) {
+      dataView.setUint8(byteOffset + i, binary[i]);
+    }
+  }
+  return byteOffset + byteLength;
+}
+function copyPaddedArrayBufferToDataView(dataView, byteOffset, sourceBuffer, padding) {
+  const paddedLength = padToNBytes(sourceBuffer.byteLength, padding);
+  const padLength = paddedLength - sourceBuffer.byteLength;
+  if (dataView) {
+    const targetArray = new Uint8Array(
+      dataView.buffer,
+      dataView.byteOffset + byteOffset,
+      sourceBuffer.byteLength
+    );
+    const sourceArray = new Uint8Array(sourceBuffer);
+    targetArray.set(sourceArray);
+    for (let i = 0; i < padLength; ++i) {
+      dataView.setUint8(byteOffset + sourceBuffer.byteLength + i, 32);
+    }
+  }
+  byteOffset += paddedLength;
+  return byteOffset;
+}
+function copyPaddedStringToDataView(dataView, byteOffset, string, padding) {
+  const textEncoder = new TextEncoder();
+  const stringBuffer = textEncoder.encode(string);
+  byteOffset = copyPaddedArrayBufferToDataView(dataView, byteOffset, stringBuffer, padding);
+  return byteOffset;
+}
+var init_dataview_copy_utils = __esm({
+  "../../modules/loader-utils/src/lib/binary-utils/dataview-copy-utils.ts"() {
+    "use strict";
+    init_memory_copy_utils();
+  }
+});
+
+// ../../modules/loader-utils/src/index.ts
+var init_src = __esm({
+  "../../modules/loader-utils/src/index.ts"() {
+    "use strict";
+    init_assert();
+    init_memory_copy_utils();
+    init_dataview_copy_utils();
+  }
+});
+
+// ../../modules/tiles/src/tileset-3d/common/tileset-content-traversal.ts
+async function* traverseTilesetContents(tileset, options = {}) {
+  await tileset.tilesetInitializationPromise;
+  throwIfAborted2(options.signal);
+  if (!tileset.root) {
+    throw new Error("Tileset initialization completed without a root tile");
+  }
+  const stack = [tileset.root];
+  const visitedTiles = /* @__PURE__ */ new Set();
+  while (stack.length > 0) {
+    throwIfAborted2(options.signal);
+    const tile = stack.pop();
+    if (visitedTiles.has(tile)) {
+      continue;
+    }
+    visitedTiles.add(tile);
+    if (tile.header.implicitSubtree && tile.childrenState !== "ready") {
+      const loadChildren = tileset.source.loadTileChildrenForTraversal;
+      if (!loadChildren) {
+        throw new Error("Tileset source does not support camera-independent subtree loading");
+      }
+      const result = await loadChildren.call(tileset.source, tile, options.signal);
+      if (!result.loaded) {
+        throw new Error(`Unable to load implicit subtree for tile ${tile.id}`);
+      }
+      tile.childrenState = "ready";
+    }
+    if (tileset.type === "I3S" /* I3S */ && tileset.source.loadTileChildrenForTraversal) {
+      const result = await tileset.source.loadTileChildrenForTraversal(tile, options.signal);
+      if (!result.loaded) {
+        throw new Error(`Unable to load I3S child nodes for tile ${tile.id}`);
+      }
+    }
+    throwIfAborted2(options.signal);
+    const loadsContent = tile.contentUrls.length > 0 && !tile.content;
+    try {
+      if (loadsContent) {
+        const loadResult = await tile.loadContentForTraversal();
+        throwIfAborted2(options.signal);
+        if (!loadResult.loaded) {
+          throw new Error(`Unable to load tile content for tile ${tile.id}`);
+        }
+        tileset.source.onTileLoaded?.(tileset, tile, loadResult);
+      }
+      yield { tile, contents: tile.contentEntries };
+    } finally {
+      if (options.unloadContent && loadsContent) {
+        tile.unloadContent();
+      }
+    }
+    for (let childIndex = tile.children.length - 1; childIndex >= 0; childIndex--) {
+      stack.push(tile.children[childIndex]);
+    }
+  }
+}
+function throwIfAborted2(signal) {
+  if (signal?.aborted) {
+    throw signal.reason ?? new DOMException("The operation was aborted", "AbortError");
+  }
+}
+var init_tileset_content_traversal = __esm({
+  "../../modules/tiles/src/tileset-3d/common/tileset-content-traversal.ts"() {
+    "use strict";
+  }
+});
+
+// ../../modules/tiles/src/index.ts
+var init_src2 = __esm({
+  "../../modules/tiles/src/index.ts"() {
+    "use strict";
+    init_tileset_content_traversal();
+  }
+});
+
+// ../../modules/3d-tiles/src/lib/utils/version.ts
+var VERSION;
+var init_version = __esm({
+  "../../modules/3d-tiles/src/lib/utils/version.ts"() {
+    "use strict";
+    VERSION = typeof __VERSION__ !== "undefined" ? __VERSION__ : "latest";
+  }
+});
+
+// ../../modules/3d-tiles/src/lib/constants.ts
+var TILE3D_TYPE, TILE3D_TYPES, MAGIC_ARRAY;
+var init_constants = __esm({
+  "../../modules/3d-tiles/src/lib/constants.ts"() {
+    "use strict";
+    TILE3D_TYPE = {
+      COMPOSITE: "cmpt",
+      POINT_CLOUD: "pnts",
+      BATCHED_3D_MODEL: "b3dm",
+      INSTANCED_3D_MODEL: "i3dm",
+      GEOMETRY: "geom",
+      VECTOR: "vect",
+      GLTF: "glTF"
+    };
+    TILE3D_TYPES = Object.keys(TILE3D_TYPE);
+    MAGIC_ARRAY = {
+      BATCHED_MODEL: [98, 51, 100, 109],
+      INSTANCED_MODEL: [105, 51, 100, 109],
+      POINT_CLOUD: [112, 110, 116, 115],
+      COMPOSITE: [99, 109, 112, 116]
+    };
+  }
+});
+
+// ../../modules/schema-utils/src/lib/schema/convert-arrow-schema.ts
+import * as arrow from "apache-arrow";
+function serializeArrowSchema(arrowSchema) {
+  return {
+    fields: arrowSchema.fields.map((arrowField) => serializeArrowField(arrowField)),
+    metadata: serializeArrowMetadata(arrowSchema.metadata)
+  };
+}
+function serializeArrowMetadata(arrowMetadata) {
+  return Object.fromEntries(arrowMetadata);
+}
+function serializeArrowField(field) {
+  return {
+    name: field.name,
+    type: serializeArrowType(field.type),
+    nullable: field.nullable,
+    metadata: serializeArrowMetadata(field.metadata)
+  };
+}
+function serializeArrowType(arrowType) {
+  if (isArrowViewType(arrowType, "BinaryView")) {
+    return "binary-view";
+  }
+  if (isArrowViewType(arrowType, "Utf8View")) {
+    return "utf8-view";
+  }
+  if (isOptionalArrowType(arrowType, "LargeList")) {
+    const largeListType = arrowType;
+    return {
+      type: "large-list",
+      children: [serializeArrowField(largeListType.valueField)]
+    };
+  }
+  switch (arrowType.constructor) {
+    case arrow.Null:
+      return "null";
+    case arrow.Binary:
+      return "binary";
+    case arrow.FixedSizeBinary:
+      return {
+        type: "fixed-size-binary",
+        byteWidth: arrowType.byteWidth
+      };
+    case arrow.Bool:
+      return "bool";
+    case arrow.Int:
+      const intType = arrowType;
+      return `${intType.isSigned ? "" : "u"}int${intType.bitWidth}`;
+    case arrow.Int8:
+      return "int8";
+    case arrow.Int16:
+      return "int16";
+    case arrow.Int32:
+      return "int32";
+    case arrow.Int64:
+      return "int64";
+    case arrow.Uint8:
+      return "uint8";
+    case arrow.Uint16:
+      return "uint16";
+    case arrow.Uint32:
+      return "uint32";
+    case arrow.Uint64:
+      return "uint64";
+    case arrow.Float:
+      const precision = arrowType.precision;
+      switch (precision) {
+        case arrow.Precision.HALF:
+          return "float16";
+        case arrow.Precision.SINGLE:
+          return "float32";
+        case arrow.Precision.DOUBLE:
+          return "float64";
+        default:
+          return "float16";
+      }
+    case arrow.Float16:
+      return "float16";
+    case arrow.Float32:
+      return "float32";
+    case arrow.Float64:
+      return "float64";
+    case arrow.Utf8:
+      return "utf8";
+    case arrow.Decimal:
+      const decimal = arrowType;
+      return {
+        type: "decimal",
+        bitWidth: decimal.bitWidth,
+        precision: decimal.precision,
+        scale: decimal.scale
+      };
+    case arrow.Date_:
+      const dateUnit = arrowType.unit;
+      return dateUnit === arrow.DateUnit.DAY ? "date-day" : "date-millisecond";
+    case arrow.DateDay:
+      return "date-day";
+    case arrow.DateMillisecond:
+      return "date-millisecond";
+    case arrow.Time:
+      const timeUnit = arrowType.unit;
+      switch (timeUnit) {
+        case arrow.TimeUnit.SECOND:
+          return "time-second";
+        case arrow.TimeUnit.MILLISECOND:
+          return "time-millisecond";
+        case arrow.TimeUnit.MICROSECOND:
+          return "time-microsecond";
+        case arrow.TimeUnit.NANOSECOND:
+          return "time-nanosecond";
+        default:
+          return "time-second";
+      }
+    case arrow.TimeMillisecond:
+      return "time-millisecond";
+    case arrow.TimeSecond:
+      return "time-second";
+    case arrow.TimeMicrosecond:
+      return "time-microsecond";
+    case arrow.TimeNanosecond:
+      return "time-nanosecond";
+    case arrow.Timestamp:
+      const timeStampUnit = arrowType.unit;
+      switch (timeStampUnit) {
+        case arrow.TimeUnit.SECOND:
+          return "timestamp-second";
+        case arrow.TimeUnit.MILLISECOND:
+          return "timestamp-millisecond";
+        case arrow.TimeUnit.MICROSECOND:
+          return "timestamp-microsecond";
+        case arrow.TimeUnit.NANOSECOND:
+          return "timestamp-nanosecond";
+        default:
+          return "timestamp-second";
+      }
+    case arrow.TimestampSecond:
+      return "timestamp-second";
+    case arrow.TimestampMillisecond:
+      return "timestamp-millisecond";
+    case arrow.TimestampMicrosecond:
+      return "timestamp-microsecond";
+    case arrow.TimestampNanosecond:
+      return "timestamp-nanosecond";
+    case arrow.Interval:
+      const intervalUnit = arrowType.unit;
+      switch (intervalUnit) {
+        case arrow.IntervalUnit.DAY_TIME:
+          return "interval-daytime";
+        case arrow.IntervalUnit.YEAR_MONTH:
+          return "interval-yearmonth";
+        default:
+          return "interval-daytime";
+      }
+    case arrow.IntervalDayTime:
+      return "interval-daytime";
+    case arrow.IntervalYearMonth:
+      return "interval-yearmonth";
+    case arrow.Map_:
+      const mapType = arrowType;
+      return {
+        type: "map",
+        keysSorted: mapType.keysSorted,
+        children: mapType.children.map((arrowField) => serializeArrowField(arrowField))
+      };
+    case arrow.List:
+      const listType = arrowType;
+      const listField = listType.valueField;
+      return {
+        type: "list",
+        children: [serializeArrowField(listField)]
+      };
+    case arrow.FixedSizeList:
+      const fixedSizeList = arrowType;
+      return {
+        type: "fixed-size-list",
+        listSize: fixedSizeList.listSize,
+        children: [serializeArrowField(fixedSizeList.children[0])]
+      };
+    case arrow.Struct:
+      const structType = arrowType;
+      return {
+        type: "struct",
+        children: structType.children.map((arrowField) => serializeArrowField(arrowField))
+      };
+    case arrow.SparseUnion:
+    case arrow.DenseUnion:
+      const unionType = arrowType;
+      return {
+        type: unionType instanceof arrow.DenseUnion ? "dense-union" : "sparse-union",
+        typeIds: unionType.typeIds,
+        children: unionType.children.map((arrowField) => serializeArrowField(arrowField)),
+        typeIdToChildIndex: { ...unionType.typeIdToChildIndex }
+      };
+    case arrow.Dictionary:
+      const dictionaryType = arrowType;
+      return {
+        type: "dictionary",
+        id: dictionaryType.id,
+        indices: serializeArrowDictionaryKeyType(dictionaryType.indices),
+        dictionary: serializeArrowType(dictionaryType.dictionary),
+        isOrdered: dictionaryType.isOrdered
+      };
+    default:
+      throw new Error(`arrow type not supported: ${arrowType.constructor.name}`);
+  }
+}
+function getOptionalArrowConstructor(typeName) {
+  return arrow[typeName];
+}
+function isArrowViewType(arrowType, viewTypeName) {
+  const constructor = getOptionalArrowConstructor(viewTypeName);
+  if (constructor && arrowType instanceof constructor) {
+    return true;
+  }
+  const guards = arrow.DataType;
+  const guard = viewTypeName === "BinaryView" ? guards.isBinaryView : guards.isUtf8View;
+  return Boolean(guard?.(arrowType));
+}
+function isOptionalArrowType(arrowType, typeName) {
+  const constructor = getOptionalArrowConstructor(typeName);
+  return Boolean(constructor && arrowType instanceof constructor);
+}
+function serializeArrowDictionaryKeyType(arrowType) {
+  if (arrowType instanceof arrow.Int) {
+    const prefix = arrowType.isSigned ? "int" : "uint";
+    const keyType = `${prefix}${arrowType.bitWidth}`;
+    if (isSchemaDictionaryKeyType(keyType)) {
+      return keyType;
+    }
+  }
+  switch (arrowType.constructor) {
+    case arrow.Int8:
+      return "int8";
+    case arrow.Int16:
+      return "int16";
+    case arrow.Int32:
+      return "int32";
+    case arrow.Uint8:
+      return "uint8";
+    case arrow.Uint16:
+      return "uint16";
+    case arrow.Uint32:
+      return "uint32";
+    default:
+      throw new Error(`arrow dictionary index type not supported: ${arrowType.constructor.name}`);
+  }
+}
+function isSchemaDictionaryKeyType(keyType) {
+  return ["int8", "int16", "int32", "uint8", "uint16", "uint32"].includes(keyType);
+}
+var init_convert_arrow_schema = __esm({
+  "../../modules/schema-utils/src/lib/schema/convert-arrow-schema.ts"() {
+    "use strict";
+  }
+});
+
+// ../../modules/schema-utils/src/lib/mesh/mesh-utils.ts
+function getMeshBoundingBox(attributes) {
+  let minX = Infinity;
+  let minY = Infinity;
+  let minZ = Infinity;
+  let maxX = -Infinity;
+  let maxY = -Infinity;
+  let maxZ = -Infinity;
+  const positions = attributes.POSITION ? attributes.POSITION.value : [];
+  const len = positions && positions.length;
+  for (let i = 0; i < len; i += 3) {
+    const x = positions[i];
+    const y = positions[i + 1];
+    const z = positions[i + 2];
+    minX = x < minX ? x : minX;
+    minY = y < minY ? y : minY;
+    minZ = z < minZ ? z : minZ;
+    maxX = x > maxX ? x : maxX;
+    maxY = y > maxY ? y : maxY;
+    maxZ = z > maxZ ? z : maxZ;
+  }
+  return [
+    [minX, minY, minZ],
+    [maxX, maxY, maxZ]
+  ];
+}
+var init_mesh_utils = __esm({
+  "../../modules/schema-utils/src/lib/mesh/mesh-utils.ts"() {
+    "use strict";
+  }
+});
+
+// ../../modules/schema/src/float16.ts
+import { getFloat16ArrayConstructor, NativeFloat16ArrayConstructor } from "@math.gl/types";
+function createFloat16Array(length) {
+  const ArrayConstructor = getFloat16ArrayConstructor();
+  return new ArrayConstructor(length);
+}
+function isNativeFloat16Array(value) {
+  return Boolean(NativeFloat16ArrayConstructor && value instanceof NativeFloat16ArrayConstructor);
+}
+function setFloat16Value(array, index, value) {
+  if (isNativeFloat16Array(array)) {
+    array[index] = value;
+  } else {
+    array[index] = encodeFloat16(value);
+  }
+}
+function getFloat16Value(array, index) {
+  if (isNativeFloat16Array(array)) {
+    return array[index];
+  }
+  return decodeFloat16(array[index]);
+}
+function encodeFloat16(value) {
+  if (!Number.isFinite(value)) {
+    return value === Infinity ? 31744 : value === -Infinity ? 64512 : 32256;
+  }
+  const sign = value < 0 || Object.is(value, -0) ? 32768 : 0;
+  const absoluteValue = Math.abs(value);
+  if (absoluteValue === 0) {
+    return sign;
+  }
+  if (absoluteValue >= 65520) {
+    return sign | 31744;
+  }
+  if (absoluteValue >= 65504) {
+    return sign | 31743;
+  }
+  const exponent = Math.floor(Math.log2(absoluteValue));
+  if (exponent < -14) {
+    return sign | Math.round(absoluteValue / 2 ** -24);
+  }
+  const normalizedExponent = exponent + 15;
+  const mantissa = Math.round((absoluteValue / 2 ** exponent - 1) * 1024);
+  if (mantissa === 1024) {
+    return sign | normalizedExponent + 1 << 10;
+  }
+  return sign | normalizedExponent << 10 | mantissa;
+}
+function decodeFloat16(value) {
+  const sign = value & 32768 ? -1 : 1;
+  const exponent = value >> 10 & 31;
+  const mantissa = value & 1023;
+  if (exponent === 0) {
+    return sign * mantissa * 2 ** -24;
+  }
+  if (exponent === 31) {
+    return mantissa ? NaN : sign * Infinity;
+  }
+  return sign * (1 + mantissa / 1024) * 2 ** (exponent - 15);
+}
+var init_float16 = __esm({
+  "../../modules/schema/src/float16.ts"() {
+    "use strict";
+  }
+});
+
+// ../../modules/schema/src/index.ts
+var init_src3 = __esm({
+  "../../modules/schema/src/index.ts"() {
+    "use strict";
+    init_float16();
+  }
+});
+
+// ../../modules/schema-utils/src/lib/arrow-utils/arrow-fixed-size-list-utils.ts
+import * as arrow2 from "apache-arrow";
+function getFixedSizeListSize(vector) {
+  return vector.type instanceof arrow2.FixedSizeList ? vector.type.listSize : 1;
+}
+var init_arrow_fixed_size_list_utils = __esm({
+  "../../modules/schema-utils/src/lib/arrow-utils/arrow-fixed-size-list-utils.ts"() {
+    "use strict";
+  }
+});
+
+// ../../modules/schema-utils/src/lib/mesh/convert-table-to-mesh.ts
+import * as arrow3 from "apache-arrow";
+function convertTableToMesh(table) {
+  switch (table.shape) {
+    // case 'columnar-table':
+    //   return convertColumnarTableToMesh(table);
+    case "arrow-table":
+      return convertArrowTableToMesh(table);
+    default:
+      throw new Error(table.shape);
+  }
+}
+function convertArrowTableToMesh(table) {
+  const arrowTable = table.data;
+  const schema = serializeArrowSchema(arrowTable.schema);
+  const fields = schema.fields;
+  const attributes = {};
+  for (const field of fields) {
+    const { name } = field;
+    if (name === "indices") {
+      continue;
+    }
+    const attributeData = arrowTable.getChild(name);
+    const size = getFixedSizeListSize(attributeData);
+    const typedArray = getAttributeTypedArray(attributeData, size);
+    const metadata = getMeshAttributeMetadata(field.metadata);
+    attributes[name] = {
+      value: metadata.componentType === "float16" ? restoreFloat16Array(typedArray) : typedArray,
+      size,
+      ...metadata
+    };
+  }
+  fixMetadata(schema);
+  const topology = schema.metadata.topology;
+  const mode = getMeshMode(schema);
+  const indices = getIndices(arrowTable);
+  const boundingBox = attributes.POSITION?.transform?.type === "quantization" ? getMeshBoundingBoxFromSchema(schema) || getMeshBoundingBox(attributes) : getMeshBoundingBox(attributes);
+  return {
+    schema,
+    attributes,
+    topology,
+    mode,
+    indices,
+    header: {
+      vertexCount: arrowTable.numRows,
+      boundingBox
+    }
+  };
+}
+function getMeshBoundingBoxFromSchema(schema) {
+  const serializedBoundingBox = schema.metadata?.boundingBox;
+  if (!serializedBoundingBox) {
+    return null;
+  }
+  try {
+    const boundingBox = JSON.parse(serializedBoundingBox);
+    if (Array.isArray(boundingBox) && boundingBox.length === 2 && boundingBox.every(
+      (corner) => Array.isArray(corner) && corner.length === 3 && corner.every((value) => typeof value === "number")
+    )) {
+      return boundingBox;
+    }
+  } catch {
+  }
+  return null;
+}
+function getMeshAttributeMetadata(metadata = {}) {
+  const result = {};
+  if (metadata.byteOffset !== void 0) {
+    result.byteOffset = Number(metadata.byteOffset);
+  }
+  if (metadata.byteStride !== void 0) {
+    result.byteStride = Number(metadata.byteStride);
+  }
+  if (metadata.normalized !== void 0) {
+    result.normalized = metadata.normalized === "true";
+  }
+  if (metadata.componentType === "float16") {
+    result.componentType = "float16";
+  }
+  if (metadata["loaders.gl.transform"]) {
+    try {
+      const transform = JSON.parse(metadata["loaders.gl.transform"]);
+      if (isMeshAttributeTransform(transform)) {
+        result.transform = transform;
+      }
+    } catch {
+    }
+  }
+  return result;
+}
+function isMeshAttributeTransform(value) {
+  if (!value || typeof value !== "object" || !("type" in value)) {
+    return false;
+  }
+  const transform = value;
+  if (transform.type === "octahedron") {
+    return Number.isInteger(transform.bits) && transform.bits >= 1 && transform.bits <= 30;
+  }
+  return transform.type === "quantization" && Number.isInteger(transform.bits) && transform.bits >= 1 && transform.bits <= 30 && Array.isArray(transform.origin) && transform.origin.every((component) => typeof component === "number") && typeof transform.range === "number";
+}
+function fixMetadata(schema) {
+  schema.metadata ||= {};
+  schema.metadata.topology ||= "point-list";
+  schema.metadata.mode ||= "0";
+}
+function getAttributeTypedArray(attributeData, size) {
+  if (!(attributeData.type instanceof arrow3.FixedSizeList)) {
+    return attributeData.toArray();
+  }
+  const values = attributeData.data[0].children[0].values;
+  const TypedArrayConstructor = values.constructor;
+  const typedArray = new TypedArrayConstructor(attributeData.length * size);
+  let targetOffset = 0;
+  for (const data of attributeData.data) {
+    const child = data.children[0];
+    const sourceLength = data.length * size;
+    const sourceOffset = child.offset || data.offset * size;
+    const sourceStart = sourceOffset + sourceLength <= child.values.length ? sourceOffset : 0;
+    const source = child.values.subarray(sourceStart, sourceStart + sourceLength);
+    typedArray.set(source, targetOffset);
+    targetOffset += sourceLength;
+  }
+  return typedArray;
+}
+function restoreFloat16Array(typedArray) {
+  const result = createFloat16Array(typedArray.length);
+  for (let index = 0; index < typedArray.length; index++) {
+    setFloat16Value(result, index, getFloat16Value(typedArray, index));
+  }
+  return result;
+}
+function getMeshMode(schema) {
+  const mode = Number(schema.metadata?.mode);
+  return Number.isFinite(mode) ? mode : 0;
+}
+function getIndices(arrowTable) {
+  const indicesColumn = arrowTable.getChild("indices");
+  if (!indicesColumn?.isValid(0)) {
+    return void 0;
+  }
+  const indicesData = indicesColumn.data[0];
+  const valueOffsets = indicesData.valueOffsets;
+  const start = valueOffsets[indicesData.offset];
+  const end = valueOffsets[indicesData.offset + 1];
+  const values = indicesData.children[0].values.subarray(start, end);
+  return { value: values, size: 1 };
+}
+var init_convert_table_to_mesh = __esm({
+  "../../modules/schema-utils/src/lib/mesh/convert-table-to-mesh.ts"() {
+    "use strict";
+    init_src3();
+    init_arrow_fixed_size_list_utils();
+    init_convert_arrow_schema();
+    init_mesh_utils();
+  }
+});
+
+// ../../modules/schema-utils/src/index.ts
+var init_src4 = __esm({
+  "../../modules/schema-utils/src/index.ts"() {
+    "use strict";
+    init_convert_table_to_mesh();
+  }
+});
+
+// src/v5/conversion-api.ts
+var TileConversionError = class extends Error {
+  /** Stable machine-readable failure code. */
+  code;
+  /** Diagnostics associated with this failure. */
+  diagnostics;
+  /** Creates a typed conversion failure. */
+  constructor(code, message, diagnostics = []) {
+    super(message);
+    this.name = "TileConversionError";
+    this.code = code;
+    this.diagnostics = diagnostics;
+  }
+};
+async function inspectTileset(source, signal) {
+  throwIfAborted(signal);
+  const inspection = await source.inspect(signal);
+  throwIfAborted(signal);
+  return inspection;
+}
+async function convertTileset(options) {
+  const {
+    source,
+    codec,
+    sink,
+    measureInputBytes,
+    measureOutputBytes,
+    maxInputResourceBytes = Number.POSITIVE_INFINITY,
+    maxOutputResourceBytes = Number.POSITIVE_INFINITY,
+    signal,
+    onProgress
+  } = options;
+  let inputResources = 0;
+  let outputResources = 0;
+  let inputBytes = 0;
+  let outputBytes = 0;
+  let largestOutputResourceBytes = 0;
+  const diagnostics = [];
+  const reportProgress = (phase) => {
+    onProgress?.({ phase, inputResources, outputResources, inputBytes, outputBytes });
+  };
+  try {
+    if (maxInputResourceBytes !== Number.POSITIVE_INFINITY && (!Number.isSafeInteger(maxInputResourceBytes) || maxInputResourceBytes < 0)) {
+      throw new TileConversionError(
+        "INVALID_INPUT_RESOURCE_LIMIT",
+        "maxInputResourceBytes must be a nonnegative safe integer or Infinity"
+      );
+    }
+    reportProgress("inspect");
+    const inspection = await inspectTileset(source, signal);
+    for await (const inputResource of source.read(inspection, signal)) {
+      throwIfAborted(signal);
+      const inputResourceBytes = measureInputBytes(inputResource);
+      if (!Number.isSafeInteger(inputResourceBytes) || inputResourceBytes < 0) {
+        throw new TileConversionError(
+          "INVALID_INPUT_RESOURCE_SIZE",
+          "measureInputBytes must return a nonnegative safe integer"
+        );
+      }
+      if (inputResourceBytes > maxInputResourceBytes) {
+        throw new TileConversionError(
+          "INPUT_RESOURCE_TOO_LARGE",
+          `Input resource is ${inputResourceBytes} bytes, exceeding the configured limit of ${maxInputResourceBytes} bytes`
+        );
+      }
+      inputResources++;
+      inputBytes += inputResourceBytes;
+      reportProgress("convert");
+      const convertedResources = await codec.convert(inputResource, inspection, signal);
+      for await (const outputResource of convertedResources) {
+        throwIfAborted(signal);
+        reportProgress("validate");
+        const resourceDiagnostics = await codec.validateOutput?.(outputResource, signal) || [];
+        diagnostics.push(...resourceDiagnostics);
+        const outputResourceBytes = measureOutputBytes(outputResource);
+        largestOutputResourceBytes = Math.max(largestOutputResourceBytes, outputResourceBytes);
+        if (outputResourceBytes > maxOutputResourceBytes) {
+          throw new TileConversionError(
+            "OUTPUT_RESOURCE_TOO_LARGE",
+            `Output resource is ${outputResourceBytes} bytes, exceeding the configured limit of ${maxOutputResourceBytes} bytes`
+          );
+        }
+        if (resourceDiagnostics.some((diagnostic) => diagnostic.severity === "error")) {
+          throw new TileConversionError(
+            "OUTPUT_VALIDATION_FAILED",
+            "Output resource validation failed",
+            resourceDiagnostics
+          );
+        }
+        throwIfAborted(signal);
+        await sink.write(outputResource, signal);
+        throwIfAborted(signal);
+        outputResources++;
+        outputBytes += outputResourceBytes;
+        reportProgress("convert");
+      }
+    }
+    const report = {
+      state: "completed",
+      inputResources,
+      outputResources,
+      inputBytes,
+      outputBytes,
+      largestOutputResourceBytes,
+      diagnostics
+    };
+    throwIfAborted(signal);
+    reportProgress("finalize");
+    await sink.finalize(report);
+    return report;
+  } catch (error) {
+    try {
+      await sink.abort(error);
+    } catch (abortError) {
+      throw new AggregateError(
+        [error, abortError],
+        "Conversion failed and the destination could not abort"
+      );
+    }
+    throw error;
+  }
+}
+async function validateTileset(options) {
+  throwIfAborted(options.signal);
+  const diagnostics = await options.validate(options.tileset, options.signal);
+  throwIfAborted(options.signal);
+  return {
+    valid: !diagnostics.some((diagnostic) => diagnostic.severity === "error"),
+    diagnostics
+  };
+}
+function throwIfAborted(signal) {
+  if (signal?.aborted) {
+    throw signal.reason ?? new DOMException("The operation was aborted", "AbortError");
+  }
+}
+
+// src/v5/tileset-source.ts
+init_src2();
+function createTilesetConversionSource(tileset, options = {}) {
+  return {
+    async inspect(signal) {
+      signal?.throwIfAborted();
+      await tileset.tilesetInitializationPromise;
+      signal?.throwIfAborted();
+      if (!tileset.root) {
+        throw new TileConversionError(
+          "TILESET_ROOT_REQUIRED",
+          "Tileset initialization completed without a root tile"
+        );
+      }
+      return tileset.source.getMetadata();
+    },
+    read: (_inspection, signal) => traverseTilesetContents(tileset, { unloadContent: options.unloadContent, signal })
+  };
+}
+
+// src/v5/browser-sink.ts
+var BLOB_SIZE_GETTER = Object.getOwnPropertyDescriptor(Blob.prototype, "size")?.get;
+function createBoundedMemoryTileConversionSink(options) {
+  if (!Number.isSafeInteger(options.maxTotalBytes) || options.maxTotalBytes < 0) {
+    throw new TileConversionError(
+      "INVALID_OUTPUT_MEMORY_LIMIT",
+      "The browser output memory limit must be a non-negative safe integer"
+    );
+  }
+  const files = /* @__PURE__ */ new Map();
+  let totalBytes = 0;
+  let closed = false;
+  return {
+    getFiles() {
+      return [...files.values()].sort(
+        (left, right) => left.resourceId < right.resourceId ? -1 : left.resourceId > right.resourceId ? 1 : 0
+      );
+    },
+    async write(resource, signal) {
+      if (signal?.aborted) {
+        throw signal.reason ?? new DOMException("The operation was aborted", "AbortError");
+      }
+      if (closed) {
+        throw new TileConversionError(
+          "RESOURCE_SINK_CLOSED",
+          "Cannot write after sink finalization"
+        );
+      }
+      if (!resource.resourceId || files.has(resource.resourceId)) {
+        throw new TileConversionError(
+          "INVALID_BROWSER_RESOURCE_ID",
+          "Browser output resource IDs must be non-empty and unique"
+        );
+      }
+      const byteLength = resource.parts.reduce((total, part) => total + measureBlobPart(part), 0);
+      if (!Number.isSafeInteger(byteLength) || totalBytes + byteLength > options.maxTotalBytes) {
+        throw new TileConversionError(
+          "OUTPUT_MEMORY_LIMIT_EXCEEDED",
+          `Browser output exceeds the configured ${options.maxTotalBytes} byte memory limit`
+        );
+      }
+      const blob = new Blob([...resource.parts], { type: resource.contentType });
+      files.set(resource.resourceId, { resourceId: resource.resourceId, blob });
+      totalBytes += blob.size;
+    },
+    async finalize(_report) {
+      if (closed) {
+        throw new TileConversionError("RESOURCE_SINK_CLOSED", "Sink has already been finalized");
+      }
+      closed = true;
+    },
+    async abort() {
+      files.clear();
+      totalBytes = 0;
+      closed = true;
+    }
+  };
+}
+function measureBlobPart(part) {
+  if (typeof part === "string") {
+    return new TextEncoder().encode(part).byteLength;
+  }
+  if (BLOB_SIZE_GETTER) {
+    try {
+      return BLOB_SIZE_GETTER.call(part);
+    } catch {
+    }
+  }
+  if (part instanceof ArrayBuffer || ArrayBuffer.isView(part)) {
+    return part.byteLength;
+  }
+  throw new TileConversionError("UNSUPPORTED_BROWSER_RESOURCE", "Unsupported browser Blob part");
+}
+
+// src/v5/browser-source.ts
+function createBrowserTileConversionSource(options) {
+  if (!options.resourceId || !Number.isSafeInteger(options.maxInputBytes) || options.maxInputBytes < 0) {
+    throw new TileConversionError(
+      "INVALID_BROWSER_SOURCE_OPTIONS",
+      "Browser sources require a resource ID and a non-negative safe input byte limit"
+    );
+  }
+  return {
+    async inspect(signal) {
+      throwIfAborted3(signal);
+      const contentType = options.contentType ?? getBlobContentType(options.input);
+      return {
+        resourceId: options.resourceId,
+        ...contentType ? { contentType } : {}
+      };
+    },
+    async *read(inspection, signal) {
+      throwIfAborted3(signal);
+      const input = options.input;
+      let data;
+      let contentType = inspection.contentType;
+      if (typeof input === "string") {
+        const response = await fetch(input, { signal });
+        if (!response.ok) {
+          throw new TileConversionError(
+            "BROWSER_SOURCE_FETCH_FAILED",
+            `Could not fetch browser input (${response.status} ${response.statusText})`
+          );
+        }
+        contentType = contentType ?? response.headers.get("content-type") ?? void 0;
+        data = await readResponseBytes(response, options.maxInputBytes, signal);
+      } else {
+        if (input.size > options.maxInputBytes) {
+          throw createInputLimitError(options.maxInputBytes);
+        }
+        data = new Uint8Array(await input.arrayBuffer());
+      }
+      throwIfAborted3(signal);
+      yield {
+        resourceId: inspection.resourceId,
+        data,
+        ...contentType ? { contentType } : {}
+      };
+    }
+  };
+}
+async function readResponseBytes(response, maxInputBytes, signal) {
+  const reader = response.body?.getReader();
+  if (!reader) {
+    throw new TileConversionError(
+      "BROWSER_SOURCE_STREAM_UNAVAILABLE",
+      "Browser URL inputs must provide a readable response stream"
+    );
+  }
+  const data = new Uint8Array(maxInputBytes);
+  let totalBytes = 0;
+  try {
+    while (true) {
+      throwIfAborted3(signal);
+      const { done, value } = await reader.read();
+      if (done) break;
+      if (value.byteLength > maxInputBytes - totalBytes) {
+        await reader.cancel();
+        throw createInputLimitError(maxInputBytes);
+      }
+      data.set(value, totalBytes);
+      totalBytes += value.byteLength;
+    }
+  } finally {
+    reader.releaseLock();
+  }
+  return data.subarray(0, totalBytes);
+}
+function getBlobContentType(input) {
+  return typeof input === "string" ? void 0 : input.type || void 0;
+}
+function createInputLimitError(maxInputBytes) {
+  return new TileConversionError(
+    "INPUT_RESOURCE_TOO_LARGE",
+    `Browser input exceeds the configured ${maxInputBytes} byte memory limit`
+  );
+}
+function throwIfAborted3(signal) {
+  if (signal?.aborted) {
+    throw signal.reason ?? new DOMException("The operation was aborted", "AbortError");
+  }
+}
+
+// src/v5/browser-tileset-source.ts
+function createBrowserTilesetConversionSource(options) {
+  if (!Number.isSafeInteger(options.maxInputBytes) || options.maxInputBytes < 1 || !Number.isSafeInteger(options.maxInputResources) || options.maxInputResources < 1) {
+    throw new TileConversionError(
+      "INVALID_BROWSER_SOURCE_OPTIONS",
+      "Browser tileset sources require positive byte and resource limits"
+    );
+  }
+  const fetcher = options.fetcher ?? fetch;
+  return {
+    async inspect(signal) {
+      throwIfAborted4(signal);
+      const rootUrl = new URL(options.input).href;
+      const response = await fetcher(rootUrl, { signal });
+      if (!response.ok) {
+        throw new TileConversionError(
+          "BROWSER_SOURCE_FETCH_FAILED",
+          `Could not fetch browser tileset (${response.status} ${response.statusText})`
+        );
+      }
+      const data = await readResponseBytes2(response, options.maxInputBytes, signal);
+      let tileset;
+      try {
+        tileset = JSON.parse(new TextDecoder().decode(data));
+      } catch {
+        throw new TileConversionError("INVALID_BROWSER_TILESET", "Tileset input is not valid JSON");
+      }
+      if (!isRecord(tileset) || !["1.0", "1.1"].includes(tileset.asset?.version || "") || !isRecord(tileset.root)) {
+        throw new TileConversionError(
+          "UNSUPPORTED_BROWSER_TILESET",
+          "Browser tileset traversal supports explicit 3D Tiles 1.0 and 1.1 documents"
+        );
+      }
+      const resources = collectResources(tileset.root, options.maxInputResources);
+      return { rootUrl, tileset, resources, tilesetBytes: data.byteLength };
+    },
+    async *read(inspection, signal) {
+      let inputBytes = inspection.tilesetBytes;
+      for (const descriptor of inspection.resources) {
+        throwIfAborted4(signal);
+        const resourceUrl = resolveResourceUrl(descriptor.uri, inspection.rootUrl);
+        const response = await fetcher(resourceUrl, { signal });
+        if (!response.ok) {
+          throw new TileConversionError(
+            "BROWSER_SOURCE_FETCH_FAILED",
+            `Could not fetch browser tile content (${response.status} ${response.statusText})`,
+            [
+              {
+                code: "BROWSER_SOURCE_FETCH_FAILED",
+                message: resourceUrl,
+                severity: "error",
+                resourceId: descriptor.resourceId
+              }
+            ]
+          );
+        }
+        const remainingBytes = options.maxInputBytes - inputBytes;
+        const data = await readResponseBytes2(response, remainingBytes, signal);
+        inputBytes += data.byteLength;
+        const contentType = response.headers.get("content-type") ?? void 0;
+        if (isJsonContent(data, contentType)) {
+          throw new TileConversionError(
+            "UNSUPPORTED_BROWSER_TILESET_CONTENT",
+            `Nested tilesets and JSON tile content are not supported: ${descriptor.uri}`
+          );
+        }
+        yield { ...descriptor, data, ...contentType ? { contentType } : {} };
+      }
+    }
+  };
+}
+function collectResources(root, maxInputResources) {
+  const resources = [];
+  const stack = [
+    { tile: root, path: [], transform: identityMatrix() }
+  ];
+  while (stack.length > 0) {
+    const { tile, path, transform: parentTransform } = stack.pop();
+    if (!isRecord(tile)) {
+      throw new TileConversionError("INVALID_BROWSER_TILESET", "Tile entries must be objects");
+    }
+    if (tile.implicitTiling !== void 0 || tile.extensions?.["3DTILES_implicit_tiling"] !== void 0) {
+      throw new TileConversionError(
+        "UNSUPPORTED_BROWSER_TILESET",
+        "Browser tileset traversal does not yet support implicit tiling"
+      );
+    }
+    if (tile.contents !== void 0 && !Array.isArray(tile.contents)) {
+      throw new TileConversionError("INVALID_BROWSER_TILESET", "Tile contents must be an array");
+    }
+    if (tile.children !== void 0 && !Array.isArray(tile.children)) {
+      throw new TileConversionError("INVALID_BROWSER_TILESET", "Tile children must be an array");
+    }
+    const transform = multiplyMatrices(parentTransform, normalizeMatrix(tile.transform));
+    const contents = tile.contents ?? (tile.content ? [tile.content] : []);
+    for (let contentIndex = 0; contentIndex < contents.length; contentIndex++) {
+      const content = contents[contentIndex];
+      if (!isRecord(content)) {
+        throw new TileConversionError(
+          "INVALID_BROWSER_TILESET",
+          "Tile content entries must be objects"
+        );
+      }
+      const uri = content.uri ?? content.url;
+      if (typeof uri !== "string" || !uri) {
+        throw new TileConversionError(
+          "INVALID_BROWSER_TILESET",
+          `Tile content at ${path.join("/")} has no URI`
+        );
+      }
+      if (resources.length >= maxInputResources) {
+        throw new TileConversionError(
+          "INPUT_RESOURCE_COUNT_EXCEEDED",
+          `Browser tileset exceeds the configured ${maxInputResources} resource limit`
+        );
+      }
+      resources.push({
+        resourceId: `tile-${path.length ? path.join("-") : "root"}-content-${contentIndex}`,
+        uri,
+        tilePath: path,
+        transform
+      });
+    }
+    const children = tile.children ?? [];
+    for (let childIndex = children.length - 1; childIndex >= 0; childIndex--) {
+      stack.push({
+        tile: children[childIndex],
+        path: [...path, childIndex],
+        transform
+      });
+    }
+  }
+  return resources;
+}
+async function readResponseBytes2(response, maximumBytes, signal) {
+  const reader = response.body?.getReader();
+  if (!reader) {
+    throw new TileConversionError(
+      "BROWSER_SOURCE_STREAM_UNAVAILABLE",
+      "Browser inputs must provide a readable response stream"
+    );
+  }
+  const data = new Uint8Array(maximumBytes);
+  let byteLength = 0;
+  try {
+    while (true) {
+      throwIfAborted4(signal);
+      const { done, value } = await reader.read();
+      if (done) break;
+      if (value.byteLength > maximumBytes - byteLength) {
+        await reader.cancel();
+        throw new TileConversionError(
+          "INPUT_RESOURCE_TOO_LARGE",
+          `Browser tileset input exceeds the configured ${maximumBytes} byte remaining limit`
+        );
+      }
+      data.set(value, byteLength);
+      byteLength += value.byteLength;
+    }
+  } finally {
+    reader.releaseLock();
+  }
+  return data.subarray(0, byteLength);
+}
+function isJsonContent(data, contentType) {
+  if (contentType?.includes("json")) return true;
+  let byteOffset = data[0] === 239 && data[1] === 187 && data[2] === 191 ? 3 : 0;
+  while ([9, 10, 13, 32].includes(data[byteOffset])) byteOffset++;
+  return data[byteOffset] === 123;
+}
+function resolveResourceUrl(uri, rootUrl) {
+  const root = new URL(rootUrl);
+  const resource = new URL(uri, root);
+  if (resource.origin === root.origin) {
+    for (const [name, value] of root.searchParams) {
+      if (!resource.searchParams.has(name)) resource.searchParams.append(name, value);
+    }
+  }
+  return resource.href;
+}
+function isRecord(value) {
+  return Boolean(value && typeof value === "object" && !Array.isArray(value));
+}
+function identityMatrix() {
+  return [1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1];
+}
+function normalizeMatrix(matrix) {
+  if (matrix === void 0) return identityMatrix();
+  if (!Array.isArray(matrix) || matrix.length !== 16 || matrix.some((value) => !Number.isFinite(value))) {
+    throw new TileConversionError(
+      "INVALID_BROWSER_TILESET",
+      "Tile transform must contain 16 finite numbers"
+    );
+  }
+  return matrix;
+}
+function multiplyMatrices(left, right) {
+  const result = new Array(16);
+  for (let column = 0; column < 4; column++) {
+    for (let row = 0; row < 4; row++) {
+      result[column * 4 + row] = left[row] * right[column * 4] + left[4 + row] * right[column * 4 + 1] + left[8 + row] * right[column * 4 + 2] + left[12 + row] * right[column * 4 + 3];
+    }
+  }
+  return result;
+}
+function throwIfAborted4(signal) {
+  if (signal?.aborted) {
+    throw signal.reason ?? new DOMException("The operation was aborted", "AbortError");
+  }
+}
+
+// ../../modules/3d-tiles/src/tile-3d-writer.ts
+init_version();
+
+// ../../modules/3d-tiles/src/lib/encoders/encode-3d-tile.ts
+init_constants();
+init_src();
+
+// ../../modules/3d-tiles/src/lib/encoders/encode-3d-tile-composite.ts
+init_constants();
+
+// ../../modules/3d-tiles/src/lib/encoders/helpers/encode-3d-tile-header.ts
+init_src();
+function encode3DTileHeader(tile, dataView, byteOffset) {
+  const HEADER_SIZE = 12;
+  if (!dataView) {
+    return byteOffset + HEADER_SIZE;
+  }
+  const { magic, version = 1, byteLength = 12 } = tile;
+  assert(Array.isArray(magic) && Number.isFinite(version) && Number.isFinite(byteLength));
+  dataView.setUint8(byteOffset + 0, magic[0]);
+  dataView.setUint8(byteOffset + 1, magic[1]);
+  dataView.setUint8(byteOffset + 2, magic[2]);
+  dataView.setUint8(byteOffset + 3, magic[3]);
+  dataView.setUint32(byteOffset + 4, version, true);
+  dataView.setUint32(byteOffset + 8, byteLength, true);
+  byteOffset += HEADER_SIZE;
+  return byteOffset;
+}
+function encode3DTileByteLength(dataView, byteOffsetTileStart, byteLength) {
+  if (!dataView) {
+    return;
+  }
+  dataView.setUint32(byteOffsetTileStart + 8, byteLength, true);
+}
+
+// ../../modules/3d-tiles/src/lib/encoders/encode-3d-tile-composite.ts
+function encodeComposite3DTile(tile, dataView, byteOffset, options, encode3DTile2) {
+  tile = { magic: MAGIC_ARRAY.COMPOSITE, tiles: [], ...tile };
+  const byteOffsetStart = byteOffset;
+  byteOffset += encode3DTileHeader(tile, dataView, byteOffset);
+  if (dataView) {
+    dataView.setUint32(byteOffset, tile.tiles.length, true);
+  }
+  byteOffset += 4;
+  for (let i = 0; i < tile.tiles.length; ++i) {
+    byteOffset += encode3DTile2(tile.tiles[i], dataView, byteOffset, options);
+  }
+  encode3DTileByteLength(dataView, byteOffsetStart, byteOffset - byteOffsetStart);
+  return byteOffset;
+}
+
+// ../../modules/3d-tiles/src/lib/encoders/encode-3d-tile-batched-model.ts
+init_src();
+init_constants();
+function encodeBatchedModel3DTile(tile, dataView, byteOffset, options) {
+  const { featuresLength = 0, batchTable } = tile;
+  const featureTableJson = {
+    BATCH_LENGTH: featuresLength
+  };
+  const featureTableJsonString = JSON.stringify(featureTableJson);
+  const batchTableJsonString = batchTable ? JSON.stringify(batchTable) : "";
+  const featureTableJsonByteLength = padToNBytes(featureTableJsonString.length, 8);
+  const batchTableJsonByteLength = batchTableJsonString ? padToNBytes(batchTableJsonString.length, 8) : 0;
+  tile = { magic: MAGIC_ARRAY.BATCHED_MODEL, ...tile };
+  const byteOffsetStart = byteOffset;
+  byteOffset = encode3DTileHeader(tile, dataView, byteOffset);
+  if (dataView) {
+    dataView.setUint32(12, featureTableJsonByteLength, true);
+    dataView.setUint32(16, 0, true);
+    dataView.setUint32(20, batchTableJsonByteLength, true);
+    dataView.setUint32(24, 0, true);
+  }
+  byteOffset += 16;
+  byteOffset = copyPaddedStringToDataView(dataView, byteOffset, featureTableJsonString, 8);
+  if (batchTable) {
+    byteOffset = copyPaddedStringToDataView(dataView, byteOffset, batchTableJsonString, 8);
+  }
+  const gltfEncoded = tile.gltfEncoded;
+  if (gltfEncoded) {
+    byteOffset = copyBinaryToDataView(dataView, byteOffset, gltfEncoded, gltfEncoded.byteLength);
+  }
+  encode3DTileByteLength(dataView, byteOffsetStart, byteOffset - byteOffsetStart);
+  return byteOffset;
+}
+
+// ../../modules/3d-tiles/src/lib/encoders/encode-3d-tile-instanced-model.ts
+init_src();
+init_constants();
+function encodeInstancedModel3DTile(tile, dataView, byteOffset, options) {
+  const { featuresLength = 1, gltfFormat = 1, gltfUri = "" } = tile;
+  const gltfUriByteLength = gltfUri.length;
+  const featureTableJson = {
+    INSTANCES_LENGTH: featuresLength,
+    POSITION: new Array(featuresLength * 3).fill(0)
+  };
+  const featureTableJsonString = JSON.stringify(featureTableJson);
+  const featureTableJsonByteLength = featureTableJsonString.length;
+  tile = { magic: MAGIC_ARRAY.INSTANCED_MODEL, ...tile };
+  const byteOffsetStart = byteOffset;
+  byteOffset = encode3DTileHeader(tile, dataView, 0);
+  if (dataView) {
+    dataView.setUint32(12, featureTableJsonByteLength, true);
+    dataView.setUint32(16, 0, true);
+    dataView.setUint32(20, 0, true);
+    dataView.setUint32(24, 0, true);
+    dataView.setUint32(28, gltfFormat, true);
+  }
+  byteOffset += 20;
+  byteOffset += copyStringToDataView(
+    dataView,
+    byteOffset,
+    featureTableJsonString,
+    featureTableJsonByteLength
+  );
+  byteOffset += copyStringToDataView(dataView, byteOffset, gltfUri, gltfUriByteLength);
+  encode3DTileByteLength(dataView, byteOffsetStart, byteOffset - byteOffsetStart);
+  return byteOffset;
+}
+
+// ../../modules/3d-tiles/src/lib/encoders/encode-3d-tile-point-cloud.ts
+init_constants();
+init_src();
+var DEFAULT_FEATURE_TABLE_JSON = {
+  POINTS_LENGTH: 1,
+  POSITIONS: {
+    byteOffset: 0
+  }
+};
+function encodePointCloud3DTile(tile, dataView, byteOffset, options) {
+  const pointData = getPointCloudFeatureTable(tile);
+  const featureTableJsonString = padStringToByteAlignment(JSON.stringify(pointData.json), 4);
+  const featureTableJsonByteLength = tile.featureTableJsonByteLength ?? featureTableJsonString.length;
+  const featureTableBinary = pointData.binary;
+  const featureTableBinaryByteLength = featureTableBinary.byteLength;
+  const batchTableJsonString = tile.batchTableJson ? JSON.stringify(tile.batchTableJson) : "";
+  const batchTableJsonByteLength = batchTableJsonString ? padStringToByteAlignment(batchTableJsonString, 4).length : 0;
+  const paddedBatchTableJsonString = batchTableJsonByteLength ? padStringToByteAlignment(batchTableJsonString, 4) : "";
+  const batchTableBinary = tile.batchTableBinary || new Uint8Array();
+  tile = { magic: MAGIC_ARRAY.POINT_CLOUD, ...tile };
+  const byteOffsetStart = byteOffset;
+  byteOffset = encode3DTileHeader(tile, dataView, byteOffset);
+  if (dataView) {
+    dataView.setUint32(byteOffset + 0, featureTableJsonByteLength, true);
+    dataView.setUint32(byteOffset + 4, featureTableBinaryByteLength, true);
+    dataView.setUint32(byteOffset + 8, batchTableJsonByteLength, true);
+    dataView.setUint32(byteOffset + 12, batchTableBinary.byteLength, true);
+  }
+  byteOffset += 16;
+  byteOffset = copyStringToDataView(
+    dataView,
+    byteOffset,
+    featureTableJsonString,
+    featureTableJsonByteLength
+  );
+  byteOffset = copyBinaryToDataView(
+    dataView,
+    byteOffset,
+    featureTableBinary,
+    featureTableBinaryByteLength
+  );
+  if (batchTableJsonByteLength > 0) {
+    byteOffset = copyStringToDataView(
+      dataView,
+      byteOffset,
+      paddedBatchTableJsonString,
+      batchTableJsonByteLength
+    );
+  }
+  byteOffset = copyBinaryToDataView(
+    dataView,
+    byteOffset,
+    batchTableBinary,
+    batchTableBinary.byteLength
+  );
+  encode3DTileByteLength(dataView, byteOffsetStart, byteOffset - byteOffsetStart);
+  return byteOffset;
+}
+function getPointCloudFeatureTable(tile) {
+  const positions = tile.attributes?.positions;
+  if (!positions) {
+    const json2 = tile.featureTableJson || DEFAULT_FEATURE_TABLE_JSON;
+    return { json: json2, binary: new Uint8Array(12) };
+  }
+  if (positions.length === 0 || positions.length % 3 !== 0) {
+    throw new Error("3D Tiles point cloud positions must contain one or more xyz triples");
+  }
+  const pointCount = positions.length / 3;
+  const properties = [];
+  properties.push({ name: "POSITION", alignment: 4, bytes: encodeFloat32Array(positions) });
+  const colors = tile.attributes?.colors;
+  if (colors) {
+    const colorValues = Array.isArray(colors) ? colors : colors.value;
+    const colorSize = Array.isArray(colors) ? colorValues.length / pointCount : colors.size;
+    if (colorSize !== 3 && colorSize !== 4) {
+      throw new Error("3D Tiles point cloud colors must contain RGB or RGBA values");
+    }
+    const colorBytes = encodeColorBytes(
+      colorValues,
+      !Array.isArray(colors) && colors.normalized,
+      pointCount,
+      colorSize
+    );
+    properties.push({ name: colorSize === 4 ? "RGBA" : "RGB", alignment: 1, bytes: colorBytes });
+  }
+  const normals = tile.attributes?.normals;
+  if (normals) {
+    const normalValues = Array.isArray(normals) ? normals : normals.value;
+    if (normalValues.length !== pointCount * 3) {
+      throw new Error("3D Tiles point cloud normal count does not match the position count");
+    }
+    properties.push({ name: "NORMAL", alignment: 4, bytes: encodeFloat32Array(normalValues) });
+  }
+  const batchIds = tile.attributes?.batchIds;
+  let batchLength = 0;
+  if (batchIds) {
+    if (batchIds.length !== pointCount) {
+      throw new Error("3D Tiles point cloud batch ID count does not match the position count");
+    }
+    const batchIdValues = new Uint16Array(batchIds.length);
+    for (let index = 0; index < batchIds.length; index++) {
+      const batchId = batchIds[index];
+      if (!Number.isInteger(batchId) || batchId < 0 || batchId > 65535) {
+        throw new Error("3D Tiles point cloud batch IDs must be unsigned 16-bit integers");
+      }
+      batchIdValues[index] = batchId;
+      batchLength = Math.max(batchLength, batchId + 1);
+    }
+    const batchIdBytes = new Uint8Array(batchIdValues.length * 2);
+    const dataView = new DataView(batchIdBytes.buffer);
+    for (let index = 0; index < batchIdValues.length; index++) {
+      dataView.setUint16(index * 2, batchIdValues[index], true);
+    }
+    properties.push({ name: "BATCH_ID", alignment: 2, bytes: batchIdBytes });
+  }
+  const json = {
+    ...tile.featureTableJson || {},
+    POINTS_LENGTH: pointCount
+  };
+  if (batchIds) {
+    json.BATCH_LENGTH = batchLength;
+  }
+  const binaryByteLength = getPointCloudFeatureTableByteLength(properties);
+  const binary = new Uint8Array(binaryByteLength);
+  let byteOffset = 0;
+  for (const property of properties) {
+    byteOffset = align(byteOffset, property.alignment);
+    json[property.name] = { byteOffset };
+    binary.set(property.bytes, byteOffset);
+    byteOffset += property.bytes.byteLength;
+  }
+  return { json, binary };
+}
+function getPointCloudFeatureTableByteLength(properties) {
+  let byteLength = 0;
+  for (const property of properties) {
+    byteLength = align(byteLength, property.alignment) + property.bytes.byteLength;
+  }
+  return byteLength;
+}
+function align(byteOffset, alignment) {
+  return Math.ceil(byteOffset / alignment) * alignment;
+}
+function encodeFloat32Array(values) {
+  const bytes = new Uint8Array(values.length * 4);
+  const dataView = new DataView(bytes.buffer);
+  for (let index = 0; index < values.length; index++) {
+    const value = values[index];
+    if (!Number.isFinite(value)) {
+      throw new Error("3D Tiles point cloud attributes must contain finite values");
+    }
+    dataView.setFloat32(index * 4, value, true);
+  }
+  return bytes;
+}
+function encodeColorBytes(colors, normalized, pointCount, colorSize) {
+  if (colors.length !== pointCount * colorSize) {
+    throw new Error("3D Tiles point cloud color count does not match the position count");
+  }
+  const bytes = new Uint8Array(colors.length);
+  for (let index = 0; index < colors.length; index++) {
+    const value = colors[index];
+    const scaledValue = normalized ? value * 255 : value;
+    if (!Number.isFinite(scaledValue) || scaledValue < 0 || scaledValue > 255) {
+      throw new Error("3D Tiles point cloud color components must be between 0 and 255");
+    }
+    bytes[index] = Math.round(scaledValue);
+  }
+  return bytes;
+}
+
+// ../../modules/3d-tiles/src/lib/encoders/encode-3d-tile.ts
+function encode3DTile(tile, options) {
+  const byteLength = encode3DTileToDataView(tile, null, 0, options);
+  const arrayBuffer = new ArrayBuffer(byteLength);
+  const dataView = new DataView(arrayBuffer);
+  encode3DTileToDataView(tile, dataView, 0, options);
+  return arrayBuffer;
+}
+function encode3DTileToDataView(tile, dataView, byteOffset, options) {
+  assert(typeof tile.type === "string");
+  switch (tile.type) {
+    case TILE3D_TYPE.COMPOSITE:
+      return encodeComposite3DTile(tile, dataView, byteOffset, options, encode3DTileToDataView);
+    case TILE3D_TYPE.POINT_CLOUD:
+      return encodePointCloud3DTile(tile, dataView, byteOffset, options);
+    case TILE3D_TYPE.BATCHED_3D_MODEL:
+      return encodeBatchedModel3DTile(tile, dataView, byteOffset, options);
+    case TILE3D_TYPE.INSTANCED_3D_MODEL:
+      return encodeInstancedModel3DTile(tile, dataView, byteOffset, options);
+    default:
+      throw new Error("3D Tiles: unknown tile type");
+  }
+}
+
+// ../../modules/3d-tiles/src/tile-3d-writer.ts
+var Tile3DWriter = {
+  name: "3D Tile",
+  id: "3d-tiles",
+  module: "3d-tiles",
+  version: VERSION,
+  extensions: ["cmpt", "pnts", "b3dm", "i3dm"],
+  mimeTypes: ["application/octet-stream"],
+  binary: true,
+  options: {
+    ["3d-tiles"]: {}
+  },
+  encode: async (tile, options) => encodeSync(tile, options),
+  encodeSync
+};
+function encodeSync(tile, options) {
+  return encode3DTile(tile, options);
+}
+
+// ../../modules/3d-tiles/src/index.ts
+init_constants();
+
+// src/v5/point-cloud.ts
+init_src4();
+function encodePointCloudTile(pointBatch, options = {}) {
+  const mesh = "attributes" in pointBatch ? pointBatch : convertTableToMesh(pointBatch);
+  validatePointAttributes(mesh.attributes);
+  const positionAttribute = mesh.attributes.POSITION;
+  if (!positionAttribute || positionAttribute.size !== 3) {
+    throw new TileConversionError(
+      "POINT_CLOUD_POSITION_REQUIRED",
+      "Point cloud batches must contain a three-component POSITION attribute"
+    );
+  }
+  const positions = getPositionValues(positionAttribute, options.rtcCenter);
+  const pointCount = positions.length / 3;
+  if (pointCount === 0 || !Number.isInteger(pointCount)) {
+    throw new TileConversionError(
+      "POINT_CLOUD_POSITION_COUNT_INVALID",
+      "Point cloud POSITION must contain one or more xyz triples"
+    );
+  }
+  const colors = getColorAttribute(mesh.attributes.COLOR_0 || mesh.attributes.COLOR, pointCount);
+  const constantRGBA = colors ? null : getConstantRgba(options.constantRGBA);
+  const normals = getNormalAttribute(mesh.attributes.NORMAL, pointCount);
+  const batchIds = getBatchIds(mesh.attributes.BATCH_ID, pointCount);
+  const batchTableJson = validateBatchTable(options.batchTableJson, batchIds);
+  return Tile3DWriter.encodeSync(
+    {
+      type: TILE3D_TYPE.POINT_CLOUD,
+      featureTableJson: options.rtcCenter || constantRGBA ? {
+        ...options.rtcCenter ? { RTC_CENTER: [...options.rtcCenter] } : {},
+        ...constantRGBA ? { CONSTANT_RGBA: constantRGBA } : {}
+      } : void 0,
+      batchTableJson,
+      attributes: { positions, colors, normals, batchIds }
+    },
+    {}
+  );
+}
+function validatePointAttributes(attributes) {
+  const supportedAttributes = /* @__PURE__ */ new Set([
+    "POSITION",
+    "NORMAL",
+    "BATCH_ID",
+    attributes.COLOR_0 ? "COLOR_0" : "COLOR"
+  ]);
+  const unsupportedAttributes = Object.keys(attributes).filter(
+    (name) => !supportedAttributes.has(name)
+  );
+  if (unsupportedAttributes.length > 0) {
+    throw new TileConversionError(
+      "POINT_CLOUD_ATTRIBUTE_UNSUPPORTED",
+      `PNTS encoding does not support these point attributes: ${unsupportedAttributes.join(", ")}`
+    );
+  }
+}
+function getConstantRgba(constantRGBA) {
+  if (!constantRGBA) {
+    return null;
+  }
+  if (constantRGBA.length !== 4 || constantRGBA.some((value) => !Number.isInteger(value) || value < 0 || value > 255)) {
+    throw new TileConversionError(
+      "POINT_CLOUD_CONSTANT_RGBA_INVALID",
+      "Point cloud constantRGBA must contain four unsigned byte values"
+    );
+  }
+  return [constantRGBA[0], constantRGBA[1], constantRGBA[2], constantRGBA[3]];
+}
+function getPositionValues(attribute, rtcCenter) {
+  if (rtcCenter && (rtcCenter.length !== 3 || rtcCenter.some((value) => !Number.isFinite(value)))) {
+    throw new TileConversionError(
+      "POINT_CLOUD_RTC_CENTER_INVALID",
+      "Point cloud RTC_CENTER must contain three finite values"
+    );
+  }
+  const values = attribute.value;
+  const result = new Float32Array(values.length);
+  const transform = attribute.transform;
+  for (let index = 0; index < values.length; index++) {
+    const component = index % 3;
+    const value = values[index];
+    const absoluteValue = transform?.type === "quantization" ? transform.origin[component] + value / (2 ** transform.bits - 1) * transform.range : value;
+    result[index] = absoluteValue - (rtcCenter?.[component] ?? 0);
+  }
+  return result;
+}
+function getColorAttribute(attribute, pointCount) {
+  if (!attribute) {
+    return null;
+  }
+  if (attribute.size !== 3 && attribute.size !== 4) {
+    throw new TileConversionError(
+      "POINT_CLOUD_COLOR_SIZE_UNSUPPORTED",
+      "Point cloud color attributes must contain three or four components"
+    );
+  }
+  if (attribute.value.length !== pointCount * attribute.size) {
+    throw new TileConversionError(
+      "POINT_CLOUD_COLOR_COUNT_MISMATCH",
+      "Point cloud color count does not match the POSITION count"
+    );
+  }
+  const colors = new Uint8Array(attribute.value.length);
+  const maximum = getIntegerColorMaximum(attribute.value);
+  for (let index = 0; index < attribute.value.length; index++) {
+    const value = attribute.value[index];
+    const scaledValue = maximum ? value / maximum * 255 : value <= 1 ? value * 255 : value;
+    if (!Number.isFinite(scaledValue) || scaledValue < 0 || scaledValue > 255) {
+      throw new TileConversionError(
+        "POINT_CLOUD_COLOR_VALUE_INVALID",
+        "Point cloud color components must be finite values from 0 through 255"
+      );
+    }
+    colors[index] = Math.round(scaledValue);
+  }
+  return { type: 5121, value: colors, size: attribute.size, normalized: false };
+}
+function getIntegerColorMaximum(values) {
+  if (values instanceof Uint8Array || values instanceof Uint8ClampedArray) {
+    return 255;
+  }
+  if (values instanceof Uint16Array) {
+    return 65535;
+  }
+  if (values instanceof Uint32Array) {
+    return 4294967295;
+  }
+  return null;
+}
+function getNormalAttribute(attribute, pointCount) {
+  if (!attribute) {
+    return null;
+  }
+  if (attribute.size !== 3 || attribute.value.length !== pointCount * 3) {
+    throw new TileConversionError(
+      "POINT_CLOUD_NORMAL_COUNT_MISMATCH",
+      "Point cloud normals must contain one xyz triple per position"
+    );
+  }
+  return { type: 5126, value: Float32Array.from(attribute.value), size: 3 };
+}
+function getBatchIds(attribute, pointCount) {
+  if (!attribute) {
+    return null;
+  }
+  if (attribute.size !== 1 || attribute.value.length !== pointCount) {
+    throw new TileConversionError(
+      "POINT_CLOUD_BATCH_ID_COUNT_MISMATCH",
+      "Point cloud BATCH_ID must contain one value per position"
+    );
+  }
+  const batchIds = new Uint16Array(pointCount);
+  for (let index = 0; index < pointCount; index++) {
+    const batchId = attribute.value[index];
+    if (!Number.isInteger(batchId) || batchId < 0 || batchId > 65535) {
+      throw new TileConversionError(
+        "POINT_CLOUD_BATCH_ID_OUT_OF_RANGE",
+        "Point cloud BATCH_ID values must be unsigned 16-bit integers"
+      );
+    }
+    batchIds[index] = batchId;
+  }
+  return batchIds;
+}
+function validateBatchTable(batchTableJson, batchIds) {
+  if (!batchTableJson) {
+    if (batchIds) {
+      throw new TileConversionError(
+        "POINT_CLOUD_BATCH_TABLE_REQUIRED",
+        "BATCH_ID values require matching batchTableJson properties"
+      );
+    }
+    return void 0;
+  }
+  if (!batchIds) {
+    throw new TileConversionError(
+      "POINT_CLOUD_BATCH_ID_REQUIRED",
+      "batchTableJson requires a BATCH_ID attribute"
+    );
+  }
+  let batchLength = 0;
+  for (const batchId of batchIds) {
+    batchLength = Math.max(batchLength, batchId + 1);
+  }
+  const normalizedBatchTable = {};
+  for (const [name, values] of Object.entries(batchTableJson)) {
+    if (values.length !== batchLength) {
+      throw new TileConversionError(
+        "POINT_CLOUD_BATCH_TABLE_LENGTH_MISMATCH",
+        `Batch table property "${name}" must contain ${batchLength} values`
+      );
+    }
+    normalizedBatchTable[name] = [...values];
+  }
+  return normalizedBatchTable;
+}
+
+// src/v5/point-cloud-source.ts
+async function* traversePointCloudSource(source, options = {}) {
+  const { maxDepth = Number.POSITIVE_INFINITY, signal } = options;
+  if (maxDepth !== Number.POSITIVE_INFINITY && (!Number.isSafeInteger(maxDepth) || maxDepth < 0)) {
+    throw new RangeError("Point-cloud source maxDepth must be a non-negative integer");
+  }
+  throwIfAborted5(signal);
+  if (!source.isReady) {
+    await source.initialize();
+  }
+  throwIfAborted5(signal);
+  const root = await source.getRootTile();
+  const pendingTiles = [root];
+  const visitedTileIds = /* @__PURE__ */ new Set();
+  while (pendingTiles.length > 0) {
+    throwIfAborted5(signal);
+    const header = pendingTiles.pop();
+    if (visitedTileIds.has(header.id)) {
+      continue;
+    }
+    visitedTileIds.add(header.id);
+    const content = await source.loadTileContent(header);
+    throwIfAborted5(signal);
+    yield { header, content };
+    throwIfAborted5(signal);
+    if (header.level >= maxDepth) {
+      continue;
+    }
+    const children = await source.getChildren(header);
+    throwIfAborted5(signal);
+    for (let index = children.length - 1; index >= 0; index--) {
+      pendingTiles.push(children[index]);
+    }
+  }
+}
+function throwIfAborted5(signal) {
+  if (signal?.aborted) {
+    throw signal.reason ?? new DOMException("The operation was aborted", "AbortError");
+  }
+}
+
+// src/v5/point-cloud-source-encoder.ts
+async function* encodePointCloudSource(source, options = {}) {
+  for await (const sourceTile of traversePointCloudSource(source, options)) {
+    const encodingOptions = sourceTile.content ? options.getTileEncodingOptions?.(sourceTile) : void 0;
+    const encodedTile = encodePointCloudSourceTile(sourceTile, encodingOptions);
+    if (encodedTile) {
+      yield encodedTile;
+    }
+  }
+}
+function encodePointCloudSourceTile(sourceTile, options = {}) {
+  const { header, content } = sourceTile;
+  if (!content) {
+    return null;
+  }
+  return {
+    id: header.id,
+    header,
+    pnts: encodePointCloudTile(content.data, {
+      ...options,
+      constantRGBA: options.constantRGBA ?? content.constantRGBA
+    }),
+    pointCount: content.pointCount,
+    coordinateSystem: content.coordinateSystem,
+    cartographicOrigin: [...content.cartographicOrigin],
+    modelMatrix: content.modelMatrix ? Array.from(content.modelMatrix) : void 0,
+    spatialReference: content.spatialReference,
+    spatialBoundingVolume: content.spatialBoundingVolume || header.spatialBoundingVolume
+  };
+}
+
+// src/v5/point-cloud-conversion.ts
+function convertPointCloudSource(source, options) {
+  return convertTileset({
+    source: {
+      async inspect() {
+        if (!source.isReady) {
+          await source.initialize();
+        }
+      },
+      read: (_inspection, signal) => traversePointCloudSource(source, { maxDepth: options.maxDepth, signal })
+    },
+    codec: {
+      async *convert(sourceTile) {
+        const encodingOptions = sourceTile.content ? options.getTileEncodingOptions?.(sourceTile) : void 0;
+        const encodedTile = encodePointCloudSourceTile(sourceTile, encodingOptions);
+        if (encodedTile) {
+          yield encodedTile;
+        }
+      }
+    },
+    sink: options.sink,
+    measureInputBytes: options.measureInputBytes,
+    measureOutputBytes: (resource) => resource.pnts.byteLength,
+    maxInputResourceBytes: options.maxInputResourceBytes,
+    maxOutputResourceBytes: options.maxOutputResourceBytes,
+    signal: options.signal,
+    onProgress: options.onProgress
+  });
+}
+export {
+  TileConversionError,
+  convertPointCloudSource,
+  convertTileset,
+  createBoundedMemoryTileConversionSink,
+  createBrowserTileConversionSource,
+  createBrowserTilesetConversionSource,
+  createTilesetConversionSource,
+  encodePointCloudSource,
+  encodePointCloudSourceTile,
+  encodePointCloudTile,
+  inspectTileset,
+  traversePointCloudSource,
+  validateTileset
+};