pdf-codec 1.6.0 → 1.8.0

package/dist/math-stretch-Bwk_bxh1.d.ts

@@ -0,0 +1,24 @@
+import { r as MathGlyphConstruction } from "./math-table-DhPrNoPa.js";
+//#region src/math-stretch.d.ts
+type MathStretchAxis = 'vertical' | 'horizontal';
+interface MathStretchPlacement {
+  readonly glyphId: number;
+  readonly offset: number;
+  readonly advance: number;
+}
+interface MathStretchConstruction {
+  readonly kind: 'base' | 'variant' | 'assembly';
+  readonly axis: MathStretchAxis;
+  readonly size: number;
+  readonly italicsCorrection: number;
+  readonly placements: readonly MathStretchPlacement[];
+}
+interface MathStretchOptions {
+  readonly axis: MathStretchAxis;
+  readonly targetSize: number;
+  readonly minConnectorOverlap: number;
+}
+declare function assembleStretchyGlyph(construction: MathGlyphConstruction, options: MathStretchOptions): MathStretchConstruction | undefined;
+declare function scaleMathStretchConstruction(construction: MathStretchConstruction, factor: number): MathStretchConstruction;
+//#endregion
+export { assembleStretchyGlyph as a, MathStretchPlacement as i, MathStretchConstruction as n, scaleMathStretchConstruction as o, MathStretchOptions as r, MathStretchAxis as t };

package/dist/math-stretch-DXWjs8gL.d.cts

@@ -0,0 +1,24 @@
+import { r as MathGlyphConstruction } from "./math-table-gFNB8DmQ.cjs";
+//#region src/math-stretch.d.ts
+type MathStretchAxis = 'vertical' | 'horizontal';
+interface MathStretchPlacement {
+  readonly glyphId: number;
+  readonly offset: number;
+  readonly advance: number;
+}
+interface MathStretchConstruction {
+  readonly kind: 'base' | 'variant' | 'assembly';
+  readonly axis: MathStretchAxis;
+  readonly size: number;
+  readonly italicsCorrection: number;
+  readonly placements: readonly MathStretchPlacement[];
+}
+interface MathStretchOptions {
+  readonly axis: MathStretchAxis;
+  readonly targetSize: number;
+  readonly minConnectorOverlap: number;
+}
+declare function assembleStretchyGlyph(construction: MathGlyphConstruction, options: MathStretchOptions): MathStretchConstruction | undefined;
+declare function scaleMathStretchConstruction(construction: MathStretchConstruction, factor: number): MathStretchConstruction;
+//#endregion
+export { assembleStretchyGlyph as a, MathStretchPlacement as i, MathStretchConstruction as n, scaleMathStretchConstruction as o, MathStretchOptions as r, MathStretchAxis as t };

package/dist/math-stretch.cjs

@@ -0,0 +1,96 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+//#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
+exports.assembleStretchyGlyph = assembleStretchyGlyph;
+exports.scaleMathStretchConstruction = scaleMathStretchConstruction;

package/dist/math-stretch.d.cts

@@ -0,0 +1,2 @@
+import { a as assembleStretchyGlyph, i as MathStretchPlacement, n as MathStretchConstruction, o as scaleMathStretchConstruction, r as MathStretchOptions, t as MathStretchAxis } from "./math-stretch-DXWjs8gL.cjs";
+export { MathStretchAxis, MathStretchConstruction, MathStretchOptions, MathStretchPlacement, assembleStretchyGlyph, scaleMathStretchConstruction };

package/dist/math-stretch.d.ts

@@ -0,0 +1,2 @@
+import { a as assembleStretchyGlyph, i as MathStretchPlacement, n as MathStretchConstruction, o as scaleMathStretchConstruction, r as MathStretchOptions, t as MathStretchAxis } from "./math-stretch-Bwk_bxh1.js";
+export { MathStretchAxis, MathStretchConstruction, MathStretchOptions, MathStretchPlacement, assembleStretchyGlyph, scaleMathStretchConstruction };

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 { 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 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 { 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 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