@loaders.gl/pointclouds 0.0.0-stage → 5.0.0-beta.2

package/dist/las-writer.cjs

@@ -0,0 +1,1056 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/las-writer.ts
+var las_writer_exports = {};
+__export(las_writer_exports, {
+  LASWriter: () => LASWriter
+});
+module.exports = __toCommonJS(las_writer_exports);
+
+// src/las/las-writer.ts
+var import_loader_utils = require("@loaders.gl/core/loader-utils");
+var import_schema_utils = require("@loaders.gl/core/schema-utils");
+var import_las_format = require("./las-format.cjs");
+var VERSION = true ? "5.0.0-beta.2" : "latest";
+var LAS_HEADER_LENGTH = 227;
+var LAS_1_4_HEADER_LENGTH = 375;
+var LAS_1_5_HEADER_LENGTH = 393;
+var VLR_HEADER_LENGTH = 54;
+var EXTRA_BYTES_DESCRIPTOR_LENGTH = 192;
+var DEFAULT_LAZ_CHUNK_SIZE = 5e4;
+var VARIABLE_LAZ_CHUNK_SIZE = 4294967295;
+var LAS_RETURN_BUCKET_COUNT = 15;
+var POINT_RECORD_LENGTHS = {
+  0: 20,
+  1: 28,
+  2: 26,
+  3: 34,
+  4: 57,
+  5: 63,
+  6: 30,
+  7: 36,
+  8: 38,
+  9: 59,
+  10: 67
+};
+var LASWriter = {
+  ...import_las_format.LASFormat,
+  dataType: null,
+  batchType: null,
+  version: VERSION,
+  extensions: ["las", "laz"],
+  options: {
+    las: {}
+  },
+  encode: async (data, options) => encodeLASSync(data, options),
+  encodeSync: encodeLASSync,
+  encodeInBatches: async function* (dataIterator, options) {
+    const batches = [];
+    for await (const batch of dataIterator) {
+      batches.push(batch);
+    }
+    yield encodeLASSync(mergeMeshBatches(batches), options);
+  }
+};
+function encodeLASSync(data, options = {}) {
+  const format = options.las?.format || "las";
+  const colorDepth = options.las?.colorDepth;
+  if (colorDepth !== void 0 && colorDepth !== "auto" && colorDepth !== 8 && colorDepth !== 16)
+    throw new Error("LASWriter: invalid source color depth");
+  const mesh = normalizeMesh(data);
+  const positionAttribute = getRequiredAttribute(mesh, "POSITION");
+  validatePositionAttribute(positionAttribute);
+  const vertexCount = positionAttribute.value.length / positionAttribute.size;
+  validateOptionalPointAttributes(mesh, vertexCount);
+  const colorAttribute = mesh.attributes.COLOR_0;
+  const intensityAttribute = mesh.attributes.intensity;
+  const classificationAttribute = mesh.attributes.classification;
+  const nirAttribute = mesh.attributes.nir;
+  const extraByteFields = getExtraByteFields(mesh, options, vertexCount);
+  const gpsTimeAttribute = mesh.attributes.gpsTime;
+  const scanAngleAttribute = mesh.attributes.scanAngle;
+  const userDataAttribute = mesh.attributes.userData;
+  const pointSourceIdAttribute = mesh.attributes.pointSourceId;
+  const returnNumberAttribute = mesh.attributes.returnNumber;
+  const numberOfReturnsAttribute = mesh.attributes.numberOfReturns;
+  const scannerChannelAttribute = mesh.attributes.scannerChannel;
+  const scanDirectionFlagAttribute = mesh.attributes.scanDirectionFlag;
+  const edgeOfFlightLineAttribute = mesh.attributes.edgeOfFlightLine;
+  const syntheticAttribute = mesh.attributes.synthetic;
+  const keyPointAttribute = mesh.attributes.keyPoint;
+  const withheldAttribute = mesh.attributes.withheld;
+  const overlapAttribute = mesh.attributes.overlap;
+  const waveformDescriptorAttribute = mesh.attributes.wavePacketDescriptorIndex;
+  const waveformOffsetAttribute = mesh.attributes.wavePacketOffset;
+  const waveformSizeAttribute = mesh.attributes.wavePacketSize;
+  const waveformReturnPointAttribute = mesh.attributes.wavePacketReturnPoint;
+  const waveformVectorAttribute = mesh.attributes.wavePacketVector;
+  const boundingBox = getBoundingBox(positionAttribute, vertexCount);
+  const returnCounts = getReturnCounts(returnNumberAttribute, vertexCount);
+  const scale = getScale(mesh, options);
+  const offset = getOffset(mesh, options, boundingBox);
+  validateCoordinateEncoding(positionAttribute, vertexCount, scale, offset);
+  const pointDataRecordFormat = options.las?.pointDataRecordFormat ?? getDefaultPointDataRecordFormat(options, colorAttribute);
+  validateReturnAttributes(mesh, vertexCount, pointDataRecordFormat);
+  const basePointDataRecordLength = POINT_RECORD_LENGTHS[pointDataRecordFormat];
+  if (!basePointDataRecordLength) {
+    throw new Error(`LASWriter: unsupported point data record format ${pointDataRecordFormat}`);
+  }
+  const pointDataRecordLength = basePointDataRecordLength + extraByteFields.reduce((byteLength, field) => byteLength + field.byteLength, 0);
+  if (pointDataRecordLength > 65535) {
+    throw new Error(
+      `LASWriter: point data record length ${pointDataRecordLength} exceeds the LAS limit`
+    );
+  }
+  validateExtraBytesVLR(extraByteFields);
+  const version = options.las?.version || (pointDataRecordFormat >= 6 ? "1.4" : "1.2");
+  const headerLength = version === "1.5" ? LAS_1_5_HEADER_LENGTH : version === "1.4" ? LAS_1_4_HEADER_LENGTH : LAS_HEADER_LENGTH;
+  validateLASVersionOptions(version, pointDataRecordFormat, options);
+  const gpsTimeRange = getGpsTimeRange(gpsTimeAttribute, vertexCount);
+  if (version === "1.5" && options.las?.timeOffset && !gpsTimeAttribute) {
+    throw new Error("LASWriter: LAS 1.5 timeOffset requires a GPS time attribute");
+  }
+  if (format === "laz") {
+    validateLAZOptions(version, pointDataRecordFormat, options.las?.chunkSize);
+  }
+  validatePointDataRecordVersion(version, pointDataRecordFormat);
+  const rawPointData = new Uint8Array(vertexCount * pointDataRecordLength);
+  const pointDataView = new DataView(rawPointData.buffer);
+  for (let vertexIndex = 0; vertexIndex < vertexCount; vertexIndex++) {
+    const pointOffset = vertexIndex * pointDataRecordLength;
+    pointDataView.setInt32(
+      pointOffset,
+      Math.round((getComponent(positionAttribute, vertexIndex, 0) - offset[0]) / scale[0]),
+      true
+    );
+    pointDataView.setInt32(
+      pointOffset + 4,
+      Math.round((getComponent(positionAttribute, vertexIndex, 1) - offset[1]) / scale[1]),
+      true
+    );
+    pointDataView.setInt32(
+      pointOffset + 8,
+      Math.round((getComponent(positionAttribute, vertexIndex, 2) - offset[2]) / scale[2]),
+      true
+    );
+    writePointRecord(
+      pointDataView,
+      pointOffset,
+      vertexIndex,
+      pointDataRecordFormat,
+      basePointDataRecordLength,
+      {
+        intensityAttribute,
+        classificationAttribute,
+        nirAttribute,
+        colorAttribute,
+        colorDepth,
+        gpsTimeAttribute,
+        scanAngleAttribute,
+        userDataAttribute,
+        pointSourceIdAttribute,
+        returnNumberAttribute,
+        numberOfReturnsAttribute,
+        scannerChannelAttribute,
+        scanDirectionFlagAttribute,
+        edgeOfFlightLineAttribute,
+        syntheticAttribute,
+        keyPointAttribute,
+        withheldAttribute,
+        overlapAttribute,
+        waveformDescriptorAttribute,
+        waveformOffsetAttribute,
+        waveformSizeAttribute,
+        waveformReturnPointAttribute,
+        waveformVectorAttribute,
+        extraByteFields
+      }
+    );
+  }
+  const writeParameters = {
+    vertexCount,
+    boundingBox,
+    scale,
+    offset,
+    version,
+    headerLength,
+    pointDataRecordFormat,
+    pointDataRecordLength,
+    returnCounts,
+    maxGpsTime: gpsTimeRange.maximum,
+    minGpsTime: gpsTimeRange.minimum,
+    timeOffset: options.las?.timeOffset || 0,
+    hasGpsTime: Boolean(gpsTimeAttribute),
+    hasWkt: Boolean(options.las?.wkt)
+  };
+  if (format === "laz") {
+    return encodeLAZFile(
+      rawPointData,
+      writeParameters,
+      options.las?.chunkSize,
+      options.las?.variableChunkTable,
+      extraByteFields,
+      options
+    );
+  }
+  const metadataVLR = encodeMetadataVLRs(extraByteFields, options);
+  const pointDataOffset = headerLength + metadataVLR.byteLength;
+  const arrayBuffer = new ArrayBuffer(pointDataOffset + rawPointData.byteLength);
+  writeHeader(new DataView(arrayBuffer), {
+    ...writeParameters,
+    pointDataOffset,
+    vlrCount: countMetadataVLRs(extraByteFields, options)
+  });
+  const bytes = new Uint8Array(arrayBuffer);
+  bytes.set(metadataVLR, headerLength);
+  bytes.set(rawPointData, pointDataOffset);
+  return arrayBuffer;
+}
+function validatePointDataRecordVersion(version, pointDataRecordFormat) {
+  const minimumVersionByPointFormat = {
+    0: "1.0",
+    1: "1.1",
+    2: "1.2",
+    3: "1.2"
+  };
+  const minimumVersion = minimumVersionByPointFormat[pointDataRecordFormat];
+  if (minimumVersion && version < minimumVersion) {
+    throw new Error(
+      `LASWriter: point data record format ${pointDataRecordFormat} requires LAS ${minimumVersion} or newer; received ${version}`
+    );
+  }
+  if (pointDataRecordFormat >= 4 && pointDataRecordFormat <= 5 && !["1.3", "1.4", "1.5"].includes(version)) {
+    throw new Error(
+      `LASWriter: point data record format ${pointDataRecordFormat} requires LAS 1.3; received ${version}`
+    );
+  }
+  if (pointDataRecordFormat >= 6 && !["1.4", "1.5"].includes(version)) {
+    throw new Error(
+      `LASWriter: point data record format ${pointDataRecordFormat} requires LAS 1.4; received ${version}`
+    );
+  }
+}
+function validateLASVersionOptions(version, pointDataRecordFormat, options) {
+  if (version === "1.5") {
+    if (pointDataRecordFormat < 6 || pointDataRecordFormat > 10) {
+      throw new Error("LASWriter: LAS 1.5 output requires point data record format 6-10");
+    }
+    if (!options.las?.wkt?.trim()) {
+      throw new Error("LASWriter: LAS 1.5 output requires las.wkt");
+    }
+    const timeOffset = options.las?.timeOffset ?? 0;
+    if (!Number.isInteger(timeOffset) || timeOffset < 0 || timeOffset > 65535) {
+      throw new Error("LASWriter: LAS 1.5 timeOffset must be an unsigned 16-bit integer");
+    }
+  }
+}
+function encodeLAZFile(rawPointData, parameters, requestedChunkSize, variableChunkTable = false, extraByteFields = [], options = {}) {
+  const chunkSize = requestedChunkSize || DEFAULT_LAZ_CHUNK_SIZE;
+  const laszipVLR = (0, import_loader_utils.encodeLASzipVLR)({
+    pointDataRecordFormat: parameters.pointDataRecordFormat,
+    pointDataRecordLength: parameters.pointDataRecordLength,
+    chunkSize: variableChunkTable ? VARIABLE_LAZ_CHUNK_SIZE : chunkSize
+  });
+  const metadataVLR = encodeMetadataVLRs(extraByteFields, options);
+  const pointDataOffset = parameters.headerLength + metadataVLR.byteLength + laszipVLR.byteLength;
+  const compressedChunks = [];
+  const chunkTableEntries = [];
+  for (let pointOffset = 0; pointOffset < parameters.vertexCount; pointOffset += chunkSize) {
+    const pointCount = Math.min(chunkSize, parameters.vertexCount - pointOffset);
+    const byteOffset = pointOffset * parameters.pointDataRecordLength;
+    const compressed = (0, import_loader_utils.encodeLAZChunk)(
+      rawPointData.subarray(byteOffset, byteOffset + pointCount * parameters.pointDataRecordLength),
+      {
+        pointDataRecordFormat: parameters.pointDataRecordFormat,
+        pointDataRecordLength: parameters.pointDataRecordLength,
+        pointCount,
+        point14ItemVersion: 3,
+        rgb14ItemVersion: 3,
+        byte14ItemVersion: 3
+      }
+    );
+    compressedChunks.push(compressed);
+    chunkTableEntries.push({ pointCount, byteLength: compressed.byteLength });
+  }
+  const compressedPointDataByteLength = compressedChunks.reduce(
+    (byteLength, chunk) => byteLength + chunk.byteLength,
+    0
+  );
+  const chunkTablePayload = (0, import_loader_utils.encodeLAZChunkTable)(chunkTableEntries, {
+    variable: variableChunkTable
+  });
+  const chunkTableOffset = pointDataOffset + 8 + compressedPointDataByteLength;
+  const arrayBuffer = new ArrayBuffer(chunkTableOffset + 8 + chunkTablePayload.byteLength);
+  const bytes = new Uint8Array(arrayBuffer);
+  const dataView = new DataView(arrayBuffer);
+  writeHeader(dataView, {
+    ...parameters,
+    pointDataOffset,
+    vlrCount: countMetadataVLRs(extraByteFields, options) + 1,
+    compressed: true
+  });
+  bytes.set(metadataVLR, parameters.headerLength);
+  bytes.set(laszipVLR, parameters.headerLength + metadataVLR.byteLength);
+  writeUint64Fallback(dataView, pointDataOffset, chunkTableOffset);
+  let compressedOffset = pointDataOffset + 8;
+  for (const chunk of compressedChunks) {
+    bytes.set(chunk, compressedOffset);
+    compressedOffset += chunk.byteLength;
+  }
+  dataView.setUint32(chunkTableOffset, 0, true);
+  dataView.setUint32(chunkTableOffset + 4, chunkTableEntries.length, true);
+  bytes.set(chunkTablePayload, chunkTableOffset + 8);
+  return arrayBuffer;
+}
+function getExtraByteFields(mesh, options, vertexCount) {
+  const extraBytes = options.las?.extraBytes || [];
+  const attributes = /* @__PURE__ */ new Set();
+  return extraBytes.map((field) => {
+    if (attributes.has(field.attribute)) {
+      throw new Error(`LASWriter: duplicate Extra Bytes attribute ${field.attribute}`);
+    }
+    attributes.add(field.attribute);
+    const meshAttribute = mesh.attributes[field.attribute];
+    if (!meshAttribute) {
+      throw new Error(`LASWriter: Extra Bytes attribute ${field.attribute} is missing`);
+    }
+    if (![1, 3].includes(meshAttribute.size)) {
+      throw new Error(`LASWriter: Extra Bytes attribute ${field.attribute} must have size 1 or 3`);
+    }
+    if (meshAttribute.value.length < vertexCount * meshAttribute.size) {
+      throw new Error(`LASWriter: Extra Bytes attribute ${field.attribute} is too short`);
+    }
+    validateFiniteAttributeValues(field.attribute, meshAttribute);
+    const dataType = getExtraBytesDataType(meshAttribute.value, meshAttribute.size);
+    return {
+      ...field,
+      meshAttribute,
+      dataType,
+      byteLength: getExtraBytesDataTypeByteLength(dataType, meshAttribute.size),
+      componentCount: meshAttribute.size
+    };
+  });
+}
+function getExtraBytesDataType(values, componentCount) {
+  let scalarDataType = 0;
+  if (values instanceof Uint8Array) scalarDataType = 1;
+  else if (values instanceof Int8Array) scalarDataType = 2;
+  else if (values instanceof Uint16Array) scalarDataType = 3;
+  else if (values instanceof Int16Array) scalarDataType = 4;
+  else if (values instanceof Uint32Array) scalarDataType = 5;
+  else if (values instanceof Int32Array) scalarDataType = 6;
+  else if (values instanceof BigUint64Array) scalarDataType = 7;
+  else if (values instanceof BigInt64Array) scalarDataType = 8;
+  else if (values instanceof Float32Array) scalarDataType = 9;
+  else if (values instanceof Float64Array) scalarDataType = 10;
+  if (scalarDataType) {
+    return scalarDataType + (componentCount === 3 ? 20 : 0);
+  }
+  throw new Error("LASWriter: Extra Bytes attributes require a supported typed array");
+}
+function getExtraBytesDataTypeByteLength(dataType, componentCount) {
+  const scalarDataType = dataType > 20 ? dataType - 20 : dataType > 10 ? dataType - 10 : dataType;
+  const scalarByteLength = scalarDataType <= 2 ? 1 : scalarDataType <= 4 ? 2 : scalarDataType <= 6 || scalarDataType === 9 ? 4 : 8;
+  return scalarByteLength * componentCount;
+}
+function encodeExtraBytesVLR(fields) {
+  if (fields.length === 0) {
+    return new Uint8Array(0);
+  }
+  const payload = new Uint8Array(fields.length * EXTRA_BYTES_DESCRIPTOR_LENGTH);
+  const dataView = new DataView(payload.buffer);
+  let byteOffset = 0;
+  for (const field of fields) {
+    dataView.setUint8(byteOffset + 2, field.dataType);
+    writeString(dataView, byteOffset + 4, field.name || field.attribute, 32);
+    writeString(dataView, byteOffset + 160, field.description || "", 32);
+    byteOffset += EXTRA_BYTES_DESCRIPTOR_LENGTH;
+  }
+  const bytes = new Uint8Array(VLR_HEADER_LENGTH + payload.byteLength);
+  const headerView = new DataView(bytes.buffer);
+  writeString(headerView, 2, "LASF_Spec", 16);
+  headerView.setUint16(18, 4, true);
+  headerView.setUint16(20, payload.byteLength, true);
+  writeString(headerView, 22, "Extra Bytes", 32);
+  bytes.set(payload, VLR_HEADER_LENGTH);
+  return bytes;
+}
+function encodeMetadataVLRs(fields, options) {
+  const records = [];
+  if (options.las?.wktMathTransform) {
+    records.push(encodeProjectionVLR(2111, "WKT Math Transform", options.las.wktMathTransform));
+  }
+  if (options.las?.wkt) {
+    records.push(encodeProjectionVLR(2112, "WKT Coordinate System", options.las.wkt));
+  }
+  const extraBytesVLR = encodeExtraBytesVLR(fields);
+  if (extraBytesVLR.byteLength) {
+    records.push(extraBytesVLR);
+  }
+  const byteLength = records.reduce((total, record) => total + record.byteLength, 0);
+  const bytes = new Uint8Array(byteLength);
+  let offset = 0;
+  for (const record of records) {
+    bytes.set(record, offset);
+    offset += record.byteLength;
+  }
+  return bytes;
+}
+function encodeProjectionVLR(recordId, description, wkt) {
+  const payload = new TextEncoder().encode(`${wkt}\0`);
+  if (payload.byteLength > 65535) {
+    throw new Error(`LASWriter: WKT VLR ${recordId} exceeds the LAS VLR size limit`);
+  }
+  const bytes = new Uint8Array(VLR_HEADER_LENGTH + payload.byteLength);
+  const dataView = new DataView(bytes.buffer);
+  writeString(dataView, 2, "LASF_Projection", 16);
+  dataView.setUint16(18, recordId, true);
+  dataView.setUint16(20, payload.byteLength, true);
+  writeString(dataView, 22, description, 32);
+  bytes.set(payload, VLR_HEADER_LENGTH);
+  return bytes;
+}
+function countMetadataVLRs(fields, options) {
+  return (options.las?.wktMathTransform ? 1 : 0) + (options.las?.wkt ? 1 : 0) + (fields.length ? 1 : 0);
+}
+function getGpsTimeRange(attribute, vertexCount) {
+  if (!attribute) {
+    return { minimum: 0, maximum: 0 };
+  }
+  let minimum = Number(attribute.value[0]);
+  let maximum = minimum;
+  for (let vertexIndex = 1; vertexIndex < vertexCount; vertexIndex++) {
+    const value = Number(attribute.value[vertexIndex * attribute.size]);
+    minimum = Math.min(minimum, value);
+    maximum = Math.max(maximum, value);
+  }
+  return { minimum, maximum };
+}
+function validateExtraBytesVLR(fields) {
+  const payloadByteLength = fields.length * EXTRA_BYTES_DESCRIPTOR_LENGTH;
+  if (payloadByteLength > 65535) {
+    throw new Error(
+      `LASWriter: Extra Bytes VLR payload ${payloadByteLength} exceeds the LAS limit`
+    );
+  }
+}
+function validateLAZOptions(version, pointDataRecordFormat, chunkSize) {
+  if (pointDataRecordFormat === 1 && !["1.1", "1.2", "1.3", "1.4", "1.5"].includes(version)) {
+    throw new Error(`LASWriter: LAZ PDRF 1 output requires LAS 1.1 or newer; received ${version}`);
+  }
+  if (pointDataRecordFormat >= 2 && pointDataRecordFormat <= 3 && !["1.2", "1.3", "1.4", "1.5"].includes(version)) {
+    throw new Error(
+      `LASWriter: LAZ PDRF ${pointDataRecordFormat} output requires LAS 1.2 or newer; received ${version}`
+    );
+  }
+  if (pointDataRecordFormat >= 4 && pointDataRecordFormat <= 5 && !["1.3", "1.4", "1.5"].includes(version)) {
+    throw new Error(
+      `LASWriter: LAZ PDRF ${pointDataRecordFormat} requires LAS 1.3 or newer; received ${version}`
+    );
+  }
+  if (pointDataRecordFormat >= 6 && !["1.4", "1.5"].includes(version)) {
+    throw new Error(`LASWriter: LAZ output requires LAS 1.4; received ${version}`);
+  }
+  if (![0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10].includes(pointDataRecordFormat)) {
+    throw new Error(
+      `LASWriter: LAZ output currently supports point data record formats 0-10; received ${pointDataRecordFormat}`
+    );
+  }
+  if (chunkSize !== void 0 && (!Number.isInteger(chunkSize) || chunkSize <= 0 || chunkSize > 4294967295)) {
+    throw new Error(`LASWriter: invalid LAZ chunk size ${chunkSize}`);
+  }
+}
+function normalizeMesh(data) {
+  if ("shape" in data && data.shape === "arrow-table") {
+    return (0, import_schema_utils.convertTableToMesh)(data);
+  }
+  return data;
+}
+function normalizeMeshArrowTable(data) {
+  return "shape" in data && data.shape === "arrow-table" ? data : (0, import_schema_utils.convertMeshToTable)(data, "arrow-table");
+}
+function mergeMeshBatches(batches) {
+  if (batches.length === 0) {
+    throw new Error("LASWriter: at least one input batch is required");
+  }
+  if (batches.length === 1) {
+    return batches[0];
+  }
+  const meshes = batches.map((batch) => (0, import_schema_utils.convertTableToMesh)(normalizeMeshArrowTable(batch)));
+  const firstMesh = meshes[0];
+  const mergedAttributes = {};
+  validateBatchAttributes(meshes);
+  for (const attributeName of Object.keys(firstMesh.attributes)) {
+    const firstAttribute = firstMesh.attributes[attributeName];
+    const values = meshes.map((mesh) => mesh.attributes[attributeName]?.value);
+    if (values.some((value) => !value)) {
+      continue;
+    }
+    const totalLength = values.reduce((length, value) => length + value.length, 0);
+    const Constructor = firstAttribute.value.constructor;
+    const mergedValue = new Constructor(totalLength);
+    let offset = 0;
+    for (const value of values) {
+      mergedValue.set(value, offset);
+      offset += value.length;
+    }
+    mergedAttributes[attributeName] = { ...firstAttribute, value: mergedValue };
+  }
+  return {
+    ...firstMesh,
+    attributes: mergedAttributes,
+    header: {
+      ...firstMesh.header,
+      vertexCount: getRequiredAttribute({ ...firstMesh, attributes: mergedAttributes }, "POSITION").value.length / 3
+    }
+  };
+}
+function validateBatchAttributes(meshes) {
+  const attributeNames = Object.keys(meshes[0].attributes);
+  for (const mesh of meshes.slice(1)) {
+    const meshAttributeNames = Object.keys(mesh.attributes);
+    if (meshAttributeNames.length !== attributeNames.length || attributeNames.some((attributeName) => !mesh.attributes[attributeName])) {
+      throw new Error("LASWriter: encodeInBatches requires consistent attribute names");
+    }
+    for (const attributeName of attributeNames) {
+      const firstAttribute = meshes[0].attributes[attributeName];
+      const attribute = mesh.attributes[attributeName];
+      if (attribute.size !== firstAttribute.size || attribute.value.constructor !== firstAttribute.value.constructor) {
+        throw new Error(`LASWriter: encodeInBatches requires a consistent ${attributeName} layout`);
+      }
+    }
+  }
+}
+function getRequiredAttribute(mesh, attributeName) {
+  const attribute = mesh.attributes[attributeName];
+  if (!attribute) {
+    throw new Error(`LASWriter: ${attributeName} attribute is required`);
+  }
+  return attribute;
+}
+function validatePositionAttribute(attribute) {
+  if (attribute.size !== 3) {
+    throw new Error(`LASWriter: POSITION attribute must have size 3`);
+  }
+  if (attribute.value.length % attribute.size !== 0) {
+    throw new Error(`LASWriter: POSITION attribute length must be divisible by its size`);
+  }
+}
+function validateCoordinateEncoding(attribute, vertexCount, scale, offset) {
+  for (let componentIndex = 0; componentIndex < 3; componentIndex++) {
+    if (!Number.isFinite(scale[componentIndex]) || scale[componentIndex] <= 0) {
+      throw new Error(`LASWriter: coordinate scale must be finite and positive`);
+    }
+    if (!Number.isFinite(offset[componentIndex])) {
+      throw new Error(`LASWriter: coordinate offset must be finite`);
+    }
+  }
+  for (let vertexIndex = 0; vertexIndex < vertexCount; vertexIndex++) {
+    for (let componentIndex = 0; componentIndex < 3; componentIndex++) {
+      const positionValue = attribute.value[vertexIndex * attribute.size + componentIndex];
+      if (!Number.isFinite(positionValue)) {
+        throw new Error(`LASWriter: POSITION values must be finite`);
+      }
+      const encodedValue = Math.round(
+        (positionValue - offset[componentIndex]) / scale[componentIndex]
+      );
+      if (encodedValue < -2147483648 || encodedValue > 2147483647) {
+        throw new Error(`LASWriter: encoded coordinate exceeds the signed 32-bit LAS range`);
+      }
+    }
+  }
+}
+function validateOptionalPointAttributes(mesh, vertexCount) {
+  const scalarAttributeNames = [
+    "intensity",
+    "classification",
+    "gpsTime",
+    "scanAngle",
+    "userData",
+    "pointSourceId",
+    "returnNumber",
+    "numberOfReturns",
+    "scannerChannel",
+    "scanDirectionFlag",
+    "edgeOfFlightLine",
+    "synthetic",
+    "keyPoint",
+    "withheld",
+    "overlap",
+    "nir",
+    "wavePacketDescriptorIndex",
+    "wavePacketOffset",
+    "wavePacketSize",
+    "wavePacketReturnPoint"
+  ];
+  for (const attributeName of scalarAttributeNames) {
+    const attribute = mesh.attributes[attributeName];
+    if (attribute) {
+      validateOptionalAttribute(attributeName, attribute, vertexCount, 1);
+    }
+  }
+  const colorAttribute = mesh.attributes.COLOR_0;
+  if (colorAttribute) {
+    validateOptionalAttribute("COLOR_0", colorAttribute, vertexCount, 3, false);
+  }
+  const waveformVectorAttribute = mesh.attributes.wavePacketVector;
+  if (waveformVectorAttribute) {
+    validateOptionalAttribute("wavePacketVector", waveformVectorAttribute, vertexCount, 3);
+  }
+}
+function validateReturnAttributes(mesh, vertexCount, pointDataRecordFormat) {
+  const maximumReturnNumber = pointDataRecordFormat >= 6 ? 15 : 5;
+  const returnNumberAttribute = mesh.attributes.returnNumber;
+  const numberOfReturnsAttribute = mesh.attributes.numberOfReturns;
+  for (let vertexIndex = 0; vertexIndex < vertexCount; vertexIndex++) {
+    const returnNumber = getUInt8Attribute(returnNumberAttribute, vertexIndex, 1);
+    const numberOfReturns = getUInt8Attribute(numberOfReturnsAttribute, vertexIndex, 1);
+    if (returnNumber < 1 || returnNumber > maximumReturnNumber) {
+      throw new Error(
+        `LASWriter: returnNumber must be between 1 and ${maximumReturnNumber} for point data record format ${pointDataRecordFormat}`
+      );
+    }
+    if (numberOfReturns < 1 || numberOfReturns > maximumReturnNumber) {
+      throw new Error(
+        `LASWriter: numberOfReturns must be between 1 and ${maximumReturnNumber} for point data record format ${pointDataRecordFormat}`
+      );
+    }
+    if (returnNumber > numberOfReturns) {
+      throw new Error(`LASWriter: returnNumber cannot exceed numberOfReturns`);
+    }
+  }
+}
+function validateOptionalAttribute(attributeName, attribute, vertexCount, minimumSize, requirePointCount = true) {
+  if (minimumSize === 1 ? attribute.size !== 1 : attribute.size < minimumSize) {
+    throw new Error(`LASWriter: ${attributeName} attribute must have size ${minimumSize}`);
+  }
+  validateFiniteAttributeValues(attributeName, attribute);
+  if (requirePointCount && attribute.value.length < vertexCount * attribute.size) {
+    throw new Error(`LASWriter: ${attributeName} attribute is too short`);
+  }
+  if (!requirePointCount && attribute.value.length < attribute.size) {
+    throw new Error(`LASWriter: ${attributeName} attribute is too short`);
+  }
+}
+function validateFiniteAttributeValues(attributeName, attribute) {
+  for (const value of attribute.value) {
+    if (!Number.isFinite(Number(value))) {
+      throw new Error(`LASWriter: ${attributeName} attribute must contain finite values`);
+    }
+  }
+}
+function writeHeader(dataView, parameters) {
+  const [versionMajor, versionMinor] = parameters.version.split(".").map(Number);
+  writeString(dataView, 0, "LASF", 4);
+  dataView.setUint8(24, versionMajor);
+  dataView.setUint8(25, versionMinor);
+  writeString(dataView, 26, "loaders.gl", 32);
+  writeString(dataView, 58, "loaders.gl", 32);
+  dataView.setUint16(94, parameters.headerLength, true);
+  dataView.setUint32(96, parameters.pointDataOffset, true);
+  dataView.setUint32(100, parameters.vlrCount || 0, true);
+  dataView.setUint8(104, parameters.pointDataRecordFormat | (parameters.compressed ? 128 : 0));
+  dataView.setUint16(105, parameters.pointDataRecordLength, true);
+  const isExtendedHeader = parameters.version === "1.4" || parameters.version === "1.5";
+  dataView.setUint32(107, isExtendedHeader ? 0 : parameters.vertexCount, true);
+  for (let returnIndex = 0; returnIndex < 5; returnIndex++) {
+    dataView.setUint32(
+      111 + returnIndex * 4,
+      isExtendedHeader ? 0 : parameters.returnCounts[returnIndex],
+      true
+    );
+  }
+  if (parameters.version === "1.5") {
+    dataView.setUint16(
+      6,
+      16 | (parameters.hasGpsTime ? 1 : 0) | (parameters.timeOffset ? 64 : 0),
+      true
+    );
+  } else if (parameters.version === "1.4" && parameters.hasWkt) {
+    dataView.setUint16(6, 16, true);
+  }
+  dataView.setFloat64(131, parameters.scale[0], true);
+  dataView.setFloat64(139, parameters.scale[1], true);
+  dataView.setFloat64(147, parameters.scale[2], true);
+  dataView.setFloat64(155, parameters.offset[0], true);
+  dataView.setFloat64(163, parameters.offset[1], true);
+  dataView.setFloat64(171, parameters.offset[2], true);
+  dataView.setFloat64(179, parameters.boundingBox[1][0], true);
+  dataView.setFloat64(187, parameters.boundingBox[0][0], true);
+  dataView.setFloat64(195, parameters.boundingBox[1][1], true);
+  dataView.setFloat64(203, parameters.boundingBox[0][1], true);
+  dataView.setFloat64(211, parameters.boundingBox[1][2], true);
+  dataView.setFloat64(219, parameters.boundingBox[0][2], true);
+  if (isExtendedHeader) {
+    writeUint64Fallback(dataView, 247, parameters.vertexCount);
+    for (let returnIndex = 0; returnIndex < LAS_RETURN_BUCKET_COUNT; returnIndex++) {
+      writeUint64Fallback(dataView, 255 + returnIndex * 8, parameters.returnCounts[returnIndex]);
+    }
+  }
+  if (parameters.version === "1.5") {
+    dataView.setFloat64(375, parameters.maxGpsTime, true);
+    dataView.setFloat64(383, parameters.minGpsTime, true);
+    dataView.setUint16(391, parameters.timeOffset, true);
+  }
+}
+function writePointRecord(dataView, pointOffset, vertexIndex, pointDataRecordFormat, basePointDataRecordLength, attributes) {
+  dataView.setUint16(
+    pointOffset + 12,
+    getUInt16Attribute(attributes.intensityAttribute, vertexIndex),
+    true
+  );
+  if (pointDataRecordFormat <= 5) {
+    const returnNumber = getUInt8Attribute(attributes.returnNumberAttribute, vertexIndex, 1) & 7;
+    const numberOfReturns = getUInt8Attribute(attributes.numberOfReturnsAttribute, vertexIndex, 1) & 7;
+    dataView.setUint8(pointOffset + 14, returnNumber | numberOfReturns << 3);
+    dataView.setUint8(
+      pointOffset + 15,
+      getUInt8Attribute(attributes.classificationAttribute, vertexIndex) & 31
+    );
+    dataView.setInt8(
+      pointOffset + 16,
+      getInt16Attribute(attributes.scanAngleAttribute, vertexIndex)
+    );
+    dataView.setUint8(
+      pointOffset + 17,
+      getUInt8Attribute(attributes.userDataAttribute, vertexIndex)
+    );
+    dataView.setUint16(
+      pointOffset + 18,
+      getUInt16Attribute(attributes.pointSourceIdAttribute, vertexIndex),
+      true
+    );
+    if (pointDataRecordFormat === 1 || pointDataRecordFormat === 3 || pointDataRecordFormat >= 4) {
+      dataView.setFloat64(
+        pointOffset + 20,
+        getAttributeValue(attributes.gpsTimeAttribute, vertexIndex),
+        true
+      );
+    }
+    if (pointDataRecordFormat === 4 || pointDataRecordFormat === 5) {
+      const waveformOffset = pointDataRecordFormat === 4 ? 28 : 34;
+      writeWaveformPacket(dataView, pointOffset + waveformOffset, vertexIndex, attributes);
+    }
+  } else {
+    const returnNumber = getUInt8Attribute(attributes.returnNumberAttribute, vertexIndex, 1) & 15;
+    const numberOfReturns = getUInt8Attribute(attributes.numberOfReturnsAttribute, vertexIndex, 1) & 15;
+    const scannerChannel = getUInt8Attribute(attributes.scannerChannelAttribute, vertexIndex) & 3;
+    const returnFlags = returnNumber | numberOfReturns << 4;
+    const classificationFlags = (getBooleanAttribute(attributes.syntheticAttribute, vertexIndex) ? 1 << 0 : 0) | (getBooleanAttribute(attributes.keyPointAttribute, vertexIndex) ? 1 << 1 : 0) | (getBooleanAttribute(attributes.withheldAttribute, vertexIndex) ? 1 << 2 : 0) | (getBooleanAttribute(attributes.overlapAttribute, vertexIndex) ? 1 << 3 : 0) | scannerChannel << 4 | (getBooleanAttribute(attributes.scanDirectionFlagAttribute, vertexIndex) ? 1 << 6 : 0) | (getBooleanAttribute(attributes.edgeOfFlightLineAttribute, vertexIndex) ? 1 << 7 : 0);
+    dataView.setUint8(pointOffset + 14, returnFlags);
+    dataView.setUint8(pointOffset + 15, classificationFlags);
+    dataView.setUint8(
+      pointOffset + 16,
+      getUInt8Attribute(attributes.classificationAttribute, vertexIndex)
+    );
+    dataView.setUint8(
+      pointOffset + 17,
+      getUInt8Attribute(attributes.userDataAttribute, vertexIndex)
+    );
+    dataView.setInt16(
+      pointOffset + 18,
+      getInt16Attribute(attributes.scanAngleAttribute, vertexIndex),
+      true
+    );
+    dataView.setUint16(
+      pointOffset + 20,
+      getUInt16Attribute(attributes.pointSourceIdAttribute, vertexIndex),
+      true
+    );
+    dataView.setFloat64(
+      pointOffset + 22,
+      getAttributeValue(attributes.gpsTimeAttribute, vertexIndex),
+      true
+    );
+    if (pointDataRecordFormat === 9 || pointDataRecordFormat === 10) {
+      const waveformOffset = pointDataRecordFormat === 9 ? 30 : 38;
+      writeWaveformPacket(dataView, pointOffset + waveformOffset, vertexIndex, attributes);
+    }
+  }
+  writePointColor(
+    dataView,
+    pointOffset,
+    vertexIndex,
+    pointDataRecordFormat,
+    attributes.colorAttribute,
+    attributes.colorDepth
+  );
+  if (pointDataRecordFormat === 8 || pointDataRecordFormat === 10) {
+    dataView.setUint16(
+      pointOffset + 36,
+      getUInt16Attribute(attributes.nirAttribute, vertexIndex),
+      true
+    );
+  }
+  writeExtraBytes(
+    dataView,
+    pointOffset,
+    vertexIndex,
+    basePointDataRecordLength,
+    attributes.extraByteFields
+  );
+}
+function writeWaveformPacket(dataView, byteOffset, vertexIndex, attributes) {
+  dataView.setUint8(
+    byteOffset,
+    getUInt8Attribute(attributes.waveformDescriptorAttribute, vertexIndex)
+  );
+  dataView.setBigUint64(
+    byteOffset + 1,
+    getBigUint64Attribute(attributes.waveformOffsetAttribute, vertexIndex),
+    true
+  );
+  dataView.setUint32(
+    byteOffset + 9,
+    getUInt32Attribute(attributes.waveformSizeAttribute, vertexIndex),
+    true
+  );
+  dataView.setFloat32(
+    byteOffset + 13,
+    getAttributeValue(attributes.waveformReturnPointAttribute, vertexIndex),
+    true
+  );
+  for (let componentIndex = 0; componentIndex < 3; componentIndex++) {
+    dataView.setFloat32(
+      byteOffset + 17 + componentIndex * 4,
+      getComponent(attributes.waveformVectorAttribute, vertexIndex, componentIndex),
+      true
+    );
+  }
+}
+function writeExtraBytes(dataView, pointOffset, vertexIndex, basePointDataRecordLength, fields) {
+  let byteOffset = pointOffset + basePointDataRecordLength;
+  for (const field of fields) {
+    for (let componentIndex = 0; componentIndex < field.componentCount; componentIndex++) {
+      writeExtraBytesValue(dataView, byteOffset, vertexIndex, componentIndex, field);
+      byteOffset += field.byteLength / field.componentCount;
+    }
+  }
+}
+function writeExtraBytesValue(dataView, byteOffset, vertexIndex, componentIndex, field) {
+  const value = field.meshAttribute.value[vertexIndex * field.componentCount + componentIndex];
+  const scalarDataType = field.dataType > 20 ? field.dataType - 20 : field.dataType > 10 ? field.dataType - 10 : field.dataType;
+  switch (scalarDataType) {
+    case 1:
+      dataView.setUint8(byteOffset, Number(value));
+      break;
+    case 2:
+      dataView.setInt8(byteOffset, Number(value));
+      break;
+    case 3:
+      dataView.setUint16(byteOffset, Number(value), true);
+      break;
+    case 4:
+      dataView.setInt16(byteOffset, Number(value), true);
+      break;
+    case 5:
+      dataView.setUint32(byteOffset, Number(value), true);
+      break;
+    case 6:
+      dataView.setInt32(byteOffset, Number(value), true);
+      break;
+    case 7:
+      dataView.setBigUint64(byteOffset, BigInt(value), true);
+      break;
+    case 8:
+      dataView.setBigInt64(byteOffset, BigInt(value), true);
+      break;
+    case 9:
+      dataView.setFloat32(byteOffset, Number(value), true);
+      break;
+    case 10:
+      dataView.setFloat64(byteOffset, Number(value), true);
+      break;
+    default:
+      throw new Error(`LASWriter: unsupported Extra Bytes data type ${field.dataType}`);
+  }
+}
+function writePointColor(dataView, pointOffset, vertexIndex, pointDataRecordFormat, colorAttribute, colorDepth) {
+  const colorOffset = getColorOffset(pointDataRecordFormat);
+  if (colorOffset < 0 || !colorAttribute) {
+    return;
+  }
+  dataView.setUint16(
+    pointOffset + colorOffset,
+    getLASColor(colorAttribute, vertexIndex, 0, colorDepth),
+    true
+  );
+  dataView.setUint16(
+    pointOffset + colorOffset + 2,
+    getLASColor(colorAttribute, vertexIndex, 1, colorDepth),
+    true
+  );
+  dataView.setUint16(
+    pointOffset + colorOffset + 4,
+    getLASColor(colorAttribute, vertexIndex, 2, colorDepth),
+    true
+  );
+}
+function getColorOffset(pointDataRecordFormat) {
+  switch (pointDataRecordFormat) {
+    case 2:
+      return 20;
+    case 3:
+      return 28;
+    case 5:
+      return 57;
+    case 7:
+    case 8:
+    case 10:
+      return 30;
+    default:
+      return -1;
+  }
+}
+function getDefaultPointDataRecordFormat(options, colorAttribute) {
+  if (options.las?.format === "laz" || options.las?.version === "1.4") {
+    return colorAttribute ? 7 : 6;
+  }
+  return colorAttribute ? 2 : 0;
+}
+function writeUint64Fallback(dataView, byteOffset, value) {
+  dataView.setUint32(byteOffset, value >>> 0, true);
+  dataView.setUint32(byteOffset + 4, Math.floor(value / 2 ** 32), true);
+}
+function writeString(dataView, byteOffset, text, byteLength) {
+  if (/[^\x00-\x7f]/.test(text)) {
+    throw new Error("LASWriter fixed-width text must be ASCII");
+  }
+  for (let characterIndex = 0; characterIndex < byteLength; characterIndex++) {
+    dataView.setUint8(byteOffset + characterIndex, text.charCodeAt(characterIndex) || 0);
+  }
+}
+function getComponent(attribute, vertexIndex, componentIndex) {
+  return attribute ? attribute.value[vertexIndex * attribute.size + componentIndex] || 0 : 0;
+}
+function getUInt16Attribute(attribute, vertexIndex) {
+  return attribute ? Math.max(0, Math.min(65535, Math.round(getComponent(attribute, vertexIndex, 0)))) : 0;
+}
+function getUInt32Attribute(attribute, vertexIndex) {
+  return attribute ? Math.max(0, Math.min(4294967295, Math.round(getComponent(attribute, vertexIndex, 0)))) : 0;
+}
+function getBigUint64Attribute(attribute, vertexIndex) {
+  if (!attribute) {
+    return 0n;
+  }
+  const value = attribute.value[vertexIndex * attribute.size];
+  return typeof value === "bigint" ? value : BigInt(Math.max(0, Math.round(Number(value))));
+}
+function getUInt8Attribute(attribute, vertexIndex, defaultValue = 0) {
+  return attribute ? Math.max(0, Math.min(255, Math.round(getComponent(attribute, vertexIndex, 0)))) : defaultValue;
+}
+function getInt16Attribute(attribute, vertexIndex) {
+  return attribute ? Math.max(-32768, Math.min(32767, Math.round(getComponent(attribute, vertexIndex, 0)))) : 0;
+}
+function getAttributeValue(attribute, vertexIndex) {
+  return attribute ? getComponent(attribute, vertexIndex, 0) : 0;
+}
+function getBooleanAttribute(attribute, vertexIndex) {
+  return Boolean(getAttributeValue(attribute, vertexIndex));
+}
+function getReturnCounts(returnNumberAttribute, vertexCount) {
+  const returnCounts = new Array(LAS_RETURN_BUCKET_COUNT).fill(0);
+  for (let vertexIndex = 0; vertexIndex < vertexCount; vertexIndex++) {
+    const returnNumber = getUInt8Attribute(returnNumberAttribute, vertexIndex, 1) & 15;
+    if (returnNumber >= 1 && returnNumber <= LAS_RETURN_BUCKET_COUNT) {
+      returnCounts[returnNumber - 1]++;
+    }
+  }
+  return returnCounts;
+}
+function getLASColor(attribute, vertexIndex, componentIndex, colorDepth) {
+  const value = getComponent(attribute, vertexIndex, componentIndex);
+  if (attribute.normalized) {
+    return scaleNormalizedColor(attribute, value);
+  }
+  if (colorDepth === 8) return clampUInt16(value * 257);
+  if (colorDepth === 16) return clampUInt16(value);
+  if (value <= 1) {
+    return clampUInt16(value * 65535);
+  }
+  if (value <= 255) {
+    return clampUInt16(value * 257);
+  }
+  return clampUInt16(value);
+}
+function scaleNormalizedColor(attribute, value) {
+  const componentMaximum = getComponentMaximum(attribute.value);
+  return clampUInt16(value / componentMaximum * 65535);
+}
+function getComponentMaximum(values) {
+  if (values instanceof Uint8Array || values instanceof Uint8ClampedArray) {
+    return 255;
+  }
+  if (values instanceof Uint16Array) {
+    return 65535;
+  }
+  return 1;
+}
+function clampUInt16(value) {
+  return Math.max(0, Math.min(65535, Math.round(value)));
+}
+function getBoundingBox(positionAttribute, vertexCount) {
+  if (vertexCount === 0) {
+    return [
+      [0, 0, 0],
+      [0, 0, 0]
+    ];
+  }
+  const minimum = [
+    Number.POSITIVE_INFINITY,
+    Number.POSITIVE_INFINITY,
+    Number.POSITIVE_INFINITY
+  ];
+  const maximum = [
+    Number.NEGATIVE_INFINITY,
+    Number.NEGATIVE_INFINITY,
+    Number.NEGATIVE_INFINITY
+  ];
+  for (let vertexIndex = 0; vertexIndex < vertexCount; vertexIndex++) {
+    for (let componentIndex = 0; componentIndex < 3; componentIndex++) {
+      const value = getComponent(positionAttribute, vertexIndex, componentIndex);
+      minimum[componentIndex] = Math.min(minimum[componentIndex], value);
+      maximum[componentIndex] = Math.max(maximum[componentIndex], value);
+    }
+  }
+  return [minimum, maximum];
+}
+function getScale(mesh, options) {
+  return options.las?.scale || getNumericTuple(mesh.schema.metadata?.las_scale) || [1e-3, 1e-3, 1e-3];
+}
+function getOffset(mesh, options, boundingBox) {
+  return options.las?.offset || getNumericTuple(mesh.schema.metadata?.las_offset) || boundingBox[0];
+}
+function getNumericTuple(value) {
+  if (typeof value !== "string") {
+    return void 0;
+  }
+  try {
+    const parsedValue = JSON.parse(value);
+    return Array.isArray(parsedValue) && parsedValue.length === 3 && parsedValue.every((component) => typeof component === "number") ? [parsedValue[0], parsedValue[1], parsedValue[2]] : void 0;
+  } catch {
+    return void 0;
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  LASWriter
+});
+//# sourceMappingURL=las-writer.cjs.map