las-laz-js 0.3.1 → 0.5.0

package/src/laz/ArithmeticEncoder.js

@@ -0,0 +1,123 @@
+// src/laz/ArithmeticEncoder.js
+//==========================================================
+// The LASzip arithmetic encoder, the writing half of ArithmeticDecoder:
+// whatever it writes, the decoder reads back exactly. Bytes go into a
+// growable Uint8Array (64 KiB to start, doubled when full); done()
+// flushes the coder and returns a copy of the bytes written. A carry out
+// of base walks back over those bytes, as laz-rs walks its buffer.
+//
+// Ported from laz-rs src/encoders.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;
+// written into a growable byte array instead of laz-rs's ring buffer.
+// base and range are u32 in Numbers (no bit operators: sums and
+// products stay below 2^53 and wrap by subtraction or modulo).
+// The models are the library's (models.js): the encoder and decoder
+// must share them, as LASzip's do.
+//==========================================================
+
+var AC_MIN_LENGTH = 0x01000000;
+var FIRST_ALLOCATION = 65536;
+
+/** An arithmetic encoder over a growable byte buffer. */
+export function ArithmeticEncoder() {
+	this.buf = new Uint8Array(FIRST_ALLOCATION);
+	this.n = 0;   // bytes written
+	this.base = 0;
+	this.range = 0xFFFFFFFF;
+}
+
+ArithmeticEncoder.prototype._put = function (b) {
+	if (this.n === this.buf.length) {
+		var bigger = new Uint8Array(this.buf.length * 2);
+		bigger.set(this.buf);
+		this.buf = bigger;
+	}
+	this.buf[this.n++] = b;
+};
+
+/** Add one to the bytes already written (base overflowed 2^32). */
+ArithmeticEncoder.prototype._carry = function () {
+	var p = this.n - 1;
+	while (this.buf[p] === 0xFF) { this.buf[p] = 0; p--; }
+	this.buf[p]++;
+};
+
+ArithmeticEncoder.prototype._add = function (x) {
+	var b = this.base + x;
+	if (b >= 4294967296) { b -= 4294967296; this._carry(); }
+	this.base = b;
+};
+
+ArithmeticEncoder.prototype._renorm = function () {
+	do {
+		this._put(Math.floor(this.base / 16777216));
+		this.base = (this.base % 16777216) * 256;
+		this.range = (this.range * 256) % 4294967296;
+	} while (this.range < AC_MIN_LENGTH);
+};
+
+/** Encode one bit with an adaptive binary model. */
+ArithmeticEncoder.prototype.encodeBit = function (m, sym) {
+	var x = m.bit0Prob * Math.floor(this.range / 8192);   // BM_LENGTH_SHIFT
+	if (sym === 0) { this.range = x; m.bit0Count++; }
+	else { this._add(x); this.range -= x; }
+	if (this.range < AC_MIN_LENGTH) this._renorm();
+	if (--m.bitsUntilUpdate === 0) m.update();
+};
+
+/** Encode one symbol with an adaptive multi-symbol model. */
+ArithmeticEncoder.prototype.encodeSymbol = function (m, sym) {
+	var x;
+	if (sym === m.lastSymbol) {
+		x = m.distribution[sym] * Math.floor(this.range / 32768);   // DM_LENGTH_SHIFT
+		this._add(x);
+		this.range -= x;
+	} else {
+		this.range = Math.floor(this.range / 32768);
+		x = m.distribution[sym] * this.range;
+		this._add(x);
+		this.range = m.distribution[sym + 1] * this.range - x;
+	}
+	if (this.range < AC_MIN_LENGTH) this._renorm();
+	m.symbolCount[sym]++;
+	if (--m.symbolsUntilUpdate === 0) m.update();
+};
+
+/** `bits` raw bits (1-32) of an unsigned Number. */
+ArithmeticEncoder.prototype.writeBits = function (bits, sym) {
+	if (bits > 19) { this.writeShort(sym % 65536); sym = Math.floor(sym / 65536); bits -= 16; }
+	this.range = Math.floor(this.range / Math.pow(2, bits));
+	this._add(sym * this.range);
+	if (this.range < AC_MIN_LENGTH) this._renorm();
+};
+
+/** 16 raw bits. */
+ArithmeticEncoder.prototype.writeShort = function (sym) {
+	this.range = Math.floor(this.range / 65536);
+	this._add(sym * this.range);
+	if (this.range < AC_MIN_LENGTH) this._renorm();
+};
+
+/** 32 raw bits (low 16 first), from an unsigned Number. */
+ArithmeticEncoder.prototype.writeInt = function (sym) {
+	this.writeShort(sym % 65536);
+	this.writeShort(Math.floor(sym / 65536));
+};
+
+/**
+ * Flush the coder, as laz-rs done().
+ * @returns {Uint8Array} a copy of the bytes written (the encoder is finished)
+ */
+ArithmeticEncoder.prototype.done = function () {
+	var another = true;
+	if (this.range > 2 * AC_MIN_LENGTH) { this._add(AC_MIN_LENGTH); this.range = AC_MIN_LENGTH / 2; }
+	else { this._add(AC_MIN_LENGTH / 2); this.range = AC_MIN_LENGTH / 512; another = false; }
+	this._renorm();
+	this._put(0);
+	this._put(0);
+	if (another) this._put(0);
+	return this.buf.slice(0, this.n);
+};

package/src/laz/IntegerCompressor.js

@@ -0,0 +1,76 @@
+// src/laz/IntegerCompressor.js
+//==========================================================
+// LASzip's integer compressor, the writing half of IntegerDecompressor:
+// 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
+// correction wraps into the integer's range (i32 wrap for 32-bit
+// integers), so the decoder's wrap undoes it.
+//
+// Ported from laz-rs src/compressors.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 IntegerCompressor(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 = -this.corrRange / 2;
+		this.corrMax = this.corrMin + this.corrRange - 1;
+	} else {
+		this.corrBits = 32;
+		this.corrRange = 0;
+		this.corrMin = -2147483648;
+		this.corrMax = 2147483647;
+	}
+	this.k = 0;   // bit length of the last correction, as IntegerDecompressor.k
+	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("./ArithmeticEncoder.js").ArithmeticEncoder} enc
+ * @param {number} pred - the prediction (i32)
+ * @param {number} real - the integer to write
+ * @param {number} context
+ */
+IntegerCompressor.prototype.compress = function (enc, pred, real, context) {
+	var corr = (real - pred) | 0;   // i32 wrapping_sub
+	if (corr < this.corrMin) corr += this.corrRange;
+	else if (corr > this.corrMax) corr -= this.corrRange;
+	var c1 = corr <= 0 ? -corr : corr - 1, k = 0;
+	while (c1 >= 1) { c1 = Math.floor(c1 / 2); k++; }
+	this.k = k;
+	enc.encodeSymbol(this.mBits[context], k);
+	if (k !== 0) {
+		if (k < 32) {
+			var c = corr >= 0 ? corr - 1 : corr + Math.pow(2, k) - 1;
+			if (k <= this.bitsHigh) {
+				enc.encodeSymbol(this.mCorrector[k - 1], c);
+			} else {
+				var k1 = k - this.bitsHigh, low = c % Math.pow(2, k1);
+				enc.encodeSymbol(this.mCorrector[k - 1], Math.floor(c / Math.pow(2, k1)));
+				enc.writeBits(k1, low);
+			}
+		}
+	} else {
+		enc.encodeBit(this.mCorrector0, corr);
+	}
+};

package/src/laz/LazVlr.js

@@ -12,10 +12,12 @@
 // 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.
+// in JavaScript from that layout; lazVlrFor (the writing half) added,
+// Brent Buffham 2026.
 //==========================================================
 
 import { LasError, ERROR_CODES } from "../errors.js";
+import { POINT_FORMATS } from "../format/PointFormats.js";
 
 /** LASzip compressor kinds. */
 export var COMPRESSOR = Object.freeze({ NONE: 0, POINTWISE: 1, POINTWISE_CHUNKED: 2, LAYERED_CHUNKED: 3 });
@@ -63,3 +65,63 @@ export function findLazVlr(vlrs) {
 	}
 	return null;
 }
+
+// The items of each writable point format as [type, size, version]; the
+// extra-bytes item (Byte / Byte14) follows when the record is longer
+var FORMAT_ITEMS = {
+	0: [[ITEM.POINT10, 20, 2]],
+	1: [[ITEM.POINT10, 20, 2], [ITEM.GPSTIME11, 8, 2]],
+	2: [[ITEM.POINT10, 20, 2], [ITEM.RGB12, 6, 2]],
+	3: [[ITEM.POINT10, 20, 2], [ITEM.GPSTIME11, 8, 2], [ITEM.RGB12, 6, 2]],
+	6: [[ITEM.POINT14, 30, 3]],
+	7: [[ITEM.POINT14, 30, 3], [ITEM.RGB14, 6, 3]],
+	8: [[ITEM.POINT14, 30, 3], [ITEM.RGBNIR14, 8, 3]]
+};
+
+/**
+ * The LASzip VLR a writer puts in a file: compressor 2 (formats 0-3) or 3 (6-8),
+ * LASzip 3.4 r3, chunked.
+ * @param {number} pointFormat - 0-3 or 6-8 (4, 5, 9, 10 carry waveform or 1.3 items that are not written)
+ * @param {number} recordLength - the file's point record length
+ * @param {number} chunkSize - points per chunk
+ * @returns {{vlr: object, bytes: Uint8Array}} vlr has the parseLazVlr shape; bytes is its 34 + 6 * items payload
+ */
+export function lazVlrFor(pointFormat, recordLength, chunkSize) {
+	var layered = pointFormat >= 6;
+	if (!FORMAT_ITEMS[pointFormat]) {
+		throw new LasError(ERROR_CODES.UNSUPPORTED, "LAZ compression of point format " + pointFormat + " is not written (formats 0-3 and 6-8 only)");
+	}
+	var extra = recordLength - POINT_FORMATS[pointFormat].size;
+	if (!(extra >= 0 && extra <= 0xFFFF)) {
+		throw new LasError(ERROR_CODES.INVALID_ARGUMENT, "record length " + recordLength + " does not fit point format " + pointFormat + " (" + POINT_FORMATS[pointFormat].size + " bytes)");
+	}
+	var items = FORMAT_ITEMS[pointFormat].map(function (it) {
+		return { type: it[0], size: it[1], version: it[2] };
+	});
+	if (extra > 0) items.push({ type: layered ? ITEM.BYTE14 : ITEM.BYTE, size: extra, version: layered ? 3 : 2 });
+	var vlr = {
+		compressor: layered ? COMPRESSOR.LAYERED_CHUNKED : COMPRESSOR.POINTWISE_CHUNKED,
+		coder: 0,
+		version: { major: 3, minor: 4, revision: 3 },
+		options: 0,
+		chunkSize: chunkSize,
+		variableChunks: false,
+		items: items
+	};
+	var bytes = new Uint8Array(34 + 6 * items.length), v = new DataView(bytes.buffer);
+	v.setUint16(0, vlr.compressor, true);
+	v.setUint16(2, 0, true);
+	v.setUint8(4, 3);
+	v.setUint8(5, 4);
+	v.setUint16(6, 3, true);
+	v.setUint32(8, 0, true);
+	v.setUint32(12, chunkSize, true);
+	for (var at = 16; at < 32; at += 4) v.setUint32(at, 0xFFFFFFFF, true);   // no special EVLRs: count -1, offset -1 (two i64)
+	v.setUint16(32, items.length, true);
+	items.forEach(function (it, i) {
+		v.setUint16(34 + i * 6, it.type, true);
+		v.setUint16(36 + i * 6, it.size, true);
+		v.setUint16(38 + i * 6, it.version, true);
+	});
+	return { vlr: vlr, bytes: bytes };
+}

package/src/laz/chunkTable.js

@@ -1,109 +1,139 @@
-// 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;
-}
+// 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; the writing half (encodeChunkTable)
+// added, Brent Buffham 2026.
+//==========================================================
+
+import { LasError, ERROR_CODES } from "../errors.js";
+import { ArithmeticDecoder } from "./ArithmeticDecoder.js";
+import { IntegerDecompressor } from "./IntegerDecompressor.js";
+import { ArithmeticEncoder } from "./ArithmeticEncoder.js";
+import { IntegerCompressor } from "./IntegerCompressor.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;
+}
+
+/**
+ * Encode the chunk table body: the exact inverse of decodeChunkTable.
+ * @param {Array<{pointCount:number, byteCount:number}>} chunks
+ * @param {boolean} withPointCounts - variable-size chunks
+ * @returns {Uint8Array} u32 version 0, u32 chunk count, then the coded counts
+ */
+export function encodeChunkTable(chunks, withPointCounts) {
+	var enc = new ArithmeticEncoder();
+	var ic = new IntegerCompressor(32, 2);
+	var prevPoints = 0, prevBytes = 0;
+	for (var i = 0; i < chunks.length; i++) {
+		if (withPointCounts) {
+			ic.compress(enc, prevPoints, chunks[i].pointCount, 0);
+			prevPoints = chunks[i].pointCount;
+		}
+		ic.compress(enc, prevBytes, chunks[i].byteCount, 1);
+		prevBytes = chunks[i].byteCount;
+	}
+	var body = enc.done();
+	var out = new Uint8Array(8 + body.length);
+	var v = new DataView(out.buffer);
+	v.setUint32(0, 0, true);
+	v.setUint32(4, chunks.length, true);
+	out.set(body, 8);
+	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/chunkWorker.js

@@ -1,12 +1,16 @@
 // src/laz/chunkWorker.js
 //==========================================================
-// Worker entry for parallel LAZ decoding (src/laz/pool.js): decodes
-// whole chunks into raw LAS records and sends them back (transferred).
-// Runs as a browser module Worker or a Node worker_threads Worker.
-// In:  { id, vlr, recordLength, packed: ArrayBuffer, chunks: [{ s, e, count }], base }
+// Worker entry for parallel LAZ work (src/laz/pool.js): decodes whole
+// chunks into raw LAS records, or compresses raw records into whole
+// chunks, and sends them back (transferred). Runs as a browser module
+// Worker or a Node worker_threads Worker.
+// In (decode, no op):  { id, vlr, recordLength, packed: ArrayBuffer, chunks: [{ s, e, count }], base }
 //      (s / e index into packed; base is packed's file offset)
+// In (compress): { id, op: "compress", vlr, recordLength, records: ArrayBuffer, counts: number[] }
+//      (counts: each chunk's points, back to back from the start of records)
 // Out: { ready: true } once listening, then per task
-//      { id, records: ArrayBuffer } or { id, error: { code, message, offset } }
+//      decode { id, records: ArrayBuffer }, compress { id, chunks: ArrayBuffer, sizes: number[] }
+//      (the chunks back to back, and each one's length), or { id, error: { code, message, offset } }
 //
 // Uses the chunk decoder translated from laz-rs (https://github.com/laz-rs/laz-rs),
 // itself a port of LASzip by rapidlasso. (c) 2007-2015 martin isenburg,
@@ -16,6 +20,7 @@
 //==========================================================
 
 import { createChunkDecoder } from "./decompressChunk.js";
+import { createChunkCompressor } from "./compressChunk.js";
 
 // node:worker_threads is named at run time so browser bundlers leave it alone
 var NODE_WORKER_THREADS = ["node", "worker_threads"].join(":");
@@ -31,23 +36,49 @@ if (typeof self !== "undefined" && typeof self.postMessage === "function") {
 }
 port.post({ ready: true });                    // the pool waits for this before sending work
 
-var cached = { key: null, decode: null };
+// The decoder and the compressor, each made once per VLR + record length
+function cache(make) {
+	var key = null, made = null;
+	return function (m) {
+		var k = JSON.stringify(m.vlr) + "/" + m.recordLength;
+		if (key !== k) { made = make(m.vlr, m.recordLength); key = k; }
+		return made;
+	};
+}
+var decoder = cache(createChunkDecoder), compressor = cache(createChunkCompressor);
 
 function handle(m) {
 	try {
-		var key = JSON.stringify(m.vlr) + "/" + m.recordLength;
-		if (cached.key !== key) cached = { key: key, decode: createChunkDecoder(m.vlr, m.recordLength) };
-		var bytes = new Uint8Array(m.packed);
-		var total = m.chunks.reduce(function (s, c) { return s + c.count; }, 0);
-		var out = new ArrayBuffer(total * m.recordLength);
-		var view = new DataView(out), o = 0;
-		for (var i = 0; i < m.chunks.length; i++) {
-			var c = m.chunks[i];
-			cached.decode(bytes, c.s, c.e, c.count, view, o, m.base);
-			o += c.count * m.recordLength;
-		}
-		port.post({ id: m.id, records: out }, [out]);
+		if (m.op === "compress") compress(m);
+		else decode(m);
 	} catch (err) {
 		port.post({ id: m.id, error: { code: err && err.code, message: err && err.message ? err.message : String(err), offset: err && err.offset } });
 	}
 }
+
+function compress(m) {
+	var one = compressor(m), records = new Uint8Array(m.records);
+	var chunks = [], p = 0, total = 0;
+	for (var i = 0; i < m.counts.length; i++) {
+		chunks.push(one(records, p, m.counts[i]));
+		p += m.counts[i] * m.recordLength;
+		total += chunks[i].length;
+	}
+	var out = new Uint8Array(total), o = 0;
+	chunks.forEach(function (c) { out.set(c, o); o += c.length; });
+	port.post({ id: m.id, chunks: out.buffer, sizes: chunks.map(function (c) { return c.length; }) }, [out.buffer]);
+}
+
+function decode(m) {
+	var dec = decoder(m);
+	var bytes = new Uint8Array(m.packed);
+	var total = m.chunks.reduce(function (s, c) { return s + c.count; }, 0);
+	var out = new ArrayBuffer(total * m.recordLength);
+	var view = new DataView(out), o = 0;
+	for (var i = 0; i < m.chunks.length; i++) {
+		var c = m.chunks[i];
+		dec(bytes, c.s, c.e, c.count, view, o, m.base);
+		o += c.count * m.recordLength;
+	}
+	port.post({ id: m.id, records: out }, [out]);
+}