@loaders.gl/core 5.0.0-alpha.12 → 5.0.0-alpha.13

package/dist/loader-utils/lib/laz/laz-chunk-decoder.js

@@ -0,0 +1,4226 @@
+// loaders.gl
+// SPDX-License-Identifier: MIT AND Apache-2.0
+// Legacy item version 1 algorithms adapted from LASzip (c) 2007-2022 rapidlasso GmbH.
+// See LASZIP-LICENSE and LASZIP-NOTICE in this directory.
+// Copyright (c) vis.gl contributors
+/** Error raised when a feedable decoder needs more compressed bytes. */
+export class NeedsMoreData extends Error {
+    constructor(message = 'LAZ chunk decoder needs more compressed data') {
+        super(message);
+        this.name = 'NeedsMoreData';
+    }
+}
+/** Feedable TypeScript LAZ chunk decoder. */
+export class FeedableLAZChunkDecoder {
+    metadata;
+    chunks = [];
+    closed = false;
+    compressed = null;
+    cursor = null;
+    fedByteLength = 0;
+    requiredByteLength = null;
+    progressiveRequiredByteLength = null;
+    progressiveSelectionKey = null;
+    constructor(metadata) {
+        this.metadata = metadata;
+    }
+    /** Add compressed bytes to the decoder input. */
+    feed(chunk) {
+        if (this.closed) {
+            throw new Error('Cannot feed a closed LAZ chunk decoder');
+        }
+        const bytes = toUint8Array(chunk);
+        this.chunks.push(bytes);
+        this.compressed = null;
+        this.fedByteLength += bytes.byteLength;
+    }
+    /** Mark the compressed input as complete. */
+    close() {
+        this.closed = true;
+    }
+    /** Number of points that remain available after progressive decoding starts. */
+    get remainingPointCount() {
+        return this.cursor?.remainingPointCount ?? this.metadata.pointCount;
+    }
+    /** Decode all fed point data into raw LAS point records. */
+    decode() {
+        if (!this.closed) {
+            throw new NeedsMoreData('LAZ chunk decoder input is not closed');
+        }
+        return this.decodeAvailable();
+    }
+    /** Decode and return the next raw LAS point batch if enough bytes are available. */
+    readBatch(pointCount) {
+        if (!this.cursor) {
+            if (!this.hasCompleteChunk()) {
+                return null;
+            }
+            const compressed = this.getCompressedAvailable();
+            const byteLength = this.requiredByteLength ?? compressed.byteLength;
+            this.cursor = createLAZChunkDecoderCursor(compressed.subarray(0, byteLength), this.metadata);
+        }
+        if (this.cursor.remainingPointCount <= 0) {
+            return null;
+        }
+        const pointByteLength = this.metadata.pointDataRecordLength;
+        const batchPointCount = Math.min(pointCount, this.cursor.remainingPointCount);
+        const batch = new Uint8Array(batchPointCount * pointByteLength);
+        this.cursor.decodeInto(batch, 0, batchPointCount);
+        return batch;
+    }
+    /**
+     * Decode the next position-only point-data batch as soon as Point14 bytes arrive.
+     *
+     * This is limited to layered PDRF 6-10 chunks and targets without RGB fields.
+     * Later independent layers are represented by a zero-filled skipped tail; no
+     * values from those layers are read by the position-only decoder.
+     */
+    readPositionDataBatch(target, pointCount) {
+        if (target.colors || target.rawColors || target.nir) {
+            throw new Error('Position-only LAZ batches cannot request color or NIR output');
+        }
+        return this.readPointDataBatch(target, pointCount);
+    }
+    /** Decode the next selectively requested layered PDRF 6-10 point-data batch. */
+    readPointDataBatch(target, pointCount) {
+        const pointDataRecordFormat = this.metadata.pointDataRecordFormat;
+        if (pointDataRecordFormat < 6 || pointDataRecordFormat > 10) {
+            throw new Error('Progressive LAZ point-data batches require point formats 6-10');
+        }
+        const hasColor = pointDataRecordFormat === 7 || pointDataRecordFormat === 8 || pointDataRecordFormat === 10;
+        if ((target.colors || target.rawColors) && !hasColor) {
+            throw new Error(`Point format ${pointDataRecordFormat} does not contain RGB data`);
+        }
+        if (target.nir && pointDataRecordFormat !== 8 && pointDataRecordFormat !== 10) {
+            throw new Error('NIR output requires point format 8 or 10');
+        }
+        if (target.waveforms && pointDataRecordFormat !== 9 && pointDataRecordFormat !== 10) {
+            throw new Error('Waveform output requires point format 9 or 10');
+        }
+        if (!this.cursor) {
+            const compressed = this.getProgressivePointData(target);
+            if (!compressed) {
+                return null;
+            }
+            this.cursor = createLAZChunkDecoderCursor(compressed, this.metadata);
+        }
+        if (this.cursor.remainingPointCount <= 0) {
+            return 0;
+        }
+        const batchPointCount = Math.min(pointCount, this.cursor.remainingPointCount);
+        return this.cursor.decodeIntoPointData(target, batchPointCount);
+    }
+    hasCompleteChunk() {
+        if (!hasLayeredChunkSizeHeaders(this.metadata.pointDataRecordFormat)) {
+            return this.closed;
+        }
+        if (this.requiredByteLength !== null) {
+            return this.fedByteLength >= this.requiredByteLength;
+        }
+        if (this.fedByteLength < getLAZChunkHeaderByteLength(this.metadata)) {
+            return false;
+        }
+        try {
+            const compressed = this.getCompressedAvailable();
+            this.requiredByteLength = getLAZChunkByteLength(compressed, this.metadata);
+            return this.requiredByteLength <= this.fedByteLength;
+        }
+        catch (error) {
+            if (error instanceof NeedsMoreData) {
+                return false;
+            }
+            throw error;
+        }
+    }
+    decodeAvailable() {
+        const compressed = this.getCompressedAvailable();
+        const byteLength = this.requiredByteLength ?? compressed.byteLength;
+        return decodeLAZChunk(compressed.subarray(0, byteLength), this.metadata);
+    }
+    getCompressedAvailable() {
+        this.compressed ||= concatenateUint8Arrays(this.chunks);
+        return this.compressed;
+    }
+    getProgressivePointData(target) {
+        const selectionKey = getLAZPointDataSelectionKey(getLAZPointDataSelection(target));
+        if (this.progressiveSelectionKey !== selectionKey) {
+            this.progressiveRequiredByteLength = null;
+            this.progressiveSelectionKey = selectionKey;
+        }
+        if (this.progressiveRequiredByteLength === null) {
+            const availableHeader = this.getCompressedAvailable();
+            const headerLayout = getLayeredChunkLayout(availableHeader, this.metadata);
+            if (!headerLayout) {
+                return null;
+            }
+            const requiredLayerCount = getProgressiveLayerCount(this.metadata, target);
+            this.progressiveRequiredByteLength = headerLayout.getByteLength(requiredLayerCount);
+        }
+        if (this.fedByteLength < this.progressiveRequiredByteLength) {
+            return null;
+        }
+        const available = this.getCompressedAvailable();
+        const layout = getLayeredChunkLayout(available, this.metadata);
+        const compressed = new Uint8Array(layout.byteLength);
+        compressed.set(available.subarray(0, Math.min(available.byteLength, layout.byteLength)));
+        return compressed;
+    }
+}
+/** Create a feedable TypeScript LAZ chunk decoder. */
+export function createLAZChunkDecoder(metadata) {
+    return new FeedableLAZChunkDecoder(metadata);
+}
+/** Stateful cursor that decodes one compressed LAZ chunk into caller-provided output buffers. */
+export class LAZChunkDecoderCursor {
+    metadata;
+    stream;
+    /** Decoder initialized after the caller selects raw or direct point-data output. */
+    decoder = null;
+    pointIndex = 0;
+    /** Output mode selected by the first decode call. */
+    outputMode = null;
+    /** Direct-output fields selected by the first point-data decode call. */
+    pointDataSelectionKey = null;
+    constructor(compressed, metadata) {
+        this.metadata = metadata;
+        this.stream = new ByteReader(toUint8Array(compressed));
+    }
+    /**
+     * Append compressed input to a legacy PDRF 0-5 cursor without resetting decoder state.
+     * Layered PDRF 6-10 cursors use bounded contiguous field ranges and cannot be extended.
+     */
+    feed(compressed) {
+        if (this.metadata.pointDataRecordFormat > 5) {
+            throw new Error('Only legacy PDRF 0-5 LAZ cursors accept additional compressed input');
+        }
+        this.stream.append(toUint8Array(compressed));
+    }
+    /** Release consumed legacy bytes while preserving arithmetic and predictor state. */
+    discardConsumedInput() {
+        if (this.metadata.pointDataRecordFormat > 5) {
+            throw new Error('Only legacy PDRF 0-5 LAZ cursors can discard consumed input');
+        }
+        this.stream.discardConsumedInput();
+    }
+    /** Number of points still available in this compressed chunk. */
+    get remainingPointCount() {
+        return this.metadata.pointCount - this.pointIndex;
+    }
+    /** Number of compressed input bytes consumed by decoded points. */
+    get compressedByteOffset() {
+        return this.stream.byteOffset;
+    }
+    /** Absolute legacy chunk prefix length needed before another point decode attempt. */
+    get requiredInputByteLength() {
+        if (this.metadata.pointDataRecordFormat > 5) {
+            return this.stream.byteOffset;
+        }
+        const lookahead = this.pointIndex === 0
+            ? this.metadata.pointDataRecordLength + 4
+            : getLegacyLAZPointDecodeLookahead(this.metadata);
+        return this.stream.byteOffset + lookahead;
+    }
+    /** Decode up to `pointCount` points into `output` at `outputOffset`. */
+    decodeInto(output, outputOffset, pointCount) {
+        const pointsToDecode = Math.min(pointCount, this.remainingPointCount);
+        const decoder = this.selectOutputMode('raw', pointsToDecode);
+        if (!decoder) {
+            return 0;
+        }
+        let targetOffset = outputOffset;
+        for (let pointIndex = 0; pointIndex < pointsToDecode; pointIndex++) {
+            targetOffset = decoder.decompress(output, targetOffset);
+        }
+        this.pointIndex += pointsToDecode;
+        return pointsToDecode;
+    }
+    /**
+     * Decode complete legacy points that have enough compressed lookahead available.
+     *
+     * The method returns without mutating a partial point. Set `inputComplete` only after the
+     * enclosing input stream ends; incomplete final input then raises {@link NeedsMoreData}.
+     */
+    decodeAvailableInto(output, outputOffset, pointCount, inputComplete = false) {
+        if (this.metadata.pointDataRecordFormat > 5) {
+            throw new Error('Available-point decoding is limited to legacy PDRF 0-5 LAZ chunks');
+        }
+        const pointsToDecode = Math.min(pointCount, this.remainingPointCount);
+        if (pointsToDecode === 0) {
+            return 0;
+        }
+        const decoder = this.selectOutputMode('raw', pointsToDecode);
+        let decodedPointCount = 0;
+        let targetOffset = outputOffset;
+        while (decodedPointCount < pointsToDecode) {
+            const requiredLookahead = this.pointIndex === 0
+                ? this.metadata.pointDataRecordLength + 4
+                : getLegacyLAZPointDecodeLookahead(this.metadata);
+            if (!inputComplete && this.stream.availableByteLength < requiredLookahead) {
+                break;
+            }
+            try {
+                targetOffset = decoder.decompress(output, targetOffset);
+            }
+            catch (error) {
+                if (error instanceof NeedsMoreData && !inputComplete) {
+                    throw new Error(`Legacy LAZ point exceeded the ${requiredLookahead}-byte streaming lookahead`);
+                }
+                throw error;
+            }
+            decodedPointCount++;
+            this.pointIndex++;
+        }
+        return decodedPointCount;
+    }
+    /**
+     * Decode complete legacy PDRF 0-5 points directly into typed point-data arrays.
+     *
+     * The method preserves the point-atomic streaming contract of {@link decodeAvailableInto} but
+     * bypasses raw LAS record materialization. It returns when the next point lacks compressed
+     * lookahead and raises {@link NeedsMoreData} only after `inputComplete` is set.
+     */
+    decodeAvailableIntoPointData(target, pointCount, inputComplete = false) {
+        if (this.metadata.pointDataRecordFormat > 5) {
+            throw new Error('Available point-data decoding is limited to legacy PDRF 0-5 LAZ chunks');
+        }
+        const pointsToDecode = Math.min(pointCount, this.remainingPointCount);
+        if (pointsToDecode === 0) {
+            return 0;
+        }
+        const selection = getLAZPointDataSelection(target);
+        const decoder = this.selectOutputMode('point-data', pointsToDecode, selection);
+        let decodedPointCount = 0;
+        const targetPointOffset = target.pointOffset;
+        while (decodedPointCount < pointsToDecode) {
+            const requiredLookahead = this.pointIndex === 0
+                ? this.metadata.pointDataRecordLength + 4
+                : getLegacyLAZPointDecodeLookahead(this.metadata);
+            if (!inputComplete && this.stream.availableByteLength < requiredLookahead) {
+                break;
+            }
+            try {
+                target.pointOffset = targetPointOffset + decodedPointCount;
+                if (decoder.decompressPointData) {
+                    decoder.decompressPointData(target, target.pointOffset);
+                }
+                else {
+                    decoder.decompressPointDataBatch(target, 1);
+                }
+            }
+            catch (error) {
+                target.pointOffset = targetPointOffset;
+                if (error instanceof NeedsMoreData && !inputComplete) {
+                    throw new Error(`Legacy LAZ point exceeded the ${requiredLookahead}-byte streaming lookahead`);
+                }
+                throw error;
+            }
+            decodedPointCount++;
+            this.pointIndex++;
+        }
+        target.pointOffset = targetPointOffset;
+        return decodedPointCount;
+    }
+    /** Decode up to `pointCount` points directly into typed point-data arrays. */
+    decodeIntoPointData(target, pointCount) {
+        const pointsToDecode = Math.min(pointCount, this.remainingPointCount);
+        if (pointsToDecode > 0 && !supportsDirectPointDataOutput(this.metadata.pointDataRecordFormat)) {
+            throw new Error(`TypeScript LAZ decoder does not support direct point-data output for point format ${this.metadata.pointDataRecordFormat}`);
+        }
+        const selection = getLAZPointDataSelection(target);
+        const decoder = this.selectOutputMode('point-data', pointsToDecode, selection);
+        if (!decoder) {
+            return 0;
+        }
+        if (decoder.decompressPointDataBatch) {
+            decoder.decompressPointDataBatch(target, pointsToDecode);
+        }
+        else {
+            for (let pointIndex = 0; pointIndex < pointsToDecode; pointIndex++) {
+                decoder.decompressPointData(target, target.pointOffset + pointIndex);
+            }
+        }
+        this.pointIndex += pointsToDecode;
+        return pointsToDecode;
+    }
+    /** Lock this cursor to one output mode so skipped layered streams cannot be read later. */
+    selectOutputMode(mode, pointCount, selection = null) {
+        if (pointCount === 0) {
+            return null;
+        }
+        if (this.outputMode && this.outputMode !== mode) {
+            throw new Error('Cannot mix raw and point-data decoding in one LAZ chunk cursor');
+        }
+        if (mode === 'point-data') {
+            const selectionKey = getLAZPointDataSelectionKey(selection);
+            if (this.pointDataSelectionKey !== null && this.pointDataSelectionKey !== selectionKey) {
+                throw new Error('Cannot change selected point-data fields in one LAZ chunk cursor');
+            }
+            this.pointDataSelectionKey = selectionKey;
+        }
+        this.outputMode = mode;
+        this.decoder ||= createPointDecompressor(this.stream, this.metadata, mode, selection);
+        return this.decoder;
+    }
+}
+/** Return the independent LAZ 1.4 field layers requested by a direct output target. */
+function getLAZPointDataSelection(target) {
+    return {
+        intensity: Boolean(target.intensities),
+        classification: Boolean(target.classifications),
+        color: Boolean(target.colors || target.rawColors),
+        gpsTime: Boolean(target.gpsTimes),
+        nir: Boolean(target.nir),
+        scanAngle: Boolean(target.scanAngles),
+        userData: Boolean(target.userData),
+        pointSourceId: Boolean(target.pointSourceIds),
+        flags: Boolean(target.scannerChannels ||
+            target.scanDirectionFlags ||
+            target.edgeOfFlightLines ||
+            target.syntheticFlags ||
+            target.keyPointFlags ||
+            target.withheldFlags ||
+            target.overlapFlags),
+        waveform: Boolean(target.waveforms),
+        extraBytes: Boolean(target.extraBytes)
+    };
+}
+/** Encode a direct-output field selection as a compact cursor compatibility key. */
+function getLAZPointDataSelectionKey(selection) {
+    return ((selection.intensity ? 1 : 0) |
+        (selection.classification ? 2 : 0) |
+        (selection.color ? 4 : 0) |
+        (selection.gpsTime ? 8 : 0) |
+        (selection.nir ? 16 : 0) |
+        (selection.scanAngle ? 32 : 0) |
+        (selection.userData ? 64 : 0) |
+        (selection.pointSourceId ? 128 : 0) |
+        (selection.flags ? 256 : 0) |
+        (selection.waveform ? 512 : 0) |
+        (selection.extraBytes ? 1024 : 0));
+}
+/** Create a stateful TypeScript LAZ chunk decoder cursor. */
+export function createLAZChunkDecoderCursor(compressed, metadata) {
+    return new LAZChunkDecoderCursor(compressed, metadata);
+}
+/** Decode a complete compressed LAZ point chunk into raw LAS point records. */
+export function decodeLAZChunk(compressed, metadata) {
+    const decoder = createLAZChunkDecoderCursor(compressed, metadata);
+    const output = new Uint8Array(metadata.pointCount * metadata.pointDataRecordLength);
+    decoder.decodeInto(output, 0, metadata.pointCount);
+    return output;
+}
+/** Decode a compressed LAZ point chunk into raw LAS point record batches. */
+export async function* decodeLAZChunkInBatches(chunks, metadata, options = {}) {
+    const decoder = createLAZChunkDecoder(metadata);
+    const batchSize = options.batchSize || metadata.pointCount;
+    for await (const chunk of chunks) {
+        decoder.feed(chunk);
+        let batch = decoder.readBatch(batchSize);
+        while (batch) {
+            yield batch;
+            batch = decoder.readBatch(batchSize);
+        }
+    }
+    decoder.close();
+    let batch = decoder.readBatch(batchSize);
+    while (batch) {
+        yield batch;
+        batch = decoder.readBatch(batchSize);
+    }
+}
+/** Return the byte length of a complete LAS 1.4 layered LAZ point chunk. */
+export function getLAZChunkByteLength(compressed, metadata) {
+    if (!hasLayeredChunkSizeHeaders(metadata.pointDataRecordFormat)) {
+        throw new NeedsMoreData('Legacy LAZ chunk byte length is not self-describing');
+    }
+    const bytes = toUint8Array(compressed);
+    const extraByteCount = getExtraByteCount(metadata);
+    const firstPointByteLength = metadata.pointDataRecordLength;
+    const sizeHeaderCount = getChunkSizeHeaderCount(metadata.pointDataRecordFormat, extraByteCount);
+    const sizeHeaderOffset = firstPointByteLength + 4;
+    const sizeHeaderByteLength = sizeHeaderCount * 4;
+    if (bytes.byteLength < sizeHeaderOffset + sizeHeaderByteLength) {
+        throw new NeedsMoreData();
+    }
+    const dataView = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+    let byteLength = sizeHeaderOffset + sizeHeaderByteLength;
+    for (let index = 0; index < sizeHeaderCount; index++) {
+        byteLength += dataView.getUint32(sizeHeaderOffset + index * 4, true);
+    }
+    if (bytes.byteLength < byteLength) {
+        throw new NeedsMoreData();
+    }
+    return byteLength;
+}
+/** Decode a LASzip chunk table payload into chunk point counts and byte lengths. */
+export function decodeLAZChunkTable(compressed, options) {
+    const input = new ByteReader(toUint8Array(compressed));
+    const decoder = new ArithmeticDecoder(input);
+    const decompressor = createIntegerDecompressor(32, 2);
+    decoder.readInitBytes();
+    const chunks = [];
+    let countPredictor = 0;
+    let byteLengthPredictor = 0;
+    let remainingPointCount = options.pointCount;
+    for (let index = 0; index < options.chunkCount; index++) {
+        let pointCount;
+        if (options.variable) {
+            countPredictor = decompressor.decompress(decoder, countPredictor, 0) >>> 0;
+            pointCount = countPredictor;
+        }
+        else {
+            pointCount = Math.min(options.chunkSize, remainingPointCount);
+            remainingPointCount -= pointCount;
+        }
+        byteLengthPredictor = decompressor.decompress(decoder, byteLengthPredictor, 1) >>> 0;
+        chunks.push({ pointCount, byteLength: byteLengthPredictor });
+    }
+    return chunks;
+}
+/** Return the bytes needed to read one layered LAZ chunk's size headers. */
+export function getLAZChunkHeaderByteLength(metadata) {
+    if (!hasLayeredChunkSizeHeaders(metadata.pointDataRecordFormat)) {
+        return metadata.pointDataRecordLength + 4;
+    }
+    const extraByteCount = getExtraByteCount(metadata);
+    return (metadata.pointDataRecordLength +
+        4 +
+        getChunkSizeHeaderCount(metadata.pointDataRecordFormat, extraByteCount) * 4);
+}
+/**
+ * Return the compressed byte length declared by a layered LAZ chunk header.
+ *
+ * Unlike {@link getLAZChunkByteLength}, this function does not require the
+ * compressed layer payloads to have arrived.
+ */
+export function getLAZChunkDeclaredByteLength(compressedHeader, metadata) {
+    if (!hasLayeredChunkSizeHeaders(metadata.pointDataRecordFormat)) {
+        throw new NeedsMoreData('Legacy LAZ chunk byte length is not self-describing');
+    }
+    const layout = getLayeredChunkLayout(toUint8Array(compressedHeader), metadata);
+    if (!layout) {
+        throw new NeedsMoreData('LAZ chunk decoder needs the complete layered size header');
+    }
+    return layout.byteLength;
+}
+function getLayeredChunkLayout(bytes, metadata) {
+    const extraByteCount = getExtraByteCount(metadata);
+    const sizeHeaderOffset = metadata.pointDataRecordLength + 4;
+    const sizeHeaderCount = getChunkSizeHeaderCount(metadata.pointDataRecordFormat, extraByteCount);
+    const sizeHeaderByteLength = sizeHeaderCount * 4;
+    if (bytes.byteLength < sizeHeaderOffset + sizeHeaderByteLength) {
+        return null;
+    }
+    const dataView = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+    let byteLength = sizeHeaderOffset + sizeHeaderByteLength;
+    const layerByteLengths = [];
+    for (let index = 0; index < sizeHeaderCount; index++) {
+        const layerByteLength = dataView.getUint32(sizeHeaderOffset + index * 4, true);
+        byteLength += layerByteLength;
+        layerByteLengths.push(layerByteLength);
+    }
+    const dataOffset = sizeHeaderOffset + sizeHeaderByteLength;
+    return {
+        byteLength,
+        layerByteLengths,
+        getByteLength: layerCount => dataOffset + layerByteLengths.slice(0, layerCount).reduce((sum, value) => sum + value, 0)
+    };
+}
+/** Return the layered-stream prefix needed to satisfy a direct-output selection. */
+function getProgressiveLayerCount(metadata, target) {
+    if (target.extraBytes) {
+        return getChunkSizeHeaderCount(metadata.pointDataRecordFormat, getExtraByteCount(metadata));
+    }
+    // The first two streams contain XY and Z. Optional Point14 streams follow
+    // in codec order: classification, flags, intensity, scan angle, user data,
+    // point source ID, and GPS time.
+    let layerCount = 2;
+    if (target.classifications) {
+        layerCount = 3;
+    }
+    if (target.scannerChannels ||
+        target.scanDirectionFlags ||
+        target.edgeOfFlightLines ||
+        target.syntheticFlags ||
+        target.keyPointFlags ||
+        target.withheldFlags ||
+        target.overlapFlags) {
+        layerCount = 4;
+    }
+    if (target.intensities) {
+        layerCount = 5;
+    }
+    if (target.scanAngles) {
+        layerCount = 6;
+    }
+    if (target.userData) {
+        layerCount = 7;
+    }
+    if (target.pointSourceIds) {
+        layerCount = 8;
+    }
+    if (target.gpsTimes) {
+        layerCount = 9;
+    }
+    if (target.colors || target.rawColors) {
+        layerCount = 10;
+    }
+    if (target.nir) {
+        layerCount = 11;
+    }
+    if (target.waveforms) {
+        layerCount = metadata.pointDataRecordFormat === 9 ? 10 : 12;
+    }
+    return Math.min(layerCount, getChunkSizeHeaderCount(metadata.pointDataRecordFormat, getExtraByteCount(metadata)));
+}
+const AC_MIN_LENGTH = 0x01000000;
+const AC_MAX_LENGTH = 0xffffffff;
+const BM_LENGTH_SHIFT = 13;
+const BM_MAX_COUNT = 1 << BM_LENGTH_SHIFT;
+const BM_DISTRIBUTION_DIVISOR = 2 ** (31 - BM_LENGTH_SHIFT);
+const DM_LENGTH_SHIFT = 15;
+const DM_MAX_COUNT = 1 << DM_LENGTH_SHIFT;
+const DM_DISTRIBUTION_DIVISOR = 2 ** (31 - DM_LENGTH_SHIFT);
+const NUMBER_RETURN_MAP_6_CONTEXT = [
+    [0, 1, 2, 3, 4, 5, 3, 4, 4, 5, 5, 5, 5, 5, 5, 5],
+    [1, 0, 1, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3],
+    [2, 1, 2, 4, 4, 4, 4, 4, 4, 4, 4, 3, 3, 3, 3, 3],
+    [3, 3, 4, 5, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4],
+    [4, 3, 4, 4, 5, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4],
+    [5, 3, 4, 4, 4, 5, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4],
+    [3, 3, 4, 4, 4, 4, 5, 4, 4, 4, 4, 4, 4, 4, 4, 4],
+    [4, 3, 4, 4, 4, 4, 4, 5, 4, 4, 4, 4, 4, 4, 4, 4],
+    [4, 3, 4, 4, 4, 4, 4, 4, 5, 4, 4, 4, 4, 4, 4, 4],
+    [5, 3, 4, 4, 4, 4, 4, 4, 4, 5, 4, 4, 4, 4, 4, 4],
+    [5, 3, 4, 4, 4, 4, 4, 4, 4, 4, 5, 4, 4, 4, 4, 4],
+    [5, 3, 3, 4, 4, 4, 4, 4, 4, 4, 4, 5, 5, 4, 4, 4],
+    [5, 3, 3, 4, 4, 4, 4, 4, 4, 4, 4, 5, 5, 5, 4, 4],
+    [5, 3, 3, 4, 4, 4, 4, 4, 4, 4, 4, 4, 5, 5, 5, 4],
+    [5, 3, 3, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 5, 5, 5],
+    [5, 3, 3, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 5, 5]
+];
+const NUMBER_RETURN_LEVEL_8_CONTEXT = [
+    [0, 1, 2, 3, 4, 5, 6, 7, 7, 7, 7, 7, 7, 7, 7, 7],
+    [1, 0, 1, 2, 3, 4, 5, 6, 7, 7, 7, 7, 7, 7, 7, 7],
+    [2, 1, 0, 1, 2, 3, 4, 5, 6, 7, 7, 7, 7, 7, 7, 7],
+    [3, 2, 1, 0, 1, 2, 3, 4, 5, 6, 7, 7, 7, 7, 7, 7],
+    [4, 3, 2, 1, 0, 1, 2, 3, 4, 5, 6, 7, 7, 7, 7, 7],
+    [5, 4, 3, 2, 1, 0, 1, 2, 3, 4, 5, 6, 7, 7, 7, 7],
+    [6, 5, 4, 3, 2, 1, 0, 1, 2, 3, 4, 5, 6, 7, 7, 7],
+    [7, 6, 5, 4, 3, 2, 1, 0, 1, 2, 3, 4, 5, 6, 7, 7],
+    [7, 7, 6, 5, 4, 3, 2, 1, 0, 1, 2, 3, 4, 5, 6, 7],
+    [7, 7, 7, 6, 5, 4, 3, 2, 1, 0, 1, 2, 3, 4, 5, 6],
+    [7, 7, 7, 7, 6, 5, 4, 3, 2, 1, 0, 1, 2, 3, 4, 5],
+    [7, 7, 7, 7, 7, 6, 5, 4, 3, 2, 1, 0, 1, 2, 3, 4],
+    [7, 7, 7, 7, 7, 7, 6, 5, 4, 3, 2, 1, 0, 1, 2, 3],
+    [7, 7, 7, 7, 7, 7, 7, 6, 5, 4, 3, 2, 1, 0, 1, 2],
+    [7, 7, 7, 7, 7, 7, 7, 7, 6, 5, 4, 3, 2, 1, 0, 1],
+    [7, 7, 7, 7, 7, 7, 7, 7, 7, 6, 5, 4, 3, 2, 1, 0]
+];
+const GPS_TIME_MULTI = 500;
+const GPS_TIME_MULTI_MINUS = -10;
+const GPS_TIME_MULTI_CODE_FULL = 511;
+const GPS_TIME10_MULTI_UNCHANGED = GPS_TIME_MULTI - GPS_TIME_MULTI_MINUS + 1;
+const GPS_TIME10_MULTI_CODE_FULL = GPS_TIME_MULTI - GPS_TIME_MULTI_MINUS + 2;
+const FLOAT64_SCRATCH = new ArrayBuffer(8);
+const FLOAT64_SCRATCH_BYTES = new Uint8Array(FLOAT64_SCRATCH);
+const FLOAT64_SCRATCH_VIEW = new DataView(FLOAT64_SCRATCH);
+const LEGACY_LAZ_POINT_DECODE_LOOKAHEAD = 16 * 1024;
+/**
+ * Return enough compressed lookahead to decode one interleaved legacy point atomically.
+ * Arithmetic symbols renormalize by at most two bytes; the scaled term covers every Extra Bytes
+ * symbol (four for version 1 integer-coded bytes) while the fixed floor covers the bounded core, GPS, RGB, and waveform operations.
+ */
+function getLegacyLAZPointDecodeLookahead(metadata) {
+    const byteCorrectionBound = metadata.byteItemVersion === 1 ? 4 : 2;
+    return Math.max(LEGACY_LAZ_POINT_DECODE_LOOKAHEAD, metadata.pointDataRecordLength * byteCorrectionBound + 512);
+}
+const NUMBER_RETURN_MAP_10_CONTEXT = [
+    [15, 14, 13, 12, 11, 10, 9, 8],
+    [14, 0, 1, 3, 6, 10, 10, 9],
+    [13, 1, 2, 4, 7, 11, 11, 10],
+    [12, 3, 4, 5, 8, 12, 12, 11],
+    [11, 6, 7, 8, 9, 13, 13, 12],
+    [10, 10, 11, 12, 13, 14, 14, 13],
+    [9, 10, 11, 12, 13, 14, 15, 14],
+    [8, 9, 10, 11, 12, 13, 14, 15]
+];
+const NUMBER_RETURN_LEVEL_10_CONTEXT = [
+    [0, 1, 2, 3, 4, 5, 6, 7],
+    [1, 0, 1, 2, 3, 4, 5, 6],
+    [2, 1, 0, 1, 2, 3, 4, 5],
+    [3, 2, 1, 0, 1, 2, 3, 4],
+    [4, 3, 2, 1, 0, 1, 2, 3],
+    [5, 4, 3, 2, 1, 0, 1, 2],
+    [6, 5, 4, 3, 2, 1, 0, 1],
+    [7, 6, 5, 4, 3, 2, 1, 0]
+];
+class ByteReader {
+    bytes;
+    length;
+    offset = 0;
+    /** Absolute position of the retained byte range. */
+    discardedByteLength = 0;
+    constructor(bytes) {
+        this.bytes = bytes;
+        this.length = bytes.byteLength;
+    }
+    get byteOffset() {
+        return this.discardedByteLength + this.offset;
+    }
+    /** Number of unread bytes currently available. */
+    get availableByteLength() {
+        return this.length - this.offset;
+    }
+    /** Underlying contiguous bytes used by bounded arithmetic layers. */
+    get data() {
+        return this.length === this.bytes.byteLength ? this.bytes : this.bytes.subarray(0, this.length);
+    }
+    /** Append bytes while preserving the current read offset and decoder state. */
+    append(input) {
+        if (input.byteLength === 0) {
+            return;
+        }
+        const requiredLength = this.length + input.byteLength;
+        if (requiredLength > this.bytes.byteLength) {
+            const capacity = Math.max(requiredLength, Math.max(64, this.bytes.byteLength * 2));
+            const bytes = new Uint8Array(capacity);
+            bytes.set(this.bytes.subarray(0, this.length));
+            this.bytes = bytes;
+        }
+        this.bytes.set(input, this.length);
+        this.length = requiredLength;
+    }
+    /** Drop the consumed prefix while keeping absolute byte offsets stable. */
+    discardConsumedInput() {
+        if (this.offset === 0)
+            return;
+        this.bytes = this.bytes.slice(this.offset, this.length);
+        this.discardedByteLength += this.offset;
+        this.length -= this.offset;
+        this.offset = 0;
+    }
+    getByte() {
+        if (this.offset >= this.length) {
+            throw new NeedsMoreData();
+        }
+        return this.bytes[this.offset++];
+    }
+    getBytes(target, targetOffset, length) {
+        if (this.offset + length > this.length) {
+            throw new NeedsMoreData();
+        }
+        target.set(this.bytes.subarray(this.offset, this.offset + length), targetOffset);
+        this.offset += length;
+    }
+    /** Consume a bounded byte range without constructing a subreader. */
+    consume(length) {
+        if (this.offset + length > this.length) {
+            throw new NeedsMoreData();
+        }
+        const startOffset = this.offset;
+        this.offset += length;
+        return startOffset;
+    }
+    getUint32() {
+        const b0 = this.getByte();
+        const b1 = this.getByte();
+        const b2 = this.getByte();
+        const b3 = this.getByte();
+        return (b0 | (b1 << 8) | (b2 << 16) | ((b3 << 24) >>> 0)) >>> 0;
+    }
+}
+class ArithmeticModel {
+    symbols;
+    distribution;
+    symbolCount;
+    decoderTable;
+    totalCount = 0;
+    updateCycle;
+    symbolsUntilUpdate;
+    lastSymbol;
+    tableSize = 0;
+    tableShift = 0;
+    constructor(symbols) {
+        if (symbols < 2 || symbols > 1 << 11) {
+            throw new Error(`Invalid arithmetic model symbol count ${symbols}`);
+        }
+        this.symbols = symbols;
+        this.lastSymbol = symbols - 1;
+        if (symbols > 16) {
+            let tableBits = 3;
+            while (symbols > 1 << (tableBits + 2)) {
+                tableBits++;
+            }
+            this.tableSize = 1 << tableBits;
+            this.tableShift = DM_LENGTH_SHIFT - tableBits;
+            this.decoderTable = new Uint32Array(this.tableSize + 2);
+        }
+        else {
+            this.decoderTable = null;
+        }
+        this.distribution = new Uint32Array(symbols);
+        this.symbolCount = new Uint32Array(symbols);
+        this.symbolCount.fill(1);
+        this.updateCycle = symbols;
+        this.symbolsUntilUpdate = symbols;
+        this.update();
+        this.symbolsUntilUpdate = this.updateCycle = (symbols + 6) >> 1;
+    }
+    update() {
+        this.totalCount += this.updateCycle;
+        if (this.totalCount > DM_MAX_COUNT) {
+            this.totalCount = 0;
+            for (let symbol = 0; symbol < this.symbols; symbol++) {
+                this.symbolCount[symbol] = (this.symbolCount[symbol] + 1) >> 1;
+                this.totalCount += this.symbolCount[symbol];
+            }
+        }
+        let sum = 0;
+        let tableIndex = 0;
+        const scale = (0x80000000 / this.totalCount) | 0;
+        if (!this.decoderTable) {
+            for (let symbol = 0; symbol < this.symbols; symbol++) {
+                this.distribution[symbol] = ((scale * sum) / DM_DISTRIBUTION_DIVISOR) | 0;
+                sum += this.symbolCount[symbol];
+            }
+        }
+        else {
+            for (let symbol = 0; symbol < this.symbols; symbol++) {
+                this.distribution[symbol] = ((scale * sum) / DM_DISTRIBUTION_DIVISOR) | 0;
+                sum += this.symbolCount[symbol];
+                const width = this.distribution[symbol] >> this.tableShift;
+                while (tableIndex < width) {
+                    this.decoderTable[++tableIndex] = symbol - 1;
+                }
+            }
+            this.decoderTable[0] = 0;
+            while (tableIndex <= this.tableSize) {
+                this.decoderTable[++tableIndex] = this.symbols - 1;
+            }
+        }
+        this.updateCycle = (5 * this.updateCycle) >> 2;
+        const maxCycle = (this.symbols + 6) << 3;
+        if (this.updateCycle > maxCycle) {
+            this.updateCycle = maxCycle;
+        }
+        this.symbolsUntilUpdate = this.updateCycle;
+    }
+}
+class ArithmeticBitModel {
+    updateCycle = 4;
+    bitsUntilUpdate = 4;
+    bit0Prob = 1 << (BM_LENGTH_SHIFT - 1);
+    bit0Count = 1;
+    bitCount = 2;
+    update() {
+        this.bitCount += this.updateCycle;
+        if (this.bitCount > BM_MAX_COUNT) {
+            this.bitCount = (this.bitCount + 1) >> 1;
+            this.bit0Count = (this.bit0Count + 1) >> 1;
+            if (this.bit0Count === this.bitCount) {
+                this.bitCount++;
+            }
+        }
+        const scale = (0x80000000 / this.bitCount) | 0;
+        this.bit0Prob = ((this.bit0Count * scale) / BM_DISTRIBUTION_DIVISOR) | 0;
+        this.updateCycle = (5 * this.updateCycle) >> 2;
+        if (this.updateCycle > 64) {
+            this.updateCycle = 64;
+        }
+        this.bitsUntilUpdate = this.updateCycle;
+    }
+}
+class ArithmeticDecoder {
+    input;
+    /** Contiguous layered input used by the LAZ 1.4 hot path. */
+    inputBytes = null;
+    /** Current absolute position in {@link inputBytes}. */
+    inputOffset = 0;
+    /** Exclusive end of the bounded range in {@link inputBytes}. */
+    inputEnd = 0;
+    value = 0;
+    length = AC_MAX_LENGTH;
+    valid = false;
+    constructor(input = null) {
+        this.input = input;
+    }
+    initStream(source, count) {
+        if (count) {
+            this.inputBytes = source.data;
+            this.inputOffset = source.consume(count);
+            this.inputEnd = this.inputOffset + count;
+            this.input = null;
+            this.readInitBytes();
+            this.valid = true;
+        }
+        else {
+            this.valid = false;
+        }
+    }
+    readInitBytes() {
+        if (this.inputBytes) {
+            const offset = this.inputOffset;
+            if (offset + 4 > this.inputEnd) {
+                throw new NeedsMoreData();
+            }
+            this.value =
+                (((this.inputBytes[offset] << 24) >>> 0) |
+                    (this.inputBytes[offset + 1] << 16) |
+                    (this.inputBytes[offset + 2] << 8) |
+                    this.inputBytes[offset + 3]) >>>
+                    0;
+            this.inputOffset = offset + 4;
+            return;
+        }
+        const input = this.input;
+        this.value =
+            (((input.getByte() << 24) >>> 0) |
+                (input.getByte() << 16) |
+                (input.getByte() << 8) |
+                input.getByte()) >>>
+                0;
+    }
+    decodeBit(model) {
+        const value = this.value;
+        const length = this.length;
+        const x = model.bit0Prob * (length >>> BM_LENGTH_SHIFT);
+        const symbol = value >= x ? 1 : 0;
+        if (symbol === 0) {
+            this.length = x >>> 0;
+            model.bit0Count++;
+        }
+        else {
+            this.value = (value - x) >>> 0;
+            this.length = (length - x) >>> 0;
+        }
+        if (this.length < AC_MIN_LENGTH) {
+            this.renormalize();
+        }
+        if (--model.bitsUntilUpdate === 0) {
+            model.update();
+        }
+        return symbol;
+    }
+    decodeSymbol(model) {
+        let symbol;
+        let lower;
+        let length = this.length;
+        let upper = length;
+        const value = this.value;
+        const distribution = model.distribution;
+        const decoderTable = model.decoderTable;
+        if (decoderTable) {
+            length >>>= DM_LENGTH_SHIFT;
+            const dv = (value / length) | 0;
+            const tableIndex = dv >> model.tableShift;
+            symbol = decoderTable[tableIndex];
+            let next = decoderTable[tableIndex + 1] + 1;
+            while (next > symbol + 1) {
+                const middle = (symbol + next) >> 1;
+                if (distribution[middle] > dv) {
+                    next = middle;
+                }
+                else {
+                    symbol = middle;
+                }
+            }
+            lower = distribution[symbol] * length;
+            if (symbol !== model.lastSymbol) {
+                upper = distribution[symbol + 1] * length;
+            }
+        }
+        else {
+            lower = 0;
+            symbol = 0;
+            length >>>= DM_LENGTH_SHIFT;
+            let next = model.symbols;
+            let middle = next >> 1;
+            do {
+                const z = length * distribution[middle];
+                if (z > value) {
+                    next = middle;
+                    upper = z;
+                }
+                else {
+                    symbol = middle;
+                    lower = z;
+                }
+                middle = (symbol + next) >> 1;
+            } while (middle !== symbol);
+        }
+        this.value = (value - lower) >>> 0;
+        this.length = (upper - lower) >>> 0;
+        if (this.length < AC_MIN_LENGTH) {
+            this.renormalize();
+        }
+        model.symbolCount[symbol]++;
+        if (--model.symbolsUntilUpdate === 0) {
+            model.update();
+        }
+        return symbol;
+    }
+    readBits(bits) {
+        if (bits > 19) {
+            const lower = this.readShort();
+            const upper = this.readBits(bits - 16) << 16;
+            return (upper | lower) >>> 0;
+        }
+        const length = this.length >>> bits;
+        const value = this.value;
+        const symbol = (value / length) | 0;
+        this.value = (value - length * symbol) >>> 0;
+        this.length = length >>> 0;
+        if (length < AC_MIN_LENGTH) {
+            this.renormalize();
+        }
+        return symbol >>> 0;
+    }
+    readShort() {
+        const length = this.length >>> 16;
+        const value = this.value;
+        const symbol = (value / length) | 0;
+        this.value = (value - length * symbol) >>> 0;
+        this.length = length >>> 0;
+        if (length < AC_MIN_LENGTH) {
+            this.renormalize();
+        }
+        return symbol & 0xffff;
+    }
+    readInt() {
+        const lower = this.readShort();
+        const upper = this.readShort();
+        return ((upper << 16) | lower) >>> 0;
+    }
+    /** Read one lossless 64-bit unsigned integer from the arithmetic stream. */
+    readUint64() {
+        const lower = this.readInt();
+        const upper = this.readInt();
+        return (BigInt(upper) << 32n) | BigInt(lower);
+    }
+    renormalize() {
+        let value = this.value;
+        let length = this.length;
+        if (this.inputBytes) {
+            const inputBytes = this.inputBytes;
+            const inputEnd = this.inputEnd;
+            let inputOffset = this.inputOffset;
+            do {
+                if (inputOffset >= inputEnd) {
+                    throw new NeedsMoreData();
+                }
+                value = ((value << 8) | inputBytes[inputOffset++]) >>> 0;
+                length = (length << 8) >>> 0;
+            } while (length < AC_MIN_LENGTH);
+            this.inputOffset = inputOffset;
+        }
+        else {
+            const input = this.input;
+            do {
+                value = ((value << 8) | input.getByte()) >>> 0;
+                length = (length << 8) >>> 0;
+            } while (length < AC_MIN_LENGTH);
+        }
+        this.value = value;
+        this.length = length;
+    }
+}
+class IntegerDecompressor {
+    contexts;
+    bitsHigh;
+    corrBits;
+    corrRange;
+    corrMin;
+    mBits = [];
+    mCorrector0 = new ArithmeticBitModel();
+    mCorrector = [];
+    k = 0;
+    constructor(bits = 16, contexts = 1, bitsHigh = 8, range = 0) {
+        this.contexts = contexts;
+        this.bitsHigh = bitsHigh;
+        if (range) {
+            this.corrBits = 0;
+            this.corrRange = range;
+            while (range) {
+                range >>= 1;
+                this.corrBits++;
+            }
+            if (this.corrRange === 1 << (this.corrBits - 1)) {
+                this.corrBits--;
+            }
+            this.corrMin = -(this.corrRange / 2);
+        }
+        else if (bits && bits < 32) {
+            this.corrBits = bits;
+            this.corrRange = 1 << bits;
+            this.corrMin = -(this.corrRange / 2);
+        }
+        else {
+            this.corrBits = 32;
+            this.corrRange = 0;
+            this.corrMin = -2147483648;
+        }
+    }
+    init() {
+        if (!this.mBits.length) {
+            for (let context = 0; context < this.contexts; context++) {
+                this.mBits.push(new ArithmeticModel(this.corrBits + 1));
+            }
+            for (let bit = 1; bit <= this.corrBits; bit++) {
+                const value = bit <= this.bitsHigh ? 1 << bit : 1 << this.bitsHigh;
+                this.mCorrector.push(new ArithmeticModel(value));
+            }
+        }
+    }
+    decompress(decoder, prediction, context) {
+        // Keep corrector decoding in this hot method. Splitting it into a helper prevents
+        // V8 from optimizing the predictor and corrector as one stable operation.
+        const k = decoder.decodeSymbol(this.mBits[context]);
+        this.k = k;
+        let corrector;
+        if (k) {
+            if (k < 32) {
+                const bitsHigh = this.bitsHigh;
+                const correctorModel = this.mCorrector[k - 1];
+                if (k <= bitsHigh) {
+                    corrector = decoder.decodeSymbol(correctorModel);
+                }
+                else {
+                    const lowerBitCount = k - bitsHigh;
+                    corrector = decoder.decodeSymbol(correctorModel);
+                    corrector = (corrector << lowerBitCount) | decoder.readBits(lowerBitCount);
+                }
+                if (corrector >= 1 << (k - 1)) {
+                    corrector += 1;
+                }
+                else {
+                    corrector -= (1 << k) - 1;
+                }
+            }
+            else {
+                corrector = this.corrMin;
+            }
+        }
+        else {
+            corrector = decoder.decodeBit(this.mCorrector0);
+        }
+        let real = toInt32(prediction + corrector);
+        if (this.corrRange === 0) {
+            return real;
+        }
+        if (real < 0) {
+            real = toInt32(real + this.corrRange);
+        }
+        else if (real >= this.corrRange) {
+            real = toInt32(real - this.corrRange);
+        }
+        return real;
+    }
+}
+class StreamingMedian {
+    /** Smallest retained value. */
+    value0 = 0;
+    /** Second-smallest retained value. */
+    value1 = 0;
+    /** Current median. */
+    value2 = 0;
+    /** Second-largest retained value. */
+    value3 = 0;
+    /** Largest retained value. */
+    value4 = 0;
+    /** Whether the next update shifts values toward the upper half. */
+    high = true;
+    add(value) {
+        if (this.high) {
+            if (value < this.value2) {
+                this.value4 = this.value3;
+                this.value3 = this.value2;
+                if (value < this.value0) {
+                    this.value2 = this.value1;
+                    this.value1 = this.value0;
+                    this.value0 = value;
+                }
+                else if (value < this.value1) {
+                    this.value2 = this.value1;
+                    this.value1 = value;
+                }
+                else {
+                    this.value2 = value;
+                }
+            }
+            else {
+                if (value < this.value3) {
+                    this.value4 = this.value3;
+                    this.value3 = value;
+                }
+                else {
+                    this.value4 = value;
+                }
+                this.high = false;
+            }
+        }
+        else if (this.value2 < value) {
+            this.value0 = this.value1;
+            this.value1 = this.value2;
+            if (this.value4 < value) {
+                this.value2 = this.value3;
+                this.value3 = this.value4;
+                this.value4 = value;
+            }
+            else if (this.value3 < value) {
+                this.value2 = this.value3;
+                this.value3 = value;
+            }
+            else {
+                this.value2 = value;
+            }
+        }
+        else {
+            if (this.value1 < value) {
+                this.value0 = this.value1;
+                this.value1 = value;
+            }
+            else {
+                this.value0 = value;
+            }
+            this.high = true;
+        }
+    }
+    get() {
+        return this.value2;
+    }
+}
+/** Return the middle of three retained coordinate differences without allocating. */
+function getMedianOfThree(values) {
+    return values[0] < values[1]
+        ? values[1] < values[2]
+            ? values[1]
+            : Math.max(values[0], values[2])
+        : values[0] < values[2]
+            ? values[0]
+            : Math.max(values[1], values[2]);
+}
+class Point10Decompressor {
+    itemVersion;
+    stream;
+    decoder;
+    changedValuesModel = new ArithmeticModel(64);
+    bitByteModel = createModels(256, 256);
+    classificationModel = createModels(256, 256);
+    scanAngleRankModel = createModels(2, 256);
+    userDataModel = createModels(256, 256);
+    intensity = createIntegerDecompressor(16, 4);
+    pointSourceId = createIntegerDecompressor(16, 1);
+    dx = createIntegerDecompressor(32, 2);
+    dy = createIntegerDecompressor(32, 22);
+    z = createIntegerDecompressor(32, 20);
+    lastIntensity = new Array(16).fill(0);
+    lastHeight = new Array(8).fill(0);
+    lastXDiffMedian = Array.from({ length: 16 }, () => new StreamingMedian());
+    lastYDiffMedian = Array.from({ length: 16 }, () => new StreamingMedian());
+    haveLast = false;
+    last = createPoint10();
+    /** Stable first-point value returned before `last` becomes mutable predictor state. */
+    firstPoint = createPoint10();
+    /** Three preceding X differences for the version 1 predictor. */
+    legacyXDiffs = [0, 0, 0];
+    /** Three preceding Y differences for the version 1 predictor. */
+    legacyYDiffs = [0, 0, 0];
+    /** Ring position in the version 1 difference history. */
+    legacyDifferenceIndex = 0;
+    /** Version 1 scan-angle integer codec. */
+    legacyScanAngle = null;
+    constructor(stream, 
+    /** LASzip item codec version selected by the VLR. */ itemVersion = 2) {
+        this.itemVersion = itemVersion;
+        this.stream = stream;
+        this.decoder = new ArithmeticDecoder(stream);
+        if (itemVersion === 1) {
+            this.legacyScanAngle = createIntegerDecompressor(8, 2);
+            this.dx = createIntegerDecompressor(32, 1);
+            this.dy = createIntegerDecompressor(32, 20);
+            this.intensity = createIntegerDecompressor(16, 1);
+        }
+    }
+    getDecoder() {
+        return this.decoder;
+    }
+    decompress(output, outputOffset) {
+        const point = this.decompressPoint();
+        writePoint10(point, output, outputOffset);
+        return outputOffset + 20;
+    }
+    /** Decode one legacy core point without materializing a raw LAS record. */
+    decompressPoint() {
+        if (!this.haveLast) {
+            this.haveLast = true;
+            readPoint10FromStreamInto(this.last, this.stream);
+            copyPoint10(this.firstPoint, this.last);
+            if (this.itemVersion === 2) {
+                this.last.intensity = 0;
+            }
+            return this.firstPoint;
+        }
+        if (this.itemVersion === 1) {
+            return this.decompressLegacyPoint();
+        }
+        const changedValues = this.decoder.decodeSymbol(this.changedValuesModel);
+        if (changedValues) {
+            if (changedValues & (1 << 5)) {
+                this.last.bitByte = this.decoder.decodeSymbol(this.bitByteModel[this.last.bitByte]);
+            }
+            const returnNumber = getPoint10ReturnNumber(this.last);
+            const numberOfReturns = getPoint10NumberOfReturns(this.last);
+            const context = NUMBER_RETURN_MAP_10_CONTEXT[numberOfReturns][returnNumber];
+            if (changedValues & (1 << 4)) {
+                this.last.intensity =
+                    this.intensity.decompress(this.decoder, this.lastIntensity[context], context < 3 ? context : 3) & 0xffff;
+                this.lastIntensity[context] = this.last.intensity;
+            }
+            else {
+                this.last.intensity = this.lastIntensity[context];
+            }
+            if (changedValues & (1 << 3)) {
+                this.last.classification = this.decoder.decodeSymbol(this.classificationModel[this.last.classification]);
+            }
+            if (changedValues & (1 << 2)) {
+                const value = this.decoder.decodeSymbol(this.scanAngleRankModel[getPoint10ScanDirectionFlag(this.last)]);
+                this.last.scanAngleRank = toInt8(this.last.scanAngleRank + value);
+            }
+            if (changedValues & (1 << 1)) {
+                this.last.userData = this.decoder.decodeSymbol(this.userDataModel[this.last.userData]);
+            }
+            if (changedValues & 1) {
+                this.last.pointSourceId =
+                    this.pointSourceId.decompress(this.decoder, this.last.pointSourceId, 0) & 0xffff;
+            }
+        }
+        const returnNumber = getPoint10ReturnNumber(this.last);
+        const numberOfReturns = getPoint10NumberOfReturns(this.last);
+        const mapContext = NUMBER_RETURN_MAP_10_CONTEXT[numberOfReturns][returnNumber];
+        const levelContext = NUMBER_RETURN_LEVEL_10_CONTEXT[numberOfReturns][returnNumber];
+        const xMedian = this.lastXDiffMedian[mapContext].get();
+        const xDiff = this.dx.decompress(this.decoder, xMedian, numberOfReturns === 1 ? 1 : 0);
+        this.last.x = toInt32(this.last.x + xDiff);
+        this.lastXDiffMedian[mapContext].add(xDiff);
+        const yMedian = this.lastYDiffMedian[mapContext].get();
+        const xKbits = Math.min(this.dx.k, 20) & ~1;
+        const yDiff = this.dy.decompress(this.decoder, yMedian, (numberOfReturns === 1 ? 1 : 0) + xKbits);
+        this.last.y = toInt32(this.last.y + yDiff);
+        this.lastYDiffMedian[mapContext].add(yDiff);
+        const zKbits = Math.min((this.dx.k + this.dy.k) >> 1, 18) & ~1;
+        this.last.z = this.z.decompress(this.decoder, this.lastHeight[levelContext], (numberOfReturns === 1 ? 1 : 0) + zKbits);
+        this.lastHeight[levelContext] = this.last.z;
+        return this.last;
+    }
+    /** Decode Point10 version 1 using the LASzip median-of-three predictors. */
+    decompressLegacyPoint() {
+        const xDifference = this.dx.decompress(this.decoder, getMedianOfThree(this.legacyXDiffs), 0);
+        this.last.x = toInt32(this.last.x + xDifference);
+        let correctionBits = this.dx.k;
+        const yDifference = this.dy.decompress(this.decoder, getMedianOfThree(this.legacyYDiffs), Math.min(correctionBits, 19));
+        this.last.y = toInt32(this.last.y + yDifference);
+        correctionBits = (correctionBits + this.dy.k) >> 1;
+        this.last.z = this.z.decompress(this.decoder, this.last.z, Math.min(correctionBits, 19));
+        const changedValues = this.decoder.decodeSymbol(this.changedValuesModel);
+        if (changedValues & 32)
+            this.last.intensity =
+                this.intensity.decompress(this.decoder, this.last.intensity, 0) & 0xffff;
+        if (changedValues & 16)
+            this.last.bitByte = this.decoder.decodeSymbol(this.bitByteModel[this.last.bitByte]);
+        if (changedValues & 8)
+            this.last.classification = this.decoder.decodeSymbol(this.classificationModel[this.last.classification]);
+        if (changedValues & 4)
+            this.last.scanAngleRank = toInt8(this.legacyScanAngle.decompress(this.decoder, this.last.scanAngleRank & 0xff, correctionBits < 3 ? 1 : 0));
+        if (changedValues & 2)
+            this.last.userData = this.decoder.decodeSymbol(this.userDataModel[this.last.userData]);
+        if (changedValues & 1)
+            this.last.pointSourceId =
+                this.pointSourceId.decompress(this.decoder, this.last.pointSourceId, 0) & 0xffff;
+        this.legacyXDiffs[this.legacyDifferenceIndex] = xDifference;
+        this.legacyYDiffs[this.legacyDifferenceIndex] = yDifference;
+        this.legacyDifferenceIndex = (this.legacyDifferenceIndex + 1) % 3;
+        return this.last;
+    }
+    readFirstMetadata() {
+        this.decoder.readInitBytes();
+    }
+}
+class RGB10Decompressor {
+    itemVersion;
+    stream;
+    decoder;
+    haveLast = false;
+    lastRed = 0;
+    lastGreen = 0;
+    lastBlue = 0;
+    usedModel = new ArithmeticModel(128);
+    diffModel = createModels(6, 256);
+    /** Version 1 per-channel byte correctors. */
+    legacyRgb = null;
+    constructor(stream, decoder, 
+    /** LASzip item codec version selected by the VLR. */ itemVersion = 2) {
+        this.itemVersion = itemVersion;
+        this.stream = stream;
+        this.decoder = decoder;
+        if (itemVersion === 1) {
+            this.usedModel = new ArithmeticModel(64);
+            this.legacyRgb = createIntegerDecompressor(8, 6);
+        }
+    }
+    decompress(output, outputOffset) {
+        this.decompressRgb();
+        writeUint16(this.lastRed, output, outputOffset);
+        writeUint16(this.lastGreen, output, outputOffset + 2);
+        writeUint16(this.lastBlue, output, outputOffset + 4);
+        return outputOffset + 6;
+    }
+    /** Decode one legacy RGB item without materializing raw point bytes. */
+    decompressRgb() {
+        if (!this.haveLast) {
+            this.haveLast = true;
+            this.lastRed = readUint16FromStream(this.stream);
+            this.lastGreen = readUint16FromStream(this.stream);
+            this.lastBlue = readUint16FromStream(this.stream);
+            return;
+        }
+        const symbol = this.decoder.decodeSymbol(this.usedModel);
+        if (this.itemVersion === 1) {
+            this.lastRed = this.decodeLegacyColor(this.lastRed, 0, symbol);
+            this.lastGreen = this.decodeLegacyColor(this.lastGreen, 1, symbol);
+            this.lastBlue = this.decodeLegacyColor(this.lastBlue, 2, symbol);
+            return;
+        }
+        let red = 0;
+        let green = 0;
+        let blue = 0;
+        if (symbol & 1) {
+            red = (this.decoder.decodeSymbol(this.diffModel[0]) + (this.lastRed & 0xff)) & 0xff;
+        }
+        else {
+            red = this.lastRed & 0xff;
+        }
+        if (symbol & 2) {
+            red |= ((this.decoder.decodeSymbol(this.diffModel[1]) + (this.lastRed >> 8)) & 0xff) << 8;
+        }
+        else {
+            red |= this.lastRed & 0xff00;
+        }
+        if (symbol & 64) {
+            let diff = (red & 0xff) - (this.lastRed & 0xff);
+            if (symbol & 4) {
+                green =
+                    (this.decoder.decodeSymbol(this.diffModel[2]) +
+                        clampUint8(diff + (this.lastGreen & 0xff))) &
+                        0xff;
+            }
+            else {
+                green = this.lastGreen & 0xff;
+            }
+            if (symbol & 16) {
+                diff = ((diff + ((green & 0xff) - (this.lastGreen & 0xff))) / 2) | 0;
+                blue =
+                    (this.decoder.decodeSymbol(this.diffModel[4]) +
+                        clampUint8(diff + (this.lastBlue & 0xff))) &
+                        0xff;
+            }
+            else {
+                blue = this.lastBlue & 0xff;
+            }
+            diff = (red >> 8) - (this.lastRed >> 8);
+            if (symbol & 8) {
+                green |=
+                    ((this.decoder.decodeSymbol(this.diffModel[3]) +
+                        clampUint8(diff + (this.lastGreen >> 8))) &
+                        0xff) <<
+                        8;
+            }
+            else {
+                green |= this.lastGreen & 0xff00;
+            }
+            if (symbol & 32) {
+                diff = ((diff + (green >> 8) - (this.lastGreen >> 8)) / 2) | 0;
+                blue |=
+                    ((this.decoder.decodeSymbol(this.diffModel[5]) +
+                        clampUint8(diff + (this.lastBlue >> 8))) &
+                        0xff) <<
+                        8;
+            }
+            else {
+                blue |= this.lastBlue & 0xff00;
+            }
+        }
+        else {
+            green = red;
+            blue = red;
+        }
+        this.lastRed = red;
+        this.lastGreen = green;
+        this.lastBlue = blue;
+    }
+    /** Decode both independent integer-coded bytes of one version 1 color channel. */
+    decodeLegacyColor(previousColor, channelIndex, changedBytes) {
+        let color = 0;
+        for (let byteIndex = 0; byteIndex < 2; byteIndex++) {
+            const context = channelIndex * 2 + byteIndex;
+            const previousByte = (previousColor >> (byteIndex * 8)) & 0xff;
+            const decodedByte = changedBytes & (1 << context)
+                ? this.legacyRgb.decompress(this.decoder, previousByte, context)
+                : previousByte;
+            color |= decodedByte << (byteIndex * 8);
+        }
+        return color;
+    }
+    /** Most recently decoded red channel. */
+    get decodedRed() {
+        return this.lastRed;
+    }
+    /** Most recently decoded green channel. */
+    get decodedGreen() {
+        return this.lastGreen;
+    }
+    /** Most recently decoded blue channel. */
+    get decodedBlue() {
+        return this.lastBlue;
+    }
+}
+class Byte10Decompressor {
+    itemVersion;
+    stream;
+    decoder;
+    count;
+    haveLast = false;
+    last;
+    models;
+    /** Version 1 independent byte correctors, one context per Extra Byte. */
+    legacyBytes;
+    constructor(stream, decoder, count, 
+    /** LASzip item codec version selected by the VLR. */ itemVersion = 2) {
+        this.itemVersion = itemVersion;
+        this.stream = stream;
+        this.decoder = decoder;
+        this.count = count;
+        this.last = new Uint8Array(count);
+        this.models = createModels(count, 256);
+        this.legacyBytes = itemVersion === 1 ? createIntegerDecompressor(8, count) : null;
+    }
+    /** Number of Extra Bytes stored for each point. */
+    get byteCount() {
+        return this.count;
+    }
+    decompress(output, outputOffset) {
+        this.decompressToTarget(output, outputOffset);
+        return outputOffset + this.count;
+    }
+    /** Decode legacy Extra Bytes directly into an optional caller-owned target. */
+    decompressToTarget(output, outputOffset = 0) {
+        if (this.count === 0) {
+            return;
+        }
+        if (!this.haveLast) {
+            this.stream.getBytes(this.last, 0, this.count);
+            output?.set(this.last, outputOffset);
+            this.haveLast = true;
+            return;
+        }
+        for (let index = 0; index < this.count; index++) {
+            const value = this.itemVersion === 1
+                ? this.legacyBytes.decompress(this.decoder, this.last[index], index)
+                : (this.last[index] + this.decoder.decodeSymbol(this.models[index])) & 0xff;
+            if (output) {
+                output[outputOffset + index] = value;
+            }
+            this.last[index] = value;
+        }
+    }
+}
+/** Determines whether Point14 decoding preserves every field or only returned point data. */
+var Point14DecompressionMode;
+(function (Point14DecompressionMode) {
+    /** Preserve every field in the raw LAS point record. */
+    Point14DecompressionMode[Point14DecompressionMode["Full"] = 0] = "Full";
+    /** Decode only fields represented by {@link LAZPointDataTarget}. */
+    Point14DecompressionMode[Point14DecompressionMode["PointData"] = 1] = "PointData";
+})(Point14DecompressionMode || (Point14DecompressionMode = {}));
+class Point14Context {
+    changedValuesModel = createModels(8, 128);
+    scannerChannelModel = new ArithmeticModel(3);
+    returnNumberGpsSameModel = new ArithmeticModel(13);
+    numberReturnsModel = createModels(16, 16);
+    returnNumberModel = createModels(16, 16);
+    classModel = [];
+    flagModel = [];
+    userDataModel = [];
+    gpsTimeMultiModel;
+    gpsTime0DiffModel;
+    dx = createIntegerDecompressor(32, 2);
+    dy = createIntegerDecompressor(32, 22);
+    z = createIntegerDecompressor(32, 20);
+    intensity = null;
+    scanAngle;
+    pointSourceId;
+    gpsTime;
+    haveLast = false;
+    last = createPoint14();
+    lastIntensity = [];
+    lastZ = new Array(8).fill(0);
+    lastXDiffMedian = Array.from({ length: 12 }, () => new StreamingMedian());
+    lastYDiffMedian = Array.from({ length: 12 }, () => new StreamingMedian());
+    lastGpsSequence = 0;
+    nextGpsSequence = 0;
+    lastGpsTime = [];
+    lastGpsTimeDiff = [];
+    multiExtremeCounter = [];
+    gpsTimeChange = false;
+    /** Construct context models required by the selected output mode. */
+    constructor(mode, selection) {
+        if (mode === Point14DecompressionMode.Full || selection?.classification) {
+            this.classModel = createModels(64, 256);
+        }
+        if (mode === Point14DecompressionMode.Full || selection?.intensity) {
+            this.intensity = createIntegerDecompressor(16, 4);
+            this.lastIntensity = new Array(8).fill(0);
+        }
+        if (mode === Point14DecompressionMode.Full || selection?.userData) {
+            this.userDataModel = createModels(64, 256);
+        }
+        if (mode === Point14DecompressionMode.Full || selection?.scanAngle) {
+            this.scanAngle = createIntegerDecompressor(16, 2);
+        }
+        if (mode === Point14DecompressionMode.Full || selection?.pointSourceId) {
+            this.pointSourceId = createIntegerDecompressor(16, 1);
+        }
+        if (mode === Point14DecompressionMode.Full || selection?.flags) {
+            this.flagModel = createModels(64, 64);
+        }
+        if (mode === Point14DecompressionMode.Full || selection?.gpsTime) {
+            this.gpsTimeMultiModel = new ArithmeticModel(515);
+            this.gpsTime0DiffModel = new ArithmeticModel(5);
+            this.gpsTime = createIntegerDecompressor(32, 9);
+            this.lastGpsTime = new Array(4).fill(0);
+            this.lastGpsTimeDiff = new Array(4).fill(0);
+            this.multiExtremeCounter = new Array(4).fill(0);
+        }
+    }
+}
+class Point14Decompressor {
+    stream;
+    contexts;
+    /** Current scanner-channel context, cached because channel switches are uncommon. */
+    activeContext = null;
+    /** Whether fields omitted from direct point-data output must be decoded. */
+    decompressOptionalFields;
+    xy = new ArithmeticDecoder();
+    z = new ArithmeticDecoder();
+    classification;
+    flags;
+    intensity;
+    scanAngle;
+    userData;
+    pointSourceId;
+    gpsTime;
+    sizes = [];
+    /** Actual scanner channel used by Point14 context state. */
+    currentScannerChannel = 0;
+    /** LASzip v3 item context emitted to fields following Point14. */
+    itemContextChannel = 0;
+    /** Point14 item version controlling downstream scanner-channel propagation. */
+    itemVersion;
+    constructor(stream, mode = Point14DecompressionMode.Full, itemVersion = 3, selection = null) {
+        this.stream = stream;
+        this.itemVersion = itemVersion;
+        this.contexts = Array.from({ length: 4 }, () => new Point14Context(mode, selection));
+        this.decompressOptionalFields = mode === Point14DecompressionMode.Full;
+        this.classification =
+            this.decompressOptionalFields || selection?.classification ? new ArithmeticDecoder() : null;
+        this.flags = this.decompressOptionalFields || selection?.flags ? new ArithmeticDecoder() : null;
+        this.intensity =
+            this.decompressOptionalFields || selection?.intensity ? new ArithmeticDecoder() : null;
+        this.scanAngle =
+            this.decompressOptionalFields || selection?.scanAngle ? new ArithmeticDecoder() : null;
+        this.userData =
+            this.decompressOptionalFields || selection?.userData ? new ArithmeticDecoder() : null;
+        this.pointSourceId =
+            this.decompressOptionalFields || selection?.pointSourceId ? new ArithmeticDecoder() : null;
+        this.gpsTime =
+            this.decompressOptionalFields || selection?.gpsTime ? new ArithmeticDecoder() : null;
+    }
+    readSizes() {
+        this.sizes = [];
+        for (let index = 0; index < 9; index++) {
+            this.sizes.push(this.stream.getUint32());
+        }
+    }
+    readData() {
+        let index = 0;
+        this.xy.initStream(this.stream, this.sizes[index++]);
+        this.z.initStream(this.stream, this.sizes[index++]);
+        this.initializeOptionalStream(this.classification, this.sizes[index++]);
+        this.initializeOptionalStream(this.flags, this.sizes[index++]);
+        this.initializeOptionalStream(this.intensity, this.sizes[index++]);
+        this.initializeOptionalStream(this.scanAngle, this.sizes[index++]);
+        this.initializeOptionalStream(this.userData, this.sizes[index++]);
+        this.initializeOptionalStream(this.pointSourceId, this.sizes[index++]);
+        this.initializeOptionalStream(this.gpsTime, this.sizes[index++]);
+    }
+    /** Initialize a retained field layer or consume its compressed range. */
+    initializeOptionalStream(decoder, byteLength) {
+        if (decoder) {
+            decoder.initStream(this.stream, byteLength);
+        }
+        else {
+            this.stream.consume(byteLength);
+        }
+    }
+    decompress(output, outputOffset) {
+        const point = this.decompressPoint(output, outputOffset);
+        writePoint14(point, output, outputOffset);
+        return outputOffset + 30;
+    }
+    decompressPoint(output, outputOffset = 0) {
+        const decompressGpsTime = this.gpsTime !== null;
+        if (!this.activeContext) {
+            const point = this.contexts[0].last;
+            if (output) {
+                this.stream.getBytes(output, outputOffset, 30);
+                readPoint14Into(point, output, outputOffset);
+            }
+            else {
+                readPoint14FromStreamInto(point, this.stream);
+            }
+            this.currentScannerChannel = getScannerChannel(point);
+            this.itemContextChannel = this.currentScannerChannel;
+            const context = this.contexts[this.currentScannerChannel];
+            if (context.last !== point) {
+                copyPoint14(context.last, point);
+            }
+            context.haveLast = true;
+            if (decompressGpsTime) {
+                context.lastGpsTime[0] = context.last.gpsTime;
+            }
+            this.activeContext = context;
+            context.lastZ.fill(context.last.z);
+            if (context.lastIntensity.length) {
+                context.lastIntensity.fill(context.last.intensity);
+            }
+            return context.last;
+        }
+        const previous = this.activeContext;
+        const previousReturns = previous.last.returns;
+        const previousReturnNumber = previousReturns & 0x0f;
+        const changeStream = (previousReturnNumber === 1 ? 1 : 0) |
+            ((previousReturnNumber >= previousReturns >> 4 ? 1 : 0) << 1) |
+            ((previous.gpsTimeChange ? 1 : 0) << 2);
+        const changedValues = this.xy.decodeSymbol(previous.changedValuesModel[changeStream]);
+        const scannerChannelChanged = Boolean((changedValues >> 6) & 1);
+        const pointSourceChanged = Boolean((changedValues >> 5) & 1);
+        const gpsTimeChanged = Boolean((changedValues >> 4) & 1);
+        const scanAngleChanged = Boolean((changedValues >> 3) & 1);
+        const numberReturnsChanged = Boolean((changedValues >> 2) & 1);
+        const returnNumberMinus = Boolean((changedValues >> 1) & 1);
+        const returnNumberPlus = Boolean(changedValues & 1);
+        const returnNumberIncrements = returnNumberPlus && !returnNumberMinus;
+        const returnNumberDecrements = returnNumberMinus && !returnNumberPlus;
+        const returnNumberMiscChange = returnNumberPlus && returnNumberMinus;
+        this.itemContextChannel = 0;
+        let scannerChannel = this.currentScannerChannel;
+        let context = previous;
+        if (scannerChannelChanged) {
+            const diff = this.xy.decodeSymbol(previous.scannerChannelModel);
+            scannerChannel = (scannerChannel + diff + 1) % 4;
+            context = this.contexts[scannerChannel];
+            this.activeContext = context;
+            this.itemContextChannel = scannerChannel;
+        }
+        this.currentScannerChannel = scannerChannel;
+        if (this.itemVersion >= 4) {
+            this.itemContextChannel = scannerChannel;
+        }
+        if (!context.haveLast) {
+            context.haveLast = true;
+            copyPoint14(context.last, previous.last);
+            context.lastZ.fill(previous.last.z);
+            if (context.lastIntensity.length) {
+                context.lastIntensity.fill(previous.last.intensity);
+            }
+            if (decompressGpsTime) {
+                context.lastGpsTime[0] = previous.last.gpsTime;
+            }
+        }
+        setScannerChannel(context.last, scannerChannel);
+        let numberOfReturns = context.last.returns >> 4;
+        let returnNumber = context.last.returns & 0x0f;
+        if (numberReturnsChanged) {
+            numberOfReturns = this.xy.decodeSymbol(context.numberReturnsModel[numberOfReturns]);
+        }
+        if (returnNumberIncrements) {
+            returnNumber = (returnNumber + 1) % 16;
+        }
+        else if (returnNumberDecrements) {
+            returnNumber = (returnNumber + 15) % 16;
+        }
+        else if (returnNumberMiscChange) {
+            returnNumber = gpsTimeChanged
+                ? this.xy.decodeSymbol(context.returnNumberModel[returnNumber])
+                : (returnNumber + this.xy.decodeSymbol(context.returnNumberGpsSameModel) + 2) % 16;
+        }
+        context.last.returns = (numberOfReturns << 4) | returnNumber;
+        const xyContext = (NUMBER_RETURN_MAP_6_CONTEXT[numberOfReturns][returnNumber] << 1) | (gpsTimeChanged ? 1 : 0);
+        const xMedian = context.lastXDiffMedian[xyContext].get();
+        const xDiff = context.dx.decompress(this.xy, xMedian, numberOfReturns === 1 ? 1 : 0);
+        context.last.x = toInt32(context.last.x + xDiff);
+        context.lastXDiffMedian[xyContext].add(xDiff);
+        const yKbits = Math.min(context.dx.k, 20) & ~1;
+        const yMedian = context.lastYDiffMedian[xyContext].get();
+        const yDiff = context.dy.decompress(this.xy, yMedian, (numberOfReturns === 1 ? 1 : 0) | yKbits);
+        context.last.y = toInt32(context.last.y + yDiff);
+        context.lastYDiffMedian[xyContext].add(yDiff);
+        if (this.z.valid) {
+            const kbits = Math.min((context.dx.k + context.dy.k) >> 1, 18) & ~1;
+            const zContext = NUMBER_RETURN_LEVEL_8_CONTEXT[numberOfReturns][returnNumber];
+            const z = context.z.decompress(this.z, context.lastZ[zContext], (numberOfReturns === 1 ? 1 : 0) | kbits);
+            context.last.z = z;
+            context.lastZ[zContext] = z;
+        }
+        if (this.classification?.valid) {
+            const classContext = (returnNumber === 1 && returnNumber >= numberOfReturns ? 1 : 0) |
+                ((context.last.classification & 0x1f) << 1);
+            context.last.classification = this.classification.decodeSymbol(context.classModel[classContext]);
+        }
+        if (this.flags?.valid) {
+            const mergedFlags = mergeFlags(context.last);
+            const flags = this.flags.decodeSymbol(context.flagModel[mergedFlags]);
+            setEdgeOfFlightLine(context.last, (flags >> 5) & 1);
+            setScanDirectionFlag(context.last, (flags >> 4) & 1);
+            setClassFlags(context.last, flags & 0x0f);
+        }
+        if (this.intensity?.valid) {
+            const intensityContext = (gpsTimeChanged ? 1 : 0) |
+                ((returnNumber >= numberOfReturns ? 1 : 0) << 1) |
+                ((returnNumber === 1 ? 1 : 0) << 2);
+            const intensity = context.intensity.decompress(this.intensity, context.lastIntensity[intensityContext], intensityContext >> 1);
+            context.lastIntensity[intensityContext] = intensity & 0xffff;
+            context.last.intensity = intensity & 0xffff;
+        }
+        if (scanAngleChanged && this.scanAngle) {
+            context.last.scanAngle = toInt16(context.scanAngle.decompress(this.scanAngle, context.last.scanAngle, gpsTimeChanged ? 1 : 0));
+        }
+        if (this.userData?.valid) {
+            const userDataContext = context.last.userData >> 2;
+            context.last.userData = this.userData.decodeSymbol(context.userDataModel[userDataContext]);
+        }
+        if (pointSourceChanged && this.pointSourceId) {
+            context.last.pointSourceId =
+                context.pointSourceId.decompress(this.pointSourceId, context.last.pointSourceId, 0) &
+                    0xffff;
+        }
+        if (gpsTimeChanged && this.gpsTime) {
+            this.decodeGpsTime(context);
+        }
+        context.gpsTimeChange = gpsTimeChanged;
+        return context.last;
+    }
+    decodeGpsTime(context) {
+        const gpsTime = this.gpsTime;
+        while (true) {
+            if (context.lastGpsTimeDiff[context.lastGpsSequence] === 0) {
+                const multi = gpsTime.decodeSymbol(context.gpsTime0DiffModel);
+                if (multi === 0) {
+                    const symbol = context.gpsTime.decompress(gpsTime, 0, 0);
+                    context.lastGpsTimeDiff[context.lastGpsSequence] = symbol;
+                    context.lastGpsTime[context.lastGpsSequence] = addInt32ToFloat64Bits(context.lastGpsTime[context.lastGpsSequence], symbol);
+                    context.multiExtremeCounter[context.lastGpsSequence] = 0;
+                }
+                else if (multi === 1) {
+                    context.nextGpsSequence = (context.nextGpsSequence + 1) & 3;
+                    const lastTimeBits = float64ToBigUint64(context.lastGpsTime[context.lastGpsSequence]);
+                    const upper = context.gpsTime.decompress(gpsTime, Number(lastTimeBits >> 32n) | 0, 8);
+                    const lower = gpsTime.readInt();
+                    context.lastGpsTime[context.nextGpsSequence] = bigUint64ToFloat64((BigInt(upper >>> 0) << 32n) | BigInt(lower));
+                    context.lastGpsSequence = context.nextGpsSequence;
+                    context.lastGpsTimeDiff[context.lastGpsSequence] = 0;
+                    context.multiExtremeCounter[context.lastGpsSequence] = 0;
+                }
+                else {
+                    context.lastGpsSequence = (context.lastGpsSequence + multi - 1) & 3;
+                    continue;
+                }
+            }
+            else {
+                let multi = gpsTime.decodeSymbol(context.gpsTimeMultiModel);
+                let gpsTimeDiff = 0;
+                if (multi === 1) {
+                    const symbol = context.gpsTime.decompress(gpsTime, context.lastGpsTimeDiff[context.lastGpsSequence], 1);
+                    context.lastGpsTime[context.lastGpsSequence] = addInt32ToFloat64Bits(context.lastGpsTime[context.lastGpsSequence], symbol);
+                    context.multiExtremeCounter[context.lastGpsSequence] = 0;
+                }
+                else if (multi < GPS_TIME_MULTI_CODE_FULL) {
+                    if (multi === 0) {
+                        gpsTimeDiff = context.gpsTime.decompress(gpsTime, 0, 7);
+                        context.multiExtremeCounter[context.lastGpsSequence]++;
+                        if (context.multiExtremeCounter[context.lastGpsSequence] > 3) {
+                            context.multiExtremeCounter[context.lastGpsSequence] = 0;
+                            context.lastGpsTimeDiff[context.lastGpsSequence] = gpsTimeDiff;
+                        }
+                    }
+                    else if (multi < GPS_TIME_MULTI) {
+                        const tag = multi < 10 ? 2 : 3;
+                        gpsTimeDiff = context.gpsTime.decompress(gpsTime, multi * context.lastGpsTimeDiff[context.lastGpsSequence], tag);
+                    }
+                    else if (multi === GPS_TIME_MULTI) {
+                        gpsTimeDiff = context.gpsTime.decompress(gpsTime, GPS_TIME_MULTI * context.lastGpsTimeDiff[context.lastGpsSequence], 4);
+                        context.multiExtremeCounter[context.lastGpsSequence]++;
+                        if (context.multiExtremeCounter[context.lastGpsSequence] > 3) {
+                            context.multiExtremeCounter[context.lastGpsSequence] = 0;
+                            context.lastGpsTimeDiff[context.lastGpsSequence] = gpsTimeDiff;
+                        }
+                    }
+                    else {
+                        multi = GPS_TIME_MULTI - multi;
+                        if (multi > GPS_TIME_MULTI_MINUS) {
+                            gpsTimeDiff = context.gpsTime.decompress(gpsTime, multi * context.lastGpsTimeDiff[context.lastGpsSequence], 5);
+                        }
+                        else {
+                            gpsTimeDiff = context.gpsTime.decompress(gpsTime, GPS_TIME_MULTI_MINUS * context.lastGpsTimeDiff[context.lastGpsSequence], 6);
+                            context.multiExtremeCounter[context.lastGpsSequence]++;
+                            if (context.multiExtremeCounter[context.lastGpsSequence] > 3) {
+                                context.multiExtremeCounter[context.lastGpsSequence] = 0;
+                                context.lastGpsTimeDiff[context.lastGpsSequence] = gpsTimeDiff;
+                            }
+                        }
+                    }
+                    context.lastGpsTime[context.lastGpsSequence] = addInt32ToFloat64Bits(context.lastGpsTime[context.lastGpsSequence], gpsTimeDiff);
+                }
+                else if (multi === GPS_TIME_MULTI_CODE_FULL) {
+                    context.nextGpsSequence = (context.nextGpsSequence + 1) & 3;
+                    const lastTimeBits = float64ToBigUint64(context.lastGpsTime[context.lastGpsSequence]);
+                    const upper = context.gpsTime.decompress(gpsTime, Number(lastTimeBits >> 32n) | 0, 8);
+                    const lower = gpsTime.readInt();
+                    context.lastGpsTime[context.nextGpsSequence] = bigUint64ToFloat64((BigInt(upper >>> 0) << 32n) | BigInt(lower));
+                    context.lastGpsSequence = context.nextGpsSequence;
+                    context.lastGpsTimeDiff[context.lastGpsSequence] = 0;
+                    context.multiExtremeCounter[context.lastGpsSequence] = 0;
+                }
+                else if (multi >= GPS_TIME_MULTI_CODE_FULL) {
+                    context.lastGpsSequence =
+                        (context.lastGpsSequence + multi - GPS_TIME_MULTI_CODE_FULL) & 3;
+                    continue;
+                }
+            }
+            context.last.gpsTime = context.lastGpsTime[context.lastGpsSequence];
+            break;
+        }
+    }
+}
+class RGB14Context {
+    haveLast = false;
+    lastRed = 0;
+    lastGreen = 0;
+    lastBlue = 0;
+    usedModel = new ArithmeticModel(128);
+    diffModel = createModels(6, 256);
+}
+class RGB14Decompressor {
+    stream;
+    contexts = Array.from({ length: 4 }, () => new RGB14Context());
+    /** Current scanner-channel context, cached because channel switches are uncommon. */
+    activeContext = null;
+    lastChannel = -1;
+    rgbCount = 0;
+    rgb = new ArithmeticDecoder();
+    decodedRed = 0;
+    decodedGreen = 0;
+    decodedBlue = 0;
+    /** RGB item version controlling scanner-channel predictor selection. */
+    itemVersion;
+    constructor(stream, itemVersion = 3) {
+        this.stream = stream;
+        this.itemVersion = itemVersion;
+    }
+    readSizes() {
+        this.rgbCount = this.stream.getUint32();
+    }
+    readData() {
+        this.rgb.initStream(this.stream, this.rgbCount);
+    }
+    decompress(output, outputOffset, scannerChannel) {
+        this.decompressRgb(scannerChannel);
+        writeUint16(this.decodedRed, output, outputOffset);
+        writeUint16(this.decodedGreen, output, outputOffset + 2);
+        writeUint16(this.decodedBlue, output, outputOffset + 4);
+        return outputOffset + 6;
+    }
+    decompressRgb(scannerChannel) {
+        if (this.lastChannel === -1) {
+            this.decodedRed = this.stream.getByte() | (this.stream.getByte() << 8);
+            this.decodedGreen = this.stream.getByte() | (this.stream.getByte() << 8);
+            this.decodedBlue = this.stream.getByte() | (this.stream.getByte() << 8);
+            const context = this.contexts[scannerChannel];
+            context.lastRed = this.decodedRed;
+            context.lastGreen = this.decodedGreen;
+            context.lastBlue = this.decodedBlue;
+            context.haveLast = true;
+            this.lastChannel = scannerChannel;
+            this.activeContext = context;
+            return;
+        }
+        if (this.rgbCount === 0) {
+            const context = this.activeContext;
+            this.decodedRed = context.lastRed;
+            this.decodedGreen = context.lastGreen;
+            this.decodedBlue = context.lastBlue;
+            return;
+        }
+        let context = this.activeContext;
+        let lastContext = context;
+        if (scannerChannel !== this.lastChannel) {
+            const previous = context;
+            context = this.contexts[scannerChannel];
+            lastContext = previous;
+            this.lastChannel = scannerChannel;
+            if (!context.haveLast) {
+                context.haveLast = true;
+                context.lastRed = previous.lastRed;
+                context.lastGreen = previous.lastGreen;
+                context.lastBlue = previous.lastBlue;
+                lastContext = context;
+            }
+            if (this.itemVersion >= 4) {
+                lastContext = context;
+            }
+            this.activeContext = context;
+        }
+        const symbol = this.rgb.decodeSymbol(context.usedModel);
+        let red = 0;
+        let green = 0;
+        let blue = 0;
+        if (symbol & 1) {
+            const correction = this.rgb.decodeSymbol(context.diffModel[0]);
+            red = (correction + (lastContext.lastRed & 0xff)) & 0xff;
+        }
+        else {
+            red = lastContext.lastRed & 0xff;
+        }
+        if (symbol & 2) {
+            const correction = this.rgb.decodeSymbol(context.diffModel[1]);
+            red |= ((correction + (lastContext.lastRed >> 8)) & 0xff) << 8;
+        }
+        else {
+            red |= lastContext.lastRed & 0xff00;
+        }
+        if (symbol & 64) {
+            let diff = (red & 0xff) - (lastContext.lastRed & 0xff);
+            if (symbol & 4) {
+                const correction = this.rgb.decodeSymbol(context.diffModel[2]);
+                green = (correction + clampUint8(diff + (lastContext.lastGreen & 0xff))) & 0xff;
+            }
+            else {
+                green = lastContext.lastGreen & 0xff;
+            }
+            if (symbol & 16) {
+                const correction = this.rgb.decodeSymbol(context.diffModel[4]);
+                diff = ((diff + ((green & 0xff) - (lastContext.lastGreen & 0xff))) / 2) | 0;
+                blue = (correction + clampUint8(diff + (lastContext.lastBlue & 0xff))) & 0xff;
+            }
+            else {
+                blue = lastContext.lastBlue & 0xff;
+            }
+            diff = (red >> 8) - (lastContext.lastRed >> 8);
+            if (symbol & 8) {
+                const correction = this.rgb.decodeSymbol(context.diffModel[3]);
+                green |= ((correction + clampUint8(diff + (lastContext.lastGreen >> 8))) & 0xff) << 8;
+            }
+            else {
+                green |= lastContext.lastGreen & 0xff00;
+            }
+            if (symbol & 32) {
+                const correction = this.rgb.decodeSymbol(context.diffModel[5]);
+                diff = ((diff + (green >> 8) - (lastContext.lastGreen >> 8)) / 2) | 0;
+                blue |= ((correction + clampUint8(diff + (lastContext.lastBlue >> 8))) & 0xff) << 8;
+            }
+            else {
+                blue |= lastContext.lastBlue & 0xff00;
+            }
+        }
+        else {
+            green = red;
+            blue = red;
+        }
+        lastContext.lastRed = red;
+        lastContext.lastGreen = green;
+        lastContext.lastBlue = blue;
+        this.decodedRed = red;
+        this.decodedGreen = green;
+        this.decodedBlue = blue;
+    }
+}
+class NIR14Context {
+    haveLast = false;
+    lastValue = 0;
+    usedModel = new ArithmeticModel(4);
+    diffModel = createModels(2, 256);
+}
+class NIR14Decompressor {
+    stream;
+    contexts = Array.from({ length: 4 }, () => new NIR14Context());
+    lastChannel = -1;
+    nirCount = 0;
+    nir = new ArithmeticDecoder();
+    scratch = new Uint8Array(2);
+    /** Most recently decoded NIR value for direct point-data output. */
+    decodedNir = 0;
+    /** RGBNIR item version controlling scanner-channel predictor selection. */
+    itemVersion;
+    constructor(stream, itemVersion = 3) {
+        this.stream = stream;
+        this.itemVersion = itemVersion;
+    }
+    readSizes() {
+        this.nirCount = this.stream.getUint32();
+    }
+    readData() {
+        this.nir.initStream(this.stream, this.nirCount);
+    }
+    decompress(output, outputOffset, scannerChannel) {
+        if (this.lastChannel === -1) {
+            this.stream.getBytes(output, outputOffset, 2);
+            const context = this.contexts[scannerChannel];
+            context.lastValue = readUint16(output, outputOffset);
+            context.haveLast = true;
+            this.lastChannel = scannerChannel;
+            this.decodedNir = context.lastValue;
+            return outputOffset + 2;
+        }
+        if (this.nirCount === 0) {
+            writeUint16(this.contexts[this.lastChannel].lastValue, output, outputOffset);
+            this.decodedNir = this.contexts[this.lastChannel].lastValue;
+            return outputOffset + 2;
+        }
+        const context = this.contexts[scannerChannel];
+        let lastContext = this.contexts[this.lastChannel];
+        if (scannerChannel !== this.lastChannel) {
+            this.lastChannel = scannerChannel;
+            if (!context.haveLast) {
+                context.haveLast = true;
+                context.lastValue = lastContext.lastValue;
+                lastContext = context;
+            }
+            if (this.itemVersion >= 4) {
+                lastContext = context;
+            }
+        }
+        const symbol = this.nir.decodeSymbol(context.usedModel);
+        let value = symbol & 1
+            ? (this.nir.decodeSymbol(context.diffModel[0]) + (lastContext.lastValue & 0xff)) & 0xff
+            : lastContext.lastValue & 0xff;
+        value |=
+            symbol & 2
+                ? ((this.nir.decodeSymbol(context.diffModel[1]) + (lastContext.lastValue >> 8)) & 0xff) << 8
+                : lastContext.lastValue & 0xff00;
+        lastContext.lastValue = value;
+        this.decodedNir = value;
+        writeUint16(value, output, outputOffset);
+        return outputOffset + 2;
+    }
+    /** Decode one NIR value without allocating a temporary point record. */
+    decompressNir(scannerChannel) {
+        this.decompress(this.scratch, 0, scannerChannel);
+        return this.decodedNir;
+    }
+}
+/** Arithmetic state and last waveform packet reference for one scanner channel. */
+class WavePacketDecompressionContext {
+    /** Whether this scanner channel has inherited or decoded a waveform reference. */
+    haveLast = false;
+    /** Last waveform packet descriptor index. */
+    descriptorIndex = 0;
+    /** Last waveform packet byte offset, kept losslessly as an unsigned 64-bit integer. */
+    offset = 0n;
+    /** Last waveform packet byte size. */
+    packetSize = 0;
+    /** Raw IEEE-754 bits for the last return-point location. */
+    returnPointBits = 0;
+    /** Raw IEEE-754 bits for the last waveform X vector component. */
+    xBits = 0;
+    /** Raw IEEE-754 bits for the last waveform Y vector component. */
+    yBits = 0;
+    /** Raw IEEE-754 bits for the last waveform Z vector component. */
+    zBits = 0;
+    /** Last signed 32-bit offset difference used by the integer predictor. */
+    lastOffsetDifference = 0;
+    /** Last offset coding symbol, which selects the next four-symbol model. */
+    lastOffsetDifferenceSymbol = 0;
+    /** Waveform descriptor arithmetic model. */
+    descriptorModel = new ArithmeticModel(256);
+    /** Context-dependent waveform offset coding models. */
+    offsetDifferenceModels = createModels(4, 4);
+    /** Integer decompressor for signed waveform offset differences. */
+    offsetDifferenceDecompressor = createIntegerDecompressor(32, 1);
+    /** Integer decompressor for waveform packet sizes. */
+    packetSizeDecompressor = createIntegerDecompressor(32, 1);
+    /** Integer decompressor for raw return-point float bits. */
+    returnPointDecompressor = createIntegerDecompressor(32, 1);
+    /** Shared three-context decompressor for raw X, Y, and Z float bits. */
+    vectorDecompressor = createIntegerDecompressor(32, 3);
+}
+/** Decoder for the independent LASzip 1.4 waveform packet reference layer. */
+class WavePacket14Decompressor {
+    /** Compressed chunk source. */
+    stream;
+    /** Per-scanner-channel arithmetic and prediction state. */
+    contexts = Array.from({ length: 4 }, () => new WavePacketDecompressionContext());
+    /** Scanner channel used by the previous point. */
+    lastChannel = -1;
+    /** Compressed waveform layer byte length. */
+    wavePacketByteCount = 0;
+    /** Arithmetic decoder bounded to the waveform layer. */
+    decoder = new ArithmeticDecoder();
+    /** WavePacket14 item version selected by the LASzip VLR. */
+    itemVersion;
+    constructor(stream, itemVersion) {
+        this.stream = stream;
+        this.itemVersion = itemVersion;
+    }
+    /** Read the compressed waveform layer byte length. */
+    readSizes() {
+        this.wavePacketByteCount = this.stream.getUint32();
+    }
+    /** Bind the arithmetic decoder to the compressed waveform layer. */
+    readData() {
+        this.decoder.initStream(this.stream, this.wavePacketByteCount);
+    }
+    /** Decode one 29-byte LAS waveform packet reference. */
+    decompress(output, outputOffset, scannerChannel) {
+        if (this.lastChannel === -1) {
+            this.stream.getBytes(output, outputOffset, 29);
+            const context = this.contexts[scannerChannel];
+            this.readContext(context, output, outputOffset);
+            context.haveLast = true;
+            this.lastChannel = scannerChannel;
+            return outputOffset + 29;
+        }
+        const previousContext = this.contexts[this.lastChannel];
+        const context = this.contexts[scannerChannel];
+        let lastWavePacketContext = context;
+        if (scannerChannel !== this.lastChannel) {
+            lastWavePacketContext = previousContext;
+            if (!context.haveLast) {
+                this.copyLastWavePacket(context, previousContext);
+                context.haveLast = true;
+                lastWavePacketContext = context;
+            }
+            else if (this.itemVersion >= 4) {
+                lastWavePacketContext = context;
+            }
+            this.lastChannel = scannerChannel;
+        }
+        if (this.wavePacketByteCount) {
+            this.decodeContext(context, lastWavePacketContext);
+        }
+        this.writeContext(lastWavePacketContext, output, outputOffset);
+        return outputOffset + 29;
+    }
+    /** Decode one waveform packet reference into a caller-owned 29-byte buffer. */
+    decompressToTarget(target, targetOffset, scannerChannel) {
+        this.decompress(target, targetOffset, scannerChannel);
+    }
+    /** Decode changed waveform fields into one scanner-channel context. */
+    decodeContext(codingContext, lastWavePacketContext) {
+        lastWavePacketContext.descriptorIndex = this.decoder.decodeSymbol(codingContext.descriptorModel);
+        const offsetDifferenceSymbol = this.decoder.decodeSymbol(codingContext.offsetDifferenceModels[codingContext.lastOffsetDifferenceSymbol]);
+        codingContext.lastOffsetDifferenceSymbol = offsetDifferenceSymbol;
+        switch (offsetDifferenceSymbol) {
+            case 0:
+                break;
+            case 1:
+                lastWavePacketContext.offset = BigInt.asUintN(64, lastWavePacketContext.offset + BigInt(lastWavePacketContext.packetSize));
+                break;
+            case 2:
+                codingContext.lastOffsetDifference = codingContext.offsetDifferenceDecompressor.decompress(this.decoder, codingContext.lastOffsetDifference, 0);
+                lastWavePacketContext.offset = BigInt.asUintN(64, lastWavePacketContext.offset + BigInt(codingContext.lastOffsetDifference));
+                break;
+            default:
+                lastWavePacketContext.offset = this.decoder.readUint64();
+                break;
+        }
+        lastWavePacketContext.packetSize =
+            codingContext.packetSizeDecompressor.decompress(this.decoder, lastWavePacketContext.packetSize | 0, 0) >>> 0;
+        lastWavePacketContext.returnPointBits = codingContext.returnPointDecompressor.decompress(this.decoder, lastWavePacketContext.returnPointBits, 0);
+        lastWavePacketContext.xBits = codingContext.vectorDecompressor.decompress(this.decoder, lastWavePacketContext.xBits, 0);
+        lastWavePacketContext.yBits = codingContext.vectorDecompressor.decompress(this.decoder, lastWavePacketContext.yBits, 1);
+        lastWavePacketContext.zBits = codingContext.vectorDecompressor.decompress(this.decoder, lastWavePacketContext.zBits, 2);
+    }
+    /** Initialize one context from the previous scanner channel's last reference. */
+    copyLastWavePacket(target, source) {
+        target.descriptorIndex = source.descriptorIndex;
+        target.offset = source.offset;
+        target.packetSize = source.packetSize;
+        target.returnPointBits = source.returnPointBits;
+        target.xBits = source.xBits;
+        target.yBits = source.yBits;
+        target.zBits = source.zBits;
+    }
+    /** Read one uncompressed waveform reference into a decoder context. */
+    readContext(context, input, inputOffset) {
+        context.descriptorIndex = input[inputOffset];
+        context.offset = readBigUint64(input, inputOffset + 1);
+        context.packetSize = readUint32(input, inputOffset + 9);
+        context.returnPointBits = readInt32(input, inputOffset + 13);
+        context.xBits = readInt32(input, inputOffset + 17);
+        context.yBits = readInt32(input, inputOffset + 21);
+        context.zBits = readInt32(input, inputOffset + 25);
+    }
+    /** Write one decoder context as an uncompressed 29-byte waveform reference. */
+    writeContext(context, output, outputOffset) {
+        output[outputOffset] = context.descriptorIndex;
+        writeBigUint64(context.offset, output, outputOffset + 1);
+        writeUint32(context.packetSize, output, outputOffset + 9);
+        writeInt32(context.returnPointBits, output, outputOffset + 13);
+        writeInt32(context.xBits, output, outputOffset + 17);
+        writeInt32(context.yBits, output, outputOffset + 21);
+        writeInt32(context.zBits, output, outputOffset + 25);
+    }
+}
+class Byte14Context {
+    haveLast = false;
+    last;
+    byteModel;
+    constructor(count) {
+        this.last = new Uint8Array(count);
+        this.byteModel = createModels(count, 256);
+    }
+}
+class Byte14Decompressor {
+    stream;
+    count;
+    contexts;
+    lastChannel = -1;
+    byteCount;
+    byteDecoder;
+    /** Byte14 item version controlling scanner-channel predictor selection. */
+    itemVersion;
+    constructor(stream, count, itemVersion = 3) {
+        this.stream = stream;
+        this.count = count;
+        this.itemVersion = itemVersion;
+        this.contexts = Array.from({ length: 4 }, () => new Byte14Context(count));
+        this.byteCount = new Array(count).fill(0);
+        this.byteDecoder = Array.from({ length: count }, () => new ArithmeticDecoder());
+    }
+    readSizes() {
+        for (let index = 0; index < this.count; index++) {
+            this.byteCount[index] = this.stream.getUint32();
+        }
+    }
+    readData() {
+        for (let index = 0; index < this.count; index++) {
+            this.byteDecoder[index].initStream(this.stream, this.byteCount[index]);
+        }
+    }
+    decompress(output, outputOffset, scannerChannel) {
+        if (this.lastChannel === -1) {
+            this.stream.getBytes(output, outputOffset, this.count);
+            const context = this.contexts[scannerChannel];
+            context.last.set(output.subarray(outputOffset, outputOffset + this.count));
+            context.haveLast = true;
+            this.lastChannel = scannerChannel;
+            return outputOffset + this.count;
+        }
+        const context = this.contexts[scannerChannel];
+        let lastByte = this.contexts[this.lastChannel].last;
+        if (scannerChannel !== this.lastChannel) {
+            this.lastChannel = scannerChannel;
+            if (!context.haveLast) {
+                context.haveLast = true;
+                context.last.set(lastByte);
+                lastByte = this.contexts[this.lastChannel].last;
+            }
+            if (this.itemVersion >= 4) {
+                lastByte = context.last;
+            }
+        }
+        for (let index = 0; index < this.count; index++) {
+            if (this.byteCount[index]) {
+                const value = (lastByte[index] + this.byteDecoder[index].decodeSymbol(context.byteModel[index])) & 0xff;
+                output[outputOffset + index] = value;
+                lastByte[index] = value;
+            }
+            else {
+                output[outputOffset + index] = lastByte[index];
+            }
+        }
+        return outputOffset + this.count;
+    }
+}
+function createPointDecompressor(stream, metadata, outputMode, selection) {
+    const extraByteCount = getExtraByteCount(metadata);
+    for (const version of [
+        metadata.point10ItemVersion,
+        metadata.gpsTime11ItemVersion,
+        metadata.rgb12ItemVersion,
+        metadata.byteItemVersion
+    ]) {
+        if (version !== undefined && version !== 1 && version !== 2) {
+            throw new Error(`Unsupported legacy LASzip item version ${version}`);
+        }
+    }
+    switch (metadata.pointDataRecordFormat) {
+        case 0:
+            return new PointFormat0Decompressor(stream, extraByteCount, metadata);
+        case 1:
+            return new PointFormat1Decompressor(stream, extraByteCount, metadata);
+        case 2:
+            return new PointFormat2Decompressor(stream, extraByteCount, metadata);
+        case 3:
+            return new PointFormat3Decompressor(stream, extraByteCount, metadata, outputMode === 'point-data' ? selection : null);
+        case 4:
+            return new PointFormat4Decompressor(stream, extraByteCount, metadata);
+        case 5:
+            return new PointFormat5Decompressor(stream, extraByteCount, metadata);
+        case 6:
+            return new PointFormat6Decompressor(stream, extraByteCount, outputMode, metadata, selection);
+        case 7:
+            return new PointFormat7Decompressor(stream, extraByteCount, outputMode, metadata, selection);
+        case 8:
+            return new PointFormat8Decompressor(stream, extraByteCount, outputMode, metadata, selection);
+        case 9:
+            return new PointFormat9Decompressor(stream, extraByteCount, outputMode, metadata, selection);
+        case 10:
+            return new PointFormat10Decompressor(stream, extraByteCount, outputMode, metadata, selection);
+        default:
+            throw new Error(`TypeScript LAZ decoder does not support point format ${metadata.pointDataRecordFormat}`);
+    }
+}
+/** Return whether a point format has a direct typed-array output path. */
+function supportsDirectPointDataOutput(pointDataRecordFormat) {
+    return pointDataRecordFormat <= 5 || (pointDataRecordFormat >= 6 && pointDataRecordFormat <= 10);
+}
+class PointFormat0Decompressor {
+    point;
+    bytes;
+    first = true;
+    constructor(stream, extraByteCount, metadata) {
+        this.point = new Point10Decompressor(stream, metadata.point10ItemVersion ?? 2);
+        this.bytes = new Byte10Decompressor(stream, this.point.getDecoder(), extraByteCount, metadata.byteItemVersion ?? 2);
+    }
+    decompress(output, outputOffset) {
+        outputOffset = this.point.decompress(output, outputOffset);
+        outputOffset = this.bytes.decompress(output, outputOffset);
+        this.readFirstMetadata();
+        return outputOffset;
+    }
+    /** Decode PDRF 0 points directly into represented Arrow columns. */
+    decompressPointData(target, targetPointIndex) {
+        const point = this.point.decompressPoint();
+        this.bytes.decompressToTarget(target.extraBytes, targetPointIndex * this.bytes.byteCount);
+        this.readFirstMetadata();
+        writePoint10ToPointDataArrays(point, target.positions, target.intensities, target.classifications, target.scale, target.offset, targetPointIndex);
+        writePoint10MetadataToPointDataTarget(point, target, targetPointIndex);
+    }
+    decompressPointDataBatch(target, pointCount) {
+        for (let pointIndex = 0; pointIndex < pointCount; pointIndex++) {
+            this.decompressPointData(target, target.pointOffset + pointIndex);
+        }
+    }
+    readFirstMetadata() {
+        if (this.first) {
+            this.point.readFirstMetadata();
+            this.first = false;
+        }
+    }
+}
+class GpsTime10Decompressor {
+    itemVersion;
+    stream;
+    decoder;
+    gpsTimeMultiModel = new ArithmeticModel(516);
+    gpsTime0DiffModel = new ArithmeticModel(6);
+    gpsTime = createIntegerDecompressor(32, 9);
+    lastGpsSequence = 0;
+    nextGpsSequence = 0;
+    lastGpsTime = new Array(4).fill(0);
+    lastGpsTimeDiff = new Array(4).fill(0);
+    multiExtremeCounter = new Array(4).fill(0);
+    haveLast = false;
+    constructor(stream, decoder, 
+    /** LASzip item codec version selected by the VLR. */ itemVersion = 2) {
+        this.itemVersion = itemVersion;
+        this.stream = stream;
+        this.decoder = decoder;
+        if (itemVersion === 1) {
+            this.gpsTimeMultiModel = new ArithmeticModel(512);
+            this.gpsTime0DiffModel = new ArithmeticModel(3);
+            this.gpsTime = createIntegerDecompressor(32, 6);
+        }
+    }
+    decompress(output, outputOffset) {
+        writeFloat64(this.decompressGpsTime(), output, outputOffset);
+        return outputOffset + 8;
+    }
+    /** Decode one legacy GPS time value without materializing raw point bytes. */
+    decompressGpsTime() {
+        if (!this.haveLast) {
+            this.lastGpsTime[0] = readFloat64FromStream(this.stream);
+            this.haveLast = true;
+            return this.lastGpsTime[0];
+        }
+        if (this.itemVersion === 1)
+            this.decodeLegacyGpsTime();
+        else
+            this.decodeGpsTime();
+        return this.lastGpsTime[this.lastGpsSequence];
+    }
+    /** Decode the single GPS-time sequence used by LASzip item version 1. */
+    decodeLegacyGpsTime() {
+        const previousDifference = this.lastGpsTimeDiff[0];
+        if (previousDifference === 0) {
+            const symbol = this.decoder.decodeSymbol(this.gpsTime0DiffModel);
+            if (symbol === 1) {
+                const difference = this.gpsTime.decompress(this.decoder, 0, 0);
+                this.lastGpsTimeDiff[0] = difference;
+                this.lastGpsTime[0] = addInt32ToFloat64Bits(this.lastGpsTime[0], difference);
+            }
+            else if (symbol === 2) {
+                this.lastGpsTime[0] = bigUint64ToFloat64(this.decoder.readUint64());
+            }
+            return;
+        }
+        const multiplier = this.decoder.decodeSymbol(this.gpsTimeMultiModel);
+        if (multiplier === 511)
+            return;
+        if (multiplier === 510) {
+            this.lastGpsTime[0] = bigUint64ToFloat64(this.decoder.readUint64());
+            return;
+        }
+        const context = multiplier === 1 ? 1 : multiplier === 0 ? 2 : multiplier < 10 ? 3 : multiplier < 50 ? 4 : 5;
+        const prediction = multiplier === 0
+            ? Math.trunc(previousDifference / 4)
+            : toInt32(multiplier * previousDifference);
+        const difference = this.gpsTime.decompress(this.decoder, prediction, context);
+        if (multiplier === 1) {
+            this.lastGpsTimeDiff[0] = difference;
+            this.multiExtremeCounter[0] = 0;
+        }
+        else if (multiplier === 0 || multiplier === 509) {
+            if (++this.multiExtremeCounter[0] > 3) {
+                this.lastGpsTimeDiff[0] = difference;
+                this.multiExtremeCounter[0] = 0;
+            }
+        }
+        this.lastGpsTime[0] = addInt32ToFloat64Bits(this.lastGpsTime[0], difference);
+    }
+    decodeGpsTime() {
+        while (true) {
+            if (this.lastGpsTimeDiff[this.lastGpsSequence] === 0) {
+                const multi = this.decoder.decodeSymbol(this.gpsTime0DiffModel);
+                if (multi === 0) {
+                    break;
+                }
+                if (multi === 1) {
+                    const gpsTimeDiff = this.gpsTime.decompress(this.decoder, 0, 0);
+                    this.lastGpsTimeDiff[this.lastGpsSequence] = gpsTimeDiff;
+                    this.lastGpsTime[this.lastGpsSequence] = addInt32ToFloat64Bits(this.lastGpsTime[this.lastGpsSequence], gpsTimeDiff);
+                    this.multiExtremeCounter[this.lastGpsSequence] = 0;
+                    break;
+                }
+                if (multi === 2) {
+                    this.readFullGpsTime();
+                    break;
+                }
+                this.lastGpsSequence = (this.lastGpsSequence + multi - 2) & 3;
+                continue;
+            }
+            let multi = this.decoder.decodeSymbol(this.gpsTimeMultiModel);
+            let gpsTimeDiff = 0;
+            if (multi === 1) {
+                const symbol = this.gpsTime.decompress(this.decoder, this.lastGpsTimeDiff[this.lastGpsSequence], 1);
+                this.lastGpsTime[this.lastGpsSequence] = addInt32ToFloat64Bits(this.lastGpsTime[this.lastGpsSequence], symbol);
+                this.multiExtremeCounter[this.lastGpsSequence] = 0;
+            }
+            else if (multi < GPS_TIME10_MULTI_UNCHANGED) {
+                if (multi === 0) {
+                    gpsTimeDiff = this.gpsTime.decompress(this.decoder, 0, 7);
+                    this.multiExtremeCounter[this.lastGpsSequence]++;
+                    if (this.multiExtremeCounter[this.lastGpsSequence] > 3) {
+                        this.multiExtremeCounter[this.lastGpsSequence] = 0;
+                        this.lastGpsTimeDiff[this.lastGpsSequence] = gpsTimeDiff;
+                    }
+                }
+                else if (multi < GPS_TIME_MULTI) {
+                    const tag = multi < 10 ? 2 : 3;
+                    gpsTimeDiff = this.gpsTime.decompress(this.decoder, multi * this.lastGpsTimeDiff[this.lastGpsSequence], tag);
+                }
+                else if (multi === GPS_TIME_MULTI) {
+                    gpsTimeDiff = this.gpsTime.decompress(this.decoder, GPS_TIME_MULTI * this.lastGpsTimeDiff[this.lastGpsSequence], 4);
+                    this.multiExtremeCounter[this.lastGpsSequence]++;
+                    if (this.multiExtremeCounter[this.lastGpsSequence] > 3) {
+                        this.multiExtremeCounter[this.lastGpsSequence] = 0;
+                        this.lastGpsTimeDiff[this.lastGpsSequence] = gpsTimeDiff;
+                    }
+                }
+                else {
+                    multi = GPS_TIME_MULTI - multi;
+                    if (multi > GPS_TIME_MULTI_MINUS) {
+                        gpsTimeDiff = this.gpsTime.decompress(this.decoder, multi * this.lastGpsTimeDiff[this.lastGpsSequence], 5);
+                    }
+                    else {
+                        gpsTimeDiff = this.gpsTime.decompress(this.decoder, GPS_TIME_MULTI_MINUS * this.lastGpsTimeDiff[this.lastGpsSequence], 6);
+                        this.multiExtremeCounter[this.lastGpsSequence]++;
+                        if (this.multiExtremeCounter[this.lastGpsSequence] > 3) {
+                            this.multiExtremeCounter[this.lastGpsSequence] = 0;
+                            this.lastGpsTimeDiff[this.lastGpsSequence] = gpsTimeDiff;
+                        }
+                    }
+                }
+                this.lastGpsTime[this.lastGpsSequence] = addInt32ToFloat64Bits(this.lastGpsTime[this.lastGpsSequence], gpsTimeDiff);
+            }
+            else if (multi === GPS_TIME10_MULTI_CODE_FULL) {
+                this.readFullGpsTime();
+            }
+            else if (multi >= GPS_TIME10_MULTI_CODE_FULL) {
+                this.lastGpsSequence = (this.lastGpsSequence + multi - GPS_TIME10_MULTI_CODE_FULL) & 3;
+                continue;
+            }
+            break;
+        }
+    }
+    readFullGpsTime() {
+        this.nextGpsSequence = (this.nextGpsSequence + 1) & 3;
+        const lastTimeBits = float64ToBigUint64(this.lastGpsTime[this.lastGpsSequence]);
+        const upper = this.gpsTime.decompress(this.decoder, Number(lastTimeBits >> 32n) | 0, 8);
+        const lower = this.decoder.readInt();
+        this.lastGpsTime[this.nextGpsSequence] = bigUint64ToFloat64((BigInt(upper >>> 0) << 32n) | BigInt(lower));
+        this.lastGpsSequence = this.nextGpsSequence;
+        this.lastGpsTimeDiff[this.lastGpsSequence] = 0;
+        this.multiExtremeCounter[this.lastGpsSequence] = 0;
+    }
+}
+class PointFormat1Decompressor {
+    point;
+    gpsTime;
+    bytes;
+    first = true;
+    constructor(stream, extraByteCount, metadata) {
+        this.point = new Point10Decompressor(stream, metadata.point10ItemVersion ?? 2);
+        const decoder = this.point.getDecoder();
+        this.gpsTime = new GpsTime10Decompressor(stream, decoder, metadata.gpsTime11ItemVersion ?? 2);
+        this.bytes = new Byte10Decompressor(stream, decoder, extraByteCount, metadata.byteItemVersion ?? 2);
+    }
+    decompress(output, outputOffset) {
+        outputOffset = this.point.decompress(output, outputOffset);
+        outputOffset = this.gpsTime.decompress(output, outputOffset);
+        outputOffset = this.bytes.decompress(output, outputOffset);
+        this.readFirstMetadata();
+        return outputOffset;
+    }
+    /** Decode PDRF 1 points directly into represented Arrow columns. */
+    decompressPointData(target, targetPointIndex) {
+        const point = this.point.decompressPoint();
+        const gpsTime = this.gpsTime.decompressGpsTime();
+        this.bytes.decompressToTarget(target.extraBytes, targetPointIndex * this.bytes.byteCount);
+        this.readFirstMetadata();
+        writePoint10ToPointDataArrays(point, target.positions, target.intensities, target.classifications, target.scale, target.offset, targetPointIndex);
+        writePoint10MetadataToPointDataTarget(point, target, targetPointIndex);
+        if (target.gpsTimes) {
+            target.gpsTimes[targetPointIndex] = gpsTime;
+        }
+    }
+    decompressPointDataBatch(target, pointCount) {
+        for (let pointIndex = 0; pointIndex < pointCount; pointIndex++) {
+            this.decompressPointData(target, target.pointOffset + pointIndex);
+        }
+    }
+    readFirstMetadata() {
+        if (this.first) {
+            this.point.readFirstMetadata();
+            this.first = false;
+        }
+    }
+}
+class PointFormat2Decompressor {
+    point;
+    rgb;
+    bytes;
+    first = true;
+    constructor(stream, extraByteCount, metadata) {
+        this.point = new Point10Decompressor(stream, metadata.point10ItemVersion ?? 2);
+        const decoder = this.point.getDecoder();
+        this.rgb = new RGB10Decompressor(stream, decoder, metadata.rgb12ItemVersion ?? 2);
+        this.bytes = new Byte10Decompressor(stream, decoder, extraByteCount, metadata.byteItemVersion ?? 2);
+    }
+    decompress(output, outputOffset) {
+        outputOffset = this.point.decompress(output, outputOffset);
+        outputOffset = this.rgb.decompress(output, outputOffset);
+        outputOffset = this.bytes.decompress(output, outputOffset);
+        this.readFirstMetadata();
+        return outputOffset;
+    }
+    /** Decode PDRF 2 points directly into represented Arrow columns. */
+    decompressPointData(target, targetPointIndex) {
+        const point = this.point.decompressPoint();
+        this.rgb.decompressRgb();
+        this.bytes.decompressToTarget(target.extraBytes, targetPointIndex * this.bytes.byteCount);
+        this.readFirstMetadata();
+        writePoint10ToPointDataArrays(point, target.positions, target.intensities, target.classifications, target.scale, target.offset, targetPointIndex);
+        writePoint10MetadataToPointDataTarget(point, target, targetPointIndex);
+        writeRgbToPointDataTarget(this.rgb.decodedRed, this.rgb.decodedGreen, this.rgb.decodedBlue, target, targetPointIndex);
+    }
+    decompressPointDataBatch(target, pointCount) {
+        for (let pointIndex = 0; pointIndex < pointCount; pointIndex++) {
+            this.decompressPointData(target, target.pointOffset + pointIndex);
+        }
+    }
+    readFirstMetadata() {
+        if (this.first) {
+            this.point.readFirstMetadata();
+            this.first = false;
+        }
+    }
+}
+class PointFormat3Decompressor {
+    point;
+    gpsTime;
+    rgb;
+    bytes;
+    first = true;
+    /** Whether only the common position, color, intensity, and classification columns are needed. */
+    directCommonOutput;
+    constructor(stream, extraByteCount, metadata, selection = null) {
+        this.point = new Point10Decompressor(stream, metadata.point10ItemVersion ?? 2);
+        const decoder = this.point.getDecoder();
+        this.gpsTime = new GpsTime10Decompressor(stream, decoder, metadata.gpsTime11ItemVersion ?? 2);
+        this.rgb = new RGB10Decompressor(stream, decoder, metadata.rgb12ItemVersion ?? 2);
+        this.bytes = new Byte10Decompressor(stream, decoder, extraByteCount, metadata.byteItemVersion ?? 2);
+        this.directCommonOutput = Boolean(selection &&
+            !selection.gpsTime &&
+            !selection.scanAngle &&
+            !selection.userData &&
+            !selection.pointSourceId &&
+            !selection.flags &&
+            !selection.waveform &&
+            !selection.extraBytes);
+    }
+    decompress(output, outputOffset) {
+        outputOffset = this.point.decompress(output, outputOffset);
+        outputOffset = this.gpsTime.decompress(output, outputOffset);
+        outputOffset = this.rgb.decompress(output, outputOffset);
+        outputOffset = this.bytes.decompress(output, outputOffset);
+        this.readFirstMetadata();
+        return outputOffset;
+    }
+    /** Decode one legacy PDRF 3 point directly into typed point-data arrays. */
+    decompressPointData(target, targetPointIndex) {
+        const point = this.point.decompressPoint();
+        const gpsTime = this.gpsTime.decompressGpsTime();
+        this.rgb.decompressRgb();
+        if (this.directCommonOutput) {
+            this.bytes.decompressToTarget();
+            this.readFirstMetadata();
+            writePoint10ToPointDataArrays(point, target.positions, target.intensities, target.classifications, target.scale, target.offset, targetPointIndex);
+            if (target.colors) {
+                const colorOffset = targetPointIndex * 4;
+                target.colors[colorOffset] = this.rgb.decodedRed & 0xff;
+                target.colors[colorOffset + 1] = this.rgb.decodedGreen & 0xff;
+                target.colors[colorOffset + 2] = this.rgb.decodedBlue & 0xff;
+                target.colors[colorOffset + 3] = 255;
+            }
+            else if (target.rawColors) {
+                const colorOffset = targetPointIndex * 3;
+                target.rawColors[colorOffset] = this.rgb.decodedRed;
+                target.rawColors[colorOffset + 1] = this.rgb.decodedGreen;
+                target.rawColors[colorOffset + 2] = this.rgb.decodedBlue;
+            }
+            return;
+        }
+        this.bytes.decompressToTarget(target.extraBytes, targetPointIndex * this.bytes.byteCount);
+        this.readFirstMetadata();
+        writePoint10ToPointDataArrays(point, target.positions, target.intensities, target.classifications, target.scale, target.offset, targetPointIndex);
+        writePoint10MetadataToPointDataTarget(point, target, targetPointIndex);
+        if (target.gpsTimes) {
+            target.gpsTimes[targetPointIndex] = gpsTime;
+        }
+        writeRgbToPointDataTarget(this.rgb.decodedRed, this.rgb.decodedGreen, this.rgb.decodedBlue, target, targetPointIndex);
+    }
+    /**
+     * Decode legacy PDRF 3 directly into selected typed point-data arrays.
+     *
+     * The common-column branch deliberately duplicates the short output loop. Keeping optional
+     * metadata and Extra Bytes checks outside that loop measurably reduces work for visualization
+     * workloads, which normally request only position, color, intensity, and classification.
+     */
+    decompressPointDataBatch(target, pointCount) {
+        const positions = target.positions;
+        const intensities = target.intensities;
+        const classifications = target.classifications;
+        const colors = target.colors;
+        const rawColors = target.rawColors;
+        const scale = target.scale;
+        const offset = target.offset;
+        const extraByteCount = this.bytes.byteCount;
+        let targetPointIndex = target.pointOffset;
+        const hasMetadataOutput = Boolean(target.gpsTimes ||
+            target.scanAngles ||
+            target.userData ||
+            target.pointSourceIds ||
+            target.returnNumbers ||
+            target.numberOfReturns ||
+            target.scannerChannels ||
+            target.scanDirectionFlags ||
+            target.edgeOfFlightLines ||
+            target.syntheticFlags ||
+            target.keyPointFlags ||
+            target.withheldFlags ||
+            target.overlapFlags);
+        if (!hasMetadataOutput && !target.extraBytes) {
+            for (let pointIndex = 0; pointIndex < pointCount; pointIndex++) {
+                const point = this.point.decompressPoint();
+                this.gpsTime.decompressGpsTime();
+                this.rgb.decompressRgb();
+                this.bytes.decompressToTarget();
+                this.readFirstMetadata();
+                writePoint10ToPointDataArrays(point, positions, intensities, classifications, scale, offset, targetPointIndex);
+                if (colors) {
+                    const colorOffset = targetPointIndex * 4;
+                    colors[colorOffset] = this.rgb.decodedRed & 0xff;
+                    colors[colorOffset + 1] = this.rgb.decodedGreen & 0xff;
+                    colors[colorOffset + 2] = this.rgb.decodedBlue & 0xff;
+                    colors[colorOffset + 3] = 255;
+                }
+                else if (rawColors) {
+                    const colorOffset = targetPointIndex * 3;
+                    rawColors[colorOffset] = this.rgb.decodedRed;
+                    rawColors[colorOffset + 1] = this.rgb.decodedGreen;
+                    rawColors[colorOffset + 2] = this.rgb.decodedBlue;
+                }
+                targetPointIndex++;
+            }
+            return;
+        }
+        for (let pointIndex = 0; pointIndex < pointCount; pointIndex++) {
+            const point = this.point.decompressPoint();
+            const gpsTime = this.gpsTime.decompressGpsTime();
+            this.rgb.decompressRgb();
+            this.bytes.decompressToTarget(target.extraBytes, targetPointIndex * extraByteCount);
+            this.readFirstMetadata();
+            writePoint10ToPointDataArrays(point, positions, intensities, classifications, scale, offset, targetPointIndex);
+            writePoint10MetadataToPointDataTarget(point, target, targetPointIndex);
+            if (target.gpsTimes) {
+                target.gpsTimes[targetPointIndex] = gpsTime;
+            }
+            writeRgbToPointDataTarget(this.rgb.decodedRed, this.rgb.decodedGreen, this.rgb.decodedBlue, target, targetPointIndex);
+            targetPointIndex++;
+        }
+    }
+    readFirstMetadata() {
+        if (this.first) {
+            this.point.readFirstMetadata();
+            this.first = false;
+        }
+    }
+}
+/** LASzip v1 decoder for the interleaved legacy waveform packet item. */
+class WavePacket13Decompressor {
+    /** Compressed chunk source used for the first uncompressed item. */
+    stream;
+    /** Arithmetic decoder shared by all legacy point items. */
+    decoder;
+    /** Waveform state and arithmetic models for the preceding point. */
+    context = new WavePacketDecompressionContext();
+    constructor(stream, decoder) {
+        this.stream = stream;
+        this.decoder = decoder;
+    }
+    /** Decode one complete 29-byte legacy waveform packet reference. */
+    decompress(output, outputOffset) {
+        const context = this.context;
+        if (!context.haveLast) {
+            this.stream.getBytes(output, outputOffset, 29);
+            this.readContext(output, outputOffset);
+            context.haveLast = true;
+            return outputOffset + 29;
+        }
+        context.descriptorIndex = this.decoder.decodeSymbol(context.descriptorModel);
+        const offsetDifferenceSymbol = this.decoder.decodeSymbol(context.offsetDifferenceModels[context.lastOffsetDifferenceSymbol]);
+        context.lastOffsetDifferenceSymbol = offsetDifferenceSymbol;
+        switch (offsetDifferenceSymbol) {
+            case 0:
+                break;
+            case 1:
+                context.offset = BigInt.asUintN(64, context.offset + BigInt(context.packetSize));
+                break;
+            case 2:
+                context.lastOffsetDifference = context.offsetDifferenceDecompressor.decompress(this.decoder, context.lastOffsetDifference, 0);
+                context.offset = BigInt.asUintN(64, context.offset + BigInt(context.lastOffsetDifference));
+                break;
+            default:
+                context.offset = this.decoder.readUint64();
+                break;
+        }
+        context.packetSize =
+            context.packetSizeDecompressor.decompress(this.decoder, context.packetSize | 0, 0) >>> 0;
+        context.returnPointBits = context.returnPointDecompressor.decompress(this.decoder, context.returnPointBits, 0);
+        context.xBits = context.vectorDecompressor.decompress(this.decoder, context.xBits, 0);
+        context.yBits = context.vectorDecompressor.decompress(this.decoder, context.yBits, 1);
+        context.zBits = context.vectorDecompressor.decompress(this.decoder, context.zBits, 2);
+        this.writeContext(output, outputOffset);
+        return outputOffset + 29;
+    }
+    /** Decode one waveform packet reference into a caller-owned 29-byte buffer. */
+    decompressToTarget(target, targetOffset) {
+        this.decompress(target, targetOffset);
+    }
+    /** Initialize waveform predictors from the first uncompressed item. */
+    readContext(input, inputOffset) {
+        const context = this.context;
+        context.descriptorIndex = input[inputOffset];
+        context.offset = readBigUint64(input, inputOffset + 1);
+        context.packetSize = readUint32(input, inputOffset + 9);
+        context.returnPointBits = readInt32(input, inputOffset + 13);
+        context.xBits = readInt32(input, inputOffset + 17);
+        context.yBits = readInt32(input, inputOffset + 21);
+        context.zBits = readInt32(input, inputOffset + 25);
+    }
+    /** Write waveform predictor state as one LAS packet-reference field. */
+    writeContext(output, outputOffset) {
+        const context = this.context;
+        output[outputOffset] = context.descriptorIndex;
+        writeBigUint64(context.offset, output, outputOffset + 1);
+        writeUint32(context.packetSize, output, outputOffset + 9);
+        writeInt32(context.returnPointBits, output, outputOffset + 13);
+        writeInt32(context.xBits, output, outputOffset + 17);
+        writeInt32(context.yBits, output, outputOffset + 21);
+        writeInt32(context.zBits, output, outputOffset + 25);
+    }
+}
+/** LASzip interleaved decoder for LAS point format 4. */
+class PointFormat4Decompressor {
+    /** Legacy core point decoder. */
+    point;
+    /** GPS time decoder. */
+    gpsTime;
+    /** Legacy waveform packet decoder. */
+    wavePacket;
+    /** Extra Bytes decoder. */
+    bytes;
+    /** Reused sink for waveform references when the caller did not request WAVEFORM output. */
+    waveformScratch = new Uint8Array(29);
+    /** Whether the first raw items remain unread. */
+    first = true;
+    constructor(stream, extraByteCount, metadata) {
+        this.point = new Point10Decompressor(stream, metadata.point10ItemVersion ?? 2);
+        const decoder = this.point.getDecoder();
+        this.gpsTime = new GpsTime10Decompressor(stream, decoder, metadata.gpsTime11ItemVersion ?? 2);
+        this.wavePacket = new WavePacket13Decompressor(stream, decoder);
+        this.bytes = new Byte10Decompressor(stream, decoder, extraByteCount, metadata.byteItemVersion ?? 2);
+    }
+    /** Decode one complete PDRF 4 point record. */
+    decompress(output, outputOffset) {
+        outputOffset = this.point.decompress(output, outputOffset);
+        outputOffset = this.gpsTime.decompress(output, outputOffset);
+        outputOffset = this.wavePacket.decompress(output, outputOffset);
+        outputOffset = this.bytes.decompress(output, outputOffset);
+        this.readFirstMetadata();
+        return outputOffset;
+    }
+    /** Decode PDRF 4 points directly into represented Arrow columns and waveform references. */
+    decompressPointData(target, targetPointIndex) {
+        const point = this.point.decompressPoint();
+        const gpsTime = this.gpsTime.decompressGpsTime();
+        if (target.waveforms) {
+            this.wavePacket.decompressToTarget(target.waveforms, targetPointIndex * 29);
+        }
+        else {
+            this.wavePacket.decompressToTarget(this.waveformScratch, 0);
+        }
+        this.bytes.decompressToTarget(target.extraBytes, targetPointIndex * this.bytes.byteCount);
+        this.readFirstMetadata();
+        writePoint10ToPointDataArrays(point, target.positions, target.intensities, target.classifications, target.scale, target.offset, targetPointIndex);
+        writePoint10MetadataToPointDataTarget(point, target, targetPointIndex);
+        if (target.gpsTimes) {
+            target.gpsTimes[targetPointIndex] = gpsTime;
+        }
+    }
+    decompressPointDataBatch(target, pointCount) {
+        for (let pointIndex = 0; pointIndex < pointCount; pointIndex++) {
+            this.decompressPointData(target, target.pointOffset + pointIndex);
+        }
+    }
+    /** Initialize the shared legacy arithmetic decoder after first raw items. */
+    readFirstMetadata() {
+        if (this.first) {
+            this.point.readFirstMetadata();
+            this.first = false;
+        }
+    }
+}
+/** LASzip interleaved decoder for LAS point format 5. */
+class PointFormat5Decompressor {
+    /** Legacy core point decoder. */
+    point;
+    /** GPS time decoder. */
+    gpsTime;
+    /** RGB decoder. */
+    rgb;
+    /** Legacy waveform packet decoder. */
+    wavePacket;
+    /** Extra Bytes decoder. */
+    bytes;
+    /** Reused sink for waveform references when the caller did not request WAVEFORM output. */
+    waveformScratch = new Uint8Array(29);
+    /** Whether the first raw items remain unread. */
+    first = true;
+    constructor(stream, extraByteCount, metadata) {
+        this.point = new Point10Decompressor(stream, metadata.point10ItemVersion ?? 2);
+        const decoder = this.point.getDecoder();
+        this.gpsTime = new GpsTime10Decompressor(stream, decoder, metadata.gpsTime11ItemVersion ?? 2);
+        this.rgb = new RGB10Decompressor(stream, decoder, metadata.rgb12ItemVersion ?? 2);
+        this.wavePacket = new WavePacket13Decompressor(stream, decoder);
+        this.bytes = new Byte10Decompressor(stream, decoder, extraByteCount, metadata.byteItemVersion ?? 2);
+    }
+    /** Decode one complete PDRF 5 point record. */
+    decompress(output, outputOffset) {
+        outputOffset = this.point.decompress(output, outputOffset);
+        outputOffset = this.gpsTime.decompress(output, outputOffset);
+        outputOffset = this.rgb.decompress(output, outputOffset);
+        outputOffset = this.wavePacket.decompress(output, outputOffset);
+        outputOffset = this.bytes.decompress(output, outputOffset);
+        this.readFirstMetadata();
+        return outputOffset;
+    }
+    /** Decode PDRF 5 points directly into represented Arrow columns and waveform references. */
+    decompressPointData(target, targetPointIndex) {
+        const point = this.point.decompressPoint();
+        const gpsTime = this.gpsTime.decompressGpsTime();
+        this.rgb.decompressRgb();
+        if (target.waveforms) {
+            this.wavePacket.decompressToTarget(target.waveforms, targetPointIndex * 29);
+        }
+        else {
+            this.wavePacket.decompressToTarget(this.waveformScratch, 0);
+        }
+        this.bytes.decompressToTarget(target.extraBytes, targetPointIndex * this.bytes.byteCount);
+        this.readFirstMetadata();
+        writePoint10ToPointDataArrays(point, target.positions, target.intensities, target.classifications, target.scale, target.offset, targetPointIndex);
+        writePoint10MetadataToPointDataTarget(point, target, targetPointIndex);
+        if (target.gpsTimes) {
+            target.gpsTimes[targetPointIndex] = gpsTime;
+        }
+        writeRgbToPointDataTarget(this.rgb.decodedRed, this.rgb.decodedGreen, this.rgb.decodedBlue, target, targetPointIndex);
+    }
+    decompressPointDataBatch(target, pointCount) {
+        for (let pointIndex = 0; pointIndex < pointCount; pointIndex++) {
+            this.decompressPointData(target, target.pointOffset + pointIndex);
+        }
+    }
+    /** Initialize the shared legacy arithmetic decoder after first raw items. */
+    readFirstMetadata() {
+        if (this.first) {
+            this.point.readFirstMetadata();
+            this.first = false;
+        }
+    }
+}
+class PointFormat6Decompressor {
+    stream;
+    point;
+    bytes;
+    /** Extra bytes stored with the first point and in independent later layers. */
+    extraByteCount;
+    first = true;
+    constructor(stream, extraByteCount, outputMode, metadata, selection) {
+        this.stream = stream;
+        this.extraByteCount = extraByteCount;
+        this.point = new Point14Decompressor(stream, outputMode === 'raw' ? Point14DecompressionMode.Full : Point14DecompressionMode.PointData, metadata.point14ItemVersion ?? 3, selection);
+        this.bytes =
+            (outputMode === 'raw' || selection?.extraBytes) && extraByteCount
+                ? new Byte14Decompressor(stream, extraByteCount, metadata.byte14ItemVersion ?? 3)
+                : null;
+    }
+    decompress(output, outputOffset) {
+        outputOffset = this.point.decompress(output, outputOffset);
+        if (this.bytes) {
+            outputOffset = this.bytes.decompress(output, outputOffset, this.point.itemContextChannel);
+        }
+        this.readFirstMetadata();
+        return outputOffset;
+    }
+    decompressPointData(target, targetPointIndex) {
+        const point = this.point.decompressPoint();
+        if (this.bytes && target.extraBytes) {
+            this.bytes.decompress(target.extraBytes, targetPointIndex * this.extraByteCount, this.point.itemContextChannel);
+        }
+        else if (this.first && this.extraByteCount) {
+            this.stream.consume(this.extraByteCount);
+        }
+        this.readFirstMetadata();
+        writePoint14ToPointDataTarget(point, target, targetPointIndex);
+    }
+    decompressPointDataBatch(target, pointCount) {
+        const positions = target.positions;
+        const intensities = target.intensities;
+        const classifications = target.classifications;
+        const scale = target.scale;
+        const offset = target.offset;
+        let targetPointIndex = target.pointOffset;
+        for (let pointIndex = 0; pointIndex < pointCount; pointIndex++) {
+            const point = this.point.decompressPoint();
+            if (this.bytes && target.extraBytes) {
+                this.bytes.decompress(target.extraBytes, targetPointIndex * this.extraByteCount, this.point.itemContextChannel);
+            }
+            else if (this.first && this.extraByteCount) {
+                this.stream.consume(this.extraByteCount);
+            }
+            this.readFirstMetadata();
+            writePoint14ToPointDataArrays(point, positions, intensities, classifications, scale, offset, targetPointIndex++);
+            writeGpsTimeToPointDataTarget(point, target, targetPointIndex - 1);
+            writePoint14MetadataToPointDataTarget(point, target, targetPointIndex - 1);
+        }
+    }
+    readFirstMetadata() {
+        if (this.first) {
+            this.stream.getUint32();
+            this.point.readSizes();
+            let skippedExtraByteLength = 0;
+            if (this.bytes) {
+                this.bytes.readSizes();
+            }
+            else {
+                for (let index = 0; index < this.extraByteCount; index++) {
+                    skippedExtraByteLength += this.stream.getUint32();
+                }
+            }
+            this.point.readData();
+            if (this.bytes) {
+                this.bytes.readData();
+            }
+            else {
+                this.stream.consume(skippedExtraByteLength);
+            }
+            this.first = false;
+        }
+    }
+}
+class PointFormat7Decompressor {
+    stream;
+    point;
+    rgb;
+    bytes;
+    /** Extra bytes stored with the first point and in independent later layers. */
+    extraByteCount;
+    first = true;
+    constructor(stream, extraByteCount, outputMode, metadata, selection) {
+        this.stream = stream;
+        this.extraByteCount = extraByteCount;
+        this.point = new Point14Decompressor(stream, outputMode === 'raw' ? Point14DecompressionMode.Full : Point14DecompressionMode.PointData, metadata.point14ItemVersion ?? 3, selection);
+        this.rgb =
+            outputMode === 'raw' || selection?.color
+                ? new RGB14Decompressor(stream, metadata.rgb14ItemVersion ?? 3)
+                : null;
+        this.bytes =
+            (outputMode === 'raw' || selection?.extraBytes) && extraByteCount
+                ? new Byte14Decompressor(stream, extraByteCount, metadata.byte14ItemVersion ?? 3)
+                : null;
+    }
+    decompress(output, outputOffset) {
+        outputOffset = this.point.decompress(output, outputOffset);
+        outputOffset = this.rgb.decompress(output, outputOffset, this.point.itemContextChannel);
+        if (this.bytes) {
+            outputOffset = this.bytes.decompress(output, outputOffset, this.point.itemContextChannel);
+        }
+        this.readFirstMetadata();
+        return outputOffset;
+    }
+    /** Decode one PDRF 7 point directly into represented typed-array columns. */
+    decompressPointData(target, targetPointIndex) {
+        const point = this.point.decompressPoint();
+        if (this.rgb) {
+            this.rgb.decompressRgb(this.point.itemContextChannel);
+        }
+        else if (this.first) {
+            this.stream.consume(6);
+        }
+        // The first point stores extra bytes before the layered stream metadata.
+        if (this.bytes && target.extraBytes) {
+            this.bytes.decompress(target.extraBytes, targetPointIndex * this.extraByteCount, this.point.itemContextChannel);
+        }
+        else if (this.first && this.extraByteCount) {
+            this.stream.consume(this.extraByteCount);
+        }
+        this.readFirstMetadata();
+        writePoint14ToPointDataTarget(point, target, targetPointIndex);
+        if (this.rgb) {
+            writeRgbToPointDataTarget(this.rgb.decodedRed, this.rgb.decodedGreen, this.rgb.decodedBlue, target, targetPointIndex);
+        }
+    }
+    /**
+     * Decode PDRF 7 points directly into represented typed-array columns.
+     *
+     * First-point literals and layer metadata are handled once before the steady-state loop. The
+     * common-column loop then avoids per-point capability checks; the comprehensive loop preserves
+     * optional metadata and Extra Bytes output.
+     */
+    decompressPointDataBatch(target, pointCount) {
+        const positions = target.positions;
+        const intensities = target.intensities;
+        const classifications = target.classifications;
+        const colors = target.colors;
+        const rawColors = target.rawColors;
+        const scale = target.scale;
+        const offset = target.offset;
+        let targetPointIndex = target.pointOffset;
+        let remainingPointCount = pointCount;
+        // Decode first-point literals and layer metadata before entering the steady-state loop.
+        if (this.first && remainingPointCount > 0) {
+            const point = this.point.decompressPoint();
+            if (this.rgb) {
+                this.rgb.decompressRgb(this.point.itemContextChannel);
+            }
+            else {
+                this.stream.consume(6);
+            }
+            if (this.bytes && target.extraBytes) {
+                this.bytes.decompress(target.extraBytes, targetPointIndex * this.extraByteCount, this.point.itemContextChannel);
+            }
+            else if (this.extraByteCount) {
+                this.stream.consume(this.extraByteCount);
+            }
+            this.readFirstMetadata();
+            writePoint14ToPointDataArrays(point, positions, intensities, classifications, scale, offset, targetPointIndex);
+            writeGpsTimeToPointDataTarget(point, target, targetPointIndex);
+            writePoint14MetadataToPointDataTarget(point, target, targetPointIndex);
+            if (colors && this.rgb) {
+                const colorOffset = targetPointIndex * 4;
+                colors[colorOffset] = this.rgb.decodedRed & 0xff;
+                colors[colorOffset + 1] = this.rgb.decodedGreen & 0xff;
+                colors[colorOffset + 2] = this.rgb.decodedBlue & 0xff;
+                colors[colorOffset + 3] = 255;
+            }
+            else if (rawColors && this.rgb) {
+                const colorOffset = targetPointIndex * 3;
+                rawColors[colorOffset] = this.rgb.decodedRed;
+                rawColors[colorOffset + 1] = this.rgb.decodedGreen;
+                rawColors[colorOffset + 2] = this.rgb.decodedBlue;
+            }
+            targetPointIndex++;
+            remainingPointCount--;
+        }
+        const hasMetadataOutput = Boolean(target.gpsTimes ||
+            target.scanAngles ||
+            target.userData ||
+            target.pointSourceIds ||
+            target.returnNumbers ||
+            target.numberOfReturns ||
+            target.scannerChannels ||
+            target.scanDirectionFlags ||
+            target.edgeOfFlightLines ||
+            target.syntheticFlags ||
+            target.keyPointFlags ||
+            target.withheldFlags ||
+            target.overlapFlags);
+        const hasExtraByteOutput = Boolean(this.bytes && target.extraBytes);
+        if (!hasMetadataOutput && !hasExtraByteOutput) {
+            for (let pointIndex = 0; pointIndex < remainingPointCount; pointIndex++) {
+                const point = this.point.decompressPoint();
+                this.rgb?.decompressRgb(this.point.itemContextChannel);
+                writePoint14ToPointDataArrays(point, positions, intensities, classifications, scale, offset, targetPointIndex);
+                if (colors && this.rgb) {
+                    const colorOffset = targetPointIndex * 4;
+                    colors[colorOffset] = this.rgb.decodedRed & 0xff;
+                    colors[colorOffset + 1] = this.rgb.decodedGreen & 0xff;
+                    colors[colorOffset + 2] = this.rgb.decodedBlue & 0xff;
+                    colors[colorOffset + 3] = 255;
+                }
+                else if (rawColors && this.rgb) {
+                    const colorOffset = targetPointIndex * 3;
+                    rawColors[colorOffset] = this.rgb.decodedRed;
+                    rawColors[colorOffset + 1] = this.rgb.decodedGreen;
+                    rawColors[colorOffset + 2] = this.rgb.decodedBlue;
+                }
+                targetPointIndex++;
+            }
+            return;
+        }
+        for (let pointIndex = 0; pointIndex < remainingPointCount; pointIndex++) {
+            const point = this.point.decompressPoint();
+            this.rgb?.decompressRgb(this.point.itemContextChannel);
+            if (this.bytes && target.extraBytes) {
+                this.bytes.decompress(target.extraBytes, targetPointIndex * this.extraByteCount, this.point.itemContextChannel);
+            }
+            writePoint14ToPointDataArrays(point, positions, intensities, classifications, scale, offset, targetPointIndex);
+            writeGpsTimeToPointDataTarget(point, target, targetPointIndex);
+            writePoint14MetadataToPointDataTarget(point, target, targetPointIndex);
+            if (colors && this.rgb) {
+                const colorOffset = targetPointIndex * 4;
+                colors[colorOffset] = this.rgb.decodedRed & 0xff;
+                colors[colorOffset + 1] = this.rgb.decodedGreen & 0xff;
+                colors[colorOffset + 2] = this.rgb.decodedBlue & 0xff;
+                colors[colorOffset + 3] = 255;
+            }
+            else if (rawColors && this.rgb) {
+                const colorOffset = targetPointIndex * 3;
+                rawColors[colorOffset] = this.rgb.decodedRed;
+                rawColors[colorOffset + 1] = this.rgb.decodedGreen;
+                rawColors[colorOffset + 2] = this.rgb.decodedBlue;
+            }
+            targetPointIndex++;
+        }
+    }
+    readFirstMetadata() {
+        if (this.first) {
+            this.stream.getUint32();
+            this.point.readSizes();
+            const skippedRgbByteLength = this.rgb ? 0 : this.stream.getUint32();
+            this.rgb?.readSizes();
+            let skippedExtraByteLength = 0;
+            if (this.bytes) {
+                this.bytes.readSizes();
+            }
+            else {
+                for (let index = 0; index < this.extraByteCount; index++) {
+                    skippedExtraByteLength += this.stream.getUint32();
+                }
+            }
+            this.point.readData();
+            if (this.rgb) {
+                this.rgb.readData();
+            }
+            else {
+                this.stream.consume(skippedRgbByteLength);
+            }
+            if (this.bytes) {
+                this.bytes.readData();
+            }
+            else {
+                this.stream.consume(skippedExtraByteLength);
+            }
+            this.first = false;
+        }
+    }
+}
+class PointFormat8Decompressor {
+    stream;
+    point;
+    rgb;
+    nir;
+    bytes;
+    /** Extra bytes stored with the first point and in independent later layers. */
+    extraByteCount;
+    first = true;
+    constructor(stream, extraByteCount, outputMode, metadata, selection) {
+        this.stream = stream;
+        this.extraByteCount = extraByteCount;
+        this.point = new Point14Decompressor(stream, outputMode === 'raw' ? Point14DecompressionMode.Full : Point14DecompressionMode.PointData, metadata.point14ItemVersion ?? 3, selection);
+        this.rgb =
+            outputMode === 'raw' || selection?.color
+                ? new RGB14Decompressor(stream, metadata.rgb14ItemVersion ?? 3)
+                : null;
+        this.nir =
+            outputMode === 'raw' || selection?.nir
+                ? new NIR14Decompressor(stream, metadata.rgb14ItemVersion ?? 3)
+                : null;
+        this.bytes =
+            (outputMode === 'raw' || selection?.extraBytes) && extraByteCount
+                ? new Byte14Decompressor(stream, extraByteCount, metadata.byte14ItemVersion ?? 3)
+                : null;
+    }
+    decompress(output, outputOffset) {
+        outputOffset = this.point.decompress(output, outputOffset);
+        outputOffset = this.rgb.decompress(output, outputOffset, this.point.itemContextChannel);
+        outputOffset = this.nir.decompress(output, outputOffset, this.point.itemContextChannel);
+        if (this.bytes) {
+            outputOffset = this.bytes.decompress(output, outputOffset, this.point.itemContextChannel);
+        }
+        this.readFirstMetadata();
+        return outputOffset;
+    }
+    decompressPointData(target, targetPointIndex) {
+        const point = this.point.decompressPoint();
+        if (this.rgb) {
+            this.rgb.decompressRgb(this.point.itemContextChannel);
+        }
+        else if (this.first) {
+            this.stream.consume(6);
+        }
+        if (!this.nir && this.first) {
+            this.stream.consume(2);
+        }
+        const nir = this.nir ? this.nir.decompressNir(this.point.itemContextChannel) : 0;
+        if (this.bytes && target.extraBytes) {
+            this.bytes.decompress(target.extraBytes, targetPointIndex * this.extraByteCount, this.point.itemContextChannel);
+        }
+        if (this.first) {
+            this.stream.consume(this.bytes ? 0 : this.extraByteCount);
+        }
+        this.readFirstMetadata();
+        writePoint14ToPointDataTarget(point, target, targetPointIndex);
+        writeNirToPointDataTarget(nir, target, targetPointIndex);
+        if (this.rgb) {
+            writeRgbToPointDataTarget(this.rgb.decodedRed, this.rgb.decodedGreen, this.rgb.decodedBlue, target, targetPointIndex);
+        }
+    }
+    decompressPointDataBatch(target, pointCount) {
+        const positions = target.positions;
+        const intensities = target.intensities;
+        const classifications = target.classifications;
+        const colors = target.colors;
+        const rawColors = target.rawColors;
+        const scale = target.scale;
+        const offset = target.offset;
+        let targetPointIndex = target.pointOffset;
+        for (let pointIndex = 0; pointIndex < pointCount; pointIndex++) {
+            const point = this.point.decompressPoint();
+            if (this.rgb) {
+                this.rgb.decompressRgb(this.point.itemContextChannel);
+            }
+            else if (this.first) {
+                this.stream.consume(6);
+            }
+            if (!this.nir && this.first) {
+                this.stream.consume(2);
+            }
+            const nir = this.nir ? this.nir.decompressNir(this.point.itemContextChannel) : 0;
+            if (this.bytes && target.extraBytes) {
+                this.bytes.decompress(target.extraBytes, targetPointIndex * this.extraByteCount, this.point.itemContextChannel);
+            }
+            if (this.first) {
+                this.stream.consume(this.bytes ? 0 : this.extraByteCount);
+            }
+            this.readFirstMetadata();
+            writePoint14ToPointDataArrays(point, positions, intensities, classifications, scale, offset, targetPointIndex);
+            writeGpsTimeToPointDataTarget(point, target, targetPointIndex);
+            writePoint14MetadataToPointDataTarget(point, target, targetPointIndex);
+            if (colors && this.rgb) {
+                const colorOffset = targetPointIndex * 4;
+                colors[colorOffset] = this.rgb.decodedRed & 0xff;
+                colors[colorOffset + 1] = this.rgb.decodedGreen & 0xff;
+                colors[colorOffset + 2] = this.rgb.decodedBlue & 0xff;
+                colors[colorOffset + 3] = 255;
+            }
+            else if (rawColors && this.rgb) {
+                const colorOffset = targetPointIndex * 3;
+                rawColors[colorOffset] = this.rgb.decodedRed;
+                rawColors[colorOffset + 1] = this.rgb.decodedGreen;
+                rawColors[colorOffset + 2] = this.rgb.decodedBlue;
+            }
+            writeNirToPointDataTarget(nir, target, targetPointIndex);
+            targetPointIndex++;
+        }
+    }
+    readFirstMetadata() {
+        if (this.first) {
+            this.stream.getUint32();
+            this.point.readSizes();
+            const skippedRgbByteLength = this.rgb ? 0 : this.stream.getUint32();
+            this.rgb?.readSizes();
+            const skippedNirByteLength = this.nir ? 0 : this.stream.getUint32();
+            this.nir?.readSizes();
+            let skippedExtraByteLength = 0;
+            if (this.bytes) {
+                this.bytes.readSizes();
+            }
+            else {
+                for (let index = 0; index < this.extraByteCount; index++) {
+                    skippedExtraByteLength += this.stream.getUint32();
+                }
+            }
+            this.point.readData();
+            if (this.rgb) {
+                this.rgb.readData();
+            }
+            else {
+                this.stream.consume(skippedRgbByteLength);
+            }
+            if (this.nir) {
+                this.nir.readData();
+            }
+            else {
+                this.stream.consume(skippedNirByteLength);
+            }
+            if (this.bytes) {
+                this.bytes.readData();
+            }
+            else {
+                this.stream.consume(skippedExtraByteLength);
+            }
+            this.first = false;
+        }
+    }
+}
+/** LASzip layered decoder for LAS 1.4 point format 9. */
+class PointFormat9Decompressor {
+    /** Compressed chunk source. */
+    stream;
+    /** Core LAS 1.4 point decoder. */
+    point;
+    /** Waveform packet reference decoder, omitted for selective Arrow output. */
+    wavePacket;
+    /** Extra Bytes decoder retained for raw or selected direct output. */
+    bytes;
+    /** Extra bytes stored with the first point and in independent later layers. */
+    extraByteCount;
+    /** Whether the first point and layered stream metadata remain unread. */
+    first = true;
+    waveformScratch = new Uint8Array(29);
+    constructor(stream, extraByteCount, outputMode, metadata, selection) {
+        this.stream = stream;
+        this.extraByteCount = extraByteCount;
+        this.point = new Point14Decompressor(stream, outputMode === 'raw' ? Point14DecompressionMode.Full : Point14DecompressionMode.PointData, metadata.point14ItemVersion ?? 3, selection);
+        this.wavePacket =
+            outputMode === 'raw' || Boolean(selection?.waveform)
+                ? new WavePacket14Decompressor(stream, metadata.wavePacketItemVersion ?? 3)
+                : null;
+        this.bytes =
+            (outputMode === 'raw' || selection?.extraBytes) && extraByteCount
+                ? new Byte14Decompressor(stream, extraByteCount, metadata.byte14ItemVersion ?? 3)
+                : null;
+    }
+    /** Decode one complete PDRF 9 point record. */
+    decompress(output, outputOffset) {
+        outputOffset = this.point.decompress(output, outputOffset);
+        outputOffset = this.wavePacket.decompress(output, outputOffset, this.point.itemContextChannel);
+        if (this.bytes) {
+            outputOffset = this.bytes.decompress(output, outputOffset, this.point.itemContextChannel);
+        }
+        this.readFirstMetadata();
+        return outputOffset;
+    }
+    /** Decode one PDRF 9 point directly into represented Arrow columns. */
+    decompressPointData(target, targetPointIndex) {
+        const point = this.point.decompressPoint();
+        if (this.wavePacket) {
+            this.wavePacket.decompressToTarget(this.waveformScratch, 0, this.point.itemContextChannel);
+            if (target.waveforms) {
+                target.waveforms.set(this.waveformScratch, targetPointIndex * 29);
+            }
+        }
+        else if (this.first) {
+            this.stream.consume(29);
+        }
+        if (this.bytes && target.extraBytes) {
+            this.bytes.decompress(target.extraBytes, targetPointIndex * this.extraByteCount, this.point.itemContextChannel);
+        }
+        else if (this.first) {
+            this.stream.consume(this.extraByteCount);
+        }
+        this.readFirstMetadata();
+        writePoint14ToPointDataTarget(point, target, targetPointIndex);
+    }
+    /** Decode PDRF 9 points directly into represented Arrow columns. */
+    decompressPointDataBatch(target, pointCount) {
+        const positions = target.positions;
+        const intensities = target.intensities;
+        const classifications = target.classifications;
+        const scale = target.scale;
+        const offset = target.offset;
+        let targetPointIndex = target.pointOffset;
+        for (let pointIndex = 0; pointIndex < pointCount; pointIndex++) {
+            const point = this.point.decompressPoint();
+            if (this.wavePacket) {
+                this.wavePacket.decompressToTarget(this.waveformScratch, 0, this.point.itemContextChannel);
+                if (target.waveforms) {
+                    target.waveforms.set(this.waveformScratch, targetPointIndex * 29);
+                }
+            }
+            else if (this.first) {
+                this.stream.consume(29);
+            }
+            if (this.bytes && target.extraBytes) {
+                this.bytes.decompress(target.extraBytes, targetPointIndex * this.extraByteCount, this.point.itemContextChannel);
+            }
+            else if (this.first) {
+                this.stream.consume(this.extraByteCount);
+            }
+            this.readFirstMetadata();
+            writePoint14ToPointDataArrays(point, positions, intensities, classifications, scale, offset, targetPointIndex++);
+            writeGpsTimeToPointDataTarget(point, target, targetPointIndex - 1);
+            writePoint14MetadataToPointDataTarget(point, target, targetPointIndex - 1);
+        }
+    }
+    /** Read and bind or skip the independent PDRF 9 field layers. */
+    readFirstMetadata() {
+        if (this.first) {
+            this.stream.getUint32();
+            this.point.readSizes();
+            const skippedWavePacketByteLength = this.wavePacket ? 0 : this.stream.getUint32();
+            this.wavePacket?.readSizes();
+            let skippedExtraByteLength = 0;
+            if (this.bytes) {
+                this.bytes.readSizes();
+            }
+            else {
+                for (let index = 0; index < this.extraByteCount; index++) {
+                    skippedExtraByteLength += this.stream.getUint32();
+                }
+            }
+            this.point.readData();
+            if (this.wavePacket) {
+                this.wavePacket.readData();
+            }
+            else {
+                this.stream.consume(skippedWavePacketByteLength);
+            }
+            if (this.bytes) {
+                this.bytes.readData();
+            }
+            else {
+                this.stream.consume(skippedExtraByteLength);
+            }
+            this.first = false;
+        }
+    }
+}
+/** LASzip layered decoder for LAS 1.4 point format 10. */
+class PointFormat10Decompressor {
+    /** Compressed chunk source. */
+    stream;
+    /** Core LAS 1.4 point decoder. */
+    point;
+    /** RGB decoder retained for raw output or when direct output requests color. */
+    rgb;
+    /** NIR decoder, omitted for selective Arrow output. */
+    nir;
+    /** Waveform packet reference decoder, omitted for selective Arrow output. */
+    wavePacket;
+    /** Extra Bytes decoder retained for raw or selected direct output. */
+    bytes;
+    /** Extra bytes stored with the first point and in independent later layers. */
+    extraByteCount;
+    /** Whether the first point and layered stream metadata remain unread. */
+    first = true;
+    waveformScratch = new Uint8Array(29);
+    constructor(stream, extraByteCount, outputMode, metadata, selection) {
+        this.stream = stream;
+        this.extraByteCount = extraByteCount;
+        this.point = new Point14Decompressor(stream, outputMode === 'raw' ? Point14DecompressionMode.Full : Point14DecompressionMode.PointData, metadata.point14ItemVersion ?? 3, selection);
+        this.rgb =
+            outputMode === 'raw' || selection?.color
+                ? new RGB14Decompressor(stream, metadata.rgb14ItemVersion ?? 3)
+                : null;
+        this.nir =
+            outputMode === 'raw' || selection?.nir
+                ? new NIR14Decompressor(stream, metadata.rgb14ItemVersion ?? 3)
+                : null;
+        this.wavePacket =
+            outputMode === 'raw' || Boolean(selection?.waveform)
+                ? new WavePacket14Decompressor(stream, metadata.wavePacketItemVersion ?? 3)
+                : null;
+        this.bytes =
+            (outputMode === 'raw' || selection?.extraBytes) && extraByteCount
+                ? new Byte14Decompressor(stream, extraByteCount, metadata.byte14ItemVersion ?? 3)
+                : null;
+    }
+    /** Decode one complete PDRF 10 point record. */
+    decompress(output, outputOffset) {
+        outputOffset = this.point.decompress(output, outputOffset);
+        outputOffset = this.rgb.decompress(output, outputOffset, this.point.itemContextChannel);
+        outputOffset = this.nir.decompress(output, outputOffset, this.point.itemContextChannel);
+        outputOffset = this.wavePacket.decompress(output, outputOffset, this.point.itemContextChannel);
+        if (this.bytes) {
+            outputOffset = this.bytes.decompress(output, outputOffset, this.point.itemContextChannel);
+        }
+        this.readFirstMetadata();
+        return outputOffset;
+    }
+    /** Decode one PDRF 10 point directly into represented Arrow columns. */
+    decompressPointData(target, targetPointIndex) {
+        const point = this.point.decompressPoint();
+        if (this.rgb) {
+            this.rgb.decompressRgb(this.point.itemContextChannel);
+        }
+        else if (this.first) {
+            this.stream.consume(6);
+        }
+        const nir = this.nir ? this.nir.decompressNir(this.point.itemContextChannel) : 0;
+        if (this.first) {
+            this.stream.consume(this.nir ? 0 : 2);
+        }
+        if (this.wavePacket) {
+            this.wavePacket.decompressToTarget(this.waveformScratch, 0, this.point.itemContextChannel);
+            if (target.waveforms) {
+                target.waveforms.set(this.waveformScratch, targetPointIndex * 29);
+            }
+        }
+        else if (this.first) {
+            this.stream.consume(29);
+        }
+        if (this.bytes && target.extraBytes) {
+            this.bytes.decompress(target.extraBytes, targetPointIndex * this.extraByteCount, this.point.itemContextChannel);
+        }
+        else if (this.first) {
+            this.stream.consume(this.extraByteCount);
+        }
+        this.readFirstMetadata();
+        writePoint14ToPointDataTarget(point, target, targetPointIndex);
+        writeNirToPointDataTarget(nir, target, targetPointIndex);
+        if (this.rgb) {
+            writeRgbToPointDataTarget(this.rgb.decodedRed, this.rgb.decodedGreen, this.rgb.decodedBlue, target, targetPointIndex);
+        }
+    }
+    /** Decode PDRF 10 points directly into represented Arrow columns. */
+    decompressPointDataBatch(target, pointCount) {
+        const positions = target.positions;
+        const intensities = target.intensities;
+        const classifications = target.classifications;
+        const colors = target.colors;
+        const rawColors = target.rawColors;
+        const scale = target.scale;
+        const offset = target.offset;
+        let targetPointIndex = target.pointOffset;
+        for (let pointIndex = 0; pointIndex < pointCount; pointIndex++) {
+            const point = this.point.decompressPoint();
+            if (this.rgb) {
+                this.rgb.decompressRgb(this.point.itemContextChannel);
+            }
+            else if (this.first) {
+                this.stream.consume(6);
+            }
+            const nir = this.nir ? this.nir.decompressNir(this.point.itemContextChannel) : 0;
+            if (this.first) {
+                this.stream.consume(this.nir ? 0 : 2);
+            }
+            if (this.wavePacket) {
+                this.wavePacket.decompressToTarget(this.waveformScratch, 0, this.point.itemContextChannel);
+                if (target.waveforms) {
+                    target.waveforms.set(this.waveformScratch, targetPointIndex * 29);
+                }
+            }
+            else if (this.first) {
+                this.stream.consume(29);
+            }
+            if (this.bytes && target.extraBytes) {
+                this.bytes.decompress(target.extraBytes, targetPointIndex * this.extraByteCount, this.point.itemContextChannel);
+            }
+            else if (this.first) {
+                this.stream.consume(this.extraByteCount);
+            }
+            this.readFirstMetadata();
+            writePoint14ToPointDataArrays(point, positions, intensities, classifications, scale, offset, targetPointIndex);
+            writeGpsTimeToPointDataTarget(point, target, targetPointIndex);
+            writePoint14MetadataToPointDataTarget(point, target, targetPointIndex);
+            if (colors && this.rgb) {
+                const colorOffset = targetPointIndex * 4;
+                colors[colorOffset] = this.rgb.decodedRed & 0xff;
+                colors[colorOffset + 1] = this.rgb.decodedGreen & 0xff;
+                colors[colorOffset + 2] = this.rgb.decodedBlue & 0xff;
+                colors[colorOffset + 3] = 255;
+            }
+            else if (rawColors && this.rgb) {
+                const colorOffset = targetPointIndex * 3;
+                rawColors[colorOffset] = this.rgb.decodedRed;
+                rawColors[colorOffset + 1] = this.rgb.decodedGreen;
+                rawColors[colorOffset + 2] = this.rgb.decodedBlue;
+            }
+            writeNirToPointDataTarget(nir, target, targetPointIndex);
+            targetPointIndex++;
+        }
+    }
+    /** Read and bind or skip the independent PDRF 10 field layers. */
+    readFirstMetadata() {
+        if (this.first) {
+            this.stream.getUint32();
+            this.point.readSizes();
+            const skippedRgbByteLength = this.rgb ? 0 : this.stream.getUint32();
+            this.rgb?.readSizes();
+            const skippedNirByteLength = this.nir ? 0 : this.stream.getUint32();
+            this.nir?.readSizes();
+            const skippedWavePacketByteLength = this.wavePacket ? 0 : this.stream.getUint32();
+            this.wavePacket?.readSizes();
+            let skippedExtraByteLength = 0;
+            if (this.bytes) {
+                this.bytes.readSizes();
+            }
+            else {
+                for (let index = 0; index < this.extraByteCount; index++) {
+                    skippedExtraByteLength += this.stream.getUint32();
+                }
+            }
+            this.point.readData();
+            if (this.rgb) {
+                this.rgb.readData();
+            }
+            else {
+                this.stream.consume(skippedRgbByteLength);
+            }
+            if (this.nir) {
+                this.nir.readData();
+            }
+            else {
+                this.stream.consume(skippedNirByteLength);
+            }
+            if (this.wavePacket) {
+                this.wavePacket.readData();
+            }
+            else {
+                this.stream.consume(skippedWavePacketByteLength);
+            }
+            if (this.bytes) {
+                this.bytes.readData();
+            }
+            else {
+                this.stream.consume(skippedExtraByteLength);
+            }
+            this.first = false;
+        }
+    }
+}
+function createIntegerDecompressor(bits, contexts) {
+    const decompressor = new IntegerDecompressor(bits, contexts);
+    decompressor.init();
+    return decompressor;
+}
+function createModels(count, symbols) {
+    return Array.from({ length: count }, () => new ArithmeticModel(symbols));
+}
+function getExtraByteCount(metadata) {
+    const baseLength = getPointDataRecordBaseLength(metadata.pointDataRecordFormat);
+    const extraByteCount = metadata.pointDataRecordLength - baseLength;
+    if (extraByteCount < 0) {
+        throw new Error(`Invalid point record length ${metadata.pointDataRecordLength}`);
+    }
+    return extraByteCount;
+}
+function getPointDataRecordBaseLength(pointDataRecordFormat) {
+    switch (pointDataRecordFormat) {
+        case 0:
+            return 20;
+        case 1:
+            return 28;
+        case 2:
+            return 26;
+        case 3:
+            return 34;
+        case 4:
+            return 57;
+        case 5:
+            return 63;
+        case 6:
+            return 30;
+        case 7:
+            return 36;
+        case 8:
+            return 38;
+        case 9:
+            return 59;
+        case 10:
+            return 67;
+        default:
+            throw new Error(`TypeScript LAZ decoder does not support point format ${pointDataRecordFormat}`);
+    }
+}
+function hasLayeredChunkSizeHeaders(pointDataRecordFormat) {
+    return pointDataRecordFormat >= 6 && pointDataRecordFormat <= 10;
+}
+function getChunkSizeHeaderCount(pointDataRecordFormat, extraByteCount) {
+    switch (pointDataRecordFormat) {
+        case 6:
+            return 9 + extraByteCount;
+        case 7:
+            return 10 + extraByteCount;
+        case 8:
+            return 11 + extraByteCount;
+        case 9:
+            return 10 + extraByteCount;
+        case 10:
+            return 12 + extraByteCount;
+        default:
+            throw new Error(`TypeScript LAZ decoder does not support point format ${pointDataRecordFormat}`);
+    }
+}
+function createPoint14() {
+    return {
+        x: 0,
+        y: 0,
+        z: 0,
+        intensity: 0,
+        returns: 0,
+        flags: 0,
+        classification: 0,
+        userData: 0,
+        scanAngle: 0,
+        pointSourceId: 0,
+        gpsTime: 0
+    };
+}
+function createPoint10() {
+    return {
+        x: 0,
+        y: 0,
+        z: 0,
+        intensity: 0,
+        bitByte: 0,
+        classification: 0,
+        scanAngleRank: 0,
+        userData: 0,
+        pointSourceId: 0
+    };
+}
+/** Read one unaligned legacy core point directly into reusable predictor state. */
+function readPoint10FromStreamInto(point, stream) {
+    point.x = readInt32FromStream(stream);
+    point.y = readInt32FromStream(stream);
+    point.z = readInt32FromStream(stream);
+    point.intensity = readUint16FromStream(stream);
+    point.bitByte = stream.getByte();
+    point.classification = stream.getByte();
+    point.scanAngleRank = toInt8(stream.getByte());
+    point.userData = stream.getByte();
+    point.pointSourceId = readUint16FromStream(stream);
+}
+/** Copy legacy point predictor state in place without allocating an object. */
+function copyPoint10(target, source) {
+    target.x = source.x;
+    target.y = source.y;
+    target.z = source.z;
+    target.intensity = source.intensity;
+    target.bitByte = source.bitByte;
+    target.classification = source.classification;
+    target.scanAngleRank = source.scanAngleRank;
+    target.userData = source.userData;
+    target.pointSourceId = source.pointSourceId;
+}
+function writePoint10(point, bytes, offset) {
+    writeInt32(point.x, bytes, offset);
+    writeInt32(point.y, bytes, offset + 4);
+    writeInt32(point.z, bytes, offset + 8);
+    writeUint16(point.intensity, bytes, offset + 12);
+    bytes[offset + 14] = point.bitByte;
+    bytes[offset + 15] = point.classification;
+    bytes[offset + 16] = point.scanAngleRank & 0xff;
+    bytes[offset + 17] = point.userData;
+    writeUint16(point.pointSourceId, bytes, offset + 18);
+}
+/** Write common legacy point fields directly into caller-owned typed arrays. */
+function writePoint10ToPointDataArrays(point, positions, intensities, classifications, scale, offset, targetPointIndex) {
+    const positionOffset = targetPointIndex * 3;
+    positions[positionOffset] = point.x * scale[0] + offset[0];
+    positions[positionOffset + 1] = point.y * scale[1] + offset[1];
+    positions[positionOffset + 2] = point.z * scale[2] + offset[2];
+    if (intensities) {
+        intensities[targetPointIndex] = point.intensity;
+    }
+    if (classifications) {
+        classifications[targetPointIndex] = point.classification & 0x1f;
+    }
+}
+/** Write optional legacy point metadata into the columns represented by a decode target. */
+function writePoint10MetadataToPointDataTarget(point, target, targetPointIndex) {
+    const classificationFlags = point.classification >> 5;
+    if (target.syntheticFlags) {
+        target.syntheticFlags[targetPointIndex] = classificationFlags & 1;
+    }
+    if (target.keyPointFlags) {
+        target.keyPointFlags[targetPointIndex] = (classificationFlags >> 1) & 1;
+    }
+    if (target.withheldFlags) {
+        target.withheldFlags[targetPointIndex] = (classificationFlags >> 2) & 1;
+    }
+    if (target.overlapFlags) {
+        target.overlapFlags[targetPointIndex] = 0;
+    }
+    if (target.scanAngles) {
+        target.scanAngles[targetPointIndex] = point.scanAngleRank;
+    }
+    if (target.userData) {
+        target.userData[targetPointIndex] = point.userData;
+    }
+    if (target.pointSourceIds) {
+        target.pointSourceIds[targetPointIndex] = point.pointSourceId;
+    }
+    if (target.returnNumbers) {
+        target.returnNumbers[targetPointIndex] = point.bitByte & 0x07;
+    }
+    if (target.numberOfReturns) {
+        target.numberOfReturns[targetPointIndex] = (point.bitByte >> 3) & 0x07;
+    }
+    if (target.scannerChannels) {
+        target.scannerChannels[targetPointIndex] = 0;
+    }
+    if (target.scanDirectionFlags) {
+        target.scanDirectionFlags[targetPointIndex] = (point.bitByte >> 6) & 1;
+    }
+    if (target.edgeOfFlightLines) {
+        target.edgeOfFlightLines[targetPointIndex] = (point.bitByte >> 7) & 1;
+    }
+}
+function getPoint10ReturnNumber(point) {
+    return point.bitByte & 0x07;
+}
+function getPoint10NumberOfReturns(point) {
+    return (point.bitByte >> 3) & 0x07;
+}
+function getPoint10ScanDirectionFlag(point) {
+    return (point.bitByte >> 6) & 1;
+}
+function copyPoint14(target, source) {
+    target.x = source.x;
+    target.y = source.y;
+    target.z = source.z;
+    target.intensity = source.intensity;
+    target.returns = source.returns;
+    target.flags = source.flags;
+    target.classification = source.classification;
+    target.userData = source.userData;
+    target.scanAngle = source.scanAngle;
+    target.pointSourceId = source.pointSourceId;
+    target.gpsTime = source.gpsTime;
+}
+function readPoint14Into(point, bytes, offset) {
+    point.x = readInt32(bytes, offset);
+    point.y = readInt32(bytes, offset + 4);
+    point.z = readInt32(bytes, offset + 8);
+    point.intensity = readUint16(bytes, offset + 12);
+    point.returns = bytes[offset + 14];
+    point.flags = bytes[offset + 15];
+    point.classification = bytes[offset + 16];
+    point.userData = bytes[offset + 17];
+    point.scanAngle = readInt16(bytes, offset + 18);
+    point.pointSourceId = readUint16(bytes, offset + 20);
+    point.gpsTime = readFloat64(bytes, offset + 22);
+}
+function readPoint14FromStreamInto(point, stream) {
+    point.x = readInt32FromStream(stream);
+    point.y = readInt32FromStream(stream);
+    point.z = readInt32FromStream(stream);
+    point.intensity = readUint16FromStream(stream);
+    point.returns = stream.getByte();
+    point.flags = stream.getByte();
+    point.classification = stream.getByte();
+    point.userData = stream.getByte();
+    point.scanAngle = toInt16(readUint16FromStream(stream));
+    point.pointSourceId = readUint16FromStream(stream);
+    point.gpsTime = readFloat64FromStream(stream);
+}
+function writePoint14(point, bytes, offset) {
+    writeInt32(point.x, bytes, offset);
+    writeInt32(point.y, bytes, offset + 4);
+    writeInt32(point.z, bytes, offset + 8);
+    writeUint16(point.intensity, bytes, offset + 12);
+    bytes[offset + 14] = point.returns;
+    bytes[offset + 15] = point.flags;
+    bytes[offset + 16] = point.classification;
+    bytes[offset + 17] = point.userData;
+    writeInt16(point.scanAngle, bytes, offset + 18);
+    writeUint16(point.pointSourceId, bytes, offset + 20);
+    writeFloat64(point.gpsTime, bytes, offset + 22);
+}
+function writePoint14ToPointDataTarget(point, target, targetPointIndex) {
+    writePoint14ToPointDataArrays(point, target.positions, target.intensities, target.classifications, target.scale, target.offset, targetPointIndex);
+    writeGpsTimeToPointDataTarget(point, target, targetPointIndex);
+    writePoint14MetadataToPointDataTarget(point, target, targetPointIndex);
+}
+function writePoint14ToPointDataArrays(point, positions, intensities, classifications, scale, offset, targetPointIndex) {
+    const positionOffset = targetPointIndex * 3;
+    positions[positionOffset] = point.x * scale[0] + offset[0];
+    positions[positionOffset + 1] = point.y * scale[1] + offset[1];
+    positions[positionOffset + 2] = point.z * scale[2] + offset[2];
+    if (intensities) {
+        intensities[targetPointIndex] = point.intensity;
+    }
+    if (classifications) {
+        classifications[targetPointIndex] = point.classification;
+    }
+}
+function writeGpsTimeToPointDataTarget(point, target, targetPointIndex) {
+    if (target.gpsTimes) {
+        target.gpsTimes[targetPointIndex] = point.gpsTime;
+    }
+}
+function writePoint14MetadataToPointDataTarget(point, target, targetPointIndex) {
+    if (target.scanAngles) {
+        target.scanAngles[targetPointIndex] = point.scanAngle;
+    }
+    if (target.userData) {
+        target.userData[targetPointIndex] = point.userData;
+    }
+    if (target.pointSourceIds) {
+        target.pointSourceIds[targetPointIndex] = point.pointSourceId;
+    }
+    if (target.returnNumbers) {
+        target.returnNumbers[targetPointIndex] = point.returns & 0x0f;
+    }
+    if (target.numberOfReturns) {
+        target.numberOfReturns[targetPointIndex] = point.returns >> 4;
+    }
+    if (target.scannerChannels) {
+        target.scannerChannels[targetPointIndex] = (point.flags >> 4) & 0x03;
+    }
+    if (target.scanDirectionFlags) {
+        target.scanDirectionFlags[targetPointIndex] = (point.flags >> 6) & 1;
+    }
+    if (target.edgeOfFlightLines) {
+        target.edgeOfFlightLines[targetPointIndex] = (point.flags >> 7) & 1;
+    }
+    if (target.syntheticFlags) {
+        target.syntheticFlags[targetPointIndex] = point.flags & 1;
+    }
+    if (target.keyPointFlags) {
+        target.keyPointFlags[targetPointIndex] = (point.flags >> 1) & 1;
+    }
+    if (target.withheldFlags) {
+        target.withheldFlags[targetPointIndex] = (point.flags >> 2) & 1;
+    }
+    if (target.overlapFlags) {
+        target.overlapFlags[targetPointIndex] = (point.flags >> 3) & 1;
+    }
+}
+function writeNirToPointDataTarget(value, target, targetPointIndex) {
+    if (target.nir) {
+        target.nir[targetPointIndex] = value;
+    }
+}
+function writeRgbToPointDataTarget(red, green, blue, target, targetPointIndex) {
+    if (target.colors) {
+        const colorOffset = targetPointIndex * 4;
+        target.colors[colorOffset] = red & 0xff;
+        target.colors[colorOffset + 1] = green & 0xff;
+        target.colors[colorOffset + 2] = blue & 0xff;
+        target.colors[colorOffset + 3] = 255;
+        return;
+    }
+    if (!target.rawColors) {
+        return;
+    }
+    const colorOffset = targetPointIndex * 3;
+    target.rawColors[colorOffset] = red;
+    target.rawColors[colorOffset + 1] = green;
+    target.rawColors[colorOffset + 2] = blue;
+}
+function getScannerChannel(point) {
+    return (point.flags >> 4) & 0x03;
+}
+function setScannerChannel(point, scannerChannel) {
+    point.flags = ((scannerChannel & 0x03) << 4) | (point.flags & ~0x30);
+}
+function setClassFlags(point, flags) {
+    point.flags = (flags & 0x0f) | (point.flags & 0xf0);
+}
+function setScanDirectionFlag(point, flag) {
+    point.flags = ((flag & 1) << 6) | (point.flags & 0xbf);
+}
+function setEdgeOfFlightLine(point, flag) {
+    point.flags = ((flag & 1) << 7) | (point.flags & 0x7f);
+}
+function mergeFlags(point) {
+    return (point.flags & 0x0f) | (((point.flags >> 6) & 1) << 4) | (((point.flags >> 7) & 1) << 5);
+}
+function readUint16(bytes, offset) {
+    return bytes[offset] | (bytes[offset + 1] << 8);
+}
+/** Read an unaligned little-endian unsigned 16-bit integer without allocating a DataView. */
+function readUint16FromStream(stream) {
+    const b0 = stream.getByte();
+    const b1 = stream.getByte();
+    return b0 | (b1 << 8);
+}
+function writeUint16(value, bytes, offset) {
+    bytes[offset] = value & 0xff;
+    bytes[offset + 1] = (value >> 8) & 0xff;
+}
+function readInt16(bytes, offset) {
+    return toInt16(readUint16(bytes, offset));
+}
+function writeInt16(value, bytes, offset) {
+    writeUint16(value, bytes, offset);
+}
+/** Read an unaligned little-endian unsigned 32-bit integer. */
+function readUint32(bytes, offset) {
+    return ((bytes[offset] |
+        (bytes[offset + 1] << 8) |
+        (bytes[offset + 2] << 16) |
+        ((bytes[offset + 3] << 24) >>> 0)) >>>
+        0);
+}
+/** Write an unaligned little-endian unsigned 32-bit integer. */
+function writeUint32(value, bytes, offset) {
+    writeInt32(value, bytes, offset);
+}
+/** Read an unaligned little-endian unsigned 64-bit integer without precision loss. */
+function readBigUint64(bytes, offset) {
+    const lower = readUint32(bytes, offset);
+    const upper = readUint32(bytes, offset + 4);
+    return (BigInt(upper) << 32n) | BigInt(lower);
+}
+/** Write an unaligned little-endian unsigned 64-bit integer without precision loss. */
+function writeBigUint64(value, bytes, offset) {
+    writeUint32(Number(value & 0xffffffffn), bytes, offset);
+    writeUint32(Number((value >> 32n) & 0xffffffffn), bytes, offset + 4);
+}
+function readInt32(bytes, offset) {
+    return (bytes[offset] | (bytes[offset + 1] << 8) | (bytes[offset + 2] << 16) | (bytes[offset + 3] << 24));
+}
+/** Read an unaligned little-endian signed 32-bit integer without allocating a DataView. */
+function readInt32FromStream(stream) {
+    const b0 = stream.getByte();
+    const b1 = stream.getByte();
+    const b2 = stream.getByte();
+    const b3 = stream.getByte();
+    return b0 | (b1 << 8) | (b2 << 16) | (b3 << 24);
+}
+function writeInt32(value, bytes, offset) {
+    bytes[offset] = value & 0xff;
+    bytes[offset + 1] = (value >> 8) & 0xff;
+    bytes[offset + 2] = (value >> 16) & 0xff;
+    bytes[offset + 3] = (value >> 24) & 0xff;
+}
+function readFloat64(bytes, offset) {
+    for (let index = 0; index < 8; index++) {
+        FLOAT64_SCRATCH_BYTES[index] = bytes[offset + index];
+    }
+    return FLOAT64_SCRATCH_VIEW.getFloat64(0, true);
+}
+/** Read an unaligned little-endian float64 through the shared aligned scratch view. */
+function readFloat64FromStream(stream) {
+    for (let index = 0; index < 8; index++) {
+        FLOAT64_SCRATCH_BYTES[index] = stream.getByte();
+    }
+    return FLOAT64_SCRATCH_VIEW.getFloat64(0, true);
+}
+function writeFloat64(value, bytes, offset) {
+    FLOAT64_SCRATCH_VIEW.setFloat64(0, value, true);
+    for (let index = 0; index < 8; index++) {
+        bytes[offset + index] = FLOAT64_SCRATCH_BYTES[index];
+    }
+}
+function clampUint8(value) {
+    return value <= 0 ? 0 : value >= 255 ? 255 : value;
+}
+function toInt16(value) {
+    const uint16 = value & 0xffff;
+    return uint16 & 0x8000 ? uint16 - 0x10000 : uint16;
+}
+function toInt8(value) {
+    const uint8 = value & 0xff;
+    return uint8 & 0x80 ? uint8 - 0x100 : uint8;
+}
+function toInt32(value) {
+    return value | 0;
+}
+function float64ToBigUint64(value) {
+    FLOAT64_SCRATCH_VIEW.setFloat64(0, value, true);
+    return FLOAT64_SCRATCH_VIEW.getBigUint64(0, true);
+}
+function bigUint64ToFloat64(value) {
+    FLOAT64_SCRATCH_VIEW.setBigUint64(0, value, true);
+    return FLOAT64_SCRATCH_VIEW.getFloat64(0, true);
+}
+function addInt32ToFloat64Bits(value, diff) {
+    const bits = BigInt.asIntN(64, BigInt.asIntN(64, float64ToBigUint64(value)) + BigInt(diff));
+    return bigUint64ToFloat64(BigInt.asUintN(64, bits));
+}
+function toUint8Array(arrayBuffer) {
+    if (arrayBuffer instanceof ArrayBuffer) {
+        return new Uint8Array(arrayBuffer);
+    }
+    return new Uint8Array(arrayBuffer.buffer, arrayBuffer.byteOffset, arrayBuffer.byteLength);
+}
+function concatenateUint8Arrays(chunks) {
+    const byteLength = chunks.reduce((total, chunk) => total + chunk.byteLength, 0);
+    const result = new Uint8Array(byteLength);
+    let offset = 0;
+    for (const chunk of chunks) {
+        result.set(chunk, offset);
+        offset += chunk.byteLength;
+    }
+    return result;
+}
+//# sourceMappingURL=laz-chunk-decoder.js.map