woff2-decode 0.1.2 → 0.1.4

package/dist/index.cjs

@@ -26,8 +26,8 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 }) : target, mod));
 
 //#endregion
-let brotli_decompress = require("brotli/decompress");
-brotli_decompress = __toESM(brotli_decompress);
+let brotli_decompress_js = require("brotli/decompress.js");
+brotli_decompress_js = __toESM(brotli_decompress_js);
 
 //#region src/brotli.ts
 let nativeBrotli = null;
@@ -46,10 +46,10 @@ function tryLoadNative() {
 nativeBrotli = tryLoadNative();
 function decompress(data) {
 	if (nativeBrotli) return nativeBrotli(data);
-	return (0, brotli_decompress.default)(data);
+	return (0, brotli_decompress_js.default)(data);
 }
 function decompressPure(data) {
-	return (0, brotli_decompress.default)(data);
+	return (0, brotli_decompress_js.default)(data);
 }
 const hasNative = nativeBrotli !== null;
 
@@ -60,9 +60,11 @@ var Buffer$1 = class {
 		this.pos = 0;
 		if (data instanceof Uint8Array) {
 			const len = length ?? data.byteLength - offset;
+			this.u8 = data.subarray(offset, offset + len);
 			this.view = new DataView(data.buffer, data.byteOffset + offset, len);
 		} else {
 			const len = length ?? data.byteLength - offset;
+			this.u8 = new Uint8Array(data, offset, len);
 			this.view = new DataView(data, offset, len);
 		}
 	}
@@ -70,66 +72,67 @@ var Buffer$1 = class {
 		return this.pos;
 	}
 	get length() {
-		return this.view.byteLength;
+		return this.u8.byteLength;
 	}
 	get remaining() {
-		return this.view.byteLength - this.pos;
+		return this.u8.byteLength - this.pos;
 	}
 	get buffer() {
 		return this.view;
 	}
 	skip(n) {
-		if (this.pos + n > this.view.byteLength || this.pos + n < this.pos) return false;
+		if (this.pos + n > this.u8.byteLength || this.pos + n < this.pos) return false;
 		this.pos += n;
 		return true;
 	}
 	seek(offset) {
-		if (offset > this.view.byteLength || offset < 0) return false;
+		if (offset > this.u8.byteLength || offset < 0) return false;
 		this.pos = offset;
 		return true;
 	}
 	readU8() {
-		if (this.pos + 1 > this.view.byteLength) return null;
-		return this.view.getUint8(this.pos++);
+		if (this.pos + 1 > this.u8.byteLength) return null;
+		return this.u8[this.pos++];
 	}
 	readU16() {
-		if (this.pos + 2 > this.view.byteLength) return null;
-		const val = this.view.getUint16(this.pos, false);
-		this.pos += 2;
-		return val;
+		if (this.pos + 2 > this.u8.byteLength) return null;
+		const idx = this.pos;
+		this.pos = idx + 2;
+		return this.u8[idx] << 8 | this.u8[idx + 1];
 	}
 	readS16() {
-		if (this.pos + 2 > this.view.byteLength) return null;
-		const val = this.view.getInt16(this.pos, false);
-		this.pos += 2;
-		return val;
+		if (this.pos + 2 > this.u8.byteLength) return null;
+		const idx = this.pos;
+		this.pos = idx + 2;
+		const val = this.u8[idx] << 8 | this.u8[idx + 1];
+		return (val & 32768) !== 0 ? val - 65536 : val;
 	}
 	readU32() {
-		if (this.pos + 4 > this.view.byteLength) return null;
-		const val = this.view.getUint32(this.pos, false);
-		this.pos += 4;
-		return val;
+		if (this.pos + 4 > this.u8.byteLength) return null;
+		const idx = this.pos;
+		this.pos = idx + 4;
+		return this.u8[idx] * 16777216 + (this.u8[idx + 1] << 16 | this.u8[idx + 2] << 8 | this.u8[idx + 3]) >>> 0;
 	}
 	readS32() {
-		if (this.pos + 4 > this.view.byteLength) return null;
-		const val = this.view.getInt32(this.pos, false);
-		this.pos += 4;
-		return val;
+		if (this.pos + 4 > this.u8.byteLength) return null;
+		const idx = this.pos;
+		this.pos = idx + 4;
+		return this.u8[idx] << 24 | this.u8[idx + 1] << 16 | this.u8[idx + 2] << 8 | this.u8[idx + 3];
 	}
 	readBytes(n) {
-		if (this.pos + n > this.view.byteLength || n < 0) return null;
-		const result = new Uint8Array(this.view.buffer, this.view.byteOffset + this.pos, n);
+		if (this.pos + n > this.u8.byteLength || n < 0) return null;
+		const result = this.u8.subarray(this.pos, this.pos + n);
 		this.pos += n;
 		return result;
 	}
 	peekU8(offset = 0) {
 		const idx = this.pos + offset;
-		if (idx >= this.view.byteLength || idx < 0) return null;
-		return this.view.getUint8(idx);
+		if (idx >= this.u8.byteLength || idx < 0) return null;
+		return this.u8[idx];
 	}
 	subarray(offset, length) {
-		if (offset + length > this.view.byteLength || offset < 0 || length < 0) return null;
-		return new Uint8Array(this.view.buffer, this.view.byteOffset + offset, length);
+		if (offset + length > this.u8.byteLength || offset < 0 || length < 0) return null;
+		return this.u8.subarray(offset, offset + length);
 	}
 };
 
@@ -245,6 +248,13 @@ function readBase128(buf) {
 //#region src/decode.ts
 const SFNT_HEADER_SIZE = 12;
 const SFNT_ENTRY_SIZE = 16;
+const FLAG_ON_CURVE = 1;
+const FLAG_X_SHORT = 2;
+const FLAG_Y_SHORT = 4;
+const FLAG_REPEAT = 8;
+const FLAG_X_SAME = 16;
+const FLAG_Y_SAME = 32;
+const FLAG_OVERLAP_SIMPLE = 64;
 function decode(data, options) {
 	const input = data instanceof Uint8Array ? data : new Uint8Array(data);
 	const header = readHeader(new Buffer$1(input), input.byteLength);
@@ -366,7 +376,8 @@ function readTableDirectory(buf, numTables) {
 			srcOffset,
 			srcLength: transformLength,
 			dstOffset: 0,
-			dstLength: origLength
+			dstLength: origLength,
+			key: `${tag}:${srcOffset}`
 		});
 		srcOffset += transformLength;
 	}
@@ -469,8 +480,8 @@ function reconstructFont(decompressed, header, fontIndex, fontInfo, output, outV
 	for (const table of sortedTables) {
 		const entryOffset = fontInfo.tableEntryByTag.get(table.tag);
 		if (entryOffset === void 0) continue;
-		const tableKey = `${table.tag}:${table.srcOffset}`;
-		const existing = writtenTables.get(tableKey);
+		const tKey = table.key;
+		const existing = writtenTables.get(tKey);
 		if (existing) {
 			updateTableEntry(outView, entryOffset, existing.checksum, existing.dstOffset, existing.dstLength);
 			if (isTTC) {
@@ -495,7 +506,7 @@ function reconstructFont(decompressed, header, fontIndex, fontInfo, output, outV
 				fontChecksum = fontChecksum + checksum >>> 0;
 				fontChecksum = fontChecksum + computeTableEntryChecksum(checksum, dstOffset, tableData.byteLength) >>> 0;
 			}
-			writtenTables.set(tableKey, {
+			writtenTables.set(tKey, {
 				dstOffset,
 				dstLength: tableData.byteLength,
 				checksum
@@ -510,8 +521,7 @@ function reconstructFont(decompressed, header, fontIndex, fontInfo, output, outV
 					fontChecksum = fontChecksum + locaChecksum >>> 0;
 					fontChecksum = fontChecksum + computeTableEntryChecksum(locaChecksum, dstOffset, result.locaData.byteLength) >>> 0;
 				}
-				const locaKey = `${TAG_LOCA}:${locaTable.srcOffset}`;
-				writtenTables.set(locaKey, {
+				writtenTables.set(locaTable.key, {
 					dstOffset,
 					dstLength: result.locaData.byteLength,
 					checksum: locaChecksum
@@ -537,7 +547,7 @@ function reconstructFont(decompressed, header, fontIndex, fontInfo, output, outV
 			fontChecksum = fontChecksum + checksum >>> 0;
 			fontChecksum = fontChecksum + computeTableEntryChecksum(checksum, dstOffset, tableData.byteLength) >>> 0;
 		}
-		writtenTables.set(tableKey, {
+		writtenTables.set(tKey, {
 			dstOffset,
 			dstLength: tableData.byteLength,
 			checksum
@@ -546,7 +556,7 @@ function reconstructFont(decompressed, header, fontIndex, fontInfo, output, outV
 	}
 	const headTable = sortedTables.find((t) => t.tag === TAG_HEAD);
 	if (headTable) {
-		const headEntry = writtenTables.get(`${TAG_HEAD}:${headTable.srcOffset}`);
+		const headEntry = writtenTables.get(headTable.key);
 		if (headEntry && headEntry.dstLength >= 12) {
 			const finalChecksum = isTTC ? fontChecksum : computeChecksum(output, 0, dstOffset);
 			outView.setUint32(headEntry.dstOffset + 8, 2981146554 - finalChecksum >>> 0);
@@ -557,54 +567,100 @@ function reconstructFont(decompressed, header, fontIndex, fontInfo, output, outV
 function computeTableEntryChecksum(checksum, offset, length) {
 	return checksum + offset + length >>> 0;
 }
+function makeByteStream(data, start, length) {
+	return {
+		data,
+		pos: start,
+		end: start + length
+	};
+}
+function bsReadU8(stream) {
+	if (stream.pos >= stream.end) throw new Error("Stream overflow");
+	return stream.data[stream.pos++];
+}
+function bsReadU16(stream) {
+	if (stream.pos + 2 > stream.end) throw new Error("Stream overflow");
+	const idx = stream.pos;
+	stream.pos = idx + 2;
+	return stream.data[idx] << 8 | stream.data[idx + 1];
+}
+function bsReadS16(stream) {
+	if (stream.pos + 2 > stream.end) throw new Error("Stream overflow");
+	const idx = stream.pos;
+	stream.pos = idx + 2;
+	const val = stream.data[idx] << 8 | stream.data[idx + 1];
+	return (val & 32768) !== 0 ? val - 65536 : val;
+}
+function fsReadU32(stream) {
+	if (stream.pos + 4 > stream.end) throw new Error("Stream overflow");
+	const idx = stream.pos;
+	stream.pos = idx + 4;
+	return stream.data[idx] * 16777216 + (stream.data[idx + 1] << 16 | stream.data[idx + 2] << 8 | stream.data[idx + 3]) >>> 0;
+}
+function bsSkip(stream, n) {
+	if (stream.pos + n > stream.end || n < 0) throw new Error("Stream overflow");
+	stream.pos += n;
+}
+function fsReadBytes(stream, n) {
+	if (stream.pos + n > stream.end || n < 0) throw new Error("Stream overflow");
+	const start = stream.pos;
+	stream.pos += n;
+	return stream.data.subarray(start, start + n);
+}
+function bsRead255UShort(stream) {
+	const code = bsReadU8(stream);
+	if (code === 253) return bsReadU16(stream);
+	else if (code === 255) return 253 + bsReadU8(stream);
+	else if (code === 254) return 506 + bsReadU8(stream);
+	return code;
+}
 function reconstructGlyf(data, glyfTable, locaTable, fontInfo) {
-	const buf = new Buffer$1(data, glyfTable.srcOffset, glyfTable.transformLength);
-	const version = buf.readU16();
-	const optionFlags = buf.readU16();
-	const numGlyphs = buf.readU16();
-	const indexFormat = buf.readU16();
-	if (version === null || optionFlags === null || numGlyphs === null || indexFormat === null) throw new Error("Invalid glyf transform header");
+	const headerStream = makeByteStream(data, glyfTable.srcOffset, glyfTable.transformLength);
+	bsReadU16(headerStream);
+	const optionFlags = bsReadU16(headerStream);
+	const numGlyphs = bsReadU16(headerStream);
+	const indexFormat = bsReadU16(headerStream);
 	fontInfo.numGlyphs = numGlyphs;
 	fontInfo.indexFormat = indexFormat;
-	const nContourStreamSize = buf.readU32();
-	const nPointsStreamSize = buf.readU32();
-	const flagStreamSize = buf.readU32();
-	const glyphStreamSize = buf.readU32();
-	const compositeStreamSize = buf.readU32();
-	const bboxStreamSize = buf.readU32();
-	const instructionStreamSize = buf.readU32();
-	if (nContourStreamSize === null || nPointsStreamSize === null || flagStreamSize === null || glyphStreamSize === null || compositeStreamSize === null || bboxStreamSize === null || instructionStreamSize === null) throw new Error("Invalid glyf substream sizes");
-	let offset = buf.offset;
-	const nContourStream = new Buffer$1(data, glyfTable.srcOffset + offset, nContourStreamSize);
+	const nContourStreamSize = fsReadU32(headerStream);
+	const nPointsStreamSize = fsReadU32(headerStream);
+	const flagStreamSize = fsReadU32(headerStream);
+	const glyphStreamSize = fsReadU32(headerStream);
+	const compositeStreamSize = fsReadU32(headerStream);
+	const bboxStreamSize = fsReadU32(headerStream);
+	const instructionStreamSize = fsReadU32(headerStream);
+	let offset = headerStream.pos;
+	const nContourStream = makeByteStream(data, offset, nContourStreamSize);
 	offset += nContourStreamSize;
-	const nPointsStream = new Buffer$1(data, glyfTable.srcOffset + offset, nPointsStreamSize);
+	const nPointsStream = makeByteStream(data, offset, nPointsStreamSize);
 	offset += nPointsStreamSize;
-	const flagStream = new Buffer$1(data, glyfTable.srcOffset + offset, flagStreamSize);
+	const flagStream = makeByteStream(data, offset, flagStreamSize);
 	offset += flagStreamSize;
-	const glyphStream = new Buffer$1(data, glyfTable.srcOffset + offset, glyphStreamSize);
+	const glyphStream = makeByteStream(data, offset, glyphStreamSize);
 	offset += glyphStreamSize;
-	const compositeStream = new Buffer$1(data, glyfTable.srcOffset + offset, compositeStreamSize);
+	const compositeStream = makeByteStream(data, offset, compositeStreamSize);
 	offset += compositeStreamSize;
-	const bboxStream = new Buffer$1(data, glyfTable.srcOffset + offset, bboxStreamSize);
+	const bboxStream = makeByteStream(data, offset, bboxStreamSize);
 	offset += bboxStreamSize;
-	const instructionStream = new Buffer$1(data, glyfTable.srcOffset + offset, instructionStreamSize);
+	const instructionStream = makeByteStream(data, offset, instructionStreamSize);
 	const hasOverlapBitmap = (optionFlags & 1) !== 0;
 	let overlapBitmap = null;
 	if (hasOverlapBitmap) {
 		const overlapBitmapLength = numGlyphs + 7 >> 3;
-		overlapBitmap = data.subarray(glyfTable.srcOffset + offset + instructionStreamSize, glyfTable.srcOffset + offset + instructionStreamSize + overlapBitmapLength);
+		overlapBitmap = data.subarray(offset + instructionStreamSize, offset + instructionStreamSize + overlapBitmapLength);
 	}
-	const bboxBitmapLength = numGlyphs + 31 >> 5 << 2;
-	const bboxBitmap = bboxStream.readBytes(bboxBitmapLength);
-	if (!bboxBitmap) throw new Error("Failed to read bbox bitmap");
+	const bboxBitmap = fsReadBytes(bboxStream, numGlyphs + 31 >> 5 << 2);
 	let glyfOutput = new Uint8Array(glyfTable.origLength * 2);
 	let glyfOffset = 0;
-	const locaValues = [];
+	const locaValues = new Uint32Array(numGlyphs + 1);
 	fontInfo.xMins = new Int16Array(numGlyphs);
+	let contourEndsScratch = new Uint16Array(128);
+	let flagsScratch = new Uint8Array(512);
+	let xScratch = new Uint8Array(512);
+	let yScratch = new Uint8Array(512);
 	for (let glyphId = 0; glyphId < numGlyphs; glyphId++) {
-		locaValues.push(glyfOffset);
-		const nContours = nContourStream.readS16();
-		if (nContours === null) throw new Error(`Failed to read nContours for glyph ${glyphId}`);
+		locaValues[glyphId] = glyfOffset;
+		const nContours = bsReadS16(nContourStream);
 		const haveBbox = (bboxBitmap[glyphId >> 3] & 128 >> (glyphId & 7)) !== 0;
 		if (nContours === 0) {
 			if (haveBbox) throw new Error(`Empty glyph ${glyphId} has bbox`);
@@ -614,34 +670,76 @@ function reconstructGlyf(data, glyfTable, locaTable, fontInfo) {
 			if (!haveBbox) throw new Error(`Composite glyph ${glyphId} missing bbox`);
 			const { compositeData, haveInstructions } = readCompositeGlyph(compositeStream);
 			let instructionSize = 0;
-			if (haveInstructions) instructionSize = read255UShort(glyphStream) ?? 0;
+			if (haveInstructions) instructionSize = bsRead255UShort(glyphStream);
 			const glyphSize = 10 + compositeData.byteLength + (haveInstructions ? 2 + instructionSize : 0);
 			ensureCapacity(glyphSize);
-			new DataView(glyfOutput.buffer, glyfOffset).setInt16(0, -1);
-			const bbox = bboxStream.readBytes(8);
-			if (!bbox) throw new Error("Failed to read bbox");
+			writeInt16BE(glyfOutput, glyfOffset, -1);
+			const bbox = fsReadBytes(bboxStream, 8);
 			glyfOutput.set(bbox, glyfOffset + 2);
-			fontInfo.xMins[glyphId] = new DataView(bbox.buffer, bbox.byteOffset).getInt16(0);
+			fontInfo.xMins[glyphId] = readInt16BE(bbox, 0);
 			glyfOutput.set(compositeData, glyfOffset + 10);
 			if (haveInstructions) {
 				const instrOffset = glyfOffset + 10 + compositeData.byteLength;
-				new DataView(glyfOutput.buffer, instrOffset).setUint16(0, instructionSize);
-				const instructions = instructionStream.readBytes(instructionSize);
-				if (!instructions) throw new Error("Failed to read instructions");
+				writeUint16BE(glyfOutput, instrOffset, instructionSize);
+				const instructions = fsReadBytes(instructionStream, instructionSize);
 				glyfOutput.set(instructions, instrOffset + 2);
 			}
 			glyfOffset += glyphSize;
 			glyfOffset = pad4(glyfOffset);
 		} else {
-			const result = reconstructSimpleGlyph(nContours, haveBbox, (overlapBitmap?.[glyphId >> 3] ?? 0) & 128 >> (glyphId & 7), nPointsStream, flagStream, glyphStream, bboxStream, instructionStream);
-			ensureCapacity(result.byteLength);
-			glyfOutput.set(result, glyfOffset);
-			if (result.byteLength >= 4) fontInfo.xMins[glyphId] = new DataView(result.buffer, result.byteOffset).getInt16(2);
-			glyfOffset += result.byteLength;
+			if (nContours > contourEndsScratch.length) contourEndsScratch = new Uint16Array(nContours * 2);
+			let totalPoints = 0;
+			let endPoint = -1;
+			for (let i = 0; i < nContours; i++) {
+				const n = bsRead255UShort(nPointsStream);
+				totalPoints += n;
+				endPoint += n;
+				contourEndsScratch[i] = endPoint;
+			}
+			const scratchSize = totalPoints * 2;
+			if (scratchSize > flagsScratch.length) flagsScratch = new Uint8Array(scratchSize);
+			if (scratchSize > xScratch.length) xScratch = new Uint8Array(scratchSize);
+			if (scratchSize > yScratch.length) yScratch = new Uint8Array(scratchSize);
+			const encoded = encodeTripletsToScratch(flagStream, glyphStream, totalPoints, ((overlapBitmap?.[glyphId >> 3] ?? 0) & 128 >> (glyphId & 7)) !== 0, flagsScratch, xScratch, yScratch);
+			const instructionSize = bsRead255UShort(glyphStream);
+			const glyphSize = 10 + 2 * nContours + 2 + instructionSize + encoded.flagsLen + encoded.xLen + encoded.yLen;
+			ensureCapacity(glyphSize);
+			writeInt16BE(glyfOutput, glyfOffset, nContours);
+			let xMin = 0;
+			if (haveBbox) {
+				const bbox = fsReadBytes(bboxStream, 8);
+				glyfOutput.set(bbox, glyfOffset + 2);
+				xMin = readInt16BE(bbox, 0);
+			} else {
+				writeInt16BE(glyfOutput, glyfOffset + 2, encoded.xMin);
+				writeInt16BE(glyfOutput, glyfOffset + 4, encoded.yMin);
+				writeInt16BE(glyfOutput, glyfOffset + 6, encoded.xMax);
+				writeInt16BE(glyfOutput, glyfOffset + 8, encoded.yMax);
+				xMin = encoded.xMin;
+			}
+			let writeOffset = glyfOffset + 10;
+			for (let i = 0; i < nContours; i++) {
+				writeUint16BE(glyfOutput, writeOffset, contourEndsScratch[i]);
+				writeOffset += 2;
+			}
+			writeUint16BE(glyfOutput, writeOffset, instructionSize);
+			writeOffset += 2;
+			if (instructionSize > 0) {
+				const instructions = fsReadBytes(instructionStream, instructionSize);
+				glyfOutput.set(instructions, writeOffset);
+				writeOffset += instructionSize;
+			}
+			glyfOutput.set(flagsScratch.subarray(0, encoded.flagsLen), writeOffset);
+			writeOffset += encoded.flagsLen;
+			glyfOutput.set(xScratch.subarray(0, encoded.xLen), writeOffset);
+			writeOffset += encoded.xLen;
+			glyfOutput.set(yScratch.subarray(0, encoded.yLen), writeOffset);
+			fontInfo.xMins[glyphId] = xMin;
+			glyfOffset += glyphSize;
 			glyfOffset = pad4(glyfOffset);
 		}
 	}
-	locaValues.push(glyfOffset);
+	locaValues[numGlyphs] = glyfOffset;
 	const locaSize = indexFormat ? (numGlyphs + 1) * 4 : (numGlyphs + 1) * 2;
 	const locaData = new Uint8Array(locaSize);
 	const locaView = new DataView(locaData.buffer);
@@ -666,11 +764,11 @@ function readCompositeGlyph(stream) {
 	const FLAG_WE_HAVE_AN_X_AND_Y_SCALE = 64;
 	const FLAG_WE_HAVE_A_TWO_BY_TWO = 128;
 	const FLAG_WE_HAVE_INSTRUCTIONS = 256;
-	const startOffset = stream.offset;
+	const startOffset = stream.pos;
 	let haveInstructions = false;
 	let flags = FLAG_MORE_COMPONENTS;
 	while (flags & FLAG_MORE_COMPONENTS) {
-		flags = stream.readU16() ?? 0;
+		flags = bsReadU16(stream);
 		haveInstructions = haveInstructions || (flags & FLAG_WE_HAVE_INSTRUCTIONS) !== 0;
 		let argSize = 2;
 		if (flags & FLAG_ARG_1_AND_2_ARE_WORDS) argSize += 4;
@@ -678,126 +776,91 @@ function readCompositeGlyph(stream) {
 		if (flags & FLAG_WE_HAVE_A_SCALE) argSize += 2;
 		else if (flags & FLAG_WE_HAVE_AN_X_AND_Y_SCALE) argSize += 4;
 		else if (flags & FLAG_WE_HAVE_A_TWO_BY_TWO) argSize += 8;
-		stream.skip(argSize);
+		bsSkip(stream, argSize);
 	}
-	const compositeData = stream.subarray(startOffset, stream.offset - startOffset);
-	if (!compositeData) throw new Error("Failed to read composite glyph data");
 	return {
-		compositeData,
+		compositeData: stream.data.subarray(startOffset, stream.pos),
 		haveInstructions
 	};
 }
-function reconstructSimpleGlyph(nContours, haveBbox, hasOverlapBit, nPointsStream, flagStream, glyphStream, bboxStream, instructionStream) {
-	const pointsPerContour = [];
-	let totalPoints = 0;
-	for (let i = 0; i < nContours; i++) {
-		const n = read255UShort(nPointsStream);
-		if (n === null) throw new Error("Failed to read points count");
-		pointsPerContour.push(n);
-		totalPoints += n;
-	}
-	const points = decodeTriplets(flagStream, glyphStream, totalPoints);
-	const instructionSize = read255UShort(glyphStream) ?? 0;
-	const flagsAndCoords = encodePointsToGlyf(points, hasOverlapBit !== 0);
-	const glyphSize = 10 + 2 * nContours + 2 + instructionSize + flagsAndCoords.byteLength;
-	const output = new Uint8Array(glyphSize);
-	const view = new DataView(output.buffer);
-	let offset = 0;
-	view.setInt16(offset, nContours);
-	offset += 2;
-	if (haveBbox) {
-		const bbox = bboxStream.readBytes(8);
-		if (!bbox) throw new Error("Failed to read bbox");
-		output.set(bbox, offset);
-	} else {
-		let xMin = 0, yMin = 0, xMax = 0, yMax = 0;
-		if (points.length > 0) {
-			xMin = xMax = points[0].x;
-			yMin = yMax = points[0].y;
-			for (const p of points) {
-				xMin = Math.min(xMin, p.x);
-				xMax = Math.max(xMax, p.x);
-				yMin = Math.min(yMin, p.y);
-				yMax = Math.max(yMax, p.y);
-			}
-		}
-		view.setInt16(offset, xMin);
-		view.setInt16(offset + 2, yMin);
-		view.setInt16(offset + 4, xMax);
-		view.setInt16(offset + 6, yMax);
-	}
-	offset += 8;
-	let endPoint = -1;
-	for (let i = 0; i < nContours; i++) {
-		endPoint += pointsPerContour[i];
-		view.setUint16(offset, endPoint);
-		offset += 2;
-	}
-	view.setUint16(offset, instructionSize);
-	offset += 2;
-	if (instructionSize > 0) {
-		const instructions = instructionStream.readBytes(instructionSize);
-		if (!instructions) throw new Error("Failed to read instructions");
-		output.set(instructions, offset);
-		offset += instructionSize;
-	}
-	output.set(flagsAndCoords, offset);
-	return output;
-}
-function decodeTriplets(flagStream, glyphStream, nPoints) {
-	const points = [];
+function encodeTripletsToScratch(flagStream, glyphStream, nPoints, hasOverlapBit, flagsOut, xOut, yOut) {
+	if (nPoints === 0) return {
+		flagsLen: 0,
+		xLen: 0,
+		yLen: 0,
+		xMin: 0,
+		yMin: 0,
+		xMax: 0,
+		yMax: 0
+	};
+	let flagsLen = 0;
+	let xLen = 0;
+	let yLen = 0;
 	let x = 0;
 	let y = 0;
+	let xMin = 0;
+	let yMin = 0;
+	let xMax = 0;
+	let yMax = 0;
+	let lastFlag = -1;
+	let repeatCount = 0;
+	const flagData = flagStream.data;
+	let flagPos = flagStream.pos;
+	const flagEnd = flagStream.end;
+	const glyphData = glyphStream.data;
+	let glyphPos = glyphStream.pos;
+	const glyphEnd = glyphStream.end;
 	for (let i = 0; i < nPoints; i++) {
-		const flag = flagStream.readU8();
-		if (flag === null) throw new Error("Failed to read triplet flag");
+		if (flagPos >= flagEnd) throw new Error("Stream overflow");
+		const flag = flagData[flagPos++];
 		const onCurve = (flag & 128) === 0;
 		const flagLow = flag & 127;
-		let dx, dy;
+		let dx;
+		let dy;
 		if (flagLow < 10) {
 			dx = 0;
-			const b = glyphStream.readU8();
-			if (b === null) throw new Error("Failed to read triplet data");
+			if (glyphPos >= glyphEnd) throw new Error("Stream overflow");
+			const b = glyphData[glyphPos++];
 			dy = ((flagLow & 14) << 7) + b;
 			if ((flagLow & 1) === 0) dy = -dy;
 		} else if (flagLow < 20) {
-			const b = glyphStream.readU8();
-			if (b === null) throw new Error("Failed to read triplet data");
+			if (glyphPos >= glyphEnd) throw new Error("Stream overflow");
+			const b = glyphData[glyphPos++];
 			dx = ((flagLow - 10 & 14) << 7) + b;
 			if ((flagLow & 1) === 0) dx = -dx;
 			dy = 0;
 		} else if (flagLow < 84) {
-			const b = glyphStream.readU8();
-			if (b === null) throw new Error("Failed to read triplet data");
+			if (glyphPos >= glyphEnd) throw new Error("Stream overflow");
+			const b = glyphData[glyphPos++];
 			const b0 = flagLow - 20;
 			dx = 1 + (b0 & 48) + (b >> 4);
 			dy = 1 + ((b0 & 12) << 2) + (b & 15);
 			if ((flagLow & 1) === 0) dx = -dx;
 			if ((flagLow & 2) === 0) dy = -dy;
 		} else if (flagLow < 120) {
-			const b0 = glyphStream.readU8();
-			const b1 = glyphStream.readU8();
-			if (b0 === null || b1 === null) throw new Error("Failed to read triplet data");
+			if (glyphPos + 1 >= glyphEnd) throw new Error("Stream overflow");
+			const b0 = glyphData[glyphPos++];
+			const b1 = glyphData[glyphPos++];
 			const idx = flagLow - 84;
-			dx = 1 + (Math.floor(idx / 12) << 8) + b0;
+			dx = 1 + ((idx / 12 | 0) << 8) + b0;
 			dy = 1 + (idx % 12 >> 2 << 8) + b1;
 			if ((flagLow & 1) === 0) dx = -dx;
 			if ((flagLow & 2) === 0) dy = -dy;
 		} else if (flagLow < 124) {
-			const b0 = glyphStream.readU8();
-			const b1 = glyphStream.readU8();
-			const b2 = glyphStream.readU8();
-			if (b0 === null || b1 === null || b2 === null) throw new Error("Failed to read triplet data");
+			if (glyphPos + 2 >= glyphEnd) throw new Error("Stream overflow");
+			const b0 = glyphData[glyphPos++];
+			const b1 = glyphData[glyphPos++];
+			const b2 = glyphData[glyphPos++];
 			dx = (b0 << 4) + (b1 >> 4);
 			dy = ((b1 & 15) << 8) + b2;
 			if ((flagLow & 1) === 0) dx = -dx;
 			if ((flagLow & 2) === 0) dy = -dy;
 		} else {
-			const b0 = glyphStream.readU8();
-			const b1 = glyphStream.readU8();
-			const b2 = glyphStream.readU8();
-			const b3 = glyphStream.readU8();
-			if (b0 === null || b1 === null || b2 === null || b3 === null) throw new Error("Failed to read triplet data");
+			if (glyphPos + 3 >= glyphEnd) throw new Error("Stream overflow");
+			const b0 = glyphData[glyphPos++];
+			const b1 = glyphData[glyphPos++];
+			const b2 = glyphData[glyphPos++];
+			const b3 = glyphData[glyphPos++];
 			dx = (b0 << 8) + b1;
 			dy = (b2 << 8) + b3;
 			if ((flagLow & 1) === 0) dx = -dx;
@@ -805,138 +868,81 @@ function decodeTriplets(flagStream, glyphStream, nPoints) {
 		}
 		x += dx;
 		y += dy;
-		points.push({
-			x,
-			y,
-			onCurve
-		});
-	}
-	return points;
-}
-function encodePointsToGlyf(points, hasOverlapBit) {
-	const FLAG_ON_CURVE = 1;
-	const FLAG_X_SHORT = 2;
-	const FLAG_Y_SHORT = 4;
-	const FLAG_REPEAT = 8;
-	const FLAG_X_SAME = 16;
-	const FLAG_Y_SAME = 32;
-	const FLAG_OVERLAP_SIMPLE = 64;
-	if (points.length === 0) return new Uint8Array(0);
-	const flags = [];
-	const xCoords = [];
-	const yCoords = [];
-	let lastX = 0;
-	let lastY = 0;
-	for (let i = 0; i < points.length; i++) {
-		const p = points[i];
-		let flag = p.onCurve ? FLAG_ON_CURVE : 0;
-		if (hasOverlapBit && i === 0) flag |= FLAG_OVERLAP_SIMPLE;
-		const dx = p.x - lastX;
-		const dy = p.y - lastY;
-		if (dx === 0) flag |= FLAG_X_SAME;
+		if (i === 0) {
+			xMin = xMax = x;
+			yMin = yMax = y;
+		} else {
+			if (x < xMin) xMin = x;
+			if (x > xMax) xMax = x;
+			if (y < yMin) yMin = y;
+			if (y > yMax) yMax = y;
+		}
+		let outFlag = onCurve ? FLAG_ON_CURVE : 0;
+		if (hasOverlapBit && i === 0) outFlag |= FLAG_OVERLAP_SIMPLE;
+		if (dx === 0) outFlag |= FLAG_X_SAME;
 		else if (dx >= -255 && dx <= 255) {
-			flag |= FLAG_X_SHORT;
-			if (dx > 0) flag |= FLAG_X_SAME;
-			xCoords.push(Math.abs(dx));
-		} else xCoords.push(dx);
-		if (dy === 0) flag |= FLAG_Y_SAME;
-		else if (dy >= -255 && dy <= 255) {
-			flag |= FLAG_Y_SHORT;
-			if (dy > 0) flag |= FLAG_Y_SAME;
-			yCoords.push(Math.abs(dy));
-		} else yCoords.push(dy);
-		flags.push(flag);
-		lastX = p.x;
-		lastY = p.y;
-	}
-	const encodedFlags = [];
-	let lastFlag = -1;
-	let repeatCount = 0;
-	for (let i = 0; i < flags.length; i++) {
-		const flag = flags[i];
-		if (flag === lastFlag && repeatCount < 255) {
-			encodedFlags[encodedFlags.length - 1] |= FLAG_REPEAT;
-			repeatCount++;
+			outFlag |= FLAG_X_SHORT;
+			if (dx > 0) outFlag |= FLAG_X_SAME;
+			xOut[xLen++] = dx > 0 ? dx : -dx;
 		} else {
-			if (repeatCount > 0) encodedFlags.push(repeatCount);
-			encodedFlags.push(flag);
-			repeatCount = 0;
+			xOut[xLen++] = dx >> 8 & 255;
+			xOut[xLen++] = dx & 255;
 		}
-		lastFlag = flag;
-	}
-	if (repeatCount > 0) encodedFlags.push(repeatCount);
-	let xSize = 0;
-	let ySize = 0;
-	let xIdx = 0;
-	let yIdx = 0;
-	for (const flag of flags) {
-		if ((flag & FLAG_X_SHORT) !== 0) {
-			xSize += 1;
-			xIdx++;
-		} else if ((flag & FLAG_X_SAME) === 0) {
-			xSize += 2;
-			xIdx++;
+		if (dy === 0) outFlag |= FLAG_Y_SAME;
+		else if (dy >= -255 && dy <= 255) {
+			outFlag |= FLAG_Y_SHORT;
+			if (dy > 0) outFlag |= FLAG_Y_SAME;
+			yOut[yLen++] = dy > 0 ? dy : -dy;
+		} else {
+			yOut[yLen++] = dy >> 8 & 255;
+			yOut[yLen++] = dy & 255;
 		}
-		if ((flag & FLAG_Y_SHORT) !== 0) {
-			ySize += 1;
-			yIdx++;
-		} else if ((flag & FLAG_Y_SAME) === 0) {
-			ySize += 2;
-			yIdx++;
+		if (outFlag === lastFlag && repeatCount < 255) {
+			flagsOut[flagsLen - 1] |= FLAG_REPEAT;
+			repeatCount++;
+		} else {
+			if (repeatCount > 0) {
+				flagsOut[flagsLen++] = repeatCount;
+				repeatCount = 0;
+			}
+			flagsOut[flagsLen++] = outFlag;
+			lastFlag = outFlag;
 		}
 	}
-	const output = new Uint8Array(encodedFlags.length + xSize + ySize);
-	let offset = 0;
-	for (const f of encodedFlags) output[offset++] = f;
-	xIdx = 0;
-	for (const flag of flags) if ((flag & FLAG_X_SHORT) !== 0) output[offset++] = xCoords[xIdx++];
-	else if ((flag & FLAG_X_SAME) === 0) {
-		const val = xCoords[xIdx++];
-		output[offset++] = val >> 8 & 255;
-		output[offset++] = val & 255;
-	}
-	yIdx = 0;
-	for (const flag of flags) if ((flag & FLAG_Y_SHORT) !== 0) output[offset++] = yCoords[yIdx++];
-	else if ((flag & FLAG_Y_SAME) === 0) {
-		const val = yCoords[yIdx++];
-		output[offset++] = val >> 8 & 255;
-		output[offset++] = val & 255;
-	}
-	return output;
+	if (repeatCount > 0) flagsOut[flagsLen++] = repeatCount;
+	flagStream.pos = flagPos;
+	glyphStream.pos = glyphPos;
+	return {
+		flagsLen,
+		xLen,
+		yLen,
+		xMin,
+		yMin,
+		xMax,
+		yMax
+	};
 }
 function reconstructHmtx(data, table, numGlyphs, numHMetrics, xMins) {
-	const buf = new Buffer$1(data, table.srcOffset, table.srcLength);
-	const hmtxFlags = buf.readU8();
-	if (hmtxFlags === null) throw new Error("Failed to read hmtx flags");
+	const hmtxStream = makeByteStream(data, table.srcOffset, table.srcLength);
+	const hmtxFlags = bsReadU8(hmtxStream);
 	const hasProportionalLsbs = (hmtxFlags & 1) === 0;
 	const hasMonospaceLsbs = (hmtxFlags & 2) === 0;
-	const advanceWidths = [];
-	for (let i = 0; i < numHMetrics; i++) {
-		const w = buf.readU16();
-		if (w === null) throw new Error("Failed to read advance width");
-		advanceWidths.push(w);
-	}
-	const lsbs = [];
-	for (let i = 0; i < numHMetrics; i++) if (hasProportionalLsbs) {
-		const lsb = buf.readS16();
-		if (lsb === null) throw new Error("Failed to read proportional LSB");
-		lsbs.push(lsb);
-	} else lsbs.push(xMins[i]);
-	for (let i = numHMetrics; i < numGlyphs; i++) if (hasMonospaceLsbs) {
-		const lsb = buf.readS16();
-		if (lsb === null) throw new Error("Failed to read monospace LSB");
-		lsbs.push(lsb);
-	} else lsbs.push(xMins[i]);
+	const advanceWidths = new Uint16Array(numHMetrics);
+	for (let i = 0; i < numHMetrics; i++) advanceWidths[i] = bsReadU16(hmtxStream);
+	const lsbs = new Int16Array(numGlyphs);
+	for (let i = 0; i < numHMetrics; i++) if (hasProportionalLsbs) lsbs[i] = bsReadS16(hmtxStream);
+	else lsbs[i] = xMins[i];
+	for (let i = numHMetrics; i < numGlyphs; i++) if (hasMonospaceLsbs) lsbs[i] = bsReadS16(hmtxStream);
+	else lsbs[i] = xMins[i];
 	const outputSize = numHMetrics * 4 + (numGlyphs - numHMetrics) * 2;
 	const output = new Uint8Array(outputSize);
-	const view = new DataView(output.buffer);
 	let offset = 0;
 	for (let i = 0; i < numGlyphs; i++) {
 		if (i < numHMetrics) {
-			view.setUint16(offset, advanceWidths[i]);
+			writeUint16BE(output, offset, advanceWidths[i]);
 			offset += 2;
 		}
-		view.setInt16(offset, lsbs[i]);
+		writeInt16BE(output, offset, lsbs[i]);
 		offset += 2;
 	}
 	return output;
@@ -946,12 +952,24 @@ function updateTableEntry(view, entryOffset, checksum, offset, length) {
 	view.setUint32(entryOffset + 8, offset);
 	view.setUint32(entryOffset + 12, length);
 }
+function readInt16BE(data, offset) {
+	const val = data[offset] << 8 | data[offset + 1];
+	return (val & 32768) !== 0 ? val - 65536 : val;
+}
+function writeInt16BE(data, offset, value) {
+	data[offset] = value >> 8 & 255;
+	data[offset + 1] = value & 255;
+}
+function writeUint16BE(data, offset, value) {
+	data[offset] = value >> 8 & 255;
+	data[offset + 1] = value & 255;
+}
 function computeChecksum(data, offset, length) {
 	let sum = 0;
 	const end = offset + length;
-	const view = new DataView(data.buffer, data.byteOffset);
+	const dataView = new DataView(data.buffer, data.byteOffset);
 	const alignedEnd = offset + (length & -4);
-	for (let i = offset; i < alignedEnd; i += 4) sum = sum + view.getUint32(i) >>> 0;
+	for (let i = offset; i < alignedEnd; i += 4) sum = sum + dataView.getUint32(i) >>> 0;
 	if (end > alignedEnd) {
 		let last = 0;
 		for (let i = alignedEnd; i < end; i++) last = last << 8 | data[i];