las-laz-js 0.1.0 → 0.2.0

package/src/colour/colourize.js

@@ -14,6 +14,12 @@
 //   so one hot return does not wash the rest out.
 // classification: conventional viewer colours. ASPRS defines the
 //   codes, not colours; these follow common LiDAR-viewer practice.
+//
+// createChunkColourizer colours a STREAM of chunks with one set of
+// rules, so neighbouring windows match: elevation over the file's
+// header Z range, intensity over the first chunk's percentiles, and
+// the 8-bit decision made once (it only ever moves to 16-bit, when a
+// later chunk holds a value above 255).
 //==========================================================
 
 import { LasError, ERROR_CODES } from "../errors.js";
@@ -81,9 +87,15 @@ function rampColours(values, n, range, ramp) {
 	return out;
 }
 
+function maxRgb(points) {
+	var n = points.count;
+	return Math.max(rangeOf(need(points, "red"), n)[1], rangeOf(need(points, "green"), n)[1], rangeOf(need(points, "blue"), n)[1]);
+}
+
 /**
  * @param {object} points - PointColumns.
- * @param {{by:string, ramp?:string, range?:number[]}} opts
+ * @param {{by:string, ramp?:string, range?:number[], eightBit?:boolean}} opts - eightBit
+ *   overrides the 8-bit colour detection
  * @returns {Uint8Array} r, g, b per point
  */
 export function colourize(points, opts) {
@@ -96,8 +108,7 @@ export function colourize(points, opts) {
 	switch (opts.by) {
 		case "rgb": {
 			var r = need(points, "red"), g = need(points, "green"), b = need(points, "blue");
-			var max = Math.max(rangeOf(r, n)[1], rangeOf(g, n)[1], rangeOf(b, n)[1]);
-			var eightBit = max <= 255;
+			var eightBit = typeof opts.eightBit === "boolean" ? opts.eightBit : maxRgb(points) <= 255;
 			out = new Uint8Array(n * 3);
 			for (i = 0; i < n; i++) {
 				out[i * 3] = eightBit ? r[i] : Math.min(255, Math.round(r[i] / 256));
@@ -127,3 +138,24 @@ export function colourize(points, opts) {
 			throw new LasError(ERROR_CODES.INVALID_ARGUMENT, "colourize by \"" + opts.by + "\" is not a mode (rgb, intensity, elevation, classification)");
 	}
 }
+
+/**
+ * Colour a stream of chunks (reader.chunks) consistently from window to window.
+ * @param {{by:string, ramp?:string, range?:number[]}} opts - as colourize
+ * @param {{minZ:number, maxZ:number}} [bounds] - the file's header bounds (elevation range)
+ * @param {{z?:number}} [localOrigin] - the origin the chunks were read with
+ * @returns {function(object): Uint8Array} colours one chunk
+ */
+export function createChunkColourizer(opts, bounds, localOrigin) {
+	opts = opts || {};
+	var range = opts.range || null, eightBit = null;
+	if (!range && opts.by === "elevation" && bounds && bounds.maxZ >= bounds.minZ) {
+		var oz = localOrigin && isFinite(localOrigin.z) ? localOrigin.z : 0;
+		range = [bounds.minZ - oz, bounds.maxZ - oz];
+	}
+	return function (points) {
+		if (opts.by === "intensity" && !range && points.count) range = percentiles(need(points, "intensity"), points.count);
+		if (opts.by === "rgb" && points.count && eightBit !== false) eightBit = maxRgb(points) <= 255;
+		return colourize(points, Object.assign({}, opts, { range: range || undefined, eightBit: eightBit === null ? undefined : eightBit }));
+	};
+}

package/src/filter/dedupe.js

@@ -20,35 +20,52 @@ export function dedupe(cols, tolerance, opts) {
 	if (!(tolerance > 0)) throw new LasError(ERROR_CODES.INVALID_ARGUMENT, "dedupe tolerance must be > 0");
 	var use3d = !!(opts && opts.z && cols.z);
 	var tol2 = tolerance * tolerance;
-	var grid = new Map();
-	var kept = new Uint32Array(cols.count);
-	var nKept = 0;
+	var n = cols.count;
 	var x = cols.x, y = cols.y, z = cols.z;
 	var dzRange = use3d ? 1 : 0;
 
-	for (var i = 0; i < cols.count; i++) {
-		var cx = Math.floor(x[i] / tolerance), cy = Math.floor(y[i] / tolerance);
-		var cz = use3d ? Math.floor(z[i] / tolerance) : 0;
+	// Cell indices, shifted so every neighbour is >= 0
+	var lo = [Infinity, Infinity, Infinity], hi = [-Infinity, -Infinity, -Infinity];
+	for (var p = 0; p < n; p++) {
+		var a0 = Math.floor(x[p] / tolerance), a1 = Math.floor(y[p] / tolerance), a2 = use3d ? Math.floor(z[p] / tolerance) : 0;
+		if (a0 < lo[0]) lo[0] = a0; if (a0 > hi[0]) hi[0] = a0;
+		if (a1 < lo[1]) lo[1] = a1; if (a1 > hi[1]) hi[1] = a1;
+		if (a2 < lo[2]) lo[2] = a2; if (a2 > hi[2]) hi[2] = a2;
+	}
+	var SY = hi[1] - lo[1] + 3, SZ = hi[2] - lo[2] + 3;
+	// A dense numeric key when the cell count fits 2^53; else a hashed one —
+	// two cells may then share a key, which only adds candidates: every
+	// candidate is still distance-checked, so the result is exact either way
+	var dense = (hi[0] - lo[0] + 3) * SY * SZ <= 9007199254740992;
+	function key(i, j, k) { return dense ? (i * SY + j) * SZ + k : (i * 73856093 + j * 19349663 + k * 83492791) % 9007199254740881; }
+
+	// Each cell is a linked list through next[] (Map: key -> most recent point)
+	var head = new Map();
+	var next = new Int32Array(n);
+	var kept = new Uint32Array(n);
+	var nKept = 0;
+	for (var i = 0; i < n; i++) {
+		var cx = Math.floor(x[i] / tolerance) - lo[0] + 1, cy = Math.floor(y[i] / tolerance) - lo[1] + 1;
+		var cz = use3d ? Math.floor(z[i] / tolerance) - lo[2] + 1 : 1;
 		var dup = false;
 		for (var dx = -1; dx <= 1 && !dup; dx++) {
 			for (var dy = -1; dy <= 1 && !dup; dy++) {
 				for (var dz = -dzRange; dz <= dzRange && !dup; dz++) {
-					var cell = grid.get((cx + dx) + "_" + (cy + dy) + "_" + (cz + dz));
-					if (!cell) continue;
-					for (var j = 0; j < cell.length; j++) {
-						var k = cell[j];
+					var k = head.get(key(cx + dx, cy + dy, cz + dz));
+					while (k !== undefined && k >= 0) {
 						var ex = x[k] - x[i], ey = y[k] - y[i];
 						var ez = use3d ? z[k] - z[i] : 0;
 						if (ex * ex + ey * ey + ez * ez <= tol2) { dup = true; break; }
+						k = next[k];
 					}
 				}
 			}
 		}
 		if (dup) continue;
-		var key = cx + "_" + cy + "_" + cz;
-		var own = grid.get(key);
-		if (!own) { own = []; grid.set(key, own); }
-		own.push(i);
+		var own = key(cx, cy, cz);
+		var prev = head.get(own);
+		next[i] = prev === undefined ? -1 : prev;
+		head.set(own, i);
 		kept[nKept++] = i;
 	}
 

package/src/filter/filters.js

@@ -4,9 +4,10 @@
 // rejected points cost one or two byte reads (Kirra's classFilter
 // trick, generalised): classification codes, return numbers and a
 // 3D box. Filters combine with AND.
-// strideFor is Kirra's maxPoints rule: keep every
-// floor(count / maxPoints)-th record; 0 keeps every point. The
-// reader also caps the kept count at maxPoints.
+// maxPoints thinning is NOT Kirra's floor-stride-and-cap rule, which
+// kept only the start of the file and, run before the filters,
+// could leave nothing: decodeRecords thins the records that PASS,
+// evenly over the whole file (countKept supplies their number).
 //==========================================================
 
 import { POINT_FORMATS } from "../format/PointFormats.js";
@@ -57,12 +58,15 @@ export function makeKeep(filter, header) {
 }
 
 /**
- * Record stride for a maxPoints cap (Kirra's rule).
- * @param {number} pointCount
- * @param {number} maxPoints - 0 = keep every point
- * @returns {number} stride, at least 1
+ * Count the records in a window of whole records that pass keep.
+ * @param {Uint8Array} bytes
+ * @param {number} recordLength
+ * @param {function(DataView, number): boolean} keep
+ * @returns {number}
  */
-export function strideFor(pointCount, maxPoints) {
-	if (!(maxPoints > 0) || pointCount <= maxPoints) return 1;
-	return Math.max(1, Math.floor(pointCount / maxPoints));
+export function countKept(bytes, recordLength, keep) {
+	var view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+	var n = Math.floor(bytes.length / recordLength), k = 0;
+	for (var i = 0; i < n; i++) if (keep(view, i * recordLength)) k++;
+	return k;
 }

package/src/format/LasVlr.js

@@ -16,7 +16,7 @@ var LE = true;
  * @param {number} start - offset of the first record in src.
  * @param {number} count
  * @param {number} [limit] - records must end at or before this offset (default: end of src).
- * @returns {Array<{userId:string, recordId:number, description:string, start:number, bytes:Uint8Array}>}
+ * @returns {Array<{userId:string, recordId:number, description:string, start:number, length:number, bytes:Uint8Array}>}
  */
 export function parseVlrs(src, start, count, limit) {
 	var end = typeof limit === "number" ? limit : src.length();
@@ -31,6 +31,7 @@ export function parseVlrs(src, start, count, limit) {
 			recordId: src.getUint16(pos + 18, LE),
 			description: readAscii(src, pos + 22, 32),
 			start: pos + 54,
+			length: len,
 			bytes: new Uint8Array(src.slice(pos + 54, pos + 54 + len))
 		});
 		pos += 54 + len;
@@ -43,21 +44,23 @@ export function parseVlrs(src, start, count, limit) {
  * @param {object} src - sync source holding the records (offsets in src).
  * @param {number} start
  * @param {number} count
- * @returns {Array<{userId:string, recordId:number, description:string, start:number, bytes:Uint8Array}>}
+ * @param {boolean} [headersOnly] - src holds only the headers: no bytes (null), no length check
+ * @returns {Array<{userId:string, recordId:number, description:string, start:number, length:number, bytes:Uint8Array|null}>}
  */
-export function parseEvlrs(src, start, count) {
+export function parseEvlrs(src, start, count, headersOnly) {
 	var out = [];
 	var pos = start;
 	for (var i = 0; i < count; i++) {
 		if (pos + 60 > src.length()) throw new LasError(ERROR_CODES.BAD_VLR, "EVLR " + (i + 1) + " starts past the end of the file", pos);
 		var len = readU64(src, pos + 20, LE);
-		if (len === null || pos + 60 + len > src.length()) throw new LasError(ERROR_CODES.BAD_VLR, "EVLR " + (i + 1) + " runs past the end of the file", pos);
+		if (len === null || (!headersOnly && pos + 60 + len > src.length())) throw new LasError(ERROR_CODES.BAD_VLR, "EVLR " + (i + 1) + " runs past the end of the file", pos);
 		out.push({
 			userId: readAscii(src, pos + 2, 16),
 			recordId: src.getUint16(pos + 18, LE),
 			description: readAscii(src, pos + 28, 32),
 			start: pos + 60,
-			bytes: new Uint8Array(src.slice(pos + 60, pos + 60 + len))
+			length: len,
+			bytes: headersOnly ? null : new Uint8Array(src.slice(pos + 60, pos + 60 + len))
 		});
 		pos += 60 + len;
 	}

package/src/index.js

@@ -6,7 +6,7 @@
 //==========================================================
 
 /** Library version, matches package.json. */
-export var VERSION = "0.1.0";
+export var VERSION = "0.2.0";
 
 export { LasError, ERROR_CODES } from "./errors.js";
 export { openLas, LasReader } from "./LasReader.js";
@@ -15,13 +15,13 @@ export { parseVlrs, parseEvlrs } from "./format/LasVlr.js";
 export { parseCrs } from "./format/LasCrs.js";
 export { POINT_FORMATS, formatHasRgb } from "./format/PointFormats.js";
 export { decodeRecords, DEFAULT_FIELDS, FIELD_TYPES } from "./read/decodeRecords.js";
-export { makeKeep, strideFor } from "./filter/filters.js";
+export { makeKeep, countKept } from "./filter/filters.js";
 export { dedupe } from "./filter/dedupe.js";
 export { MemorySource } from "./io/MemorySource.js";
 export { BlobSource } from "./io/BlobSource.js";
 export { NodeFileSource } from "./io/NodeFileSource.js";
 export { SCRATCH_DIR, openScratchSyncWriter, openScratchReader, removeScratchFile, sweepStaleScratchFiles, listScratchFiles, getScratchFile } from "./io/ScratchBinaryFile.js";
-export { colourize, RAMPS, CLASS_COLOURS } from "./colour/colourize.js";
+export { colourize, createChunkColourizer, RAMPS, CLASS_COLOURS } from "./colour/colourize.js";
 export { writeLas, createLasWriter } from "./write/writeLas.js";
 export { chooseScaleOffset } from "./write/scaleOffset.js";
 export { createWorkerHandler } from "./workers/workerProtocol.js";

package/src/io/NodeFileSource.js

@@ -26,11 +26,15 @@ export function NodeFileSource(handle, size) {
  * @param {string} path
  * @returns {Promise<NodeFileSource>}
  */
+var NODE_FS = ["node", "fs/promises"].join(":");
+
 NodeFileSource.open = async function (path) {
 	if (typeof path !== "string" || !path) {
 		throw new LasError(ERROR_CODES.INVALID_ARGUMENT, "NodeFileSource needs a file path");
 	}
-	var fs = await import("node:fs/promises");
+	// A non-literal specifier, so browser bundlers (esbuild, webpack, Vite)
+	// leave it alone instead of failing to resolve a Node built-in
+	var fs = await import(/* webpackIgnore: true */ /* @vite-ignore */ NODE_FS);
 	var handle = await fs.open(path, "r");
 	var stat = await handle.stat();
 	return new NodeFileSource(handle, stat.size);
@@ -49,7 +53,25 @@ NodeFileSource.prototype.read = async function (start, end) {
 	if (end > this.size) {
 		throw new LasError(ERROR_CODES.TRUNCATED, "read past end of " + this.size + "-byte file", end);
 	}
-	var out = new Uint8Array(end - start);
+	return this.readInto(start, end, new Uint8Array(end - start));
+};
+
+/**
+ * Read bytes [start, end) into the front of target (reused by the reader
+ * from window to window, so a big read leaves no per-window garbage).
+ * @param {number} start
+ * @param {number} end
+ * @param {Uint8Array} target - at least end - start bytes
+ * @returns {Promise<Uint8Array>} the filled view of target
+ */
+NodeFileSource.prototype.readInto = async function (start, end, target) {
+	if (start < 0 || end < start) {
+		throw new LasError(ERROR_CODES.INVALID_ARGUMENT, "bad read range " + start + ".." + end);
+	}
+	if (end > this.size) {
+		throw new LasError(ERROR_CODES.TRUNCATED, "read past end of " + this.size + "-byte file", end);
+	}
+	var out = target.subarray(0, end - start);
 	var done = 0;
 	while (done < out.length) {
 		var r = await this._handle.read(out, done, out.length - done, start + done);

package/src/laz/ArithmeticDecoder.js

@@ -0,0 +1,136 @@
+// src/laz/ArithmeticDecoder.js
+//==========================================================
+// The LASzip arithmetic decoder, over a byte range of one Uint8Array
+// (a LAZ chunk, read whole). Running past the range end is TRUNCATED:
+// a well-formed stream never needs a byte beyond its own end, so a
+// short or corrupt chunk fails loudly instead of decoding garbage.
+//
+// Ported from laz-rs src/decoders.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;
+// the coder interval laz-rs calls `length` is `range` here.
+// value and range are u32 in Numbers (>>> 0 after every shift); every
+// product of a probability and the shifted range stays below 2^32.
+//==========================================================
+
+import { LasError, ERROR_CODES } from "../errors.js";
+
+var AC_MAX_LENGTH = 0xFFFFFFFF;
+var AC_MIN_LENGTH = 0x01000000;
+
+/**
+ * @param {Uint8Array} bytes
+ * @param {number} [start] - first byte of the stream (default 0)
+ * @param {number} [end] - one past the last byte (default bytes.length)
+ * @param {number} [base] - file offset of bytes[0], so errors report file offsets (default 0)
+ */
+export function ArithmeticDecoder(bytes, start, end, base) {
+	this.bytes = bytes;
+	this.base = base || 0;
+	this.p = start || 0;
+	this.end = end === undefined ? bytes.length : end;
+	this.value = 0;
+	this.range = AC_MAX_LENGTH;
+}
+
+ArithmeticDecoder.prototype._next = function () {
+	if (this.p >= this.end) throw new LasError(ERROR_CODES.TRUNCATED, "compressed LAZ data ended early", this.base + this.p);
+	return this.bytes[this.p++];
+};
+
+/** Read the 4 big-endian bytes that start the stream. */
+ArithmeticDecoder.prototype.readInitBytes = function () {
+	this.value = this._next() * 16777216 + this._next() * 65536 + this._next() * 256 + this._next();
+	this.range = AC_MAX_LENGTH;
+};
+
+ArithmeticDecoder.prototype._renorm = function () {
+	do {
+		this.value = ((this.value << 8) | this._next()) >>> 0;
+		this.range = (this.range << 8) >>> 0;
+	} while (this.range < AC_MIN_LENGTH);
+};
+
+/** Decode one bit with an adaptive binary model. */
+ArithmeticDecoder.prototype.decodeBit = function (m) {
+	var x = m.bit0Prob * (this.range >>> 13);   // BM_LENGTH_SHIFT
+	var sym;
+	if (this.value < x) {
+		sym = 0;
+		this.range = x;
+		m.bit0Count++;
+	} else {
+		sym = 1;
+		this.value -= x;
+		this.range -= x;
+	}
+	if (this.range < AC_MIN_LENGTH) this._renorm();
+	if (--m.bitsUntilUpdate === 0) m.update();
+	return sym;
+};
+
+/** Decode one symbol with an adaptive multi-symbol model. */
+ArithmeticDecoder.prototype.decodeSymbol = function (m) {
+	var dist = m.distribution, sym, n, x, k, y = this.range;
+	if (m.decoderTable) {
+		this.range = this.range >>> 15;   // DM_LENGTH_SHIFT
+		if (this.range === 0) throw new LasError(ERROR_CODES.TRUNCATED, "corrupt LAZ stream (zero interval)", this.base + this.p);
+		var dv = Math.floor(this.value / this.range);
+		var t = dv >>> m.tableShift;
+		sym = m.decoderTable[t];
+		n = m.decoderTable[t + 1] + 1;
+		while (n > sym + 1) {
+			k = (sym + n) >>> 1;
+			if (dist[k] > dv) n = k; else sym = k;
+		}
+		x = dist[sym] * this.range;
+		if (sym !== m.lastSymbol) y = dist[sym + 1] * this.range;
+	} else {
+		x = 0;
+		sym = 0;
+		this.range = this.range >>> 15;
+		n = m.symbols;
+		k = n >>> 1;
+		do {
+			var z = this.range * dist[k];
+			if (z > this.value) { n = k; y = z; } else { sym = k; x = z; }
+			k = (sym + n) >>> 1;
+		} while (k !== sym);
+	}
+	this.value -= x;
+	this.range = y - x;
+	if (this.range < AC_MIN_LENGTH) this._renorm();
+	m.symbolCount[sym]++;
+	if (--m.symbolsUntilUpdate === 0) m.update();
+	return sym;
+};
+
+/** `bits` raw bits (1-32), as an unsigned Number. */
+ArithmeticDecoder.prototype.readBits = function (bits) {
+	if (bits > 19) {
+		var low = this.readShort();
+		return this.readBits(bits - 16) * 65536 + low;
+	}
+	this.range = this.range >>> bits;
+	var sym = Math.floor(this.value / this.range);
+	this.value -= this.range * sym;
+	if (this.range < AC_MIN_LENGTH) this._renorm();
+	return sym;
+};
+
+/** 16 raw bits. */
+ArithmeticDecoder.prototype.readShort = function () {
+	this.range = this.range >>> 16;
+	var sym = Math.floor(this.value / this.range);
+	this.value -= this.range * sym;
+	if (this.range < AC_MIN_LENGTH) this._renorm();
+	return sym;
+};
+
+/** 32 raw bits (low 16 first), as an unsigned Number. */
+ArithmeticDecoder.prototype.readInt = function () {
+	var low = this.readShort();
+	return this.readShort() * 65536 + low;
+};

package/src/laz/IntegerDecompressor.js

@@ -0,0 +1,77 @@
+// src/laz/IntegerDecompressor.js
+//==========================================================
+// LASzip's integer decompressor: an integer is coded as a correction
+// to a prediction — first k, the bit length of the correction (one
+// model per context), then the correction's bits (modelled up to
+// bitsHigh bits, raw above). The result wraps into the integer's
+// range like the encoder's did (i32 wrap for 32-bit integers).
+//
+// Ported from laz-rs src/decompressors.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.
+//==========================================================
+
+import { ArithmeticModel, ArithmeticBitModel } from "./models.js";
+
+/**
+ * @param {number} [bits] - integer width (default 16; 32 wraps as i32)
+ * @param {number} [contexts] - number of k models (default 1)
+ * @param {number} [bitsHigh] - correction bits that are modelled (default 8)
+ * (laz-rs also takes an explicit range; no LAZ item uses one, so it is left out)
+ */
+export function IntegerDecompressor(bits, contexts, bitsHigh) {
+	bits = bits === undefined ? 16 : bits;
+	this.contexts = contexts === undefined ? 1 : contexts;
+	this.bitsHigh = bitsHigh === undefined ? 8 : bitsHigh;
+	if (bits && bits < 32) {
+		this.corrBits = bits;
+		this.corrRange = Math.pow(2, bits);
+		this.corrMin = -Math.floor(this.corrRange / 2);
+	} else {
+		this.corrBits = 32;
+		this.corrRange = 0;
+		this.corrMin = -2147483648;
+	}
+	// laz-rs compares and adds `corr_range as i32`
+	this.corrRangeI32 = this.corrRange > 2147483647 ? this.corrRange - 4294967296 : this.corrRange;
+	this.k = 0;
+	this.mBits = [];
+	for (var c = 0; c < this.contexts; c++) this.mBits.push(new ArithmeticModel(this.corrBits + 1));
+	this.mCorrector0 = new ArithmeticBitModel();
+	this.mCorrector = [];
+	for (var i = 1; i <= this.corrBits; i++) this.mCorrector.push(new ArithmeticModel(Math.pow(2, i <= this.bitsHigh ? i : this.bitsHigh)));
+}
+
+/**
+ * @param {import("./ArithmeticDecoder.js").ArithmeticDecoder} dec
+ * @param {number} pred - the prediction (i32)
+ * @param {number} context
+ * @returns {number} the decoded integer (i32; within [0, range) for narrower integers)
+ */
+IntegerDecompressor.prototype.decompress = function (dec, pred, context) {
+	var k = dec.decodeSymbol(this.mBits[context]);
+	var c;
+	this.k = k;
+	if (k !== 0) {
+		if (k < 32) {
+			if (k <= this.bitsHigh) {
+				c = dec.decodeSymbol(this.mCorrector[k - 1]);
+			} else {
+				var k1 = k - this.bitsHigh;
+				c = dec.decodeSymbol(this.mCorrector[k - 1]) * Math.pow(2, k1) + dec.readBits(k1);
+			}
+			if (c >= Math.pow(2, k - 1)) c += 1;
+			else c -= Math.pow(2, k) - 1;
+		} else {
+			c = this.corrMin;
+		}
+	} else {
+		c = dec.decodeBit(this.mCorrector0);
+	}
+	var real = (pred + c) | 0;   // i32 wrapping_add
+	if (real < 0) real = (real + this.corrRangeI32) | 0;
+	else if (real >= this.corrRangeI32) real = (real - this.corrRangeI32) | 0;
+	return real;
+};

package/src/laz/LazVlr.js

@@ -0,0 +1,65 @@
+// src/laz/LazVlr.js
+//==========================================================
+// The LASzip VLR ("laszip encoded", record 22204): how the points are
+// compressed — the compressor (point-wise, point-wise chunked, layered
+// chunked), the chunk size (0 / 0xFFFFFFFF = variable, the table then
+// carries each chunk's point count) and the items that make up one
+// record (Point10, GpsTime, RGB12, Byte … or the 1.4 Point14 family),
+// each with its size and coder version.
+//
+// Layout from laz-rs src/laszip/vlr.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 from that layout, Brent Buffham 2026.
+//==========================================================
+
+import { LasError, ERROR_CODES } from "../errors.js";
+
+/** LASzip compressor kinds. */
+export var COMPRESSOR = Object.freeze({ NONE: 0, POINTWISE: 1, POINTWISE_CHUNKED: 2, LAYERED_CHUNKED: 3 });
+
+/** LASzip item types. */
+export var ITEM = Object.freeze({ BYTE: 0, POINT10: 6, GPSTIME11: 7, RGB12: 8, WAVEPACKET13: 9, POINT14: 10, RGB14: 11, RGBNIR14: 12, WAVEPACKET14: 13, BYTE14: 14 });
+
+/** User id and record id of the LASzip VLR. */
+export var LASZIP_USER_ID = "laszip encoded";
+export var LASZIP_RECORD_ID = 22204;
+
+var VARIABLE = 0xFFFFFFFF;
+
+/**
+ * @param {Uint8Array} bytes - the VLR's payload
+ * @returns {{compressor:number, coder:number, version:{major:number, minor:number, revision:number},
+ *   options:number, chunkSize:number, variableChunks:boolean, items:Array<{type:number, size:number, version:number}>}}
+ */
+export function parseLazVlr(bytes) {
+	if (!bytes || bytes.length < 34) throw new LasError(ERROR_CODES.BAD_VLR, "the LASzip VLR is " + (bytes ? bytes.length : 0) + " bytes (needs 34 or more)");
+	var v = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+	var n = v.getUint16(32, true);
+	if (bytes.length < 34 + n * 6) throw new LasError(ERROR_CODES.BAD_VLR, "the LASzip VLR lists " + n + " items but holds only " + bytes.length + " bytes");
+	var chunk = v.getUint32(12, true);
+	var items = [];
+	for (var i = 0; i < n; i++) items.push({ type: v.getUint16(34 + i * 6, true), size: v.getUint16(36 + i * 6, true), version: v.getUint16(38 + i * 6, true) });
+	return {
+		compressor: v.getUint16(0, true),
+		coder: v.getUint16(2, true),
+		version: { major: v.getUint8(4), minor: v.getUint8(5), revision: v.getUint16(6, true) },
+		options: v.getUint32(8, true),
+		chunkSize: chunk === 0 ? VARIABLE : chunk,
+		variableChunks: chunk === 0 || chunk === VARIABLE,
+		items: items
+	};
+}
+
+/**
+ * The LASzip VLR among a file's VLRs, or null.
+ * @param {Array<{userId:string, recordId:number, bytes:Uint8Array}>} vlrs
+ */
+export function findLazVlr(vlrs) {
+	for (var i = 0; i < vlrs.length; i++) {
+		if (vlrs[i].recordId === LASZIP_RECORD_ID && vlrs[i].userId === LASZIP_USER_ID) return parseLazVlr(vlrs[i].bytes);
+	}
+	return null;
+}