pdf-codec 1.3.0 → 1.4.0

package/dist/lexer.cjs

@@ -0,0 +1,180 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_bytes_reader = require("./bytes/reader.cjs");
+//#region src/lexer.ts
+const DELIMITER_BYTES = /* @__PURE__ */ new Set([
+	40,
+	41,
+	60,
+	62,
+	91,
+	93,
+	123,
+	125,
+	47,
+	37
+]);
+function isRegularByte(byte) {
+	return !require_bytes_reader.isAsciiWhitespace(byte) && !DELIMITER_BYTES.has(byte);
+}
+function isDigit(byte) {
+	return byte !== void 0 && byte >= 48 && byte <= 57;
+}
+function isHexDigit(byte) {
+	return byte !== void 0 && (byte >= 48 && byte <= 57 || byte >= 65 && byte <= 70 || byte >= 97 && byte <= 102);
+}
+function hexDigitValue(byte) {
+	if (byte >= 48 && byte <= 57) return byte - 48;
+	if (byte >= 65 && byte <= 70) return byte - 65 + 10;
+	return byte - 97 + 10;
+}
+function skipWhitespaceAndComments(reader) {
+	for (;;) {
+		reader.skipWhitespace();
+		if (reader.peek() !== 37) return;
+		while (!reader.atEnd() && reader.peek() !== 10 && reader.peek() !== 13) reader.next();
+	}
+}
+function readNumberToken(reader) {
+	const start = reader.offset;
+	if (reader.peek() === 43 || reader.peek() === 45) reader.next();
+	while (isDigit(reader.peek())) reader.next();
+	if (reader.peek() === 46) {
+		reader.next();
+		while (isDigit(reader.peek())) reader.next();
+	}
+	const text = new TextDecoder("latin1").decode(reader.slice(start, reader.offset));
+	return {
+		kind: "number",
+		value: Number(text)
+	};
+}
+function readNameToken(reader) {
+	reader.next();
+	const bytes = [];
+	for (;;) {
+		const byte = reader.peek();
+		if (byte === void 0 || !isRegularByte(byte)) break;
+		if (byte === 35 && isHexDigit(reader.peek(1)) && isHexDigit(reader.peek(2))) {
+			reader.next();
+			const hi = hexDigitValue(reader.next());
+			const lo = hexDigitValue(reader.next());
+			bytes.push(hi * 16 + lo);
+		} else bytes.push(reader.next());
+	}
+	return {
+		kind: "name",
+		value: new TextDecoder("latin1").decode(new Uint8Array(bytes))
+	};
+}
+function readLiteralStringToken(reader) {
+	reader.next();
+	const bytes = [];
+	let depth = 1;
+	for (;;) {
+		const byte = reader.next();
+		if (byte === void 0) break;
+		if (byte === 92) {
+			const esc = reader.next();
+			if (esc === void 0) break;
+			if (esc === 110) bytes.push(10);
+			else if (esc === 114) bytes.push(13);
+			else if (esc === 116) bytes.push(9);
+			else if (esc === 98) bytes.push(8);
+			else if (esc === 102) bytes.push(12);
+			else if (esc === 40 || esc === 41 || esc === 92) bytes.push(esc);
+			else if (esc === 13) {
+				if (reader.peek() === 10) reader.next();
+			} else if (esc === 10) {} else if (esc >= 48 && esc <= 55) {
+				let value = esc - 48;
+				for (let i = 0; i < 2 && reader.peek() !== void 0 && reader.peek() >= 48 && reader.peek() <= 55; i++) value = value * 8 + (reader.next() - 48);
+				bytes.push(value & 255);
+			} else bytes.push(esc);
+			continue;
+		}
+		if (byte === 40) {
+			depth++;
+			bytes.push(byte);
+			continue;
+		}
+		if (byte === 41) {
+			depth--;
+			if (depth === 0) break;
+			bytes.push(byte);
+			continue;
+		}
+		if (byte === 13) {
+			if (reader.peek() === 10) reader.next();
+			bytes.push(10);
+			continue;
+		}
+		bytes.push(byte);
+	}
+	return {
+		kind: "literalString",
+		value: new Uint8Array(bytes)
+	};
+}
+function readHexStringToken(reader) {
+	reader.next();
+	const digits = [];
+	for (;;) {
+		const byte = reader.next();
+		if (byte === void 0 || byte === 62) break;
+		if (isHexDigit(byte)) digits.push(hexDigitValue(byte));
+	}
+	if (digits.length % 2 === 1) digits.push(0);
+	const bytes = new Uint8Array(digits.length / 2);
+	for (let i = 0; i < bytes.length; i++) bytes[i] = digits[i * 2] * 16 + digits[i * 2 + 1];
+	return {
+		kind: "hexString",
+		value: bytes
+	};
+}
+function readKeywordToken(reader) {
+	const start = reader.offset;
+	while (reader.peek() !== void 0 && isRegularByte(reader.peek())) reader.next();
+	return {
+		kind: "keyword",
+		value: new TextDecoder("latin1").decode(reader.slice(start, reader.offset))
+	};
+}
+function nextToken(reader) {
+	skipWhitespaceAndComments(reader);
+	const byte = reader.peek();
+	if (byte === void 0) return;
+	if (byte === 47) return readNameToken(reader);
+	if (byte === 40) return readLiteralStringToken(reader);
+	if (byte === 60) {
+		if (reader.peek(1) === 60) {
+			reader.next();
+			reader.next();
+			return { kind: "dictStart" };
+		}
+		return readHexStringToken(reader);
+	}
+	if (byte === 62) {
+		if (reader.peek(1) === 62) {
+			reader.next();
+			reader.next();
+			return { kind: "dictEnd" };
+		}
+		reader.next();
+		return nextToken(reader);
+	}
+	if (byte === 91) {
+		reader.next();
+		return { kind: "arrayStart" };
+	}
+	if (byte === 93) {
+		reader.next();
+		return { kind: "arrayEnd" };
+	}
+	if (byte === 123 || byte === 125) {
+		reader.next();
+		return nextToken(reader);
+	}
+	if (byte === 43 || byte === 45 || byte === 46 || isDigit(byte)) return readNumberToken(reader);
+	return readKeywordToken(reader);
+}
+//#endregion
+exports.nextToken = nextToken;

package/dist/lexer.d.cts

@@ -0,0 +1,29 @@
+import { ByteReader } from "./bytes/reader.cjs";
+//#region src/lexer.d.ts
+type Token = {
+  readonly kind: 'number';
+  readonly value: number;
+} | {
+  readonly kind: 'name';
+  readonly value: string;
+} | {
+  readonly kind: 'literalString';
+  readonly value: Uint8Array<ArrayBuffer>;
+} | {
+  readonly kind: 'hexString';
+  readonly value: Uint8Array<ArrayBuffer>;
+} | {
+  readonly kind: 'arrayStart';
+} | {
+  readonly kind: 'arrayEnd';
+} | {
+  readonly kind: 'dictStart';
+} | {
+  readonly kind: 'dictEnd';
+} | {
+  readonly kind: 'keyword';
+  readonly value: string;
+};
+declare function nextToken(reader: ByteReader): Token | undefined;
+//#endregion
+export { Token, nextToken };

package/dist/lexer.d.ts

@@ -0,0 +1,29 @@
+import { ByteReader } from "./bytes/reader.js";
+//#region src/lexer.d.ts
+type Token = {
+  readonly kind: 'number';
+  readonly value: number;
+} | {
+  readonly kind: 'name';
+  readonly value: string;
+} | {
+  readonly kind: 'literalString';
+  readonly value: Uint8Array<ArrayBuffer>;
+} | {
+  readonly kind: 'hexString';
+  readonly value: Uint8Array<ArrayBuffer>;
+} | {
+  readonly kind: 'arrayStart';
+} | {
+  readonly kind: 'arrayEnd';
+} | {
+  readonly kind: 'dictStart';
+} | {
+  readonly kind: 'dictEnd';
+} | {
+  readonly kind: 'keyword';
+  readonly value: string;
+};
+declare function nextToken(reader: ByteReader): Token | undefined;
+//#endregion
+export { Token, nextToken };

package/dist/lexer.js

@@ -0,0 +1,179 @@
+import { isAsciiWhitespace } from "./bytes/reader.js";
+//#region src/lexer.ts
+const DELIMITER_BYTES = /* @__PURE__ */ new Set([
+	40,
+	41,
+	60,
+	62,
+	91,
+	93,
+	123,
+	125,
+	47,
+	37
+]);
+function isRegularByte(byte) {
+	return !isAsciiWhitespace(byte) && !DELIMITER_BYTES.has(byte);
+}
+function isDigit(byte) {
+	return byte !== void 0 && byte >= 48 && byte <= 57;
+}
+function isHexDigit(byte) {
+	return byte !== void 0 && (byte >= 48 && byte <= 57 || byte >= 65 && byte <= 70 || byte >= 97 && byte <= 102);
+}
+function hexDigitValue(byte) {
+	if (byte >= 48 && byte <= 57) return byte - 48;
+	if (byte >= 65 && byte <= 70) return byte - 65 + 10;
+	return byte - 97 + 10;
+}
+function skipWhitespaceAndComments(reader) {
+	for (;;) {
+		reader.skipWhitespace();
+		if (reader.peek() !== 37) return;
+		while (!reader.atEnd() && reader.peek() !== 10 && reader.peek() !== 13) reader.next();
+	}
+}
+function readNumberToken(reader) {
+	const start = reader.offset;
+	if (reader.peek() === 43 || reader.peek() === 45) reader.next();
+	while (isDigit(reader.peek())) reader.next();
+	if (reader.peek() === 46) {
+		reader.next();
+		while (isDigit(reader.peek())) reader.next();
+	}
+	const text = new TextDecoder("latin1").decode(reader.slice(start, reader.offset));
+	return {
+		kind: "number",
+		value: Number(text)
+	};
+}
+function readNameToken(reader) {
+	reader.next();
+	const bytes = [];
+	for (;;) {
+		const byte = reader.peek();
+		if (byte === void 0 || !isRegularByte(byte)) break;
+		if (byte === 35 && isHexDigit(reader.peek(1)) && isHexDigit(reader.peek(2))) {
+			reader.next();
+			const hi = hexDigitValue(reader.next());
+			const lo = hexDigitValue(reader.next());
+			bytes.push(hi * 16 + lo);
+		} else bytes.push(reader.next());
+	}
+	return {
+		kind: "name",
+		value: new TextDecoder("latin1").decode(new Uint8Array(bytes))
+	};
+}
+function readLiteralStringToken(reader) {
+	reader.next();
+	const bytes = [];
+	let depth = 1;
+	for (;;) {
+		const byte = reader.next();
+		if (byte === void 0) break;
+		if (byte === 92) {
+			const esc = reader.next();
+			if (esc === void 0) break;
+			if (esc === 110) bytes.push(10);
+			else if (esc === 114) bytes.push(13);
+			else if (esc === 116) bytes.push(9);
+			else if (esc === 98) bytes.push(8);
+			else if (esc === 102) bytes.push(12);
+			else if (esc === 40 || esc === 41 || esc === 92) bytes.push(esc);
+			else if (esc === 13) {
+				if (reader.peek() === 10) reader.next();
+			} else if (esc === 10) {} else if (esc >= 48 && esc <= 55) {
+				let value = esc - 48;
+				for (let i = 0; i < 2 && reader.peek() !== void 0 && reader.peek() >= 48 && reader.peek() <= 55; i++) value = value * 8 + (reader.next() - 48);
+				bytes.push(value & 255);
+			} else bytes.push(esc);
+			continue;
+		}
+		if (byte === 40) {
+			depth++;
+			bytes.push(byte);
+			continue;
+		}
+		if (byte === 41) {
+			depth--;
+			if (depth === 0) break;
+			bytes.push(byte);
+			continue;
+		}
+		if (byte === 13) {
+			if (reader.peek() === 10) reader.next();
+			bytes.push(10);
+			continue;
+		}
+		bytes.push(byte);
+	}
+	return {
+		kind: "literalString",
+		value: new Uint8Array(bytes)
+	};
+}
+function readHexStringToken(reader) {
+	reader.next();
+	const digits = [];
+	for (;;) {
+		const byte = reader.next();
+		if (byte === void 0 || byte === 62) break;
+		if (isHexDigit(byte)) digits.push(hexDigitValue(byte));
+	}
+	if (digits.length % 2 === 1) digits.push(0);
+	const bytes = new Uint8Array(digits.length / 2);
+	for (let i = 0; i < bytes.length; i++) bytes[i] = digits[i * 2] * 16 + digits[i * 2 + 1];
+	return {
+		kind: "hexString",
+		value: bytes
+	};
+}
+function readKeywordToken(reader) {
+	const start = reader.offset;
+	while (reader.peek() !== void 0 && isRegularByte(reader.peek())) reader.next();
+	return {
+		kind: "keyword",
+		value: new TextDecoder("latin1").decode(reader.slice(start, reader.offset))
+	};
+}
+function nextToken(reader) {
+	skipWhitespaceAndComments(reader);
+	const byte = reader.peek();
+	if (byte === void 0) return;
+	if (byte === 47) return readNameToken(reader);
+	if (byte === 40) return readLiteralStringToken(reader);
+	if (byte === 60) {
+		if (reader.peek(1) === 60) {
+			reader.next();
+			reader.next();
+			return { kind: "dictStart" };
+		}
+		return readHexStringToken(reader);
+	}
+	if (byte === 62) {
+		if (reader.peek(1) === 62) {
+			reader.next();
+			reader.next();
+			return { kind: "dictEnd" };
+		}
+		reader.next();
+		return nextToken(reader);
+	}
+	if (byte === 91) {
+		reader.next();
+		return { kind: "arrayStart" };
+	}
+	if (byte === 93) {
+		reader.next();
+		return { kind: "arrayEnd" };
+	}
+	if (byte === 123 || byte === 125) {
+		reader.next();
+		return nextToken(reader);
+	}
+	if (byte === 43 || byte === 45 || byte === 46 || isDigit(byte)) return readNumberToken(reader);
+	return readKeywordToken(reader);
+}
+//#endregion
+export { nextToken };

package/dist/math-cmap.cjs

@@ -0,0 +1,81 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_sfnt = require("./sfnt.cjs");
+//#region src/math-cmap.ts
+function parseFormat4(bytes, subtableOffset) {
+	const segCountX2 = require_sfnt.u16(bytes, subtableOffset + 6);
+	const segCount = segCountX2 / 2;
+	const endCodesOffset = subtableOffset + 14;
+	const startCodesOffset = endCodesOffset + segCountX2 + 2;
+	const idDeltasOffset = startCodesOffset + segCountX2;
+	const idRangeOffsetsOffset = idDeltasOffset + segCountX2;
+	const groups = [];
+	for (let i = 0; i < segCount; i++) {
+		const idRangeOffsetPos = idRangeOffsetsOffset + i * 2;
+		groups.push({
+			endCode: require_sfnt.u16(bytes, endCodesOffset + i * 2),
+			startCode: require_sfnt.u16(bytes, startCodesOffset + i * 2),
+			idDelta: (() => {
+				const raw = require_sfnt.u16(bytes, idDeltasOffset + i * 2);
+				return raw >= 32768 ? raw - 65536 : raw;
+			})(),
+			idRangeOffsetPos,
+			idRangeOffset: require_sfnt.u16(bytes, idRangeOffsetPos)
+		});
+	}
+	return (codePoint) => {
+		if (codePoint > 65535) return;
+		for (const group of groups) {
+			if (codePoint < group.startCode || codePoint > group.endCode) continue;
+			if (group.idRangeOffset === 0) return codePoint + group.idDelta & 65535;
+			const glyphIndexAddress = group.idRangeOffsetPos + group.idRangeOffset + (codePoint - group.startCode) * 2;
+			const glyphId = require_sfnt.u16(bytes, glyphIndexAddress);
+			return glyphId === 0 ? void 0 : glyphId + group.idDelta & 65535;
+		}
+	};
+}
+function parseFormat12(bytes, subtableOffset) {
+	const numGroups = require_sfnt.u32(bytes, subtableOffset + 12);
+	const groups = [];
+	for (let i = 0; i < numGroups; i++) {
+		const recordOffset = subtableOffset + 16 + i * 12;
+		groups.push({
+			startCharCode: require_sfnt.u32(bytes, recordOffset),
+			endCharCode: require_sfnt.u32(bytes, recordOffset + 4),
+			startGlyphId: require_sfnt.u32(bytes, recordOffset + 8)
+		});
+	}
+	return (codePoint) => {
+		for (const group of groups) if (codePoint >= group.startCharCode && codePoint <= group.endCharCode) return group.startGlyphId + (codePoint - group.startCharCode);
+	};
+}
+function buildCmapLookup(font) {
+	const cmapBytes = require_sfnt.sfntTableBytes(font, "cmap");
+	if (cmapBytes === void 0) throw new Error("math font has no cmap table");
+	const numTables = require_sfnt.u16(cmapBytes, 2);
+	const subtables = [];
+	for (let i = 0; i < numTables; i++) {
+		const recordOffset = 4 + i * 8;
+		const platformId = require_sfnt.u16(cmapBytes, recordOffset);
+		const encodingId = require_sfnt.u16(cmapBytes, recordOffset + 2);
+		const offset = require_sfnt.u32(cmapBytes, recordOffset + 4);
+		subtables.push({
+			platformId,
+			encodingId,
+			offset,
+			format: require_sfnt.u16(cmapBytes, offset)
+		});
+	}
+	const byPreference = (a) => {
+		if (a.format === 12 && a.platformId === 3 && a.encodingId === 10) return 0;
+		if (a.format === 12 && a.platformId === 0) return 1;
+		if (a.format === 12) return 2;
+		if (a.format === 4 && a.platformId === 3 && a.encodingId === 1) return 3;
+		if (a.format === 4) return 4;
+		return 5;
+	};
+	const best = subtables.filter((s) => s.format === 4 || s.format === 12).sort((a, b) => byPreference(a) - byPreference(b))[0];
+	if (best === void 0) throw new Error("math font cmap has no format 4 or format 12 subtable");
+	return best.format === 12 ? parseFormat12(cmapBytes, best.offset) : parseFormat4(cmapBytes, best.offset);
+}
+//#endregion
+exports.buildCmapLookup = buildCmapLookup;

package/dist/math-cmap.d.cts

@@ -0,0 +1,6 @@
+import { SfntFont } from "./sfnt.cjs";
+//#region src/math-cmap.d.ts
+type CmapLookup = (codePoint: number) => number | undefined;
+declare function buildCmapLookup(font: SfntFont): CmapLookup;
+//#endregion
+export { CmapLookup, buildCmapLookup };

package/dist/math-cmap.d.ts

@@ -0,0 +1,6 @@
+import { SfntFont } from "./sfnt.js";
+//#region src/math-cmap.d.ts
+type CmapLookup = (codePoint: number) => number | undefined;
+declare function buildCmapLookup(font: SfntFont): CmapLookup;
+//#endregion
+export { CmapLookup, buildCmapLookup };

package/dist/math-cmap.js

@@ -0,0 +1,80 @@
+import { sfntTableBytes, u16, u32 } from "./sfnt.js";
+//#region src/math-cmap.ts
+function parseFormat4(bytes, subtableOffset) {
+	const segCountX2 = u16(bytes, subtableOffset + 6);
+	const segCount = segCountX2 / 2;
+	const endCodesOffset = subtableOffset + 14;
+	const startCodesOffset = endCodesOffset + segCountX2 + 2;
+	const idDeltasOffset = startCodesOffset + segCountX2;
+	const idRangeOffsetsOffset = idDeltasOffset + segCountX2;
+	const groups = [];
+	for (let i = 0; i < segCount; i++) {
+		const idRangeOffsetPos = idRangeOffsetsOffset + i * 2;
+		groups.push({
+			endCode: u16(bytes, endCodesOffset + i * 2),
+			startCode: u16(bytes, startCodesOffset + i * 2),
+			idDelta: (() => {
+				const raw = u16(bytes, idDeltasOffset + i * 2);
+				return raw >= 32768 ? raw - 65536 : raw;
+			})(),
+			idRangeOffsetPos,
+			idRangeOffset: u16(bytes, idRangeOffsetPos)
+		});
+	}
+	return (codePoint) => {
+		if (codePoint > 65535) return;
+		for (const group of groups) {
+			if (codePoint < group.startCode || codePoint > group.endCode) continue;
+			if (group.idRangeOffset === 0) return codePoint + group.idDelta & 65535;
+			const glyphIndexAddress = group.idRangeOffsetPos + group.idRangeOffset + (codePoint - group.startCode) * 2;
+			const glyphId = u16(bytes, glyphIndexAddress);
+			return glyphId === 0 ? void 0 : glyphId + group.idDelta & 65535;
+		}
+	};
+}
+function parseFormat12(bytes, subtableOffset) {
+	const numGroups = u32(bytes, subtableOffset + 12);
+	const groups = [];
+	for (let i = 0; i < numGroups; i++) {
+		const recordOffset = subtableOffset + 16 + i * 12;
+		groups.push({
+			startCharCode: u32(bytes, recordOffset),
+			endCharCode: u32(bytes, recordOffset + 4),
+			startGlyphId: u32(bytes, recordOffset + 8)
+		});
+	}
+	return (codePoint) => {
+		for (const group of groups) if (codePoint >= group.startCharCode && codePoint <= group.endCharCode) return group.startGlyphId + (codePoint - group.startCharCode);
+	};
+}
+function buildCmapLookup(font) {
+	const cmapBytes = sfntTableBytes(font, "cmap");
+	if (cmapBytes === void 0) throw new Error("math font has no cmap table");
+	const numTables = u16(cmapBytes, 2);
+	const subtables = [];
+	for (let i = 0; i < numTables; i++) {
+		const recordOffset = 4 + i * 8;
+		const platformId = u16(cmapBytes, recordOffset);
+		const encodingId = u16(cmapBytes, recordOffset + 2);
+		const offset = u32(cmapBytes, recordOffset + 4);
+		subtables.push({
+			platformId,
+			encodingId,
+			offset,
+			format: u16(cmapBytes, offset)
+		});
+	}
+	const byPreference = (a) => {
+		if (a.format === 12 && a.platformId === 3 && a.encodingId === 10) return 0;
+		if (a.format === 12 && a.platformId === 0) return 1;
+		if (a.format === 12) return 2;
+		if (a.format === 4 && a.platformId === 3 && a.encodingId === 1) return 3;
+		if (a.format === 4) return 4;
+		return 5;
+	};
+	const best = subtables.filter((s) => s.format === 4 || s.format === 12).sort((a, b) => byPreference(a) - byPreference(b))[0];
+	if (best === void 0) throw new Error("math font cmap has no format 4 or format 12 subtable");
+	return best.format === 12 ? parseFormat12(cmapBytes, best.offset) : parseFormat4(cmapBytes, best.offset);
+}
+//#endregion
+export { buildCmapLookup };

package/dist/math-content-write.cjs

@@ -0,0 +1,83 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_bytes_writer = require("./bytes/writer.cjs");
+const require_objects = require("./objects.cjs");
+const require_serialize = require("./serialize.cjs");
+//#region src/math-content-write.ts
+function toPdfX(positioned, itemXPt) {
+	return positioned.xPt + itemXPt;
+}
+function toPdfY(positioned, itemYPt) {
+	return positioned.yPt + positioned.box.heightPt - itemYPt;
+}
+function writeRgbOperator(writer, color, operator) {
+	writer.writeAscii(`${require_serialize.formatNumber(color.r)} ${require_serialize.formatNumber(color.g)} ${require_serialize.formatNumber(color.b)} ${operator}\n`);
+}
+function encodeGlyphRunToCids(font, text) {
+	const gids = [];
+	for (const ch of text) {
+		const codePoint = ch.codePointAt(0);
+		if (codePoint === void 0) continue;
+		const glyphId = font.glyphId(codePoint);
+		if (glyphId !== void 0) gids.push(glyphId);
+	}
+	const bytes = new Uint8Array(gids.length * 2);
+	gids.forEach((gid, index) => {
+		bytes[index * 2] = gid >> 8 & 255;
+		bytes[index * 2 + 1] = gid & 255;
+	});
+	return bytes;
+}
+function writeGlyphRun(writer, positioned, item, ctx) {
+	const cidBytes = encodeGlyphRunToCids(ctx.font, item.text);
+	if (cidBytes.length === 0) return;
+	const x = toPdfX(positioned, item.xPt);
+	const y = toPdfY(positioned, item.yPt);
+	writer.writeAscii("BT\n");
+	writer.writeAscii(`/${ctx.resourceName} ${require_serialize.formatNumber(item.sizePt)} Tf\n`);
+	writeRgbOperator(writer, item.color, "rg");
+	writer.writeAscii(`1 0 0 1 ${require_serialize.formatNumber(x)} ${require_serialize.formatNumber(y)} Tm\n`);
+	require_serialize.writeObject(writer, require_objects.pdfHexString(cidBytes));
+	writer.writeAscii(" Tj\n");
+	writer.writeAscii("ET\n");
+}
+function writeRule(writer, positioned, item) {
+	const x = toPdfX(positioned, item.xPt);
+	const topY = toPdfY(positioned, item.yPt);
+	writeRgbOperator(writer, item.color, "rg");
+	writer.writeAscii(`${require_serialize.formatNumber(x)} ${require_serialize.formatNumber(topY - item.heightPt)} ${require_serialize.formatNumber(item.widthPt)} ${require_serialize.formatNumber(item.heightPt)} re\n`);
+	writer.writeAscii("f\n");
+}
+function writeStroke(writer, positioned, item) {
+	if (item.points.length < 2) return;
+	writeRgbOperator(writer, item.color, "RG");
+	writer.writeAscii(`${require_serialize.formatNumber(item.widthPt)} w\n`);
+	item.points.forEach((point, index) => {
+		const x = toPdfX(positioned, point.xPt);
+		const y = toPdfY(positioned, point.yPt);
+		writer.writeAscii(`${require_serialize.formatNumber(x)} ${require_serialize.formatNumber(y)} ${index === 0 ? "m" : "l"}\n`);
+	});
+	writer.writeAscii("S\n");
+}
+function writeFormulaContentStream(formulas, ctx) {
+	const writer = new require_bytes_writer.ByteWriter();
+	for (const positioned of formulas) for (const item of positioned.box.items) if (item.kind === "glyphs") writeGlyphRun(writer, positioned, item, ctx);
+	else if (item.kind === "rule") writeRule(writer, positioned, item);
+	else writeStroke(writer, positioned, item);
+	return writer.toBytes();
+}
+function collectUsedGlyphs(formulas, font) {
+	const used = /* @__PURE__ */ new Map();
+	for (const positioned of formulas) for (const item of positioned.box.items) {
+		if (item.kind !== "glyphs") continue;
+		for (const ch of item.text) {
+			const codePoint = ch.codePointAt(0);
+			if (codePoint === void 0) continue;
+			const glyphId = font.glyphId(codePoint);
+			if (glyphId !== void 0 && !used.has(glyphId)) used.set(glyphId, codePoint);
+		}
+	}
+	return used;
+}
+//#endregion
+exports.collectUsedGlyphs = collectUsedGlyphs;
+exports.writeFormulaContentStream = writeFormulaContentStream;

package/dist/math-content-write.d.cts

@@ -0,0 +1,11 @@
+import { PositionedFormula } from "./formula.cjs";
+import { MathFont } from "./math-font.cjs";
+//#region src/math-content-write.d.ts
+interface MathContentWriteContext {
+  readonly font: MathFont;
+  readonly resourceName: string;
+}
+declare function writeFormulaContentStream(formulas: readonly PositionedFormula[], ctx: MathContentWriteContext): Uint8Array<ArrayBuffer>;
+declare function collectUsedGlyphs(formulas: readonly PositionedFormula[], font: MathFont): ReadonlyMap<number, number>;
+//#endregion
+export { MathContentWriteContext, collectUsedGlyphs, writeFormulaContentStream };