las-laz-js 0.3.0 → 0.4.0

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,11 +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)
-// Out: { id, records: ArrayBuffer } or { id, error: { code, message, 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
+//      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,
@@ -15,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(":");
@@ -28,24 +34,51 @@ if (typeof self !== "undefined" && typeof self.postMessage === "function") {
 	port = { post: function (m, t) { wt.parentPort.postMessage(m, t); } };
 	wt.parentPort.on("message", handle);
 }
+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]);
+}

package/src/laz/compressChunk.js

@@ -0,0 +1,107 @@
+// src/laz/compressChunk.js
+//==========================================================
+// Raw LAS records -> one LAZ chunk, the writing half of
+// decompressChunk.js: fresh item compressors per chunk, the first
+// record stored raw, then — point-wise (formats 0-3) — one arithmetic
+// stream for the rest, or — layered (formats 6-8) — the point count,
+// every field's layer sizes and the layers. A 0-point chunk is empty;
+// a point-wise 1-point chunk is the raw record alone, a layered one
+// still has its count, sizes and two empty streams (as LAZperf writes
+// both).
+//
+// 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 { ArithmeticEncoder } from "./ArithmeticEncoder.js";
+import { ITEM, COMPRESSOR } from "./LazVlr.js";
+import { checkChunkVlr, checkPointwiseItem, checkLayeredItem } from "./decompressChunk.js";
+import { Point10Compressor } from "./v2/point10.js";
+import { GpsTime11Compressor } from "./v2/gpstime11.js";
+import { Rgb12Compressor } from "./v2/rgb12.js";
+import { ByteCompressor } from "./v2/byte.js";
+import { Point14Compressor } from "./v3/point14.js";
+import { Rgb14Compressor, Nir14Compressor, Byte14Compressor } from "./v3/layered.js";
+
+var LE = true;
+
+function pointwiseItem(it) {
+	checkPointwiseItem(it);
+	switch (it.type) {
+		case ITEM.POINT10: return function () { return new Point10Compressor(); };
+		case ITEM.GPSTIME11: return function () { return new GpsTime11Compressor(); };
+		case ITEM.RGB12: return function () { return new Rgb12Compressor(); };
+		default: return function () { return new ByteCompressor(it.size); };
+	}
+}
+
+// Layered (LAS 1.4) items, versions 3 and 4: each makes one or more field compressors
+function layeredItem(it) {
+	checkLayeredItem(it);
+	var v = it.version;
+	switch (it.type) {
+		case ITEM.POINT14: return function () { return [new Point14Compressor(v)]; };
+		case ITEM.RGB14: return function () { return [new Rgb14Compressor(v)]; };
+		case ITEM.RGBNIR14: return function () { return [new Rgb14Compressor(v), new Nir14Compressor(v)]; };
+		default: return function () { return [new Byte14Compressor(it.size, v)]; };
+	}
+}
+
+// A layered chunk, the mirror of decompressChunk's: the first record raw, a u32 point count,
+// every field's layer sizes (u32), then the layers; Point14 passes the scanner channel on to
+// the fields after it, from 0 at each point as the decoder starts it
+function layeredChunk(makers, recordLength) {
+	return function compressChunk(records, start, count) {
+		if (!count) return new Uint8Array(0);
+		var fields = [];
+		makers.forEach(function (make) { fields.push.apply(fields, make()); });
+		var ctx = { v: 0 }, p = start, k;
+		for (k = 0; k < fields.length; k++) { fields[k].first(records, p, ctx); p += fields[k].size; }
+		for (var i = 1; i < count; i++) {
+			ctx.v = 0;
+			for (k = 0; k < fields.length; k++) { fields[k].next(records, p, ctx); p += fields[k].size; }
+		}
+		var layers = [];
+		fields.forEach(function (f) { layers.push.apply(layers, f.finish()); });
+		var total = layers.reduce(function (n, l) { return n + l.length; }, recordLength + 4 + 4 * layers.length);
+		var out = new Uint8Array(total), dv = new DataView(out.buffer);
+		out.set(records.subarray(start, start + recordLength));
+		dv.setUint32(recordLength, count, LE);
+		var q = recordLength + 4;
+		layers.forEach(function (l) { dv.setUint32(q, l.length, LE); q += 4; });
+		layers.forEach(function (l) { out.set(l, q); q += l.length; });
+		return out;
+	};
+}
+
+/**
+ * Check a LASzip VLR against the records and build the chunk compressor.
+ * @param {object} vlr - parseLazVlr, or the VLR the writer will store
+ * @param {number} recordLength - the records' length
+ * @returns {function(Uint8Array, number, number): Uint8Array}
+ *   compress(records, start, count) — the chunk of `count` records from byte `start`,
+ *   exactly as a LAZ file stores it
+ */
+export function createChunkCompressor(vlr, recordLength) {
+	checkChunkVlr(vlr, recordLength);
+	if (vlr.compressor === COMPRESSOR.LAYERED_CHUNKED) return layeredChunk(vlr.items.map(layeredItem), recordLength);
+	var makers = vlr.items.map(pointwiseItem);
+	return function compressChunk(records, start, count) {
+		if (!count) return new Uint8Array(0);
+		var items = makers.map(function (make) { return make(); });
+		var k, p = start;
+		for (k = 0; k < items.length; k++) { items[k].first(records, p); p += items[k].size; }
+		if (count === 1) return records.slice(start, p);
+		var enc = new ArithmeticEncoder();
+		for (var i = 1; i < count; i++) {
+			for (k = 0; k < items.length; k++) { items[k].next(enc, records, p); p += items[k].size; }
+		}
+		var stream = enc.done(), out = new Uint8Array(recordLength + stream.length);
+		out.set(records.subarray(start, start + recordLength));
+		out.set(stream, recordLength);
+		return out;
+	};
+}

package/src/laz/decompressChunk.js

@@ -25,31 +25,51 @@ import { Rgb14Decompressor, Nir14Decompressor, Byte14Decompressor } from "./v3/l
 
 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) {
+/**
+ * Refuse a point-wise item this library cannot code (the compressor shares the check).
+ * @param {{type:number, size:number, version:number}} it
+ */
+export function checkPointwiseItem(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)");
 	}
+	if (it.type !== ITEM.POINT10 && it.type !== ITEM.GPSTIME11 && it.type !== ITEM.RGB12 && it.type !== ITEM.BYTE) {
+		throw new LasError(ERROR_CODES.UNSUPPORTED, "LAZ item " + (NAMES[it.type] || it.type) + " is not supported (wave packets are not read)");
+	}
+}
+
+function pointwiseItem(it) {
+	checkPointwiseItem(it);
 	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)");
+		default: return function () { return new ByteDecompressor(it.size); };
 	}
 }
 
-// Layered (LAS 1.4) items, versions 3 and 4: each makes one or more field decoders
-function layeredItem(it) {
+/**
+ * Refuse a layered (LAS 1.4) item this library cannot code (the compressor shares the check).
+ * @param {{type:number, size:number, version:number}} it
+ */
+export function checkLayeredItem(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)");
 	}
+	if (it.type !== ITEM.POINT14 && it.type !== ITEM.RGB14 && it.type !== ITEM.RGBNIR14 && it.type !== ITEM.BYTE14) {
+		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) {
+	checkLayeredItem(it);
 	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)");
+		default: return function () { return [new Byte14Decompressor(it.size, v)]; };
 	}
 }
 
@@ -81,6 +101,18 @@ function layeredChunk(makers, recordLength, layerWords) {
 	};
 }
 
+/**
+ * Check that a LASzip VLR's items make the header's records, with the one coder there is
+ * (the compressor shares the check).
+ * @param {object} vlr - parseLazVlr
+ * @param {number} recordLength - header record length
+ */
+export function checkChunkVlr(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)");
+}
+
 /**
  * Check a LASzip VLR against the file and build the chunk decoder.
  * @param {object} vlr - parseLazVlr
@@ -90,9 +122,7 @@ function layeredChunk(makers, recordLength, layerWords) {
  *   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)");
+	checkChunkVlr(vlr, recordLength);
 	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);