las-laz-js 0.1.0 → 0.2.0

package/src/laz/chunkTable.js

@@ -0,0 +1,109 @@
+// src/laz/chunkTable.js
+//==========================================================
+// Where each compressed chunk lives. A chunked LAZ file starts its
+// point data with an i64 offset to the chunk table (written last, so
+// a streaming writer leaves -1 there and repeats the offset in the
+// file's final 8 bytes). The table is u32 version, u32 chunk count,
+// then each chunk's byte count (and, for variable-size chunks, its
+// point count), arithmetic-coded as integers predicted from the
+// previous chunk. Chunk 0 starts right after the 8-byte offset.
+// A point-wise (unchunked) file is one chunk running to the end.
+//
+// From laz-rs src/laszip/chunk_table.rs (https://github.com/laz-rs/laz-rs),
+// itself from LASzip by rapidlasso. (c) 2007-2015 martin isenburg,
+// rapidlasso; (c) 2019-2023 Thomas Montaigu.
+// Licensed under the Apache License, Version 2.0 (see LICENSE-APACHE and
+// NOTICE). Changes: written
+// in JavaScript over an async byte source, Brent Buffham 2026.
+//==========================================================
+
+import { LasError, ERROR_CODES } from "../errors.js";
+import { ArithmeticDecoder } from "./ArithmeticDecoder.js";
+import { IntegerDecompressor } from "./IntegerDecompressor.js";
+import { COMPRESSOR } from "./LazVlr.js";
+
+// Signed i64 at `at` as a Number (an offset; > 2^53 is refused)
+function i64(bytes, at) {
+	var v = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+	var lo = v.getUint32(at, true), hi = v.getInt32(at + 4, true);
+	if (hi > 2097151 || hi < -2097152) throw new LasError(ERROR_CODES.BAD_HEADER, "LAZ chunk table offset is out of range", at);
+	return hi * 4294967296 + lo;
+}
+
+/**
+ * Decode the chunk table body.
+ * @param {Uint8Array} bytes - from the table's start to the end of the file
+ * @param {boolean} withPointCounts - variable-size chunks
+ * @param {number} [base] - file offset of bytes[0], for error offsets
+ * @returns {Array<{pointCount:number, byteCount:number}>}
+ */
+export function decodeChunkTable(bytes, withPointCounts, base) {
+	if (bytes.length < 8) throw new LasError(ERROR_CODES.TRUNCATED, "the LAZ chunk table is cut short");
+	var v = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+	var n = v.getUint32(4, true);
+	var out = [];
+	if (!n) return out;
+	var dec = new ArithmeticDecoder(bytes, 8, bytes.length, base);
+	dec.readInitBytes();
+	var ic = new IntegerDecompressor(32, 2);
+	var prevPoints = 0, prevBytes = 0;
+	for (var i = 0; i < n; i++) {
+		var points = withPointCounts ? ic.decompress(dec, prevPoints, 0) : 0;
+		var size = ic.decompress(dec, prevBytes, 1);
+		// coded as i32 predictions of u32 counts: the i32 is the prediction, the u32 the count
+		prevPoints = points; prevBytes = size;
+		out.push({ pointCount: points < 0 ? points + 4294967296 : points, byteCount: size < 0 ? size + 4294967296 : size });
+	}
+	return out;
+}
+
+/**
+ * Every chunk of a LAZ file: its first record, point count and byte range.
+ * @param {{size:number, read:function(number, number): Promise<Uint8Array>}} src
+ * @param {object} header - parseHeader (offsetToPointData, pointCount, evlrStart)
+ * @param {object} vlr - parseLazVlr
+ * @returns {Promise<Array<{firstRecord:number, count:number, start:number, end:number}>>}
+ */
+export async function readChunks(src, header, vlr) {
+	var dataStart = header.offsetToPointData;
+	var total = header.pointCount;
+	if (vlr.compressor === COMPRESSOR.POINTWISE) {
+		var stop = header.evlrStart > dataStart && header.evlrStart <= src.size ? header.evlrStart : src.size;
+		return total ? [{ firstRecord: 0, count: total, start: dataStart, end: stop }] : [];
+	}
+	if (vlr.compressor !== COMPRESSOR.POINTWISE_CHUNKED && vlr.compressor !== COMPRESSOR.LAYERED_CHUNKED) {
+		throw new LasError(ERROR_CODES.UNSUPPORTED, "LAZ compressor " + vlr.compressor + " is not one LASzip defines (1-3)");
+	}
+	if (dataStart + 8 > src.size) throw new LasError(ERROR_CODES.TRUNCATED, "the LAZ point data is cut short", src.size);
+	var tableAt = i64(await src.read(dataStart, dataStart + 8), 0);
+	if (tableAt <= dataStart) {
+		tableAt = i64(await src.read(src.size - 8, src.size), 0);   // streaming writers repeat it last
+		if (tableAt <= dataStart || tableAt >= src.size) {
+			throw new LasError(ERROR_CODES.UNSUPPORTED, "this LAZ file has no chunk table (an unfinished write?); it cannot be read in windows");
+		}
+	} else if (tableAt >= src.size) {
+		throw new LasError(ERROR_CODES.TRUNCATED, "the LAZ chunk table should be at byte " + tableAt + " but the file is " + src.size + " bytes (cut short?)", src.size);
+	}
+	// Read only the table: EVLRs (which can be huge) may follow it. Each coded entry
+	// is two integers of at most ~6 bytes each; 24 bytes per chunk is a safe ceiling.
+	var head = await src.read(tableAt, Math.min(src.size, tableAt + 8));
+	var nChunks = head.length === 8 ? new DataView(head.buffer, head.byteOffset, 8).getUint32(4, true) : 0;
+	var table = decodeChunkTable(await src.read(tableAt, Math.min(src.size, tableAt + 8 + nChunks * 24 + 16)), vlr.variableChunks, tableAt);
+	var chunks = [], at = dataStart + 8, first = 0;
+	for (var i = 0; i < table.length && first < total; i++) {
+		var count = vlr.variableChunks ? table[i].pointCount : Math.min(vlr.chunkSize, total - first);
+		var end = at + table[i].byteCount;
+		if (end > tableAt) throw new LasError(ERROR_CODES.BAD_HEADER, "LAZ chunk " + i + " runs into the chunk table", at);
+		chunks.push({ firstRecord: first, count: count, start: at, end: end });
+		first += count;
+		at = end;
+	}
+	if (vlr.variableChunks) {
+		// counts come from the table: they must add up to the header's, or a corrupt count
+		// would decode past the header's points (or size a huge buffer)
+		var listed = table.reduce(function (s, e) { return s + e.pointCount; }, 0);
+		if (listed !== total) throw new LasError(ERROR_CODES.BAD_HEADER, "the LAZ chunk table lists " + listed + " points but the header says " + total, tableAt);
+	}
+	if (first < total) throw new LasError(ERROR_CODES.TRUNCATED, "the LAZ chunk table covers " + first + " of " + total + " points", tableAt);
+	return chunks;
+}

package/src/laz/decompressChunk.js

@@ -0,0 +1,115 @@
+// src/laz/decompressChunk.js
+//==========================================================
+// One LAZ chunk -> the raw LAS records it holds, written into the
+// caller's buffer exactly as a LAS file stores them, so the rest of
+// the library (decodeRecords, filters, columns) reads LAZ and LAS the
+// same way. Each chunk is independent: fresh item decompressors, the
+// first record stored raw, then one arithmetic stream for the rest.
+//
+// Item dispatch after laz-rs src/record.rs and src/laszip/details.rs
+// (https://github.com/laz-rs/laz-rs), itself from LASzip by rapidlasso.
+// (c) 2007-2015 martin isenburg, rapidlasso; (c) 2019-2023 Thomas Montaigu.
+// Licensed under the Apache License, Version 2.0 (see LICENSE-APACHE and
+// NOTICE). Changes: written in JavaScript over byte buffers, Brent Buffham 2026.
+//==========================================================
+
+import { LasError, ERROR_CODES } from "../errors.js";
+import { ArithmeticDecoder } from "./ArithmeticDecoder.js";
+import { ITEM, COMPRESSOR } from "./LazVlr.js";
+import { Point10Decompressor } from "./v2/point10.js";
+import { GpsTime11Decompressor } from "./v2/gpstime11.js";
+import { Rgb12Decompressor } from "./v2/rgb12.js";
+import { ByteDecompressor } from "./v2/byte.js";
+import { Point14Decompressor } from "./v3/point14.js";
+import { Rgb14Decompressor, Nir14Decompressor, Byte14Decompressor } from "./v3/layered.js";
+
+var NAMES = { 0: "Byte", 6: "Point10", 7: "GpsTime11", 8: "RGB12", 9: "WavePacket13", 10: "Point14", 11: "RGB14", 12: "RGBNIR14", 13: "WavePacket14", 14: "Byte14" };
+
+function pointwiseItem(it) {
+	if (it.version !== 2 && !(it.type === ITEM.BYTE && it.version === 1)) {
+		throw new LasError(ERROR_CODES.UNSUPPORTED, "LAZ item " + (NAMES[it.type] || it.type) + " version " + it.version + " is not supported (version 2 is; version 1 is from LASzip before 2011)");
+	}
+	switch (it.type) {
+		case ITEM.POINT10: return function () { return new Point10Decompressor(); };
+		case ITEM.GPSTIME11: return function () { return new GpsTime11Decompressor(); };
+		case ITEM.RGB12: return function () { return new Rgb12Decompressor(); };
+		case ITEM.BYTE: return function () { return new ByteDecompressor(it.size); };
+		default: throw new LasError(ERROR_CODES.UNSUPPORTED, "LAZ item " + (NAMES[it.type] || it.type) + " is not supported (wave packets are not read)");
+	}
+}
+
+// Layered (LAS 1.4) items, versions 3 and 4: each makes one or more field decoders
+function layeredItem(it) {
+	if (it.version !== 3 && it.version !== 4) {
+		throw new LasError(ERROR_CODES.UNSUPPORTED, "LAZ item " + (NAMES[it.type] || it.type) + " version " + it.version + " is not supported in a layered file (versions 3 and 4 are)");
+	}
+	var v = it.version;
+	switch (it.type) {
+		case ITEM.POINT14: return function () { return [new Point14Decompressor(v)]; };
+		case ITEM.RGB14: return function () { return [new Rgb14Decompressor(v)]; };
+		case ITEM.RGBNIR14: return function () { return [new Rgb14Decompressor(v), new Nir14Decompressor(v)]; };
+		case ITEM.BYTE14: return function () { return [new Byte14Decompressor(it.size, v)]; };
+		default: throw new LasError(ERROR_CODES.UNSUPPORTED, "LAZ item " + (NAMES[it.type] || it.type) + " is not supported (wave packets are not read)");
+	}
+}
+
+function cutShortAt(base) { return function (at) { throw new LasError(ERROR_CODES.TRUNCATED, "a LAZ chunk is cut short", base + at); }; }
+
+// A layered chunk: the first record raw, a u32 point count, every field's
+// layer sizes, then the layers; each later point is decoded field by field,
+// Point14 passing the scanner channel on to the fields after it.
+function layeredChunk(makers, recordLength, layerWords) {
+	return function decodeChunk(bytes, s, e, count, view, o, base) {
+		if (!count) return;
+		base = base || 0;
+		var cutShort = cutShortAt(base);
+		var fields = [];
+		makers.forEach(function (make) { fields.push.apply(fields, make()); });
+		var ctx = { v: 0 }, p = s, k;
+		if (p + recordLength > e) cutShort(p);
+		for (k = 0; k < fields.length; k++) { fields[k].first(bytes, p, view, o, ctx); p += fields[k].size; o += fields[k].size; }
+		if (count === 1) return;
+		if (p + 4 + layerWords * 4 > e) cutShort(p);
+		var dv = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+		p += 4;                                                    // the chunk's point count (the table already has it)
+		for (k = 0; k < fields.length; k++) p = fields[k].readLayerSizes(dv, p);
+		for (k = 0; k < fields.length; k++) p = fields[k].readLayers(bytes, p, e, cutShort, base);
+		for (var i = 1; i < count; i++) {
+			ctx.v = 0;
+			for (k = 0; k < fields.length; k++) { fields[k].next(view, o, ctx); o += fields[k].size; }
+		}
+	};
+}
+
+/**
+ * Check a LASzip VLR against the file and build the chunk decoder.
+ * @param {object} vlr - parseLazVlr
+ * @param {number} recordLength - header record length
+ * @returns {function(Uint8Array, number, number, number, DataView, number): void}
+ *   decode(bytes, start, end, count, outView, outOffset, base) — one chunk's records into outView;
+ *   base is the file offset of bytes[0], for error offsets
+ */
+export function createChunkDecoder(vlr, recordLength) {
+	var size = vlr.items.reduce(function (s, it) { return s + it.size; }, 0);
+	if (size !== recordLength) throw new LasError(ERROR_CODES.BAD_VLR, "the LASzip items make " + size + "-byte records but the header says " + recordLength);
+	if (vlr.coder !== 0) throw new LasError(ERROR_CODES.UNSUPPORTED, "LAZ coder " + vlr.coder + " (only the arithmetic coder, 0, exists)");
+	if (vlr.compressor === COMPRESSOR.LAYERED_CHUNKED) {
+		var words = vlr.items.reduce(function (s, it) { return s + (it.type === ITEM.POINT14 ? 9 : it.type === ITEM.RGBNIR14 ? 2 : it.type === ITEM.BYTE14 ? it.size : 1); }, 0);
+		return layeredChunk(vlr.items.map(layeredItem), recordLength, words);
+	}
+	var makers = vlr.items.map(pointwiseItem);
+	return function decodeChunk(bytes, s, e, count, view, o, base) {
+		if (!count) return;
+		base = base || 0;
+		var items = makers.map(function (make) { return make(); });
+		var k, p = s;
+		if (p + recordLength > e) throw new LasError(ERROR_CODES.TRUNCATED, "a LAZ chunk is shorter than one record", base + p);
+		for (k = 0; k < items.length; k++) { items[k].first(bytes, p, view, o); p += items[k].size; o += items[k].size; }
+		if (count === 1) return;
+		var dec = new ArithmeticDecoder(bytes, p, e, base);
+		dec.readInitBytes();
+		for (var i = 1; i < count; i++) {
+			for (k = 0; k < items.length; k++) { items[k].next(dec, view, o); o += items[k].size; }
+		}
+	};
+}

package/src/laz/models.js

@@ -0,0 +1,102 @@
+// src/laz/models.js
+//==========================================================
+// Adaptive probability models for the LASzip arithmetic coder: a
+// multi-symbol model (with a decoder look-up table above 16 symbols)
+// and a binary model. Both re-estimate their probabilities on a
+// growing update cycle, exactly as the encoder did, so encoder and
+// decoder stay in step symbol for symbol.
+//
+// Ported from laz-rs src/models.rs (https://github.com/laz-rs/laz-rs),
+// itself a port of LASzip by rapidlasso. (c) 2007-2014 martin isenburg,
+// rapidlasso; (c) 2014 Uday Verma, Hobu, Inc.; (c) 2019 Thomas Montaigu.
+// Licensed under the Apache License, Version 2.0 (see LICENSE-APACHE and
+// NOTICE). Changes: translated from Rust to JavaScript, Brent Buffham 2026.
+// All values are u32 held in Numbers; every product stays below 2^32.
+//==========================================================
+
+import { LasError, ERROR_CODES } from "../errors.js";
+
+export var DM_LENGTH_SHIFT = 15;
+var DM_MAX_COUNT = 32768;          // 1 << DM_LENGTH_SHIFT
+export var BM_LENGTH_SHIFT = 13;
+var BM_MAX_COUNT = 8192;           // 1 << BM_LENGTH_SHIFT
+
+/**
+ * Adaptive model over `symbols` symbols (2..2048).
+ * @param {number} symbols
+ * @param {Uint32Array|number[]} [initTable] - starting counts (default 1 each)
+ */
+export function ArithmeticModel(symbols, initTable) {
+	if (!(symbols >= 2 && symbols <= 2048)) throw new LasError(ERROR_CODES.UNSUPPORTED, "LAZ model with " + symbols + " symbols (2-2048)");
+	this.symbols = symbols;
+	this.lastSymbol = symbols - 1;
+	this.tableSize = 0;
+	this.tableShift = 0;
+	this.decoderTable = null;
+	if (symbols > 16) {
+		var tableBits = 3;
+		while (symbols > Math.pow(2, tableBits + 2)) tableBits++;
+		this.tableSize = Math.pow(2, tableBits);
+		this.tableShift = DM_LENGTH_SHIFT - tableBits;
+		this.decoderTable = new Uint32Array(this.tableSize + 2);
+	}
+	this.distribution = new Uint32Array(symbols);
+	this.symbolCount = new Uint32Array(symbols);
+	for (var k = 0; k < symbols; k++) this.symbolCount[k] = initTable ? initTable[k] : 1;
+	this.totalCount = 0;
+	this.updateCycle = symbols;
+	this.symbolsUntilUpdate = 0;
+	this.update();
+	this.symbolsUntilUpdate = this.updateCycle = (symbols + 6) >>> 1;
+}
+
+/** Re-estimate the distribution from the counts (and rebuild the decoder table). */
+ArithmeticModel.prototype.update = function () {
+	var counts = this.symbolCount, dist = this.distribution, n = this.symbols, k;
+	this.totalCount += this.updateCycle;
+	if (this.totalCount > DM_MAX_COUNT) {
+		this.totalCount = 0;
+		for (k = 0; k < n; k++) { counts[k] = (counts[k] + 1) >>> 1; this.totalCount += counts[k]; }
+	}
+	var sum = 0, scale = Math.floor(0x80000000 / this.totalCount);
+	if (!this.decoderTable) {
+		for (k = 0; k < n; k++) { dist[k] = (scale * sum) >>> 16; sum += counts[k]; }   // >> (31 - DM_LENGTH_SHIFT)
+	} else {
+		var table = this.decoderTable, shift = this.tableShift, s = 0;
+		for (k = 0; k < n; k++) {
+			dist[k] = (scale * sum) >>> 16;
+			sum += counts[k];
+			var w = dist[k] >>> shift;
+			while (s < w) { s++; table[s] = k - 1; }
+		}
+		table[0] = 0;
+		while (s <= this.tableSize) { s++; table[s] = n - 1; }
+	}
+	this.updateCycle = (5 * this.updateCycle) >>> 2;
+	var maxCycle = (n + 6) * 8;
+	if (this.updateCycle > maxCycle) this.updateCycle = maxCycle;
+	this.symbolsUntilUpdate = this.updateCycle;
+};
+
+/** Adaptive binary model. */
+export function ArithmeticBitModel() {
+	this.bit0Count = 1;
+	this.bitCount = 2;
+	this.bit0Prob = 4096;            // 1 << (BM_LENGTH_SHIFT - 1)
+	this.bitsUntilUpdate = 4;
+	this.updateCycle = 4;
+}
+
+ArithmeticBitModel.prototype.update = function () {
+	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++;
+	}
+	var scale = Math.floor(0x80000000 / this.bitCount);
+	this.bit0Prob = (this.bit0Count * scale) >>> 18;   // >> (31 - BM_LENGTH_SHIFT)
+	this.updateCycle = (5 * this.updateCycle) >>> 2;
+	if (this.updateCycle > 64) this.updateCycle = 64;
+	this.bitsUntilUpdate = this.updateCycle;
+};

package/src/laz/v2/byte.js

@@ -0,0 +1,33 @@
+// src/laz/v2/byte.js
+//==========================================================
+// LASzip Byte item, versions 1 and 2 (the same coder): extra bytes
+// after the standard fields, each coded as a byte difference from the
+// same byte of the last point, one model per byte.
+//
+// Ported from laz-rs src/las/extra_bytes.rs, module v1 (https://github.com/laz-rs/laz-rs),
+// itself a port of LASzip by rapidlasso. (c) 2007-2014 martin isenburg,
+// rapidlasso; (c) 2014 Uday Verma, Hobu, Inc.; (c) 2019 Thomas Montaigu.
+// Licensed under the Apache License, Version 2.0 (see LICENSE-APACHE and
+// NOTICE). Changes: translated from Rust to JavaScript, Brent Buffham 2026.
+//==========================================================
+
+import { ArithmeticModel } from "../models.js";
+
+/** Byte v2 decompressor for `count` extra bytes: one per chunk. */
+export function ByteDecompressor(count) {
+	this.size = count;
+	this.last = new Uint8Array(count);
+	this.models = [];
+	for (var i = 0; i < count; i++) this.models.push(new ArithmeticModel(256));
+}
+
+ByteDecompressor.prototype.first = function (src, s, view, o) {
+	for (var i = 0; i < this.size; i++) { this.last[i] = src[s + i]; view.setUint8(o + i, src[s + i]); }
+};
+
+ByteDecompressor.prototype.next = function (dec, view, o) {
+	for (var i = 0; i < this.size; i++) {
+		this.last[i] = (this.last[i] + dec.decodeSymbol(this.models[i])) & 255;
+		view.setUint8(o + i, this.last[i]);
+	}
+};

package/src/laz/v2/gpstime11.js

@@ -0,0 +1,118 @@
+// src/laz/v2/gpstime11.js
+//==========================================================
+// LASzip GpsTime11 item, version 2: the 8-byte GPS time, coded as its
+// raw 64-bit pattern. Up to four time sequences are tracked; each
+// point is "same time", a multiple of the last difference (with a
+// correction), a jump to another tracked sequence, or a full new time.
+// The 64-bit value is held as two 32-bit halves (hi signed, lo
+// unsigned) with explicit carry, never as a float.
+//
+// Ported from laz-rs src/las/gps.rs, module v2 (https://github.com/laz-rs/laz-rs),
+// itself a port of LASzip by rapidlasso. (c) 2007-2014 martin isenburg,
+// rapidlasso; (c) 2014 Uday Verma, Hobu, Inc.; (c) 2019 Thomas Montaigu.
+// Licensed under the Apache License, Version 2.0 (see LICENSE-APACHE and
+// NOTICE). Changes: translated from Rust to JavaScript, i64 as two u32
+// halves, Brent Buffham 2026.
+//==========================================================
+
+import { ArithmeticModel } from "../models.js";
+import { IntegerDecompressor } from "../IntegerDecompressor.js";
+
+var LE = true;
+var MULTI = 500, MULTI_MINUS = -10;
+var MULTI_UNCHANGED = MULTI - MULTI_MINUS + 1;   // 511
+var MULTI_CODE_FULL = MULTI - MULTI_MINUS + 2;   // 512
+var MULTI_TOTAL = MULTI - MULTI_MINUS + 6;       // 516
+
+/** GpsTime11 v2 decompressor: one per chunk. */
+export function GpsTime11Decompressor() {
+	this.size = 8;
+	this.multiModel = new ArithmeticModel(MULTI_TOTAL);
+	this.zeroDiffModel = new ArithmeticModel(6);
+	this.ic = new IntegerDecompressor(32, 9);
+	this.last = 0;
+	this.nextSeq = 0;
+	this.hi = new Int32Array(4);
+	this.lo = new Float64Array(4);              // u32 values, held exactly
+	this.diffs = new Int32Array(4);
+	this.extremes = new Int32Array(4);
+}
+
+GpsTime11Decompressor.prototype._add = function (i, d) {
+	var lo = this.lo[i] + d;
+	if (lo >= 4294967296) { lo -= 4294967296; this.hi[i] = (this.hi[i] + 1) | 0; }
+	else if (lo < 0) { lo += 4294967296; this.hi[i] = (this.hi[i] - 1) | 0; }
+	this.lo[i] = lo;
+};
+
+GpsTime11Decompressor.prototype._full = function (dec) {
+	this.nextSeq = (this.nextSeq + 1) & 3;
+	this.hi[this.nextSeq] = this.ic.decompress(dec, this.hi[this.last], 8);
+	this.lo[this.nextSeq] = dec.readInt();
+	this.last = this.nextSeq;
+	this.diffs[this.last] = 0;
+	this.extremes[this.last] = 0;
+};
+
+// After three extreme differences in a row, the latest becomes the new reference
+GpsTime11Decompressor.prototype._extreme = function (d) {
+	if (++this.extremes[this.last] > 3) { this.diffs[this.last] = d; this.extremes[this.last] = 0; }
+};
+
+GpsTime11Decompressor.prototype.first = function (src, s, view, o) {
+	for (var i = 0; i < 8; i++) view.setUint8(o + i, src[s + i]);
+	this.lo[0] = view.getUint32(o, LE);
+	this.hi[0] = view.getInt32(o + 4, LE);
+};
+
+GpsTime11Decompressor.prototype.next = function (dec, view, o) {
+	for (;;) {
+		var L = this.last, multi, d;
+		if (this.diffs[L] === 0) {
+			multi = dec.decodeSymbol(this.zeroDiffModel);
+			if (multi === 1) {
+				this.diffs[L] = this.ic.decompress(dec, 0, 0);
+				this._add(L, this.diffs[L]);
+				this.extremes[L] = 0;
+			} else if (multi === 2) {
+				this._full(dec);
+			} else if (multi > 2) {
+				this.last = (L + multi - 2) & 3;
+				continue;                            // laz-rs recurses: decode again from the new sequence
+			}
+		} else {
+			multi = dec.decodeSymbol(this.multiModel);
+			if (multi === 1) {
+				this._add(L, this.ic.decompress(dec, this.diffs[L], 1));
+				this.extremes[L] = 0;
+			} else if (multi < MULTI_UNCHANGED) {
+				if (multi === 0) {
+					d = this.ic.decompress(dec, 0, 7);
+					this._extreme(d);
+				} else if (multi < MULTI) {
+					d = this.ic.decompress(dec, Math.imul(multi, this.diffs[L]), multi < 10 ? 2 : 3);
+				} else if (multi === MULTI) {
+					d = this.ic.decompress(dec, Math.imul(MULTI, this.diffs[L]), 4);
+					this._extreme(d);
+				} else {
+					multi = MULTI - multi;
+					if (multi > MULTI_MINUS) {
+						d = this.ic.decompress(dec, Math.imul(multi, this.diffs[L]), 5);
+					} else {
+						d = this.ic.decompress(dec, Math.imul(MULTI_MINUS, this.diffs[L]), 6);
+						this._extreme(d);
+					}
+				}
+				this._add(L, d);
+			} else if (multi === MULTI_CODE_FULL) {
+				this._full(dec);
+			} else if (multi > MULTI_CODE_FULL) {
+				this.last = (L + multi - MULTI_CODE_FULL) & 3;
+				continue;
+			}
+		}
+		break;
+	}
+	view.setUint32(o, this.lo[this.last], LE);
+	view.setInt32(o + 4, this.hi[this.last], LE);
+};

package/src/laz/v2/point10.js

@@ -0,0 +1,139 @@
+// src/laz/v2/point10.js
+//==========================================================
+// LASzip Point10 item, version 2: the 20 bytes every legacy record
+// (formats 0-5) starts with. Each point codes which attributes changed
+// since the last one; X and Y are corrections to a streaming median
+// of the recent differences, Z to the last height at the same return
+// level, all through integer decompressors whose contexts follow the
+// return structure.
+//
+// Ported from laz-rs src/las/point0.rs, module v2, and the median and
+// return tables of src/las/utils.rs (https://github.com/laz-rs/laz-rs),
+// itself a port of LASzip by rapidlasso. (c) 2007-2014 martin isenburg,
+// rapidlasso; (c) 2014 Uday Verma, Hobu, Inc.; (c) 2019 Thomas Montaigu.
+// Licensed under the Apache License, Version 2.0 (see LICENSE-APACHE and
+// NOTICE). Changes: translated from Rust to JavaScript, working on raw
+// record bytes, Brent Buffham 2026.
+//==========================================================
+
+import { ArithmeticModel } from "../models.js";
+import { IntegerDecompressor } from "../IntegerDecompressor.js";
+
+var LE = true;
+
+/** NUMBER_RETURN_MAP[numberOfReturns][returnNumber] (LASzip). */
+export var NUMBER_RETURN_MAP = [
+	[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]
+];
+/** NUMBER_RETURN_LEVEL[numberOfReturns][returnNumber] (LASzip). */
+export var NUMBER_RETURN_LEVEL = [
+	[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]
+];
+
+/** Median of the last five values, updated in O(1) (LASzip StreamingMedian5). */
+export function StreamingMedian() { this.v = new Int32Array(5); this.high = true; }
+StreamingMedian.prototype.get = function () { return this.v[2]; };
+StreamingMedian.prototype.add = function (x) {
+	var v = this.v;
+	if (this.high) {
+		if (x < v[2]) {
+			v[4] = v[3]; v[3] = v[2];
+			if (x < v[0]) { v[2] = v[1]; v[1] = v[0]; v[0] = x; }
+			else if (x < v[1]) { v[2] = v[1]; v[1] = x; }
+			else v[2] = x;
+		} else {
+			if (x < v[3]) { v[4] = v[3]; v[3] = x; } else v[4] = x;
+			this.high = false;
+		}
+	} else {
+		if (v[2] < x) {
+			v[0] = v[1]; v[1] = v[2];
+			if (v[4] < x) { v[2] = v[3]; v[3] = v[4]; v[4] = x; }
+			else if (v[3] < x) { v[2] = v[3]; v[3] = x; }
+			else v[2] = x;
+		} else {
+			if (v[1] < x) { v[0] = v[1]; v[1] = x; } else v[0] = x;
+			this.high = true;
+		}
+	}
+};
+
+function models(n, symbols) { var out = []; for (var i = 0; i < n; i++) out.push(new ArithmeticModel(symbols)); return out; }
+function medians() { var out = []; for (var i = 0; i < 16; i++) out.push(new StreamingMedian()); return out; }
+
+/** Point10 v2 decompressor: one per chunk. */
+export function Point10Decompressor() {
+	this.size = 20;
+	this.lastIntensity = new Uint16Array(16);
+	this.xMedian = medians();
+	this.yMedian = medians();
+	this.lastHeight = new Int32Array(8);
+	this.changedValues = new ArithmeticModel(64);
+	this.scanAngleRank = models(2, 256);
+	this.bitByte = models(256, 256);
+	this.classification = models(256, 256);
+	this.userData = models(256, 256);
+	this.icIntensity = new IntegerDecompressor(16, 4);
+	this.icPointSourceId = new IntegerDecompressor(16, 1);
+	this.icDx = new IntegerDecompressor(32, 2);
+	this.icDy = new IntegerDecompressor(32, 22);
+	this.icZ = new IntegerDecompressor(32, 20);
+}
+
+/** The first point of a chunk is stored raw. */
+Point10Decompressor.prototype.first = function (src, s, view, o) {
+	for (var i = 0; i < 20; i++) view.setUint8(o + i, src[s + i]);
+	this.x = view.getInt32(o, LE); this.y = view.getInt32(o + 4, LE); this.z = view.getInt32(o + 8, LE);
+	this.intensity = 0;                       // laz-rs: the first point's intensity is not a prediction
+	this.bits = view.getUint8(o + 14);
+	this.cls = view.getUint8(o + 15);
+	this.angle = view.getInt8(o + 16);
+	this.user = view.getUint8(o + 17);
+	this.psid = view.getUint16(o + 18, LE);
+};
+
+Point10Decompressor.prototype.next = function (dec, view, o) {
+	var changed = dec.decodeSymbol(this.changedValues);
+	var r, n, m, l;
+	if (changed !== 0) {
+		if (changed & 32) this.bits = dec.decodeSymbol(this.bitByte[this.bits]);
+		r = this.bits & 7; n = (this.bits >>> 3) & 7;
+		m = NUMBER_RETURN_MAP[n][r]; l = NUMBER_RETURN_LEVEL[n][r];
+		if (changed & 16) {
+			this.intensity = this.icIntensity.decompress(dec, this.lastIntensity[m], m < 3 ? m : 3);
+			this.lastIntensity[m] = this.intensity;
+		} else {
+			this.intensity = this.lastIntensity[m];
+		}
+		if (changed & 8) this.cls = dec.decodeSymbol(this.classification[this.cls]);
+		if (changed & 4) {
+			var d = dec.decodeSymbol(this.scanAngleRank[(this.bits >>> 6) & 1]);
+			this.angle = ((this.angle + d) << 24) >> 24;   // i8 wrapping_add
+		}
+		if (changed & 2) this.user = dec.decodeSymbol(this.userData[this.user]);
+		if (changed & 1) this.psid = this.icPointSourceId.decompress(dec, this.psid, 0);
+	} else {
+		r = this.bits & 7; n = (this.bits >>> 3) & 7;
+		m = NUMBER_RETURN_MAP[n][r]; l = NUMBER_RETURN_LEVEL[n][r];
+	}
+	var single = n === 1 ? 1 : 0;
+	var diff = this.icDx.decompress(dec, this.xMedian[m].get(), single);
+	this.x = (this.x + diff) | 0;
+	this.xMedian[m].add(diff);
+	var kx = this.icDx.k;
+	diff = this.icDy.decompress(dec, this.yMedian[m].get(), single + (kx < 20 ? kx & 0xFFFFFFFE : 20));
+	this.y = (this.y + diff) | 0;
+	this.yMedian[m].add(diff);
+	var kz = Math.floor((this.icDx.k + this.icDy.k) / 2);
+	this.z = this.icZ.decompress(dec, this.lastHeight[l], single + (kz < 18 ? kz & 0xFFFFFFFE : 18));
+	this.lastHeight[l] = this.z;
+	view.setInt32(o, this.x, LE); view.setInt32(o + 4, this.y, LE); view.setInt32(o + 8, this.z, LE);
+	view.setUint16(o + 12, this.intensity, LE);
+	view.setUint8(o + 14, this.bits);
+	view.setUint8(o + 15, this.cls);
+	view.setInt8(o + 16, this.angle);
+	view.setUint8(o + 17, this.user);
+	view.setUint16(o + 18, this.psid, LE);
+};