pdf-codec 1.6.0 → 1.7.0

package/dist/index.d.ts

@@ -3,6 +3,7 @@ import { crc32 } from "./bytes/crc32.js";
 import { DeflateLevel, InflateResult, MAX_INFLATE_OUTPUT_BYTES, deflate, inflate, inflateTolerant } from "./bytes/flate.js";
 import { ByteReader, isAsciiWhitespace } from "./bytes/reader.js";
 import { ByteWriter, concatBytes } from "./bytes/writer.js";
+import { t as GlyphInkBounds } from "./glyph-bounds-BV_Z40KS.js";
 import { NOOP_DIAGNOSTIC_SINK, PdfDiagnostic, PdfDiagnosticSeverity, PdfDiagnosticSink, PdfEncryptedError, PdfParseError, PdfPasswordRequiredError } from "./diagnostics.js";
 import { PdfBytesSchema, pdfCodec } from "./codec.js";
 import { n as EmbeddedFaceMetrics, r as EmbeddedFaceSubstitution, t as EmbeddedFace } from "./embedded-font-CbqkKgBl.js";
@@ -11,15 +12,23 @@ import { DEFAULT_VERTICAL_METRIC_POLICY, FontMeasurerOptions, StandardFontMeasur
 import { WinAnsiSubstitution } from "./winansi.js";
 import { i as Point, u as rotatePointAboutCenter } from "./matrix-BHzJESll.js";
 import { ResolvedFont, resolveStandardFont } from "./fonts.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-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";
 import { PositionedFormula } from "./formula.js";
 import { CcittFaxImage, CcittFaxOptions, decodeCcittFax } from "./image/ccitt.js";
+import { n as Jbig2UnsupportedError, t as Jbig2ParseError } from "./jbig2-errors-Bj6MPxrx.js";
+import { Jbig2DecodeOptions, Jbig2Image, decodeJbig2Embedded } from "./image/jbig2.js";
+import { Jp2ChannelDefinition, Jp2ColourSpace, Jp2Container, Jp2ImageHeader, looksLikeBareCodestream, parseJp2Container } from "./image/jp2-boxes.js";
 import { JpegInfo, readJpegInfo } from "./image/jpeg-info.js";
+import { Jpeg2000ProgressionOrder, Jpeg2000QuantizationStyle, Jpeg2000Transform } from "./image/jpeg2000-codestream.js";
+import { Jpeg2000ParseError, Jpeg2000UnsupportedError } from "./image/jpeg2000-errors.js";
+import { Jpeg2000ComponentMetadata, Jpeg2000DecodeOptions, Jpeg2000Image, Jpeg2000Metadata, decodeJpeg2000, readJpeg2000Metadata } from "./image/jpeg2000.js";
 import { PngDecodeOptions, RawImage, decodePng } from "./image/png-decode.js";
 import { PngEncodeOptions, encodePng } from "./image/png-encode.js";
 import { PngFilterType, filterScanlines, unfilterScanlines } from "./image/png-filter.js";
 import { ReadPdfOptions, readPdf } from "./read.js";
 import { WritePdfOptions, writePdf } from "./write.js";
+import { a as MathGlyphPart, c as MathVariants, n as MathGlyphAssembly, o as MathGlyphVariant, r as MathGlyphConstruction } from "./math-table-DhPrNoPa.js";
+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";
 import { LoadedMathFont, MathFont, MathFontDescriptorMetrics, loadMathFont } from "./math-font.js";
 import { StyledFragment, StyledRun, WrapOptions, WrappedLine, wrapRunsToWidth } from "./text-layout.js";
-export { ByteReader, ByteWriter, type CcittFaxImage, type CcittFaxOptions, DEFAULT_VERTICAL_METRIC_POLICY, type DeflateLevel, type EmbeddedFace, type EmbeddedFaceMetrics, type EmbeddedFaceSubstitution, type FontMeasurerOptions, type FontMetrics, type FontRegistry, type FontRegistryOptions, type FontSubstitution, type InflateResult, type JpegInfo, type LoadedMathFont, MAX_INFLATE_OUTPUT_BYTES, type MathBox, type MathColor, type MathFont, type MathFontDescriptorMetrics, type MathFontMetrics, type MathGlyphMetrics, type MathGlyphRun, type MathLayoutItem, type MathRule, type MathStroke, NOOP_DIAGNOSTIC_SINK, PdfBytesSchema, type PdfDiagnostic, type PdfDiagnosticSeverity, type PdfDiagnosticSink, PdfEncryptedError, PdfParseError, PdfPasswordRequiredError, type PngDecodeOptions, type PngEncodeOptions, type PngFilterType, type Point, type PositionedFormula, type ProvidedFont, type RawImage, type ReadPdfOptions, type ResolvedFace, type ResolvedFont, STANDARD_METRICS, type StandardFontMeasurerOptions, type StandardFontName, type StyledFragment, type StyledRun, type TextMeasurer, type UnderlineMetrics, type VerticalMetricPolicy, type WinAnsiSubstitution, type WrapOptions, type WrappedLine, type WritePdfOptions, concatBytes, crc32, createFontMeasurer, createFontRegistry, createStandardFontMeasurer, decodeCcittFax, decodePng, deflate, encodePng, filterScanlines, inflate, inflateTolerant, isAsciiWhitespace, loadMathFont, pdfCodec, readJpegInfo, readPdf, resolveFaceWithRegistry, resolveStandardFont, rotatePointAboutCenter, unfilterScanlines, wrapRunsToWidth, writePdf };
+export { ByteReader, ByteWriter, type CcittFaxImage, type CcittFaxOptions, DEFAULT_VERTICAL_METRIC_POLICY, type DeflateLevel, type EmbeddedFace, type EmbeddedFaceMetrics, type EmbeddedFaceSubstitution, type FontMeasurerOptions, type FontMetrics, type FontRegistry, type FontRegistryOptions, type FontSubstitution, type GlyphInkBounds, type InflateResult, type Jbig2DecodeOptions, type Jbig2Image, Jbig2ParseError, Jbig2UnsupportedError, type Jp2ChannelDefinition, type Jp2ColourSpace, type Jp2Container, type Jp2ImageHeader, type Jpeg2000ComponentMetadata, type Jpeg2000DecodeOptions, type Jpeg2000Image, type Jpeg2000Metadata, Jpeg2000ParseError, type Jpeg2000ProgressionOrder, type Jpeg2000QuantizationStyle, type Jpeg2000Transform, Jpeg2000UnsupportedError, type JpegInfo, type LoadedMathFont, MAX_INFLATE_OUTPUT_BYTES, type MathBox, type MathColor, type MathFont, type MathFontDescriptorMetrics, type MathFontMetrics, type MathGlyphAssembly, type MathGlyphConstruction, type MathGlyphMetrics, type MathGlyphPart, type MathGlyphRun, type MathGlyphVariant, type MathLayoutItem, type MathRule, type MathStretchAxis, type MathStretchConstruction, type MathStretchOptions, type MathStretchPlacement, type MathStroke, type MathVariants, NOOP_DIAGNOSTIC_SINK, PdfBytesSchema, type PdfDiagnostic, type PdfDiagnosticSeverity, type PdfDiagnosticSink, PdfEncryptedError, PdfParseError, PdfPasswordRequiredError, type PngDecodeOptions, type PngEncodeOptions, type PngFilterType, type Point, type PositionedFormula, type ProvidedFont, type RawImage, type ReadPdfOptions, type ResolvedFace, type ResolvedFont, STANDARD_METRICS, type StandardFontMeasurerOptions, type StandardFontName, type StyledFragment, type StyledRun, type TextMeasurer, type UnderlineMetrics, type VerticalMetricPolicy, type WinAnsiSubstitution, type WrapOptions, type WrappedLine, type WritePdfOptions, assembleStretchyGlyph, concatBytes, crc32, createFontMeasurer, createFontRegistry, createStandardFontMeasurer, decodeCcittFax, decodeJbig2Embedded, decodeJpeg2000, decodePng, deflate, encodePng, filterScanlines, inflate, inflateTolerant, isAsciiWhitespace, loadMathFont, looksLikeBareCodestream, parseJp2Container, pdfCodec, readJpeg2000Metadata, readJpegInfo, readPdf, resolveFaceWithRegistry, resolveStandardFont, rotatePointAboutCenter, scaleMathStretchConstruction, unfilterScanlines, wrapRunsToWidth, writePdf };

package/dist/index.js

@@ -5,17 +5,23 @@ import { ByteWriter, concatBytes } from "./bytes/writer.js";
 import { NOOP_DIAGNOSTIC_SINK, PdfEncryptedError, PdfParseError, PdfPasswordRequiredError } from "./diagnostics.js";
 import { MAX_INFLATE_OUTPUT_BYTES, deflate, inflate, inflateTolerant } from "./bytes/flate.js";
 import { decodeCcittFax } from "./image/ccitt.js";
+import { Jbig2ParseError, Jbig2UnsupportedError } from "./image/jbig2-errors.js";
+import { decodeJbig2Embedded } from "./image/jbig2.js";
 import { filterScanlines, unfilterScanlines } from "./image/png-filter.js";
 import { resolveStandardFont } from "./fonts.js";
 import { encodePng } from "./image/png-encode.js";
 import { readJpegInfo } from "./image/jpeg-info.js";
+import { Jpeg2000ParseError, Jpeg2000UnsupportedError } from "./image/jpeg2000-errors.js";
+import { looksLikeBareCodestream, parseJp2Container } from "./image/jp2-boxes.js";
+import { decodeJpeg2000, readJpeg2000Metadata } from "./image/jpeg2000.js";
 import { rotatePointAboutCenter } from "./matrix.js";
 import { decodePng } from "./image/png-decode.js";
 import { createFontRegistry, resolveFaceWithRegistry } from "./font-registry.js";
+import { assembleStretchyGlyph, scaleMathStretchConstruction } from "./math-stretch.js";
 import { loadMathFont } from "./math-font.js";
 import { DEFAULT_VERTICAL_METRIC_POLICY, createFontMeasurer, createStandardFontMeasurer } from "./measure.js";
 import { writePdf } from "./write.js";
 import { readPdf } from "./read.js";
 import { PdfBytesSchema, pdfCodec } from "./codec.js";
 import { wrapRunsToWidth } from "./text-layout.js";
-export { ByteReader, ByteWriter, DEFAULT_VERTICAL_METRIC_POLICY, MAX_INFLATE_OUTPUT_BYTES, NOOP_DIAGNOSTIC_SINK, PdfBytesSchema, PdfEncryptedError, PdfParseError, PdfPasswordRequiredError, STANDARD_METRICS, concatBytes, crc32, createFontMeasurer, createFontRegistry, createStandardFontMeasurer, decodeCcittFax, decodePng, deflate, encodePng, filterScanlines, inflate, inflateTolerant, isAsciiWhitespace, loadMathFont, pdfCodec, readJpegInfo, readPdf, resolveFaceWithRegistry, resolveStandardFont, rotatePointAboutCenter, unfilterScanlines, wrapRunsToWidth, writePdf };
+export { ByteReader, ByteWriter, DEFAULT_VERTICAL_METRIC_POLICY, Jbig2ParseError, Jbig2UnsupportedError, Jpeg2000ParseError, Jpeg2000UnsupportedError, MAX_INFLATE_OUTPUT_BYTES, NOOP_DIAGNOSTIC_SINK, PdfBytesSchema, PdfEncryptedError, PdfParseError, PdfPasswordRequiredError, STANDARD_METRICS, assembleStretchyGlyph, concatBytes, crc32, createFontMeasurer, createFontRegistry, createStandardFontMeasurer, decodeCcittFax, decodeJbig2Embedded, decodeJpeg2000, decodePng, deflate, encodePng, filterScanlines, inflate, inflateTolerant, isAsciiWhitespace, loadMathFont, looksLikeBareCodestream, parseJp2Container, pdfCodec, readJpeg2000Metadata, readJpegInfo, readPdf, resolveFaceWithRegistry, resolveStandardFont, rotatePointAboutCenter, scaleMathStretchConstruction, unfilterScanlines, wrapRunsToWidth, writePdf };

package/dist/jbig2-errors-Bj6MPxrx.d.cts

@@ -0,0 +1,9 @@
+//#region src/image/jbig2-errors.d.ts
+declare class Jbig2ParseError extends Error {
+  constructor(message: string);
+}
+declare class Jbig2UnsupportedError extends Error {
+  constructor(message: string);
+}
+//#endregion
+export { Jbig2UnsupportedError as n, Jbig2ParseError as t };

package/dist/jbig2-errors-Bj6MPxrx.d.ts

@@ -0,0 +1,9 @@
+//#region src/image/jbig2-errors.d.ts
+declare class Jbig2ParseError extends Error {
+  constructor(message: string);
+}
+declare class Jbig2UnsupportedError extends Error {
+  constructor(message: string);
+}
+//#endregion
+export { Jbig2UnsupportedError as n, Jbig2ParseError as t };

package/dist/math-font.cjs

@@ -1,15 +1,17 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 const require_sfnt = require("./sfnt.cjs");
+const require_cff_bounds = require("./cff-bounds.cjs");
 const require_cmap_table = require("./cmap-table.cjs");
 const require_util_base64 = require("./util/base64.cjs");
 const require_hmtx_table = require("./hmtx-table.cjs");
 const require_assets_stix_two_math_font = require("./assets/stix-two-math-font.cjs");
+const require_math_stretch = require("./math-stretch.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) {
+function metricsAtSize(cmap, hmtx, math, inkBounds, unitsPerEm, ascentDesignUnits, descentDesignUnits, sizePt) {
 	const c = math.constants;
 	const pt = (designUnits) => toPt(designUnits, unitsPerEm, sizePt);
 	return {
@@ -52,10 +54,13 @@ function metricsAtSize(cmap, hmtx, math, unitsPerEm, ascentDesignUnits, descentD
 			const advanceWidthPt = toPt(hmtx.advanceWidth(glyphId), unitsPerEm, glyphSizePt);
 			const italicCorrectionDesignUnits = math.glyphInfo.italicsCorrection.get(glyphId) ?? 0;
 			const topAccentDesignUnits = math.glyphInfo.topAccentAttachment.get(glyphId);
+			const ink = inkBounds?.bounds(glyphId);
 			return {
 				advanceWidthPt,
 				italicCorrectionPt: toPt(italicCorrectionDesignUnits, unitsPerEm, glyphSizePt),
-				topAccentXPt: topAccentDesignUnits === void 0 ? void 0 : toPt(topAccentDesignUnits, unitsPerEm, glyphSizePt)
+				topAccentXPt: topAccentDesignUnits === void 0 ? void 0 : toPt(topAccentDesignUnits, unitsPerEm, glyphSizePt),
+				inkAscentPt: ink === void 0 ? void 0 : toPt(ink.yMax, unitsPerEm, glyphSizePt),
+				inkDescentPt: ink === void 0 ? void 0 : toPt(-ink.yMin, unitsPerEm, glyphSizePt)
 			};
 		}
 	};
@@ -81,23 +86,43 @@ function loadMathFont() {
 	if (cmap === void 0) throw new Error("embedded math font has no readable cmap subtable");
 	const hmtx = require_hmtx_table.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
+	const inkBounds = require_cff_bounds.parseCffGlyphBounds(cffBytes);
+	const font = {
+		metrics: metricsAtSize(cmap, hmtx, math, inkBounds, unitsPerEm, ascentDesignUnits, descentDesignUnits, unitsPerEm),
+		cffBytes,
+		descriptor: {
+			unitsPerEm,
+			ascent: ascentDesignUnits,
+			descent: descentDesignUnits,
+			capHeight,
+			bboxMin,
+			bboxMax,
+			italicAngle: 0
 		},
-		metricsAt: (sizePt) => metricsAtSize(cmap, hmtx, math, unitsPerEm, ascentDesignUnits, descentDesignUnits, sizePt)
+		glyphId: (codePoint) => cmap(codePoint),
+		glyphSpaceWidth: (glyphId) => hmtx.advanceWidth(glyphId) * 1e3 / unitsPerEm,
+		glyphInkBounds: (glyphId) => inkBounds?.bounds(glyphId),
+		minConnectorOverlap: math.variants.minConnectorOverlap,
+		stretchyConstruction: (codePoint, axis) => {
+			const glyphId = cmap(codePoint);
+			if (glyphId === void 0) return;
+			return (axis === "vertical" ? math.variants.vertical : math.variants.horizontal).get(glyphId);
+		}
+	};
+	cached = {
+		font,
+		metricsAt: (sizePt) => metricsAtSize(cmap, hmtx, math, inkBounds, unitsPerEm, ascentDesignUnits, descentDesignUnits, sizePt),
+		stretchGlyph: (codePoint, axis, targetSizePt, sizePt) => {
+			const construction = font.stretchyConstruction(codePoint, axis);
+			if (construction === void 0) return;
+			const designUnitsPerPt = unitsPerEm / sizePt;
+			const assembled = require_math_stretch.assembleStretchyGlyph(construction, {
+				axis,
+				targetSize: targetSizePt * designUnitsPerPt,
+				minConnectorOverlap: math.variants.minConnectorOverlap
+			});
+			return assembled === void 0 ? void 0 : require_math_stretch.scaleMathStretchConstruction(assembled, 1 / designUnitsPerPt);
+		}
 	};
 	return cached;
 }

package/dist/math-font.d.cts

@@ -1,4 +1,7 @@
-import { r as MathFontMetrics } from "./math-types-Ba8qAf1p.cjs";
+import { t as GlyphInkBounds } from "./glyph-bounds-BV_Z40KS.cjs";
+import { r as MathFontMetrics } from "./math-types-YSQUTviw.cjs";
+import { r as MathGlyphConstruction } from "./math-table-gFNB8DmQ.cjs";
+import { n as MathStretchConstruction, t as MathStretchAxis } from "./math-stretch-DXWjs8gL.cjs";
 //#region src/math-font.d.ts
 interface MathFontDescriptorMetrics {
   readonly unitsPerEm: number;
@@ -15,10 +18,14 @@ interface MathFont {
   readonly descriptor: MathFontDescriptorMetrics;
   glyphId(codePoint: number): number | undefined;
   glyphSpaceWidth(glyphId: number): number;
+  glyphInkBounds(glyphId: number): GlyphInkBounds | undefined;
+  readonly minConnectorOverlap: number;
+  stretchyConstruction(codePoint: number, axis: MathStretchAxis): MathGlyphConstruction | undefined;
 }
 interface LoadedMathFont {
   readonly font: MathFont;
   readonly metricsAt: (sizePt: number) => MathFontMetrics;
+  readonly stretchGlyph: (codePoint: number, axis: MathStretchAxis, targetSizePt: number, sizePt: number) => MathStretchConstruction | undefined;
 }
 declare function loadMathFont(): LoadedMathFont;
 //#endregion

package/dist/math-font.d.ts

@@ -1,4 +1,7 @@
-import { r as MathFontMetrics } from "./math-types-Ba8qAf1p.js";
+import { t as GlyphInkBounds } from "./glyph-bounds-BV_Z40KS.js";
+import { r as MathFontMetrics } from "./math-types-YSQUTviw.js";
+import { r as MathGlyphConstruction } from "./math-table-DhPrNoPa.js";
+import { n as MathStretchConstruction, t as MathStretchAxis } from "./math-stretch-Bwk_bxh1.js";
 //#region src/math-font.d.ts
 interface MathFontDescriptorMetrics {
   readonly unitsPerEm: number;
@@ -15,10 +18,14 @@ interface MathFont {
   readonly descriptor: MathFontDescriptorMetrics;
   glyphId(codePoint: number): number | undefined;
   glyphSpaceWidth(glyphId: number): number;
+  glyphInkBounds(glyphId: number): GlyphInkBounds | undefined;
+  readonly minConnectorOverlap: number;
+  stretchyConstruction(codePoint: number, axis: MathStretchAxis): MathGlyphConstruction | undefined;
 }
 interface LoadedMathFont {
   readonly font: MathFont;
   readonly metricsAt: (sizePt: number) => MathFontMetrics;
+  readonly stretchGlyph: (codePoint: number, axis: MathStretchAxis, targetSizePt: number, sizePt: number) => MathStretchConstruction | undefined;
 }
 declare function loadMathFont(): LoadedMathFont;
 //#endregion

package/dist/math-font.js

@@ -1,14 +1,16 @@
 import { i16, parseSfnt, sfntTableBytes, u16 } from "./sfnt.js";
+import { parseCffGlyphBounds } from "./cff-bounds.js";
 import { buildCmapLookup } from "./cmap-table.js";
 import { base64ToBytes } from "./util/base64.js";
 import { parseHmtx } from "./hmtx-table.js";
 import { STIX_TWO_MATH_FONT_BASE64 } from "./assets/stix-two-math-font.js";
+import { assembleStretchyGlyph, scaleMathStretchConstruction } from "./math-stretch.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) {
+function metricsAtSize(cmap, hmtx, math, inkBounds, unitsPerEm, ascentDesignUnits, descentDesignUnits, sizePt) {
 	const c = math.constants;
 	const pt = (designUnits) => toPt(designUnits, unitsPerEm, sizePt);
 	return {
@@ -51,10 +53,13 @@ function metricsAtSize(cmap, hmtx, math, unitsPerEm, ascentDesignUnits, descentD
 			const advanceWidthPt = toPt(hmtx.advanceWidth(glyphId), unitsPerEm, glyphSizePt);
 			const italicCorrectionDesignUnits = math.glyphInfo.italicsCorrection.get(glyphId) ?? 0;
 			const topAccentDesignUnits = math.glyphInfo.topAccentAttachment.get(glyphId);
+			const ink = inkBounds?.bounds(glyphId);
 			return {
 				advanceWidthPt,
 				italicCorrectionPt: toPt(italicCorrectionDesignUnits, unitsPerEm, glyphSizePt),
-				topAccentXPt: topAccentDesignUnits === void 0 ? void 0 : toPt(topAccentDesignUnits, unitsPerEm, glyphSizePt)
+				topAccentXPt: topAccentDesignUnits === void 0 ? void 0 : toPt(topAccentDesignUnits, unitsPerEm, glyphSizePt),
+				inkAscentPt: ink === void 0 ? void 0 : toPt(ink.yMax, unitsPerEm, glyphSizePt),
+				inkDescentPt: ink === void 0 ? void 0 : toPt(-ink.yMin, unitsPerEm, glyphSizePt)
 			};
 		}
 	};
@@ -80,23 +85,43 @@ function loadMathFont() {
 	if (cmap === void 0) throw new Error("embedded math font has no readable cmap subtable");
 	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
+	const inkBounds = parseCffGlyphBounds(cffBytes);
+	const font = {
+		metrics: metricsAtSize(cmap, hmtx, math, inkBounds, unitsPerEm, ascentDesignUnits, descentDesignUnits, unitsPerEm),
+		cffBytes,
+		descriptor: {
+			unitsPerEm,
+			ascent: ascentDesignUnits,
+			descent: descentDesignUnits,
+			capHeight,
+			bboxMin,
+			bboxMax,
+			italicAngle: 0
 		},
-		metricsAt: (sizePt) => metricsAtSize(cmap, hmtx, math, unitsPerEm, ascentDesignUnits, descentDesignUnits, sizePt)
+		glyphId: (codePoint) => cmap(codePoint),
+		glyphSpaceWidth: (glyphId) => hmtx.advanceWidth(glyphId) * 1e3 / unitsPerEm,
+		glyphInkBounds: (glyphId) => inkBounds?.bounds(glyphId),
+		minConnectorOverlap: math.variants.minConnectorOverlap,
+		stretchyConstruction: (codePoint, axis) => {
+			const glyphId = cmap(codePoint);
+			if (glyphId === void 0) return;
+			return (axis === "vertical" ? math.variants.vertical : math.variants.horizontal).get(glyphId);
+		}
+	};
+	cached = {
+		font,
+		metricsAt: (sizePt) => metricsAtSize(cmap, hmtx, math, inkBounds, unitsPerEm, ascentDesignUnits, descentDesignUnits, sizePt),
+		stretchGlyph: (codePoint, axis, targetSizePt, sizePt) => {
+			const construction = font.stretchyConstruction(codePoint, axis);
+			if (construction === void 0) return;
+			const designUnitsPerPt = unitsPerEm / sizePt;
+			const assembled = assembleStretchyGlyph(construction, {
+				axis,
+				targetSize: targetSizePt * designUnitsPerPt,
+				minConnectorOverlap: math.variants.minConnectorOverlap
+			});
+			return assembled === void 0 ? void 0 : scaleMathStretchConstruction(assembled, 1 / designUnitsPerPt);
+		}
 	};
 	return cached;
 }

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 };