pdf-codec 1.5.0 → 1.7.0

package/dist/math-stretch.js

@@ -0,0 +1,94 @@
+//#region src/math-stretch.ts
+function sumBy(items, value) {
+	return items.reduce((total, item) => total + value(item), 0);
+}
+function requiredRepeatCount(fixed, extenders, targetSize, minConnectorOverlap) {
+	const minimumRepeat = fixed.length === 0 ? 1 : 0;
+	if (extenders.length === 0) return minimumRepeat;
+	const growthPerRepeat = sumBy(extenders, (part) => part.fullAdvance) - extenders.length * minConnectorOverlap;
+	if (growthPerRepeat <= 0) return minimumRepeat;
+	const shortfall = targetSize - sumBy(fixed, (part) => part.fullAdvance) + (fixed.length - 1) * minConnectorOverlap;
+	return Math.max(minimumRepeat, Math.ceil(shortfall / growthPerRepeat));
+}
+function expandParts(parts, repeatCount) {
+	const expanded = [];
+	for (const part of parts) for (let i = 0; i < (part.isExtender ? repeatCount : 1); i++) expanded.push(part);
+	return expanded;
+}
+function maximumOverlap(expanded) {
+	let overlap = Number.POSITIVE_INFINITY;
+	for (let i = 0; i + 1 < expanded.length; i++) overlap = Math.min(overlap, expanded[i].endConnectorLength, expanded[i + 1].startConnectorLength);
+	for (let i = 0; i < expanded.length; i++) {
+		const joins = (i === 0 ? 0 : 1) + (i === expanded.length - 1 ? 0 : 1);
+		if (joins > 0) overlap = Math.min(overlap, expanded[i].fullAdvance / joins);
+	}
+	return overlap;
+}
+function assembleFromParts(assembly, options) {
+	const fixed = assembly.parts.filter((part) => !part.isExtender);
+	const extenders = assembly.parts.filter((part) => part.isExtender);
+	const expanded = expandParts(assembly.parts, requiredRepeatCount(fixed, extenders, options.targetSize, options.minConnectorOverlap));
+	if (expanded.length === 0) return;
+	const joins = expanded.length - 1;
+	const maxOverlap = maximumOverlap(expanded);
+	const minOverlap = Math.min(options.minConnectorOverlap, maxOverlap);
+	const totalAdvance = sumBy(expanded, (part) => part.fullAdvance);
+	const exactOverlap = joins === 0 ? minOverlap : (totalAdvance - options.targetSize) / joins;
+	const overlap = Math.min(Math.max(exactOverlap, minOverlap), maxOverlap);
+	const placements = [];
+	let offset = 0;
+	for (const part of expanded) {
+		placements.push({
+			glyphId: part.glyphId,
+			offset,
+			advance: part.fullAdvance
+		});
+		offset += part.fullAdvance - overlap;
+	}
+	return {
+		kind: "assembly",
+		axis: options.axis,
+		size: totalAdvance - joins * overlap,
+		italicsCorrection: assembly.italicsCorrection,
+		placements
+	};
+}
+function fromVariant(variant, isBaseGlyph, axis) {
+	return {
+		kind: isBaseGlyph ? "base" : "variant",
+		axis,
+		size: variant.advanceMeasurement,
+		italicsCorrection: 0,
+		placements: [{
+			glyphId: variant.glyphId,
+			offset: 0,
+			advance: variant.advanceMeasurement
+		}]
+	};
+}
+function assembleStretchyGlyph(construction, options) {
+	const variants = construction.variants;
+	const reaching = variants.findIndex((variant) => variant.advanceMeasurement >= options.targetSize);
+	if (reaching !== -1) return fromVariant(variants[reaching], reaching === 0, options.axis);
+	if (construction.assembly !== void 0) {
+		const assembled = assembleFromParts(construction.assembly, options);
+		if (assembled !== void 0) return assembled;
+	}
+	const largest = variants[variants.length - 1];
+	return largest === void 0 ? void 0 : fromVariant(largest, variants.length === 1, options.axis);
+}
+function scaleMathStretchConstruction(construction, factor) {
+	return {
+		kind: construction.kind,
+		axis: construction.axis,
+		size: construction.size * factor,
+		italicsCorrection: construction.italicsCorrection * factor,
+		placements: construction.placements.map((placement) => ({
+			glyphId: placement.glyphId,
+			offset: placement.offset * factor,
+			advance: placement.advance * factor
+		}))
+	};
+}
+//#endregion
+export { assembleStretchyGlyph, scaleMathStretchConstruction };

package/dist/math-table-DhPrNoPa.d.ts

@@ -0,0 +1,70 @@
+import { t as SfntFont } from "./sfnt-V08bb5ut.js";
+//#region src/math-table.d.ts
+interface MathConstants {
+  readonly scriptPercentScaleDown: number;
+  readonly scriptScriptPercentScaleDown: number;
+  readonly axisHeight: number;
+  readonly subscriptShiftDown: number;
+  readonly subscriptBaselineDropMin: number;
+  readonly superscriptShiftUp: number;
+  readonly superscriptShiftUpCramped: number;
+  readonly superscriptBaselineDropMax: number;
+  readonly subSuperscriptGapMin: number;
+  readonly spaceAfterScript: number;
+  readonly upperLimitGapMin: number;
+  readonly upperLimitBaselineRiseMin: number;
+  readonly lowerLimitGapMin: number;
+  readonly lowerLimitBaselineDropMin: number;
+  readonly stackTopShiftUp: number;
+  readonly stackBottomShiftDown: number;
+  readonly stackGapMin: number;
+  readonly fractionNumeratorShiftUp: number;
+  readonly fractionNumeratorDisplayStyleShiftUp: number;
+  readonly fractionDenominatorShiftDown: number;
+  readonly fractionDenominatorDisplayStyleShiftDown: number;
+  readonly fractionNumeratorGapMin: number;
+  readonly fractionRuleThickness: number;
+  readonly fractionDenominatorGapMin: number;
+  readonly radicalVerticalGap: number;
+  readonly radicalRuleThickness: number;
+  readonly radicalExtraAscender: number;
+  readonly radicalKernBeforeDegree: number;
+  readonly radicalKernAfterDegree: number;
+  readonly radicalDegreeBottomRaisePercent: number;
+}
+interface MathGlyphInfo {
+  readonly italicsCorrection: ReadonlyMap<number, number>;
+  readonly topAccentAttachment: ReadonlyMap<number, number>;
+}
+interface MathGlyphVariant {
+  readonly glyphId: number;
+  readonly advanceMeasurement: number;
+}
+interface MathGlyphPart {
+  readonly glyphId: number;
+  readonly startConnectorLength: number;
+  readonly endConnectorLength: number;
+  readonly fullAdvance: number;
+  readonly isExtender: boolean;
+}
+interface MathGlyphAssembly {
+  readonly italicsCorrection: number;
+  readonly parts: readonly MathGlyphPart[];
+}
+interface MathGlyphConstruction {
+  readonly variants: readonly MathGlyphVariant[];
+  readonly assembly?: MathGlyphAssembly;
+}
+interface MathVariants {
+  readonly minConnectorOverlap: number;
+  readonly vertical: ReadonlyMap<number, MathGlyphConstruction>;
+  readonly horizontal: ReadonlyMap<number, MathGlyphConstruction>;
+}
+interface MathTable {
+  readonly constants: MathConstants;
+  readonly glyphInfo: MathGlyphInfo;
+  readonly variants: MathVariants;
+}
+declare function parseMathTable(font: SfntFont): MathTable;
+//#endregion
+export { MathGlyphPart as a, MathVariants as c, MathGlyphInfo as i, parseMathTable as l, MathGlyphAssembly as n, MathGlyphVariant as o, MathGlyphConstruction as r, MathTable as s, MathConstants as t };

package/dist/math-table-gFNB8DmQ.d.cts

@@ -0,0 +1,70 @@
+import { t as SfntFont } from "./sfnt-V08bb5ut.cjs";
+//#region src/math-table.d.ts
+interface MathConstants {
+  readonly scriptPercentScaleDown: number;
+  readonly scriptScriptPercentScaleDown: number;
+  readonly axisHeight: number;
+  readonly subscriptShiftDown: number;
+  readonly subscriptBaselineDropMin: number;
+  readonly superscriptShiftUp: number;
+  readonly superscriptShiftUpCramped: number;
+  readonly superscriptBaselineDropMax: number;
+  readonly subSuperscriptGapMin: number;
+  readonly spaceAfterScript: number;
+  readonly upperLimitGapMin: number;
+  readonly upperLimitBaselineRiseMin: number;
+  readonly lowerLimitGapMin: number;
+  readonly lowerLimitBaselineDropMin: number;
+  readonly stackTopShiftUp: number;
+  readonly stackBottomShiftDown: number;
+  readonly stackGapMin: number;
+  readonly fractionNumeratorShiftUp: number;
+  readonly fractionNumeratorDisplayStyleShiftUp: number;
+  readonly fractionDenominatorShiftDown: number;
+  readonly fractionDenominatorDisplayStyleShiftDown: number;
+  readonly fractionNumeratorGapMin: number;
+  readonly fractionRuleThickness: number;
+  readonly fractionDenominatorGapMin: number;
+  readonly radicalVerticalGap: number;
+  readonly radicalRuleThickness: number;
+  readonly radicalExtraAscender: number;
+  readonly radicalKernBeforeDegree: number;
+  readonly radicalKernAfterDegree: number;
+  readonly radicalDegreeBottomRaisePercent: number;
+}
+interface MathGlyphInfo {
+  readonly italicsCorrection: ReadonlyMap<number, number>;
+  readonly topAccentAttachment: ReadonlyMap<number, number>;
+}
+interface MathGlyphVariant {
+  readonly glyphId: number;
+  readonly advanceMeasurement: number;
+}
+interface MathGlyphPart {
+  readonly glyphId: number;
+  readonly startConnectorLength: number;
+  readonly endConnectorLength: number;
+  readonly fullAdvance: number;
+  readonly isExtender: boolean;
+}
+interface MathGlyphAssembly {
+  readonly italicsCorrection: number;
+  readonly parts: readonly MathGlyphPart[];
+}
+interface MathGlyphConstruction {
+  readonly variants: readonly MathGlyphVariant[];
+  readonly assembly?: MathGlyphAssembly;
+}
+interface MathVariants {
+  readonly minConnectorOverlap: number;
+  readonly vertical: ReadonlyMap<number, MathGlyphConstruction>;
+  readonly horizontal: ReadonlyMap<number, MathGlyphConstruction>;
+}
+interface MathTable {
+  readonly constants: MathConstants;
+  readonly glyphInfo: MathGlyphInfo;
+  readonly variants: MathVariants;
+}
+declare function parseMathTable(font: SfntFont): MathTable;
+//#endregion
+export { MathGlyphPart as a, MathVariants as c, MathGlyphInfo as i, parseMathTable as l, MathGlyphAssembly as n, MathGlyphVariant as o, MathGlyphConstruction as r, MathTable as s, MathConstants as t };

package/dist/math-table.cjs

@@ -105,12 +105,80 @@ function parseMathGlyphInfo(bytes, mathTableOffset) {
 		topAccentAttachment: topAccentOffset === 0 ? /* @__PURE__ */ new Map() : parseGlyphValueTable(bytes, glyphInfoOffset + topAccentOffset)
 	};
 }
+const MATH_GLYPH_VARIANT_RECORD_SIZE = 4;
+const GLYPH_PART_RECORD_SIZE = 10;
+const GLYPH_PART_FLAG_EXTENDER = 1;
+const MATH_VARIANTS_HEADER_SIZE = 10;
+function parseGlyphAssembly(bytes, assemblyOffset) {
+	const partCount = require_sfnt.u16(bytes, assemblyOffset + MATH_VALUE_RECORD_SIZE);
+	const parts = [];
+	for (let i = 0; i < partCount; i++) {
+		const recordOffset = assemblyOffset + MATH_VALUE_RECORD_SIZE + 2 + i * GLYPH_PART_RECORD_SIZE;
+		parts.push({
+			glyphId: require_sfnt.u16(bytes, recordOffset),
+			startConnectorLength: require_sfnt.u16(bytes, recordOffset + 2),
+			endConnectorLength: require_sfnt.u16(bytes, recordOffset + 4),
+			fullAdvance: require_sfnt.u16(bytes, recordOffset + 6),
+			isExtender: (require_sfnt.u16(bytes, recordOffset + 8) & GLYPH_PART_FLAG_EXTENDER) !== 0
+		});
+	}
+	return {
+		italicsCorrection: require_sfnt.i16(bytes, assemblyOffset),
+		parts
+	};
+}
+function parseGlyphConstruction(bytes, constructionOffset) {
+	const assemblyOffset = require_sfnt.u16(bytes, constructionOffset);
+	const variantCount = require_sfnt.u16(bytes, constructionOffset + 2);
+	const variants = [];
+	for (let i = 0; i < variantCount; i++) {
+		const recordOffset = constructionOffset + 4 + i * MATH_GLYPH_VARIANT_RECORD_SIZE;
+		variants.push({
+			glyphId: require_sfnt.u16(bytes, recordOffset),
+			advanceMeasurement: require_sfnt.u16(bytes, recordOffset + 2)
+		});
+	}
+	return assemblyOffset === 0 ? { variants } : {
+		variants,
+		assembly: parseGlyphAssembly(bytes, constructionOffset + assemblyOffset)
+	};
+}
+function parseConstructionsForAxis(bytes, variantsOffset, coverageOffset, count, constructionArrayOffset) {
+	const constructions = /* @__PURE__ */ new Map();
+	if (coverageOffset === 0) return constructions;
+	for (const [glyphId, coverageIndex] of parseCoverageIndex(bytes, variantsOffset + coverageOffset)) {
+		if (coverageIndex >= count) continue;
+		constructions.set(glyphId, parseGlyphConstruction(bytes, variantsOffset + require_sfnt.u16(bytes, constructionArrayOffset + coverageIndex * 2)));
+	}
+	return constructions;
+}
+function parseMathVariants(bytes, mathTableOffset) {
+	const variantsTableOffset = require_sfnt.u16(bytes, mathTableOffset + 8);
+	if (variantsTableOffset === 0) return {
+		minConnectorOverlap: 0,
+		vertical: /* @__PURE__ */ new Map(),
+		horizontal: /* @__PURE__ */ new Map()
+	};
+	const variantsOffset = mathTableOffset + variantsTableOffset;
+	const verticalCoverageOffset = require_sfnt.u16(bytes, variantsOffset + 2);
+	const horizontalCoverageOffset = require_sfnt.u16(bytes, variantsOffset + 4);
+	const verticalCount = require_sfnt.u16(bytes, variantsOffset + 6);
+	const horizontalCount = require_sfnt.u16(bytes, variantsOffset + 8);
+	const verticalArrayOffset = variantsOffset + MATH_VARIANTS_HEADER_SIZE;
+	const horizontalArrayOffset = verticalArrayOffset + verticalCount * 2;
+	return {
+		minConnectorOverlap: require_sfnt.u16(bytes, variantsOffset),
+		vertical: parseConstructionsForAxis(bytes, variantsOffset, verticalCoverageOffset, verticalCount, verticalArrayOffset),
+		horizontal: parseConstructionsForAxis(bytes, variantsOffset, horizontalCoverageOffset, horizontalCount, horizontalArrayOffset)
+	};
+}
 function parseMathTable(font) {
 	const mathBytes = require_sfnt.sfntTableBytes(font, "MATH");
 	if (mathBytes === void 0) throw new Error("math font has no MATH table");
 	return {
 		constants: parseMathConstants(mathBytes, 0),
-		glyphInfo: parseMathGlyphInfo(mathBytes, 0)
+		glyphInfo: parseMathGlyphInfo(mathBytes, 0),
+		variants: parseMathVariants(mathBytes, 0)
 	};
 }
 //#endregion

package/dist/math-table.d.cts

@@ -1,45 +1,2 @@
-import { SfntFont } from "./sfnt.cjs";
-//#region src/math-table.d.ts
-interface MathConstants {
-  readonly scriptPercentScaleDown: number;
-  readonly scriptScriptPercentScaleDown: number;
-  readonly axisHeight: number;
-  readonly subscriptShiftDown: number;
-  readonly subscriptBaselineDropMin: number;
-  readonly superscriptShiftUp: number;
-  readonly superscriptShiftUpCramped: number;
-  readonly superscriptBaselineDropMax: number;
-  readonly subSuperscriptGapMin: number;
-  readonly spaceAfterScript: number;
-  readonly upperLimitGapMin: number;
-  readonly upperLimitBaselineRiseMin: number;
-  readonly lowerLimitGapMin: number;
-  readonly lowerLimitBaselineDropMin: number;
-  readonly stackTopShiftUp: number;
-  readonly stackBottomShiftDown: number;
-  readonly stackGapMin: number;
-  readonly fractionNumeratorShiftUp: number;
-  readonly fractionNumeratorDisplayStyleShiftUp: number;
-  readonly fractionDenominatorShiftDown: number;
-  readonly fractionDenominatorDisplayStyleShiftDown: number;
-  readonly fractionNumeratorGapMin: number;
-  readonly fractionRuleThickness: number;
-  readonly fractionDenominatorGapMin: number;
-  readonly radicalVerticalGap: number;
-  readonly radicalRuleThickness: number;
-  readonly radicalExtraAscender: number;
-  readonly radicalKernBeforeDegree: number;
-  readonly radicalKernAfterDegree: number;
-  readonly radicalDegreeBottomRaisePercent: number;
-}
-interface MathGlyphInfo {
-  readonly italicsCorrection: ReadonlyMap<number, number>;
-  readonly topAccentAttachment: ReadonlyMap<number, number>;
-}
-interface MathTable {
-  readonly constants: MathConstants;
-  readonly glyphInfo: MathGlyphInfo;
-}
-declare function parseMathTable(font: SfntFont): MathTable;
-//#endregion
-export { MathConstants, MathGlyphInfo, MathTable, parseMathTable };
+import { a as MathGlyphPart, c as MathVariants, i as MathGlyphInfo, l as parseMathTable, n as MathGlyphAssembly, o as MathGlyphVariant, r as MathGlyphConstruction, s as MathTable, t as MathConstants } from "./math-table-gFNB8DmQ.cjs";
+export { MathConstants, MathGlyphAssembly, MathGlyphConstruction, MathGlyphInfo, MathGlyphPart, MathGlyphVariant, MathTable, MathVariants, parseMathTable };

package/dist/math-table.d.ts

@@ -1,45 +1,2 @@
-import { SfntFont } from "./sfnt.js";
-//#region src/math-table.d.ts
-interface MathConstants {
-  readonly scriptPercentScaleDown: number;
-  readonly scriptScriptPercentScaleDown: number;
-  readonly axisHeight: number;
-  readonly subscriptShiftDown: number;
-  readonly subscriptBaselineDropMin: number;
-  readonly superscriptShiftUp: number;
-  readonly superscriptShiftUpCramped: number;
-  readonly superscriptBaselineDropMax: number;
-  readonly subSuperscriptGapMin: number;
-  readonly spaceAfterScript: number;
-  readonly upperLimitGapMin: number;
-  readonly upperLimitBaselineRiseMin: number;
-  readonly lowerLimitGapMin: number;
-  readonly lowerLimitBaselineDropMin: number;
-  readonly stackTopShiftUp: number;
-  readonly stackBottomShiftDown: number;
-  readonly stackGapMin: number;
-  readonly fractionNumeratorShiftUp: number;
-  readonly fractionNumeratorDisplayStyleShiftUp: number;
-  readonly fractionDenominatorShiftDown: number;
-  readonly fractionDenominatorDisplayStyleShiftDown: number;
-  readonly fractionNumeratorGapMin: number;
-  readonly fractionRuleThickness: number;
-  readonly fractionDenominatorGapMin: number;
-  readonly radicalVerticalGap: number;
-  readonly radicalRuleThickness: number;
-  readonly radicalExtraAscender: number;
-  readonly radicalKernBeforeDegree: number;
-  readonly radicalKernAfterDegree: number;
-  readonly radicalDegreeBottomRaisePercent: number;
-}
-interface MathGlyphInfo {
-  readonly italicsCorrection: ReadonlyMap<number, number>;
-  readonly topAccentAttachment: ReadonlyMap<number, number>;
-}
-interface MathTable {
-  readonly constants: MathConstants;
-  readonly glyphInfo: MathGlyphInfo;
-}
-declare function parseMathTable(font: SfntFont): MathTable;
-//#endregion
-export { MathConstants, MathGlyphInfo, MathTable, parseMathTable };
+import { a as MathGlyphPart, c as MathVariants, i as MathGlyphInfo, l as parseMathTable, n as MathGlyphAssembly, o as MathGlyphVariant, r as MathGlyphConstruction, s as MathTable, t as MathConstants } from "./math-table-DhPrNoPa.js";
+export { MathConstants, MathGlyphAssembly, MathGlyphConstruction, MathGlyphInfo, MathGlyphPart, MathGlyphVariant, MathTable, MathVariants, parseMathTable };

package/dist/math-table.js

@@ -104,12 +104,80 @@ function parseMathGlyphInfo(bytes, mathTableOffset) {
 		topAccentAttachment: topAccentOffset === 0 ? /* @__PURE__ */ new Map() : parseGlyphValueTable(bytes, glyphInfoOffset + topAccentOffset)
 	};
 }
+const MATH_GLYPH_VARIANT_RECORD_SIZE = 4;
+const GLYPH_PART_RECORD_SIZE = 10;
+const GLYPH_PART_FLAG_EXTENDER = 1;
+const MATH_VARIANTS_HEADER_SIZE = 10;
+function parseGlyphAssembly(bytes, assemblyOffset) {
+	const partCount = u16(bytes, assemblyOffset + MATH_VALUE_RECORD_SIZE);
+	const parts = [];
+	for (let i = 0; i < partCount; i++) {
+		const recordOffset = assemblyOffset + MATH_VALUE_RECORD_SIZE + 2 + i * GLYPH_PART_RECORD_SIZE;
+		parts.push({
+			glyphId: u16(bytes, recordOffset),
+			startConnectorLength: u16(bytes, recordOffset + 2),
+			endConnectorLength: u16(bytes, recordOffset + 4),
+			fullAdvance: u16(bytes, recordOffset + 6),
+			isExtender: (u16(bytes, recordOffset + 8) & GLYPH_PART_FLAG_EXTENDER) !== 0
+		});
+	}
+	return {
+		italicsCorrection: i16(bytes, assemblyOffset),
+		parts
+	};
+}
+function parseGlyphConstruction(bytes, constructionOffset) {
+	const assemblyOffset = u16(bytes, constructionOffset);
+	const variantCount = u16(bytes, constructionOffset + 2);
+	const variants = [];
+	for (let i = 0; i < variantCount; i++) {
+		const recordOffset = constructionOffset + 4 + i * MATH_GLYPH_VARIANT_RECORD_SIZE;
+		variants.push({
+			glyphId: u16(bytes, recordOffset),
+			advanceMeasurement: u16(bytes, recordOffset + 2)
+		});
+	}
+	return assemblyOffset === 0 ? { variants } : {
+		variants,
+		assembly: parseGlyphAssembly(bytes, constructionOffset + assemblyOffset)
+	};
+}
+function parseConstructionsForAxis(bytes, variantsOffset, coverageOffset, count, constructionArrayOffset) {
+	const constructions = /* @__PURE__ */ new Map();
+	if (coverageOffset === 0) return constructions;
+	for (const [glyphId, coverageIndex] of parseCoverageIndex(bytes, variantsOffset + coverageOffset)) {
+		if (coverageIndex >= count) continue;
+		constructions.set(glyphId, parseGlyphConstruction(bytes, variantsOffset + u16(bytes, constructionArrayOffset + coverageIndex * 2)));
+	}
+	return constructions;
+}
+function parseMathVariants(bytes, mathTableOffset) {
+	const variantsTableOffset = u16(bytes, mathTableOffset + 8);
+	if (variantsTableOffset === 0) return {
+		minConnectorOverlap: 0,
+		vertical: /* @__PURE__ */ new Map(),
+		horizontal: /* @__PURE__ */ new Map()
+	};
+	const variantsOffset = mathTableOffset + variantsTableOffset;
+	const verticalCoverageOffset = u16(bytes, variantsOffset + 2);
+	const horizontalCoverageOffset = u16(bytes, variantsOffset + 4);
+	const verticalCount = u16(bytes, variantsOffset + 6);
+	const horizontalCount = u16(bytes, variantsOffset + 8);
+	const verticalArrayOffset = variantsOffset + MATH_VARIANTS_HEADER_SIZE;
+	const horizontalArrayOffset = verticalArrayOffset + verticalCount * 2;
+	return {
+		minConnectorOverlap: u16(bytes, variantsOffset),
+		vertical: parseConstructionsForAxis(bytes, variantsOffset, verticalCoverageOffset, verticalCount, verticalArrayOffset),
+		horizontal: parseConstructionsForAxis(bytes, variantsOffset, horizontalCoverageOffset, horizontalCount, horizontalArrayOffset)
+	};
+}
 function parseMathTable(font) {
 	const mathBytes = sfntTableBytes(font, "MATH");
 	if (mathBytes === void 0) throw new Error("math font has no MATH table");
 	return {
 		constants: parseMathConstants(mathBytes, 0),
-		glyphInfo: parseMathGlyphInfo(mathBytes, 0)
+		glyphInfo: parseMathGlyphInfo(mathBytes, 0),
+		variants: parseMathVariants(mathBytes, 0)
 	};
 }
 //#endregion

package/dist/{math-types-Ba8qAf1p.d.cts → math-types-YSQUTviw.d.cts}

@@ -41,6 +41,8 @@ interface MathGlyphMetrics {
   readonly advanceWidthPt: number;
   readonly italicCorrectionPt: number;
   readonly topAccentXPt?: number;
+  readonly inkAscentPt?: number;
+  readonly inkDescentPt?: number;
 }
 interface MathFontMetrics {
   readonly ascentPerEm: number;

package/dist/{math-types-Ba8qAf1p.d.ts → math-types-YSQUTviw.d.ts}

@@ -41,6 +41,8 @@ interface MathGlyphMetrics {
   readonly advanceWidthPt: number;
   readonly italicCorrectionPt: number;
   readonly topAccentXPt?: number;
+  readonly inkAscentPt?: number;
+  readonly inkDescentPt?: number;
 }
 interface MathFontMetrics {
   readonly ascentPerEm: number;

package/dist/math-types.d.cts

@@ -1,2 +1,2 @@
-import { a as MathGlyphRun, c as MathStroke, i as MathGlyphMetrics, n as MathColor, o as MathLayoutItem, r as MathFontMetrics, s as MathRule, t as MathBox } from "./math-types-Ba8qAf1p.cjs";
+import { a as MathGlyphRun, c as MathStroke, i as MathGlyphMetrics, n as MathColor, o as MathLayoutItem, r as MathFontMetrics, s as MathRule, t as MathBox } from "./math-types-YSQUTviw.cjs";
 export { MathBox, MathColor, MathFontMetrics, MathGlyphMetrics, MathGlyphRun, MathLayoutItem, MathRule, MathStroke };

package/dist/math-types.d.ts

@@ -1,2 +1,2 @@
-import { a as MathGlyphRun, c as MathStroke, i as MathGlyphMetrics, n as MathColor, o as MathLayoutItem, r as MathFontMetrics, s as MathRule, t as MathBox } from "./math-types-Ba8qAf1p.js";
+import { a as MathGlyphRun, c as MathStroke, i as MathGlyphMetrics, n as MathColor, o as MathLayoutItem, r as MathFontMetrics, s as MathRule, t as MathBox } from "./math-types-YSQUTviw.js";
 export { MathBox, MathColor, MathFontMetrics, MathGlyphMetrics, MathGlyphRun, MathLayoutItem, MathRule, MathStroke };

package/dist/measure.cjs

@@ -1,7 +1,9 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 const require_afm_widths = require("./afm-widths-BoeTOK2r.cjs");
-const require_fonts = require("./fonts.cjs");
+const require_embedded_font = require("./embedded-font.cjs");
+const require_font_registry = require("./font-registry.cjs");
 //#region src/measure.ts
+const GLYPH_SPACE_UNITS_PER_EM = 1e3;
 const DEFAULT_WIDTH_CORRECTIONS = {
 	calibri: .92,
 	aptos: .93,
@@ -13,42 +15,91 @@ const DEFAULT_WIDTH_CORRECTIONS = {
 function normalizeFamilyKey(family) {
 	return family.toLowerCase().replace(/[^a-z0-9]/g, "");
 }
-function createStandardFontMeasurer(options = {}) {
+const EMBEDDED_HORIZONTAL_SCALE = 1;
+const DEFAULT_VERTICAL_METRIC_POLICY = "hhea";
+function verticalMetricsFor(face, policy) {
+	const m = face.metrics;
+	const hhea = {
+		ascentGlyphSpace: m.ascentGlyphSpace,
+		descentGlyphSpace: m.descentGlyphSpace,
+		lineGapGlyphSpace: m.lineGapGlyphSpace
+	};
+	if (policy === "os2Typo") {
+		if (m.typoAscentGlyphSpace === void 0 || m.typoDescentGlyphSpace === void 0 || m.typoLineGapGlyphSpace === void 0) return hhea;
+		return {
+			ascentGlyphSpace: m.typoAscentGlyphSpace,
+			descentGlyphSpace: m.typoDescentGlyphSpace,
+			lineGapGlyphSpace: m.typoLineGapGlyphSpace
+		};
+	}
+	if (policy === "os2Win") {
+		if (m.winAscentGlyphSpace === void 0 || m.winDescentGlyphSpace === void 0) return hhea;
+		return {
+			ascentGlyphSpace: m.winAscentGlyphSpace,
+			descentGlyphSpace: m.winDescentGlyphSpace,
+			lineGapGlyphSpace: 0
+		};
+	}
+	return hhea;
+}
+function createFontMeasurer(registry, options = {}) {
 	const corrections = {
 		...DEFAULT_WIDTH_CORRECTIONS,
 		...options.widthCorrectionByFamily
 	};
-	function correctionFor(family) {
+	const verticalPolicy = options.verticalMetrics ?? "hhea";
+	function standardWidthCorrectionFor(family) {
 		return corrections[normalizeFamilyKey(family)] ?? 1;
 	}
-	function standardNameFor(font) {
-		return require_fonts.resolveStandardFont(font.family, font.weight === "bold", font.style === "italic").standardName;
+	function resolve(font) {
+		return require_font_registry.resolveFaceWithRegistry(registry, font);
 	}
 	return {
 		widthOfTextAtSize(text, font, sizePt) {
-			const { width1000 } = require_afm_widths.encodeForShow(text, standardNameFor(font));
-			return width1000 / 1e3 * sizePt * correctionFor(font.family);
+			const face = resolve(font);
+			if (face.kind === "embedded") return require_embedded_font.encodeForShowEmbedded(text, face.face).width1000 / GLYPH_SPACE_UNITS_PER_EM * sizePt;
+			const { width1000 } = require_afm_widths.encodeForShow(text, face.standardName);
+			return width1000 / GLYPH_SPACE_UNITS_PER_EM * sizePt * standardWidthCorrectionFor(font.family);
 		},
 		lineHeightAtSize(font, sizePt) {
-			return require_afm_widths.STANDARD_METRICS[standardNameFor(font)].lineHeightEm * sizePt;
+			const face = resolve(font);
+			if (face.kind === "embedded") {
+				const vertical = verticalMetricsFor(face.face, verticalPolicy);
+				return (vertical.ascentGlyphSpace - vertical.descentGlyphSpace + vertical.lineGapGlyphSpace) / GLYPH_SPACE_UNITS_PER_EM * sizePt;
+			}
+			return require_afm_widths.STANDARD_METRICS[face.standardName].lineHeightEm * sizePt;
 		},
 		ascenderAtSize(font, sizePt) {
-			return require_afm_widths.STANDARD_METRICS[standardNameFor(font)].ascender / 1e3 * sizePt;
+			const face = resolve(font);
+			if (face.kind === "embedded") return verticalMetricsFor(face.face, verticalPolicy).ascentGlyphSpace / GLYPH_SPACE_UNITS_PER_EM * sizePt;
+			return require_afm_widths.STANDARD_METRICS[face.standardName].ascender / GLYPH_SPACE_UNITS_PER_EM * sizePt;
 		},
 		descenderAtSize(font, sizePt) {
-			return require_afm_widths.STANDARD_METRICS[standardNameFor(font)].descender / 1e3 * sizePt;
+			const face = resolve(font);
+			if (face.kind === "embedded") return verticalMetricsFor(face.face, verticalPolicy).descentGlyphSpace / GLYPH_SPACE_UNITS_PER_EM * sizePt;
+			return require_afm_widths.STANDARD_METRICS[face.standardName].descender / GLYPH_SPACE_UNITS_PER_EM * sizePt;
 		},
 		underlineAtSize(font, sizePt) {
-			const metrics = require_afm_widths.STANDARD_METRICS[standardNameFor(font)];
+			const face = resolve(font);
+			if (face.kind === "embedded") return {
+				offsetPt: face.face.metrics.underlinePositionGlyphSpace / GLYPH_SPACE_UNITS_PER_EM * sizePt,
+				thicknessPt: face.face.metrics.underlineThicknessGlyphSpace / GLYPH_SPACE_UNITS_PER_EM * sizePt
+			};
+			const metrics = require_afm_widths.STANDARD_METRICS[face.standardName];
 			return {
-				offsetPt: metrics.underlinePosition / 1e3 * sizePt,
-				thicknessPt: metrics.underlineThickness / 1e3 * sizePt
+				offsetPt: metrics.underlinePosition / GLYPH_SPACE_UNITS_PER_EM * sizePt,
+				thicknessPt: metrics.underlineThickness / GLYPH_SPACE_UNITS_PER_EM * sizePt
 			};
 		},
 		horizontalScaleFor(font) {
-			return correctionFor(font.family);
+			return resolve(font).kind === "embedded" ? EMBEDDED_HORIZONTAL_SCALE : standardWidthCorrectionFor(font.family);
 		}
 	};
 }
+function createStandardFontMeasurer(options = {}) {
+	return createFontMeasurer(void 0, options);
+}
 //#endregion
+exports.DEFAULT_VERTICAL_METRIC_POLICY = DEFAULT_VERTICAL_METRIC_POLICY;
+exports.createFontMeasurer = createFontMeasurer;
 exports.createStandardFontMeasurer = createStandardFontMeasurer;

package/dist/measure.d.cts

@@ -1,3 +1,4 @@
+import { t as FontRegistry } from "./font-registry-yby02snZ.cjs";
 import { LayoutFont } from "document-schema.js";
 //#region src/measure.d.ts
 interface UnderlineMetrics {
@@ -12,9 +13,15 @@ interface TextMeasurer {
   underlineAtSize(font: LayoutFont, sizePt: number): UnderlineMetrics;
   horizontalScaleFor(font: LayoutFont): number;
 }
+type VerticalMetricPolicy = 'hhea' | 'os2Typo' | 'os2Win';
+declare const DEFAULT_VERTICAL_METRIC_POLICY: VerticalMetricPolicy;
 interface StandardFontMeasurerOptions {
   readonly widthCorrectionByFamily?: Readonly<Record<string, number>>;
 }
+interface FontMeasurerOptions extends StandardFontMeasurerOptions {
+  readonly verticalMetrics?: VerticalMetricPolicy;
+}
+declare function createFontMeasurer(registry?: FontRegistry, options?: FontMeasurerOptions): TextMeasurer;
 declare function createStandardFontMeasurer(options?: StandardFontMeasurerOptions): TextMeasurer;
 //#endregion
-export { StandardFontMeasurerOptions, TextMeasurer, UnderlineMetrics, createStandardFontMeasurer };
+export { DEFAULT_VERTICAL_METRIC_POLICY, FontMeasurerOptions, StandardFontMeasurerOptions, TextMeasurer, UnderlineMetrics, VerticalMetricPolicy, createFontMeasurer, createStandardFontMeasurer };