pdf-codec 1.3.0 → 1.4.0

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

@@ -0,0 +1,11 @@
+import { PositionedFormula } from "./formula.js";
+import { MathFont } from "./math-font.js";
+//#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 };

package/dist/math-content-write.js

@@ -0,0 +1,81 @@
+import { ByteWriter } from "./bytes/writer.js";
+import { pdfHexString } from "./objects.js";
+import { formatNumber, writeObject } from "./serialize.js";
+//#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(`${formatNumber(color.r)} ${formatNumber(color.g)} ${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} ${formatNumber(item.sizePt)} Tf\n`);
+	writeRgbOperator(writer, item.color, "rg");
+	writer.writeAscii(`1 0 0 1 ${formatNumber(x)} ${formatNumber(y)} Tm\n`);
+	writeObject(writer, 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(`${formatNumber(x)} ${formatNumber(topY - item.heightPt)} ${formatNumber(item.widthPt)} ${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(`${formatNumber(item.widthPt)} w\n`);
+	item.points.forEach((point, index) => {
+		const x = toPdfX(positioned, point.xPt);
+		const y = toPdfY(positioned, point.yPt);
+		writer.writeAscii(`${formatNumber(x)} ${formatNumber(y)} ${index === 0 ? "m" : "l"}\n`);
+	});
+	writer.writeAscii("S\n");
+}
+function writeFormulaContentStream(formulas, ctx) {
+	const writer = new 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
+export { collectUsedGlyphs, writeFormulaContentStream };

package/dist/math-font-write.cjs

@@ -0,0 +1,100 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_bytes_flate = require("./bytes/flate.cjs");
+const require_objects = require("./objects.cjs");
+//#region src/math-font-write.ts
+const FLAG_SYMBOLIC = 4;
+const NOMINAL_STEM_V = 80;
+function buildWidthsArray(font, usedGlyphs) {
+	const entries = [];
+	for (const glyphId of [...usedGlyphs.keys()].sort((a, b) => a - b)) entries.push(require_objects.pdfNum(glyphId), require_objects.pdfArray([require_objects.pdfNum(font.glyphSpaceWidth(glyphId))]));
+	return require_objects.pdfArray(entries);
+}
+function buildFontDescriptor(font, fontFileRef) {
+	const d = font.descriptor;
+	const scale = 1e3 / d.unitsPerEm;
+	return require_objects.pdfDict({
+		Type: require_objects.pdfName("FontDescriptor"),
+		FontName: require_objects.pdfName("STIXTwoMath-Regular"),
+		Flags: require_objects.pdfNum(FLAG_SYMBOLIC),
+		FontBBox: require_objects.pdfArray([
+			d.bboxMin[0] * scale,
+			d.bboxMin[1] * scale,
+			d.bboxMax[0] * scale,
+			d.bboxMax[1] * scale
+		].map((n) => require_objects.pdfNum(n))),
+		ItalicAngle: require_objects.pdfNum(d.italicAngle),
+		Ascent: require_objects.pdfNum(d.ascent * scale),
+		Descent: require_objects.pdfNum(d.descent * scale),
+		CapHeight: require_objects.pdfNum(d.capHeight * scale),
+		StemV: require_objects.pdfNum(NOMINAL_STEM_V),
+		FontFile3: fontFileRef
+	});
+}
+function buildFontFileStream(font, compress) {
+	const dict = require_objects.pdfDict(compress ? {
+		Subtype: require_objects.pdfName("CIDFontType0C"),
+		Filter: require_objects.pdfName("FlateDecode")
+	} : { Subtype: require_objects.pdfName("CIDFontType0C") });
+	return require_objects.pdfStream(dict, compress ? require_bytes_flate.deflate(font.cffBytes) : font.cffBytes);
+}
+function codePointToUtf16BEHex(codePoint) {
+	const text = String.fromCodePoint(codePoint);
+	let hex = "";
+	for (let i = 0; i < text.length; i++) hex += text.charCodeAt(i).toString(16).padStart(4, "0");
+	return hex;
+}
+function buildToUnicodeCMap(usedGlyphs) {
+	const sortedGids = [...usedGlyphs.keys()].sort((a, b) => a - b);
+	const lines = [
+		"/CIDInit /ProcSet findresource begin",
+		"12 dict begin",
+		"begincmap",
+		"/CIDSystemInfo << /Registry (Adobe) /Ordering (UCS) /Supplement 0 >> def",
+		"/CMapName /Adobe-Identity-UCS def",
+		"/CMapType 2 def",
+		"1 begincodespacerange",
+		"<0000> <FFFF>",
+		"endcodespacerange",
+		`${sortedGids.length} beginbfchar`
+	];
+	for (const gid of sortedGids) {
+		const codePoint = usedGlyphs.get(gid);
+		if (codePoint === void 0) continue;
+		lines.push(`<${gid.toString(16).padStart(4, "0")}> <${codePointToUtf16BEHex(codePoint)}>`);
+	}
+	lines.push("endbfchar", "endcmap", "CMapName currentdict /CMap defineresource pop", "end", "end");
+	const text = `${lines.join("\n")}\n`;
+	const bytes = new TextEncoder().encode(text);
+	return require_objects.pdfStream(require_objects.pdfDict({}), bytes);
+}
+function buildMathFontObjects(font, usedGlyphs, refs, compress) {
+	const cidFont = require_objects.pdfDict({
+		Type: require_objects.pdfName("Font"),
+		Subtype: require_objects.pdfName("CIDFontType0"),
+		BaseFont: require_objects.pdfName("STIXTwoMath-Regular"),
+		CIDSystemInfo: require_objects.pdfDict({
+			Registry: require_objects.pdfHexString(new TextEncoder().encode("Adobe")),
+			Ordering: require_objects.pdfHexString(new TextEncoder().encode("Identity")),
+			Supplement: require_objects.pdfNum(0)
+		}),
+		FontDescriptor: refs.descriptorRef,
+		DW: require_objects.pdfNum(0),
+		W: buildWidthsArray(font, usedGlyphs)
+	});
+	return {
+		type0: require_objects.pdfDict({
+			Type: require_objects.pdfName("Font"),
+			Subtype: require_objects.pdfName("Type0"),
+			BaseFont: require_objects.pdfName("STIXTwoMath-Regular"),
+			Encoding: require_objects.pdfName("Identity-H"),
+			DescendantFonts: require_objects.pdfArray([refs.cidFontRef]),
+			ToUnicode: refs.toUnicodeRef
+		}),
+		cidFont,
+		descriptor: buildFontDescriptor(font, refs.fontFileRef),
+		fontFile: buildFontFileStream(font, compress),
+		toUnicode: buildToUnicodeCMap(usedGlyphs)
+	};
+}
+//#endregion
+exports.buildMathFontObjects = buildMathFontObjects;

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

@@ -0,0 +1,19 @@
+import { PdfDict, PdfObject } from "./objects.cjs";
+import { MathFont } from "./math-font.cjs";
+//#region src/math-font-write.d.ts
+interface MathFontObjectRefs {
+  readonly cidFontRef: PdfObject;
+  readonly descriptorRef: PdfObject;
+  readonly fontFileRef: PdfObject;
+  readonly toUnicodeRef: PdfObject;
+}
+interface MathFontObjects {
+  readonly type0: PdfDict;
+  readonly cidFont: PdfDict;
+  readonly descriptor: PdfDict;
+  readonly fontFile: PdfObject;
+  readonly toUnicode: PdfObject;
+}
+declare function buildMathFontObjects(font: MathFont, usedGlyphs: ReadonlyMap<number, number>, refs: MathFontObjectRefs, compress: boolean): MathFontObjects;
+//#endregion
+export { MathFontObjectRefs, MathFontObjects, buildMathFontObjects };

package/dist/math-font-write.d.ts

@@ -0,0 +1,19 @@
+import { PdfDict, PdfObject } from "./objects.js";
+import { MathFont } from "./math-font.js";
+//#region src/math-font-write.d.ts
+interface MathFontObjectRefs {
+  readonly cidFontRef: PdfObject;
+  readonly descriptorRef: PdfObject;
+  readonly fontFileRef: PdfObject;
+  readonly toUnicodeRef: PdfObject;
+}
+interface MathFontObjects {
+  readonly type0: PdfDict;
+  readonly cidFont: PdfDict;
+  readonly descriptor: PdfDict;
+  readonly fontFile: PdfObject;
+  readonly toUnicode: PdfObject;
+}
+declare function buildMathFontObjects(font: MathFont, usedGlyphs: ReadonlyMap<number, number>, refs: MathFontObjectRefs, compress: boolean): MathFontObjects;
+//#endregion
+export { MathFontObjectRefs, MathFontObjects, buildMathFontObjects };

package/dist/math-font-write.js

@@ -0,0 +1,99 @@
+import { deflate } from "./bytes/flate.js";
+import { pdfArray, pdfDict, pdfHexString, pdfName, pdfNum, pdfStream } from "./objects.js";
+//#region src/math-font-write.ts
+const FLAG_SYMBOLIC = 4;
+const NOMINAL_STEM_V = 80;
+function buildWidthsArray(font, usedGlyphs) {
+	const entries = [];
+	for (const glyphId of [...usedGlyphs.keys()].sort((a, b) => a - b)) entries.push(pdfNum(glyphId), pdfArray([pdfNum(font.glyphSpaceWidth(glyphId))]));
+	return pdfArray(entries);
+}
+function buildFontDescriptor(font, fontFileRef) {
+	const d = font.descriptor;
+	const scale = 1e3 / d.unitsPerEm;
+	return pdfDict({
+		Type: pdfName("FontDescriptor"),
+		FontName: pdfName("STIXTwoMath-Regular"),
+		Flags: pdfNum(FLAG_SYMBOLIC),
+		FontBBox: pdfArray([
+			d.bboxMin[0] * scale,
+			d.bboxMin[1] * scale,
+			d.bboxMax[0] * scale,
+			d.bboxMax[1] * scale
+		].map((n) => pdfNum(n))),
+		ItalicAngle: pdfNum(d.italicAngle),
+		Ascent: pdfNum(d.ascent * scale),
+		Descent: pdfNum(d.descent * scale),
+		CapHeight: pdfNum(d.capHeight * scale),
+		StemV: pdfNum(NOMINAL_STEM_V),
+		FontFile3: fontFileRef
+	});
+}
+function buildFontFileStream(font, compress) {
+	const dict = pdfDict(compress ? {
+		Subtype: pdfName("CIDFontType0C"),
+		Filter: pdfName("FlateDecode")
+	} : { Subtype: pdfName("CIDFontType0C") });
+	return pdfStream(dict, compress ? deflate(font.cffBytes) : font.cffBytes);
+}
+function codePointToUtf16BEHex(codePoint) {
+	const text = String.fromCodePoint(codePoint);
+	let hex = "";
+	for (let i = 0; i < text.length; i++) hex += text.charCodeAt(i).toString(16).padStart(4, "0");
+	return hex;
+}
+function buildToUnicodeCMap(usedGlyphs) {
+	const sortedGids = [...usedGlyphs.keys()].sort((a, b) => a - b);
+	const lines = [
+		"/CIDInit /ProcSet findresource begin",
+		"12 dict begin",
+		"begincmap",
+		"/CIDSystemInfo << /Registry (Adobe) /Ordering (UCS) /Supplement 0 >> def",
+		"/CMapName /Adobe-Identity-UCS def",
+		"/CMapType 2 def",
+		"1 begincodespacerange",
+		"<0000> <FFFF>",
+		"endcodespacerange",
+		`${sortedGids.length} beginbfchar`
+	];
+	for (const gid of sortedGids) {
+		const codePoint = usedGlyphs.get(gid);
+		if (codePoint === void 0) continue;
+		lines.push(`<${gid.toString(16).padStart(4, "0")}> <${codePointToUtf16BEHex(codePoint)}>`);
+	}
+	lines.push("endbfchar", "endcmap", "CMapName currentdict /CMap defineresource pop", "end", "end");
+	const text = `${lines.join("\n")}\n`;
+	const bytes = new TextEncoder().encode(text);
+	return pdfStream(pdfDict({}), bytes);
+}
+function buildMathFontObjects(font, usedGlyphs, refs, compress) {
+	const cidFont = pdfDict({
+		Type: pdfName("Font"),
+		Subtype: pdfName("CIDFontType0"),
+		BaseFont: pdfName("STIXTwoMath-Regular"),
+		CIDSystemInfo: pdfDict({
+			Registry: pdfHexString(new TextEncoder().encode("Adobe")),
+			Ordering: pdfHexString(new TextEncoder().encode("Identity")),
+			Supplement: pdfNum(0)
+		}),
+		FontDescriptor: refs.descriptorRef,
+		DW: pdfNum(0),
+		W: buildWidthsArray(font, usedGlyphs)
+	});
+	return {
+		type0: pdfDict({
+			Type: pdfName("Font"),
+			Subtype: pdfName("Type0"),
+			BaseFont: pdfName("STIXTwoMath-Regular"),
+			Encoding: pdfName("Identity-H"),
+			DescendantFonts: pdfArray([refs.cidFontRef]),
+			ToUnicode: refs.toUnicodeRef
+		}),
+		cidFont,
+		descriptor: buildFontDescriptor(font, refs.fontFileRef),
+		fontFile: buildFontFileStream(font, compress),
+		toUnicode: buildToUnicodeCMap(usedGlyphs)
+	};
+}
+//#endregion
+export { buildMathFontObjects };

package/dist/math-font.cjs

@@ -0,0 +1,103 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_util_base64 = require("./util/base64.cjs");
+const require_assets_stix_two_math_font = require("./assets/stix-two-math-font.cjs");
+const require_sfnt = require("./sfnt.cjs");
+const require_math_cmap = require("./math-cmap.cjs");
+const require_math_hmtx = require("./math-hmtx.cjs");
+const require_math_table = require("./math-table.cjs");
+//#region src/math-font.ts
+function toPt(designUnits, unitsPerEm, sizePt) {
+	return designUnits / unitsPerEm * sizePt;
+}
+function metricsAtSize(cmap, hmtx, math, unitsPerEm, ascentDesignUnits, descentDesignUnits, sizePt) {
+	const c = math.constants;
+	const pt = (designUnits) => toPt(designUnits, unitsPerEm, sizePt);
+	return {
+		ascentPerEm: ascentDesignUnits / unitsPerEm,
+		descentPerEm: -descentDesignUnits / unitsPerEm,
+		axisHeightPt: pt(c.axisHeight),
+		fractionRuleThicknessPt: pt(c.fractionRuleThickness),
+		fractionNumeratorShiftUpPt: pt(c.fractionNumeratorShiftUp),
+		fractionNumeratorDisplayShiftUpPt: pt(c.fractionNumeratorDisplayStyleShiftUp),
+		fractionDenominatorShiftDownPt: pt(c.fractionDenominatorShiftDown),
+		fractionDenominatorDisplayShiftDownPt: pt(c.fractionDenominatorDisplayStyleShiftDown),
+		fractionNumeratorGapMinPt: pt(c.fractionNumeratorGapMin),
+		fractionDenominatorGapMinPt: pt(c.fractionDenominatorGapMin),
+		radicalRuleThicknessPt: pt(c.radicalRuleThickness),
+		radicalExtraAscenderPt: pt(c.radicalExtraAscender),
+		radicalVerticalGapPt: pt(c.radicalVerticalGap),
+		radicalKernBeforeDegreePt: pt(c.radicalKernBeforeDegree),
+		radicalKernAfterDegreePt: pt(c.radicalKernAfterDegree),
+		radicalDegreeBottomRaisePercent: c.radicalDegreeBottomRaisePercent,
+		subscriptShiftDownPt: pt(c.subscriptShiftDown),
+		superscriptShiftUpPt: pt(c.superscriptShiftUp),
+		superscriptShiftUpCrampedPt: pt(c.superscriptShiftUpCramped),
+		subSuperscriptGapMinPt: pt(c.subSuperscriptGapMin),
+		superscriptBaselineDropMaxPt: pt(c.superscriptBaselineDropMax),
+		subscriptBaselineDropMinPt: pt(c.subscriptBaselineDropMin),
+		spaceAfterScriptPt: pt(c.spaceAfterScript),
+		upperLimitGapMinPt: pt(c.upperLimitGapMin),
+		upperLimitBaselineRiseMinPt: pt(c.upperLimitBaselineRiseMin),
+		lowerLimitGapMinPt: pt(c.lowerLimitGapMin),
+		lowerLimitBaselineDropMinPt: pt(c.lowerLimitBaselineDropMin),
+		stackTopShiftUpPt: pt(c.stackTopShiftUp),
+		stackBottomShiftDownPt: pt(c.stackBottomShiftDown),
+		stackGapMinPt: pt(c.stackGapMin),
+		scriptPercentScaleDown: c.scriptPercentScaleDown,
+		scriptScriptPercentScaleDown: c.scriptScriptPercentScaleDown,
+		defaultRuleThicknessPt: pt(c.fractionRuleThickness),
+		glyph(codePoint, glyphSizePt) {
+			const glyphId = cmap(codePoint);
+			if (glyphId === void 0) return;
+			const advanceWidthPt = toPt(hmtx.advanceWidth(glyphId), unitsPerEm, glyphSizePt);
+			const italicCorrectionDesignUnits = math.glyphInfo.italicsCorrection.get(glyphId) ?? 0;
+			const topAccentDesignUnits = math.glyphInfo.topAccentAttachment.get(glyphId);
+			return {
+				advanceWidthPt,
+				italicCorrectionPt: toPt(italicCorrectionDesignUnits, unitsPerEm, glyphSizePt),
+				topAccentXPt: topAccentDesignUnits === void 0 ? void 0 : toPt(topAccentDesignUnits, unitsPerEm, glyphSizePt)
+			};
+		}
+	};
+}
+let cached;
+function loadMathFont() {
+	if (cached !== void 0) return cached;
+	const bytes = require_util_base64.base64ToBytes(require_assets_stix_two_math_font.STIX_TWO_MATH_FONT_BASE64);
+	const sfnt = require_sfnt.parseSfnt(bytes);
+	const headBytes = require_sfnt.sfntTableBytes(sfnt, "head");
+	const hheaBytes = require_sfnt.sfntTableBytes(sfnt, "hhea");
+	const os2Bytes = require_sfnt.sfntTableBytes(sfnt, "OS/2");
+	const cffBytes = require_sfnt.sfntTableBytes(sfnt, "CFF ");
+	if (headBytes === void 0 || hheaBytes === void 0 || cffBytes === void 0) throw new Error("embedded math font is missing a required sfnt table (head/hhea/CFF )");
+	const unitsPerEm = require_sfnt.u16(headBytes, 18);
+	const ascentDesignUnits = require_sfnt.i16(hheaBytes, 4);
+	const descentDesignUnits = require_sfnt.i16(hheaBytes, 6);
+	const bboxMin = [require_sfnt.i16(headBytes, 36), require_sfnt.i16(headBytes, 38)];
+	const bboxMax = [require_sfnt.i16(headBytes, 40), require_sfnt.i16(headBytes, 42)];
+	const capHeight = os2Bytes === void 0 ? ascentDesignUnits : require_sfnt.i16(os2Bytes, 88);
+	const cmap = require_math_cmap.buildCmapLookup(sfnt);
+	const hmtx = require_math_hmtx.parseHmtx(sfnt);
+	const math = require_math_table.parseMathTable(sfnt);
+	cached = {
+		font: {
+			metrics: metricsAtSize(cmap, hmtx, math, unitsPerEm, ascentDesignUnits, descentDesignUnits, unitsPerEm),
+			cffBytes,
+			descriptor: {
+				unitsPerEm,
+				ascent: ascentDesignUnits,
+				descent: descentDesignUnits,
+				capHeight,
+				bboxMin,
+				bboxMax,
+				italicAngle: 0
+			},
+			glyphId: (codePoint) => cmap(codePoint),
+			glyphSpaceWidth: (glyphId) => hmtx.advanceWidth(glyphId) * 1e3 / unitsPerEm
+		},
+		metricsAt: (sizePt) => metricsAtSize(cmap, hmtx, math, unitsPerEm, ascentDesignUnits, descentDesignUnits, sizePt)
+	};
+	return cached;
+}
+//#endregion
+exports.loadMathFont = loadMathFont;

package/dist/math-font.d.cts

@@ -0,0 +1,25 @@
+import { r as MathFontMetrics } from "./math-types-Ba8qAf1p.cjs";
+//#region src/math-font.d.ts
+interface MathFontDescriptorMetrics {
+  readonly unitsPerEm: number;
+  readonly ascent: number;
+  readonly descent: number;
+  readonly capHeight: number;
+  readonly bboxMin: readonly [number, number];
+  readonly bboxMax: readonly [number, number];
+  readonly italicAngle: number;
+}
+interface MathFont {
+  readonly metrics: MathFontMetrics;
+  readonly cffBytes: Uint8Array<ArrayBuffer>;
+  readonly descriptor: MathFontDescriptorMetrics;
+  glyphId(codePoint: number): number | undefined;
+  glyphSpaceWidth(glyphId: number): number;
+}
+interface LoadedMathFont {
+  readonly font: MathFont;
+  readonly metricsAt: (sizePt: number) => MathFontMetrics;
+}
+declare function loadMathFont(): LoadedMathFont;
+//#endregion
+export { LoadedMathFont, MathFont, MathFontDescriptorMetrics, loadMathFont };

package/dist/math-font.d.ts

@@ -0,0 +1,25 @@
+import { r as MathFontMetrics } from "./math-types-Ba8qAf1p.js";
+//#region src/math-font.d.ts
+interface MathFontDescriptorMetrics {
+  readonly unitsPerEm: number;
+  readonly ascent: number;
+  readonly descent: number;
+  readonly capHeight: number;
+  readonly bboxMin: readonly [number, number];
+  readonly bboxMax: readonly [number, number];
+  readonly italicAngle: number;
+}
+interface MathFont {
+  readonly metrics: MathFontMetrics;
+  readonly cffBytes: Uint8Array<ArrayBuffer>;
+  readonly descriptor: MathFontDescriptorMetrics;
+  glyphId(codePoint: number): number | undefined;
+  glyphSpaceWidth(glyphId: number): number;
+}
+interface LoadedMathFont {
+  readonly font: MathFont;
+  readonly metricsAt: (sizePt: number) => MathFontMetrics;
+}
+declare function loadMathFont(): LoadedMathFont;
+//#endregion
+export { LoadedMathFont, MathFont, MathFontDescriptorMetrics, loadMathFont };

package/dist/math-font.js

@@ -0,0 +1,102 @@
+import { base64ToBytes } from "./util/base64.js";
+import { STIX_TWO_MATH_FONT_BASE64 } from "./assets/stix-two-math-font.js";
+import { i16, parseSfnt, sfntTableBytes, u16 } from "./sfnt.js";
+import { buildCmapLookup } from "./math-cmap.js";
+import { parseHmtx } from "./math-hmtx.js";
+import { parseMathTable } from "./math-table.js";
+//#region src/math-font.ts
+function toPt(designUnits, unitsPerEm, sizePt) {
+	return designUnits / unitsPerEm * sizePt;
+}
+function metricsAtSize(cmap, hmtx, math, unitsPerEm, ascentDesignUnits, descentDesignUnits, sizePt) {
+	const c = math.constants;
+	const pt = (designUnits) => toPt(designUnits, unitsPerEm, sizePt);
+	return {
+		ascentPerEm: ascentDesignUnits / unitsPerEm,
+		descentPerEm: -descentDesignUnits / unitsPerEm,
+		axisHeightPt: pt(c.axisHeight),
+		fractionRuleThicknessPt: pt(c.fractionRuleThickness),
+		fractionNumeratorShiftUpPt: pt(c.fractionNumeratorShiftUp),
+		fractionNumeratorDisplayShiftUpPt: pt(c.fractionNumeratorDisplayStyleShiftUp),
+		fractionDenominatorShiftDownPt: pt(c.fractionDenominatorShiftDown),
+		fractionDenominatorDisplayShiftDownPt: pt(c.fractionDenominatorDisplayStyleShiftDown),
+		fractionNumeratorGapMinPt: pt(c.fractionNumeratorGapMin),
+		fractionDenominatorGapMinPt: pt(c.fractionDenominatorGapMin),
+		radicalRuleThicknessPt: pt(c.radicalRuleThickness),
+		radicalExtraAscenderPt: pt(c.radicalExtraAscender),
+		radicalVerticalGapPt: pt(c.radicalVerticalGap),
+		radicalKernBeforeDegreePt: pt(c.radicalKernBeforeDegree),
+		radicalKernAfterDegreePt: pt(c.radicalKernAfterDegree),
+		radicalDegreeBottomRaisePercent: c.radicalDegreeBottomRaisePercent,
+		subscriptShiftDownPt: pt(c.subscriptShiftDown),
+		superscriptShiftUpPt: pt(c.superscriptShiftUp),
+		superscriptShiftUpCrampedPt: pt(c.superscriptShiftUpCramped),
+		subSuperscriptGapMinPt: pt(c.subSuperscriptGapMin),
+		superscriptBaselineDropMaxPt: pt(c.superscriptBaselineDropMax),
+		subscriptBaselineDropMinPt: pt(c.subscriptBaselineDropMin),
+		spaceAfterScriptPt: pt(c.spaceAfterScript),
+		upperLimitGapMinPt: pt(c.upperLimitGapMin),
+		upperLimitBaselineRiseMinPt: pt(c.upperLimitBaselineRiseMin),
+		lowerLimitGapMinPt: pt(c.lowerLimitGapMin),
+		lowerLimitBaselineDropMinPt: pt(c.lowerLimitBaselineDropMin),
+		stackTopShiftUpPt: pt(c.stackTopShiftUp),
+		stackBottomShiftDownPt: pt(c.stackBottomShiftDown),
+		stackGapMinPt: pt(c.stackGapMin),
+		scriptPercentScaleDown: c.scriptPercentScaleDown,
+		scriptScriptPercentScaleDown: c.scriptScriptPercentScaleDown,
+		defaultRuleThicknessPt: pt(c.fractionRuleThickness),
+		glyph(codePoint, glyphSizePt) {
+			const glyphId = cmap(codePoint);
+			if (glyphId === void 0) return;
+			const advanceWidthPt = toPt(hmtx.advanceWidth(glyphId), unitsPerEm, glyphSizePt);
+			const italicCorrectionDesignUnits = math.glyphInfo.italicsCorrection.get(glyphId) ?? 0;
+			const topAccentDesignUnits = math.glyphInfo.topAccentAttachment.get(glyphId);
+			return {
+				advanceWidthPt,
+				italicCorrectionPt: toPt(italicCorrectionDesignUnits, unitsPerEm, glyphSizePt),
+				topAccentXPt: topAccentDesignUnits === void 0 ? void 0 : toPt(topAccentDesignUnits, unitsPerEm, glyphSizePt)
+			};
+		}
+	};
+}
+let cached;
+function loadMathFont() {
+	if (cached !== void 0) return cached;
+	const bytes = base64ToBytes(STIX_TWO_MATH_FONT_BASE64);
+	const sfnt = parseSfnt(bytes);
+	const headBytes = sfntTableBytes(sfnt, "head");
+	const hheaBytes = sfntTableBytes(sfnt, "hhea");
+	const os2Bytes = sfntTableBytes(sfnt, "OS/2");
+	const cffBytes = sfntTableBytes(sfnt, "CFF ");
+	if (headBytes === void 0 || hheaBytes === void 0 || cffBytes === void 0) throw new Error("embedded math font is missing a required sfnt table (head/hhea/CFF )");
+	const unitsPerEm = u16(headBytes, 18);
+	const ascentDesignUnits = i16(hheaBytes, 4);
+	const descentDesignUnits = i16(hheaBytes, 6);
+	const bboxMin = [i16(headBytes, 36), i16(headBytes, 38)];
+	const bboxMax = [i16(headBytes, 40), i16(headBytes, 42)];
+	const capHeight = os2Bytes === void 0 ? ascentDesignUnits : i16(os2Bytes, 88);
+	const cmap = buildCmapLookup(sfnt);
+	const hmtx = parseHmtx(sfnt);
+	const math = parseMathTable(sfnt);
+	cached = {
+		font: {
+			metrics: metricsAtSize(cmap, hmtx, math, unitsPerEm, ascentDesignUnits, descentDesignUnits, unitsPerEm),
+			cffBytes,
+			descriptor: {
+				unitsPerEm,
+				ascent: ascentDesignUnits,
+				descent: descentDesignUnits,
+				capHeight,
+				bboxMin,
+				bboxMax,
+				italicAngle: 0
+			},
+			glyphId: (codePoint) => cmap(codePoint),
+			glyphSpaceWidth: (glyphId) => hmtx.advanceWidth(glyphId) * 1e3 / unitsPerEm
+		},
+		metricsAt: (sizePt) => metricsAtSize(cmap, hmtx, math, unitsPerEm, ascentDesignUnits, descentDesignUnits, sizePt)
+	};
+	return cached;
+}
+//#endregion
+export { loadMathFont };

package/dist/math-hmtx.cjs

@@ -0,0 +1,17 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_sfnt = require("./sfnt.cjs");
+//#region src/math-hmtx.ts
+function parseHmtx(font) {
+	const hheaBytes = require_sfnt.sfntTableBytes(font, "hhea");
+	const hmtxBytes = require_sfnt.sfntTableBytes(font, "hmtx");
+	if (hheaBytes === void 0 || hmtxBytes === void 0) throw new Error("math font has no hhea/hmtx table");
+	const numberOfHMetrics = require_sfnt.u16(hheaBytes, 34);
+	if (numberOfHMetrics === 0) throw new Error("math font hhea numberOfHMetrics is zero");
+	const lastWidth = require_sfnt.u16(hmtxBytes, (numberOfHMetrics - 1) * 4);
+	return { advanceWidth(glyphId) {
+		if (glyphId < numberOfHMetrics) return require_sfnt.u16(hmtxBytes, glyphId * 4);
+		return lastWidth;
+	} };
+}
+//#endregion
+exports.parseHmtx = parseHmtx;

package/dist/math-hmtx.d.cts

@@ -0,0 +1,8 @@
+import { SfntFont } from "./sfnt.cjs";
+//#region src/math-hmtx.d.ts
+interface HmtxTable {
+  advanceWidth(glyphId: number): number;
+}
+declare function parseHmtx(font: SfntFont): HmtxTable;
+//#endregion
+export { HmtxTable, parseHmtx };

package/dist/math-hmtx.d.ts

@@ -0,0 +1,8 @@
+import { SfntFont } from "./sfnt.js";
+//#region src/math-hmtx.d.ts
+interface HmtxTable {
+  advanceWidth(glyphId: number): number;
+}
+declare function parseHmtx(font: SfntFont): HmtxTable;
+//#endregion
+export { HmtxTable, parseHmtx };

package/dist/math-hmtx.js

@@ -0,0 +1,16 @@
+import { sfntTableBytes, u16 } from "./sfnt.js";
+//#region src/math-hmtx.ts
+function parseHmtx(font) {
+	const hheaBytes = sfntTableBytes(font, "hhea");
+	const hmtxBytes = sfntTableBytes(font, "hmtx");
+	if (hheaBytes === void 0 || hmtxBytes === void 0) throw new Error("math font has no hhea/hmtx table");
+	const numberOfHMetrics = u16(hheaBytes, 34);
+	if (numberOfHMetrics === 0) throw new Error("math font hhea numberOfHMetrics is zero");
+	const lastWidth = u16(hmtxBytes, (numberOfHMetrics - 1) * 4);
+	return { advanceWidth(glyphId) {
+		if (glyphId < numberOfHMetrics) return u16(hmtxBytes, glyphId * 4);
+		return lastWidth;
+	} };
+}
+//#endregion
+export { parseHmtx };