woff2-decode 0.1.0

package/dist/index.cjs

@@ -0,0 +1,970 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+//#region \0rolldown/runtime.js
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") {
+		for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+			key = keys[i];
+			if (!__hasOwnProp.call(to, key) && key !== except) {
+				__defProp(to, key, {
+					get: ((k) => from[k]).bind(null, key),
+					enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+				});
+			}
+		}
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+
+//#endregion
+let brotli_decompress = require("brotli/decompress");
+brotli_decompress = __toESM(brotli_decompress);
+
+//#region src/brotli.ts
+let nativeBrotli = null;
+function tryLoadNative() {
+	try {
+		if (typeof process !== "undefined" && process.versions?.node) {
+			const zlib = require("node:zlib");
+			if (typeof zlib.brotliDecompressSync === "function") return (buf) => {
+				const result = zlib.brotliDecompressSync(buf);
+				return new Uint8Array(result.buffer, result.byteOffset, result.byteLength);
+			};
+		}
+	} catch {}
+	return null;
+}
+nativeBrotli = tryLoadNative();
+function decompress(data) {
+	if (nativeBrotli) return nativeBrotli(data);
+	return (0, brotli_decompress.default)(data);
+}
+function decompressPure(data) {
+	return (0, brotli_decompress.default)(data);
+}
+const hasNative = nativeBrotli !== null;
+
+//#endregion
+//#region src/buffer.ts
+var Buffer$1 = class {
+	constructor(data, offset = 0, length) {
+		this.pos = 0;
+		if (data instanceof Uint8Array) {
+			const len = length ?? data.byteLength - offset;
+			this.view = new DataView(data.buffer, data.byteOffset + offset, len);
+		} else {
+			const len = length ?? data.byteLength - offset;
+			this.view = new DataView(data, offset, len);
+		}
+	}
+	get offset() {
+		return this.pos;
+	}
+	get length() {
+		return this.view.byteLength;
+	}
+	get remaining() {
+		return this.view.byteLength - this.pos;
+	}
+	get buffer() {
+		return this.view;
+	}
+	skip(n) {
+		if (this.pos + n > this.view.byteLength || this.pos + n < this.pos) return false;
+		this.pos += n;
+		return true;
+	}
+	seek(offset) {
+		if (offset > this.view.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++);
+	}
+	readU16() {
+		if (this.pos + 2 > this.view.byteLength) return null;
+		const val = this.view.getUint16(this.pos, false);
+		this.pos += 2;
+		return val;
+	}
+	readS16() {
+		if (this.pos + 2 > this.view.byteLength) return null;
+		const val = this.view.getInt16(this.pos, false);
+		this.pos += 2;
+		return val;
+	}
+	readU32() {
+		if (this.pos + 4 > this.view.byteLength) return null;
+		const val = this.view.getUint32(this.pos, false);
+		this.pos += 4;
+		return val;
+	}
+	readS32() {
+		if (this.pos + 4 > this.view.byteLength) return null;
+		const val = this.view.getInt32(this.pos, false);
+		this.pos += 4;
+		return val;
+	}
+	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);
+		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);
+	}
+	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);
+	}
+};
+
+//#endregion
+//#region src/known-tags.ts
+const KNOWN_TAGS = [
+	1668112752,
+	1751474532,
+	1751672161,
+	1752003704,
+	1835104368,
+	1851878757,
+	1330851634,
+	1886352244,
+	1668707360,
+	1718642541,
+	1735162214,
+	1819239265,
+	1886545264,
+	1128678944,
+	1448038983,
+	1161970772,
+	1161972803,
+	1734439792,
+	1751412088,
+	1801810542,
+	1280594760,
+	1346587732,
+	1447316824,
+	1986553185,
+	1986884728,
+	1111577413,
+	1195656518,
+	1196445523,
+	1196643650,
+	1161974595,
+	1246975046,
+	1296127048,
+	1128416340,
+	1128418371,
+	1129270354,
+	1129333068,
+	1398163232,
+	1935829368,
+	1633906292,
+	1635148146,
+	1650745716,
+	1651273571,
+	1651731566,
+	1668702578,
+	1717859171,
+	1717920116,
+	1718449272,
+	1719034226,
+	1735811442,
+	1752396921,
+	1786082164,
+	1818452338,
+	1836020340,
+	1836020344,
+	1869636196,
+	1886547824,
+	1953653099,
+	1516335206,
+	1399417958,
+	1198285172,
+	1198288739,
+	1181049204,
+	1399417964
+];
+const TAG_GLYF = 1735162214;
+const TAG_LOCA = 1819239265;
+const TAG_HMTX = 1752003704;
+const TAG_HHEA = 1751672161;
+const TAG_HEAD = 1751474532;
+const TTC_FLAVOR = 1953784678;
+const WOFF2_SIGNATURE = 2001684018;
+const WOFF2_FLAGS_TRANSFORM = 32;
+function tagToString(tag) {
+	return String.fromCharCode(tag >> 24 & 255, tag >> 16 & 255, tag >> 8 & 255, tag & 255);
+}
+
+//#endregion
+//#region src/variable-length.ts
+function read255UShort(buf) {
+	const code = buf.readU8();
+	if (code === null) return null;
+	if (code === 253) return buf.readU16();
+	else if (code === 255) {
+		const next = buf.readU8();
+		if (next === null) return null;
+		return 253 + next;
+	} else if (code === 254) {
+		const next = buf.readU8();
+		if (next === null) return null;
+		return 506 + next;
+	} else return code;
+}
+function readBase128(buf) {
+	let result = 0;
+	for (let i = 0; i < 5; i++) {
+		const code = buf.readU8();
+		if (code === null) return null;
+		if (i === 0 && code === 128) return null;
+		if ((result & 4261412864) !== 0) return null;
+		result = result << 7 | code & 127;
+		if ((code & 128) === 0) return result;
+	}
+	return null;
+}
+
+//#endregion
+//#region src/decode.ts
+const SFNT_HEADER_SIZE = 12;
+const SFNT_ENTRY_SIZE = 16;
+function decode(data, options) {
+	const input = data instanceof Uint8Array ? data : new Uint8Array(data);
+	const header = readHeader(new Buffer$1(input), input.byteLength);
+	if (!header) throw new Error("Failed to read WOFF2 header");
+	const compressedData = input.subarray(header.compressedOffset, header.compressedOffset + header.compressedLength);
+	const decompressed = (options?.forcePureBrotli ? decompressPure : decompress)(compressedData);
+	if (!decompressed || decompressed.byteLength !== header.uncompressedSize) throw new Error(`Brotli decompression failed: expected ${header.uncompressedSize} bytes, got ${decompressed?.byteLength ?? 0}`);
+	let outputSize = computeOffsetToFirstTable(header);
+	for (const table of header.tables) {
+		outputSize += table.origLength;
+		outputSize += (4 - table.origLength % 4) % 4;
+	}
+	const output = new Uint8Array(outputSize);
+	const outView = new DataView(output.buffer);
+	const fontInfos = writeHeaders(header, output, outView);
+	const writtenTables = /* @__PURE__ */ new Map();
+	let nextTableOffset = computeOffsetToFirstTable(header);
+	if (header.ttcFonts.length > 0) for (let i = 0; i < header.ttcFonts.length; i++) nextTableOffset = reconstructFont(decompressed, header, i, fontInfos[i], output, outView, writtenTables, nextTableOffset);
+	else reconstructFont(decompressed, header, 0, fontInfos[0], output, outView, writtenTables, nextTableOffset);
+	return output;
+}
+function readHeader(buf, totalLength) {
+	if (buf.readU32() !== WOFF2_SIGNATURE) return null;
+	const flavor = buf.readU32();
+	if (flavor === null) return null;
+	const length = buf.readU32();
+	if (length === null || length !== totalLength) return null;
+	const numTables = buf.readU16();
+	if (numTables === null || numTables === 0) return null;
+	if (!buf.skip(2)) return null;
+	if (!buf.skip(4)) return null;
+	const compressedLength = buf.readU32();
+	if (compressedLength === null) return null;
+	if (!buf.skip(4)) return null;
+	const metaOffset = buf.readU32();
+	const metaLength = buf.readU32();
+	const metaOrigLength = buf.readU32();
+	if (metaOffset === null || metaLength === null || metaOrigLength === null) return null;
+	if (metaOffset !== 0) {
+		if (metaOffset >= totalLength || totalLength - metaOffset < metaLength) return null;
+	}
+	const privOffset = buf.readU32();
+	const privLength = buf.readU32();
+	if (privOffset === null || privLength === null) return null;
+	if (privOffset !== 0) {
+		if (privOffset >= totalLength || totalLength - privOffset < privLength) return null;
+	}
+	const tables = readTableDirectory(buf, numTables);
+	if (!tables) return null;
+	const lastTable = tables[tables.length - 1];
+	const uncompressedSize = lastTable.srcOffset + lastTable.srcLength;
+	let headerVersion = 0;
+	const ttcFonts = [];
+	if (flavor === TTC_FLAVOR) {
+		headerVersion = buf.readU32() ?? 0;
+		if (headerVersion !== 65536 && headerVersion !== 131072) return null;
+		const numFonts = read255UShort(buf);
+		if (numFonts === null || numFonts === 0) return null;
+		for (let i = 0; i < numFonts; i++) {
+			const fontNumTables = read255UShort(buf);
+			if (fontNumTables === null || fontNumTables === 0) return null;
+			const fontFlavor = buf.readU32();
+			if (fontFlavor === null) return null;
+			const tableIndices = [];
+			for (let j = 0; j < fontNumTables; j++) {
+				const idx = read255UShort(buf);
+				if (idx === null || idx >= tables.length) return null;
+				tableIndices.push(idx);
+			}
+			ttcFonts.push({
+				flavor: fontFlavor,
+				dstOffset: 0,
+				headerChecksum: 0,
+				tableIndices
+			});
+		}
+	}
+	return {
+		flavor,
+		headerVersion,
+		numTables,
+		compressedOffset: buf.offset,
+		compressedLength,
+		uncompressedSize,
+		tables,
+		ttcFonts
+	};
+}
+function readTableDirectory(buf, numTables) {
+	const tables = [];
+	let srcOffset = 0;
+	for (let i = 0; i < numTables; i++) {
+		const flagByte = buf.readU8();
+		if (flagByte === null) return null;
+		let tag;
+		if ((flagByte & 63) === 63) {
+			tag = buf.readU32() ?? 0;
+			if (tag === 0) return null;
+		} else tag = KNOWN_TAGS[flagByte & 63];
+		const xformVersion = flagByte >> 6 & 3;
+		let flags = 0;
+		if (tag === TAG_GLYF || tag === TAG_LOCA) {
+			if (xformVersion === 0) flags |= WOFF2_FLAGS_TRANSFORM;
+		} else if (xformVersion !== 0) flags |= WOFF2_FLAGS_TRANSFORM;
+		flags |= xformVersion;
+		const origLength = readBase128(buf);
+		if (origLength === null) return null;
+		let transformLength = origLength;
+		if ((flags & WOFF2_FLAGS_TRANSFORM) !== 0) {
+			transformLength = readBase128(buf) ?? 0;
+			if (transformLength === 0 && tag !== TAG_LOCA) return null;
+			if (tag === TAG_LOCA && transformLength !== 0) return null;
+		}
+		tables.push({
+			tag,
+			flags,
+			origLength,
+			transformLength,
+			srcOffset,
+			srcLength: transformLength,
+			dstOffset: 0,
+			dstLength: origLength
+		});
+		srcOffset += transformLength;
+	}
+	return tables;
+}
+function computeOffsetToFirstTable(header) {
+	if (header.ttcFonts.length === 0) return SFNT_HEADER_SIZE + SFNT_ENTRY_SIZE * header.numTables;
+	let offset = 12;
+	offset += 4 * header.ttcFonts.length;
+	if (header.headerVersion === 131072) offset += 12;
+	for (const ttcFont of header.ttcFonts) {
+		offset += SFNT_HEADER_SIZE;
+		offset += SFNT_ENTRY_SIZE * ttcFont.tableIndices.length;
+	}
+	return offset;
+}
+function writeHeaders(header, output, outView) {
+	const fontInfos = [];
+	let offset = 0;
+	if (header.ttcFonts.length > 0) {
+		outView.setUint32(offset, header.flavor);
+		offset += 4;
+		outView.setUint32(offset, header.headerVersion);
+		offset += 4;
+		outView.setUint32(offset, header.ttcFonts.length);
+		offset += 4;
+		const offsetTableStart = offset;
+		offset += 4 * header.ttcFonts.length;
+		if (header.headerVersion === 131072) offset += 12;
+		for (let i = 0; i < header.ttcFonts.length; i++) {
+			const ttcFont = header.ttcFonts[i];
+			outView.setUint32(offsetTableStart + i * 4, offset);
+			ttcFont.dstOffset = offset;
+			const numTables = ttcFont.tableIndices.length;
+			offset = writeOffsetTable(outView, offset, ttcFont.flavor, numTables);
+			const sortedIndices = [...ttcFont.tableIndices].sort((a, b) => header.tables[a].tag - header.tables[b].tag);
+			const tableEntryByTag = /* @__PURE__ */ new Map();
+			for (const tableIdx of sortedIndices) {
+				const table = header.tables[tableIdx];
+				tableEntryByTag.set(table.tag, offset);
+				offset = writeTableEntry(outView, offset, table.tag);
+			}
+			ttcFont.tableIndices = sortedIndices;
+			ttcFont.headerChecksum = computeChecksum(output, ttcFont.dstOffset, offset - ttcFont.dstOffset);
+			fontInfos.push({
+				numGlyphs: 0,
+				indexFormat: 0,
+				numHMetrics: 0,
+				xMins: new Int16Array(0),
+				tableEntryByTag
+			});
+		}
+	} else {
+		offset = writeOffsetTable(outView, offset, header.flavor, header.numTables);
+		const sortedTables = [...header.tables].sort((a, b) => a.tag - b.tag);
+		const tableEntryByTag = /* @__PURE__ */ new Map();
+		for (const table of sortedTables) {
+			tableEntryByTag.set(table.tag, offset);
+			offset = writeTableEntry(outView, offset, table.tag);
+		}
+		fontInfos.push({
+			numGlyphs: 0,
+			indexFormat: 0,
+			numHMetrics: 0,
+			xMins: new Int16Array(0),
+			tableEntryByTag
+		});
+	}
+	return fontInfos;
+}
+function writeOffsetTable(view, offset, flavor, numTables) {
+	view.setUint32(offset, flavor);
+	view.setUint16(offset + 4, numTables);
+	let maxPow2 = 0;
+	while (1 << maxPow2 + 1 <= numTables) maxPow2++;
+	const searchRange = (1 << maxPow2) * 16;
+	view.setUint16(offset + 6, searchRange);
+	view.setUint16(offset + 8, maxPow2);
+	view.setUint16(offset + 10, numTables * 16 - searchRange);
+	return offset + SFNT_HEADER_SIZE;
+}
+function writeTableEntry(view, offset, tag) {
+	view.setUint32(offset, tag);
+	view.setUint32(offset + 4, 0);
+	view.setUint32(offset + 8, 0);
+	view.setUint32(offset + 12, 0);
+	return offset + SFNT_ENTRY_SIZE;
+}
+function reconstructFont(decompressed, header, fontIndex, fontInfo, output, outView, writtenTables, dstOffset) {
+	const sortedTables = [...header.ttcFonts.length > 0 ? header.ttcFonts[fontIndex].tableIndices.map((i) => header.tables[i]) : header.tables].sort((a, b) => a.tag - b.tag);
+	const glyfTable = sortedTables.find((t) => t.tag === TAG_GLYF);
+	const locaTable = sortedTables.find((t) => t.tag === TAG_LOCA);
+	const hheaTable = sortedTables.find((t) => t.tag === TAG_HHEA);
+	if (hheaTable) {
+		const hheaData = decompressed.subarray(hheaTable.srcOffset, hheaTable.srcOffset + hheaTable.srcLength);
+		if (hheaData.byteLength >= 36) fontInfo.numHMetrics = new DataView(hheaData.buffer, hheaData.byteOffset).getUint16(34);
+	}
+	let fontChecksum = header.ttcFonts.length > 0 ? header.ttcFonts[fontIndex].headerChecksum : 0;
+	const isTTC = header.ttcFonts.length > 0;
+	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);
+		if (existing) {
+			updateTableEntry(outView, entryOffset, existing.checksum, existing.dstOffset, existing.dstLength);
+			if (isTTC) {
+				fontChecksum = fontChecksum + existing.checksum >>> 0;
+				fontChecksum = fontChecksum + computeTableEntryChecksum(existing.checksum, existing.dstOffset, existing.dstLength) >>> 0;
+			}
+			continue;
+		}
+		table.dstOffset = dstOffset;
+		let tableData;
+		let checksum;
+		if ((table.flags & WOFF2_FLAGS_TRANSFORM) !== 0) if (table.tag === TAG_GLYF && glyfTable && locaTable) {
+			const result = reconstructGlyf(decompressed, glyfTable, locaTable, fontInfo);
+			tableData = result.glyfData;
+			glyfTable.dstLength = result.glyfData.byteLength;
+			locaTable.dstOffset = dstOffset + pad4(result.glyfData.byteLength);
+			locaTable.dstLength = result.locaData.byteLength;
+			output.set(tableData, dstOffset);
+			checksum = computeChecksum(output, dstOffset, tableData.byteLength);
+			updateTableEntry(outView, entryOffset, checksum, dstOffset, tableData.byteLength);
+			if (isTTC) {
+				fontChecksum = fontChecksum + checksum >>> 0;
+				fontChecksum = fontChecksum + computeTableEntryChecksum(checksum, dstOffset, tableData.byteLength) >>> 0;
+			}
+			writtenTables.set(tableKey, {
+				dstOffset,
+				dstLength: tableData.byteLength,
+				checksum
+			});
+			dstOffset += pad4(tableData.byteLength);
+			const locaEntryOffset = fontInfo.tableEntryByTag.get(TAG_LOCA);
+			if (locaEntryOffset !== void 0) {
+				output.set(result.locaData, dstOffset);
+				const locaChecksum = computeChecksum(output, dstOffset, result.locaData.byteLength);
+				updateTableEntry(outView, locaEntryOffset, locaChecksum, dstOffset, result.locaData.byteLength);
+				if (isTTC) {
+					fontChecksum = fontChecksum + locaChecksum >>> 0;
+					fontChecksum = fontChecksum + computeTableEntryChecksum(locaChecksum, dstOffset, result.locaData.byteLength) >>> 0;
+				}
+				const locaKey = `${TAG_LOCA}:${locaTable.srcOffset}`;
+				writtenTables.set(locaKey, {
+					dstOffset,
+					dstLength: result.locaData.byteLength,
+					checksum: locaChecksum
+				});
+				dstOffset += pad4(result.locaData.byteLength);
+			}
+			continue;
+		} else if (table.tag === TAG_LOCA) continue;
+		else if (table.tag === TAG_HMTX) tableData = reconstructHmtx(decompressed, table, fontInfo.numGlyphs, fontInfo.numHMetrics, fontInfo.xMins);
+		else throw new Error(`Unknown transform for table ${tagToString(table.tag)}`);
+		else {
+			tableData = decompressed.subarray(table.srcOffset, table.srcOffset + table.srcLength);
+			if (table.tag === TAG_HEAD && tableData.byteLength >= 12) {
+				tableData = new Uint8Array(tableData);
+				new DataView(tableData.buffer, tableData.byteOffset).setUint32(8, 0);
+			}
+		}
+		output.set(tableData, dstOffset);
+		checksum = computeChecksum(output, dstOffset, tableData.byteLength);
+		table.dstLength = tableData.byteLength;
+		updateTableEntry(outView, entryOffset, checksum, dstOffset, tableData.byteLength);
+		if (isTTC) {
+			fontChecksum = fontChecksum + checksum >>> 0;
+			fontChecksum = fontChecksum + computeTableEntryChecksum(checksum, dstOffset, tableData.byteLength) >>> 0;
+		}
+		writtenTables.set(tableKey, {
+			dstOffset,
+			dstLength: tableData.byteLength,
+			checksum
+		});
+		dstOffset += pad4(tableData.byteLength);
+	}
+	const headTable = sortedTables.find((t) => t.tag === TAG_HEAD);
+	if (headTable) {
+		const headEntry = writtenTables.get(`${TAG_HEAD}:${headTable.srcOffset}`);
+		if (headEntry && headEntry.dstLength >= 12) {
+			const finalChecksum = isTTC ? fontChecksum : computeChecksum(output, 0, dstOffset);
+			outView.setUint32(headEntry.dstOffset + 8, 2981146554 - finalChecksum >>> 0);
+		}
+	}
+	return dstOffset;
+}
+function computeTableEntryChecksum(checksum, offset, length) {
+	return checksum + offset + length >>> 0;
+}
+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");
+	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);
+	offset += nContourStreamSize;
+	const nPointsStream = new Buffer$1(data, glyfTable.srcOffset + offset, nPointsStreamSize);
+	offset += nPointsStreamSize;
+	const flagStream = new Buffer$1(data, glyfTable.srcOffset + offset, flagStreamSize);
+	offset += flagStreamSize;
+	const glyphStream = new Buffer$1(data, glyfTable.srcOffset + offset, glyphStreamSize);
+	offset += glyphStreamSize;
+	const compositeStream = new Buffer$1(data, glyfTable.srcOffset + offset, compositeStreamSize);
+	offset += compositeStreamSize;
+	const bboxStream = new Buffer$1(data, glyfTable.srcOffset + offset, bboxStreamSize);
+	offset += bboxStreamSize;
+	const instructionStream = new Buffer$1(data, glyfTable.srcOffset + 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);
+	}
+	const bboxBitmapLength = numGlyphs + 31 >> 5 << 2;
+	const bboxBitmap = bboxStream.readBytes(bboxBitmapLength);
+	if (!bboxBitmap) throw new Error("Failed to read bbox bitmap");
+	let glyfOutput = new Uint8Array(glyfTable.origLength * 2);
+	let glyfOffset = 0;
+	const locaValues = [];
+	fontInfo.xMins = new Int16Array(numGlyphs);
+	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}`);
+		const haveBbox = (bboxBitmap[glyphId >> 3] & 128 >> (glyphId & 7)) !== 0;
+		if (nContours === 0) {
+			if (haveBbox) throw new Error(`Empty glyph ${glyphId} has bbox`);
+			continue;
+		}
+		if (nContours === -1) {
+			if (!haveBbox) throw new Error(`Composite glyph ${glyphId} missing bbox`);
+			const { compositeData, haveInstructions } = readCompositeGlyph(compositeStream);
+			let instructionSize = 0;
+			if (haveInstructions) instructionSize = read255UShort(glyphStream) ?? 0;
+			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");
+			glyfOutput.set(bbox, glyfOffset + 2);
+			fontInfo.xMins[glyphId] = new DataView(bbox.buffer, bbox.byteOffset).getInt16(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");
+				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;
+			glyfOffset = pad4(glyfOffset);
+		}
+	}
+	locaValues.push(glyfOffset);
+	const locaSize = indexFormat ? (numGlyphs + 1) * 4 : (numGlyphs + 1) * 2;
+	const locaData = new Uint8Array(locaSize);
+	const locaView = new DataView(locaData.buffer);
+	for (let i = 0; i <= numGlyphs; i++) if (indexFormat) locaView.setUint32(i * 4, locaValues[i]);
+	else locaView.setUint16(i * 2, locaValues[i] >> 1);
+	return {
+		glyfData: glyfOutput.subarray(0, glyfOffset),
+		locaData
+	};
+	function ensureCapacity(needed) {
+		if (glyfOffset + needed > glyfOutput.byteLength) {
+			const newOutput = new Uint8Array((glyfOffset + needed) * 2);
+			newOutput.set(glyfOutput);
+			glyfOutput = newOutput;
+		}
+	}
+}
+function readCompositeGlyph(stream) {
+	const FLAG_ARG_1_AND_2_ARE_WORDS = 1;
+	const FLAG_WE_HAVE_A_SCALE = 8;
+	const FLAG_MORE_COMPONENTS = 32;
+	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;
+	let haveInstructions = false;
+	let flags = FLAG_MORE_COMPONENTS;
+	while (flags & FLAG_MORE_COMPONENTS) {
+		flags = stream.readU16() ?? 0;
+		haveInstructions = haveInstructions || (flags & FLAG_WE_HAVE_INSTRUCTIONS) !== 0;
+		let argSize = 2;
+		if (flags & FLAG_ARG_1_AND_2_ARE_WORDS) argSize += 4;
+		else argSize += 2;
+		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);
+	}
+	const compositeData = stream.subarray(startOffset, stream.offset - startOffset);
+	if (!compositeData) throw new Error("Failed to read composite glyph data");
+	return {
+		compositeData,
+		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 = [];
+	let x = 0;
+	let y = 0;
+	for (let i = 0; i < nPoints; i++) {
+		const flag = flagStream.readU8();
+		if (flag === null) throw new Error("Failed to read triplet flag");
+		const onCurve = (flag & 128) === 0;
+		const flagLow = flag & 127;
+		let dx, dy;
+		if (flagLow < 10) {
+			dx = 0;
+			const b = glyphStream.readU8();
+			if (b === null) throw new Error("Failed to read triplet data");
+			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");
+			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");
+			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");
+			const idx = flagLow - 84;
+			dx = 1 + (Math.floor(idx / 12) << 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");
+			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");
+			dx = (b0 << 8) + b1;
+			dy = (b2 << 8) + b3;
+			if ((flagLow & 1) === 0) dx = -dx;
+			if ((flagLow & 2) === 0) dy = -dy;
+		}
+		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;
+		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++;
+		} else {
+			if (repeatCount > 0) encodedFlags.push(repeatCount);
+			encodedFlags.push(flag);
+			repeatCount = 0;
+		}
+		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 ((flag & FLAG_Y_SHORT) !== 0) {
+			ySize += 1;
+			yIdx++;
+		} else if ((flag & FLAG_Y_SAME) === 0) {
+			ySize += 2;
+			yIdx++;
+		}
+	}
+	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;
+}
+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 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 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]);
+			offset += 2;
+		}
+		view.setInt16(offset, lsbs[i]);
+		offset += 2;
+	}
+	return output;
+}
+function updateTableEntry(view, entryOffset, checksum, offset, length) {
+	view.setUint32(entryOffset + 4, checksum);
+	view.setUint32(entryOffset + 8, offset);
+	view.setUint32(entryOffset + 12, length);
+}
+function computeChecksum(data, offset, length) {
+	let sum = 0;
+	const end = offset + length;
+	const view = 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;
+	if (end > alignedEnd) {
+		let last = 0;
+		for (let i = alignedEnd; i < end; i++) last = last << 8 | data[i];
+		last <<= (4 - (end - alignedEnd)) * 8;
+		sum = sum + last >>> 0;
+	}
+	return sum;
+}
+function pad4(n) {
+	return n + 3 & -4;
+}
+
+//#endregion
+exports.decode = decode;
+exports.hasNativeBrotli = hasNative;
+//# sourceMappingURL=index.cjs.map