pdf-codec 1.7.0 → 1.9.0

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

@@ -14,6 +14,6 @@ interface MathFontObjects {
   readonly fontFile: PdfObject;
   readonly toUnicode: PdfObject;
 }
-declare function buildMathFontObjects(font: MathFont, usedGlyphs: ReadonlyMap<number, number>, refs: MathFontObjectRefs, compress: boolean): MathFontObjects;
+declare function buildMathFontObjects(font: MathFont, usedGlyphs: ReadonlyMap<number, number | undefined>, refs: MathFontObjectRefs, compress: boolean): MathFontObjects;
 //#endregion
 export { MathFontObjectRefs, MathFontObjects, buildMathFontObjects };

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

@@ -14,6 +14,6 @@ interface MathFontObjects {
   readonly fontFile: PdfObject;
   readonly toUnicode: PdfObject;
 }
-declare function buildMathFontObjects(font: MathFont, usedGlyphs: ReadonlyMap<number, number>, refs: MathFontObjectRefs, compress: boolean): MathFontObjects;
+declare function buildMathFontObjects(font: MathFont, usedGlyphs: ReadonlyMap<number, number | undefined>, refs: MathFontObjectRefs, compress: boolean): MathFontObjects;
 //#endregion
 export { MathFontObjectRefs, MathFontObjects, buildMathFontObjects };

package/dist/math-font-write.js

@@ -37,6 +37,11 @@ function buildFontFileStream(font, compress) {
 	} : { Subtype: pdfName("CIDFontType0C") });
 	return pdfStream(dict, compress ? deflate(font.cffBytes) : font.cffBytes);
 }
+function toUnicodeEntries(usedGlyphs) {
+	const entries = /* @__PURE__ */ new Map();
+	for (const [glyphId, codePoint] of usedGlyphs) if (codePoint !== void 0) entries.set(glyphId, codePoint);
+	return entries;
+}
 function buildMathFontObjects(font, usedGlyphs, refs, compress) {
 	const cidFont = pdfDict({
 		Type: pdfName("Font"),
@@ -63,7 +68,7 @@ function buildMathFontObjects(font, usedGlyphs, refs, compress) {
 		cidFont,
 		descriptor: buildFontDescriptor(font, refs.fontFileRef),
 		fontFile: buildFontFileStream(font, compress),
-		toUnicode: buildToUnicodeCMap(usedGlyphs)
+		toUnicode: buildToUnicodeCMap(toUnicodeEntries(usedGlyphs))
 	};
 }
 //#endregion

package/dist/math-font.cjs

@@ -11,6 +11,51 @@ const require_math_table = require("./math-table.cjs");
 function toPt(designUnits, unitsPerEm, sizePt) {
 	return designUnits / unitsPerEm * sizePt;
 }
+function measureConstruction(placements, axis, inkBounds, hmtx) {
+	let inkAscent = Number.NEGATIVE_INFINITY;
+	let inkDescent = Number.NEGATIVE_INFINITY;
+	let advanceWidth = 0;
+	for (const placement of placements) {
+		advanceWidth = Math.max(advanceWidth, hmtx.advanceWidth(placement.glyphId));
+		const ink = inkBounds?.bounds(placement.glyphId);
+		if (ink === void 0) continue;
+		const alongY = axis === "vertical" ? placement.offset : 0;
+		inkAscent = Math.max(inkAscent, alongY + ink.yMax);
+		inkDescent = Math.max(inkDescent, -(alongY + ink.yMin));
+	}
+	return inkAscent === Number.NEGATIVE_INFINITY ? void 0 : {
+		inkAscent,
+		inkDescent,
+		advanceWidth
+	};
+}
+function stretchAtSize(cmap, hmtx, math, inkBounds, unitsPerEm, codePoint, axis, targetSizePt, sizePt) {
+	const glyphId = cmap(codePoint);
+	if (glyphId === void 0) return;
+	const construction = (axis === "vertical" ? math.variants.vertical : math.variants.horizontal).get(glyphId);
+	if (construction === void 0) return;
+	const designUnitsPerPt = unitsPerEm / sizePt;
+	const assembled = require_math_stretch.assembleStretchyGlyph(construction, {
+		axis,
+		targetSize: targetSizePt * designUnitsPerPt,
+		minConnectorOverlap: math.variants.minConnectorOverlap
+	});
+	if (assembled === void 0) return;
+	const measured = measureConstruction(assembled.placements, axis, inkBounds, hmtx);
+	if (measured === void 0) return;
+	const pt = (designUnits) => toPt(designUnits, unitsPerEm, sizePt);
+	return {
+		kind: assembled.kind,
+		sizePt: pt(assembled.size),
+		advanceWidthPt: pt(measured.advanceWidth),
+		inkAscentPt: pt(measured.inkAscent),
+		inkDescentPt: pt(measured.inkDescent),
+		placements: assembled.placements.map((placement) => ({
+			glyphId: placement.glyphId,
+			offsetPt: pt(placement.offset)
+		}))
+	};
+}
 function metricsAtSize(cmap, hmtx, math, inkBounds, unitsPerEm, ascentDesignUnits, descentDesignUnits, sizePt) {
 	const c = math.constants;
 	const pt = (designUnits) => toPt(designUnits, unitsPerEm, sizePt);
@@ -62,6 +107,9 @@ function metricsAtSize(cmap, hmtx, math, inkBounds, unitsPerEm, ascentDesignUnit
 				inkAscentPt: ink === void 0 ? void 0 : toPt(ink.yMax, unitsPerEm, glyphSizePt),
 				inkDescentPt: ink === void 0 ? void 0 : toPt(-ink.yMin, unitsPerEm, glyphSizePt)
 			};
+		},
+		stretch(codePoint, axis, targetSizePt, glyphSizePt) {
+			return stretchAtSize(cmap, hmtx, math, inkBounds, unitsPerEm, codePoint, axis, targetSizePt, glyphSizePt);
 		}
 	};
 }

package/dist/math-font.d.cts

@@ -1,7 +1,7 @@
 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";
+import { i as MathFontMetrics } from "./math-types-BZkWO5Ow.cjs";
 //#region src/math-font.d.ts
 interface MathFontDescriptorMetrics {
   readonly unitsPerEm: number;

package/dist/math-font.d.ts

@@ -1,7 +1,7 @@
 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";
+import { i as MathFontMetrics } from "./math-types-Bq7tyV4g.js";
 //#region src/math-font.d.ts
 interface MathFontDescriptorMetrics {
   readonly unitsPerEm: number;

package/dist/math-font.js

@@ -10,6 +10,51 @@ import { parseMathTable } from "./math-table.js";
 function toPt(designUnits, unitsPerEm, sizePt) {
 	return designUnits / unitsPerEm * sizePt;
 }
+function measureConstruction(placements, axis, inkBounds, hmtx) {
+	let inkAscent = Number.NEGATIVE_INFINITY;
+	let inkDescent = Number.NEGATIVE_INFINITY;
+	let advanceWidth = 0;
+	for (const placement of placements) {
+		advanceWidth = Math.max(advanceWidth, hmtx.advanceWidth(placement.glyphId));
+		const ink = inkBounds?.bounds(placement.glyphId);
+		if (ink === void 0) continue;
+		const alongY = axis === "vertical" ? placement.offset : 0;
+		inkAscent = Math.max(inkAscent, alongY + ink.yMax);
+		inkDescent = Math.max(inkDescent, -(alongY + ink.yMin));
+	}
+	return inkAscent === Number.NEGATIVE_INFINITY ? void 0 : {
+		inkAscent,
+		inkDescent,
+		advanceWidth
+	};
+}
+function stretchAtSize(cmap, hmtx, math, inkBounds, unitsPerEm, codePoint, axis, targetSizePt, sizePt) {
+	const glyphId = cmap(codePoint);
+	if (glyphId === void 0) return;
+	const construction = (axis === "vertical" ? math.variants.vertical : math.variants.horizontal).get(glyphId);
+	if (construction === void 0) return;
+	const designUnitsPerPt = unitsPerEm / sizePt;
+	const assembled = assembleStretchyGlyph(construction, {
+		axis,
+		targetSize: targetSizePt * designUnitsPerPt,
+		minConnectorOverlap: math.variants.minConnectorOverlap
+	});
+	if (assembled === void 0) return;
+	const measured = measureConstruction(assembled.placements, axis, inkBounds, hmtx);
+	if (measured === void 0) return;
+	const pt = (designUnits) => toPt(designUnits, unitsPerEm, sizePt);
+	return {
+		kind: assembled.kind,
+		sizePt: pt(assembled.size),
+		advanceWidthPt: pt(measured.advanceWidth),
+		inkAscentPt: pt(measured.inkAscent),
+		inkDescentPt: pt(measured.inkDescent),
+		placements: assembled.placements.map((placement) => ({
+			glyphId: placement.glyphId,
+			offsetPt: pt(placement.offset)
+		}))
+	};
+}
 function metricsAtSize(cmap, hmtx, math, inkBounds, unitsPerEm, ascentDesignUnits, descentDesignUnits, sizePt) {
 	const c = math.constants;
 	const pt = (designUnits) => toPt(designUnits, unitsPerEm, sizePt);
@@ -61,6 +106,9 @@ function metricsAtSize(cmap, hmtx, math, inkBounds, unitsPerEm, ascentDesignUnit
 				inkAscentPt: ink === void 0 ? void 0 : toPt(ink.yMax, unitsPerEm, glyphSizePt),
 				inkDescentPt: ink === void 0 ? void 0 : toPt(-ink.yMin, unitsPerEm, glyphSizePt)
 			};
+		},
+		stretch(codePoint, axis, targetSizePt, glyphSizePt) {
+			return stretchAtSize(cmap, hmtx, math, inkBounds, unitsPerEm, codePoint, axis, targetSizePt, glyphSizePt);
 		}
 	};
 }

package/dist/math-table.cjs

@@ -1,5 +1,6 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 const require_sfnt = require("./sfnt.cjs");
+const require_ot_layout_common = require("./ot-layout-common.cjs");
 //#region src/math-table.ts
 const MATH_VALUE_RECORD_INDEX = {
 	axisHeight: 1,
@@ -72,28 +73,11 @@ function parseMathConstants(bytes, mathTableOffset) {
 		radicalDegreeBottomRaisePercent: require_sfnt.i16(bytes, constantsOffset + RADICAL_DEGREE_BOTTOM_RAISE_PERCENT_OFFSET)
 	};
 }
-function parseCoverageIndex(bytes, coverageOffset) {
-	const format = require_sfnt.u16(bytes, coverageOffset);
-	const index = /* @__PURE__ */ new Map();
-	if (format === 1) {
-		const glyphCount = require_sfnt.u16(bytes, coverageOffset + 2);
-		for (let i = 0; i < glyphCount; i++) index.set(require_sfnt.u16(bytes, coverageOffset + 4 + i * 2), i);
-	} else if (format === 2) {
-		const rangeCount = require_sfnt.u16(bytes, coverageOffset + 2);
-		for (let i = 0; i < rangeCount; i++) {
-			const recordOffset = coverageOffset + 4 + i * 6;
-			const startGlyphId = require_sfnt.u16(bytes, recordOffset);
-			const endGlyphId = require_sfnt.u16(bytes, recordOffset + 2);
-			const startCoverageIndex = require_sfnt.u16(bytes, recordOffset + 4);
-			for (let glyphId = startGlyphId; glyphId <= endGlyphId; glyphId++) index.set(glyphId, startCoverageIndex + (glyphId - startGlyphId));
-		}
-	}
-	return index;
-}
 function parseGlyphValueTable(bytes, tableOffset) {
-	const coverage = parseCoverageIndex(bytes, tableOffset + require_sfnt.u16(bytes, tableOffset));
+	const coverage = require_ot_layout_common.parseCoverage(bytes, tableOffset + require_sfnt.u16(bytes, tableOffset));
 	const values = /* @__PURE__ */ new Map();
-	for (const [glyphId, coverageIndex] of coverage) values.set(glyphId, require_sfnt.i16(bytes, tableOffset + 4 + coverageIndex * 4));
+	if (coverage === void 0) return values;
+	for (const [glyphId, coverageIndex] of coverage.entries()) values.set(glyphId, require_sfnt.i16(bytes, tableOffset + 4 + coverageIndex * 4));
 	return values;
 }
 function parseMathGlyphInfo(bytes, mathTableOffset) {
@@ -146,7 +130,9 @@ function parseGlyphConstruction(bytes, constructionOffset) {
 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)) {
+	const coverage = require_ot_layout_common.parseCoverage(bytes, variantsOffset + coverageOffset);
+	if (coverage === void 0) return constructions;
+	for (const [glyphId, coverageIndex] of coverage.entries()) {
 		if (coverageIndex >= count) continue;
 		constructions.set(glyphId, parseGlyphConstruction(bytes, variantsOffset + require_sfnt.u16(bytes, constructionArrayOffset + coverageIndex * 2)));
 	}

package/dist/math-table.js

@@ -1,4 +1,5 @@
 import { i16, sfntTableBytes, u16 } from "./sfnt.js";
+import { parseCoverage } from "./ot-layout-common.js";
 //#region src/math-table.ts
 const MATH_VALUE_RECORD_INDEX = {
 	axisHeight: 1,
@@ -71,28 +72,11 @@ function parseMathConstants(bytes, mathTableOffset) {
 		radicalDegreeBottomRaisePercent: i16(bytes, constantsOffset + RADICAL_DEGREE_BOTTOM_RAISE_PERCENT_OFFSET)
 	};
 }
-function parseCoverageIndex(bytes, coverageOffset) {
-	const format = u16(bytes, coverageOffset);
-	const index = /* @__PURE__ */ new Map();
-	if (format === 1) {
-		const glyphCount = u16(bytes, coverageOffset + 2);
-		for (let i = 0; i < glyphCount; i++) index.set(u16(bytes, coverageOffset + 4 + i * 2), i);
-	} else if (format === 2) {
-		const rangeCount = u16(bytes, coverageOffset + 2);
-		for (let i = 0; i < rangeCount; i++) {
-			const recordOffset = coverageOffset + 4 + i * 6;
-			const startGlyphId = u16(bytes, recordOffset);
-			const endGlyphId = u16(bytes, recordOffset + 2);
-			const startCoverageIndex = u16(bytes, recordOffset + 4);
-			for (let glyphId = startGlyphId; glyphId <= endGlyphId; glyphId++) index.set(glyphId, startCoverageIndex + (glyphId - startGlyphId));
-		}
-	}
-	return index;
-}
 function parseGlyphValueTable(bytes, tableOffset) {
-	const coverage = parseCoverageIndex(bytes, tableOffset + u16(bytes, tableOffset));
+	const coverage = parseCoverage(bytes, tableOffset + u16(bytes, tableOffset));
 	const values = /* @__PURE__ */ new Map();
-	for (const [glyphId, coverageIndex] of coverage) values.set(glyphId, i16(bytes, tableOffset + 4 + coverageIndex * 4));
+	if (coverage === void 0) return values;
+	for (const [glyphId, coverageIndex] of coverage.entries()) values.set(glyphId, i16(bytes, tableOffset + 4 + coverageIndex * 4));
 	return values;
 }
 function parseMathGlyphInfo(bytes, mathTableOffset) {
@@ -145,7 +129,9 @@ function parseGlyphConstruction(bytes, constructionOffset) {
 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)) {
+	const coverage = parseCoverage(bytes, variantsOffset + coverageOffset);
+	if (coverage === void 0) return constructions;
+	for (const [glyphId, coverageIndex] of coverage.entries()) {
 		if (coverageIndex >= count) continue;
 		constructions.set(glyphId, parseGlyphConstruction(bytes, variantsOffset + u16(bytes, constructionArrayOffset + coverageIndex * 2)));
 	}

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

@@ -1,3 +1,4 @@
+import { t as MathStretchAxis } from "./math-stretch-DXWjs8gL.cjs";
 //#region src/math-types.d.ts
 interface MathColor {
   readonly r: number;
@@ -29,7 +30,19 @@ interface MathStroke {
   readonly widthPt: number;
   readonly color: MathColor;
 }
-type MathLayoutItem = MathGlyphRun | MathRule | MathStroke;
+interface MathGlyphPlacement {
+  readonly glyphId: number;
+  readonly xPt: number;
+  readonly yPt: number;
+}
+interface MathAssembledGlyphs {
+  readonly kind: 'assembled-glyphs';
+  readonly placements: readonly MathGlyphPlacement[];
+  readonly text: string;
+  readonly sizePt: number;
+  readonly color: MathColor;
+}
+type MathLayoutItem = MathGlyphRun | MathRule | MathStroke | MathAssembledGlyphs;
 interface MathBox {
   readonly widthPt: number;
   readonly heightPt: number;
@@ -44,6 +57,18 @@ interface MathGlyphMetrics {
   readonly inkAscentPt?: number;
   readonly inkDescentPt?: number;
 }
+interface MathStretchGlyph {
+  readonly glyphId: number;
+  readonly offsetPt: number;
+}
+interface MathStretchResult {
+  readonly kind: 'base' | 'variant' | 'assembly';
+  readonly sizePt: number;
+  readonly advanceWidthPt: number;
+  readonly inkAscentPt: number;
+  readonly inkDescentPt: number;
+  readonly placements: readonly MathStretchGlyph[];
+}
 interface MathFontMetrics {
   readonly ascentPerEm: number;
   readonly descentPerEm: number;
@@ -79,6 +104,7 @@ interface MathFontMetrics {
   readonly scriptScriptPercentScaleDown: number;
   readonly defaultRuleThicknessPt: number;
   glyph(codePoint: number, sizePt: number): MathGlyphMetrics | undefined;
+  stretch(codePoint: number, axis: MathStretchAxis, targetSizePt: number, sizePt: number): MathStretchResult | undefined;
 }
 //#endregion
-export { MathGlyphRun as a, MathStroke as c, MathGlyphMetrics as i, MathColor as n, MathLayoutItem as o, MathFontMetrics as r, MathRule as s, MathBox as t };
+export { MathGlyphMetrics as a, MathLayoutItem as c, MathStretchResult as d, MathStroke as f, MathFontMetrics as i, MathRule as l, MathBox as n, MathGlyphPlacement as o, MathColor as r, MathGlyphRun as s, MathAssembledGlyphs as t, MathStretchGlyph as u };

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

@@ -1,3 +1,4 @@
+import { t as MathStretchAxis } from "./math-stretch-Bwk_bxh1.js";
 //#region src/math-types.d.ts
 interface MathColor {
   readonly r: number;
@@ -29,7 +30,19 @@ interface MathStroke {
   readonly widthPt: number;
   readonly color: MathColor;
 }
-type MathLayoutItem = MathGlyphRun | MathRule | MathStroke;
+interface MathGlyphPlacement {
+  readonly glyphId: number;
+  readonly xPt: number;
+  readonly yPt: number;
+}
+interface MathAssembledGlyphs {
+  readonly kind: 'assembled-glyphs';
+  readonly placements: readonly MathGlyphPlacement[];
+  readonly text: string;
+  readonly sizePt: number;
+  readonly color: MathColor;
+}
+type MathLayoutItem = MathGlyphRun | MathRule | MathStroke | MathAssembledGlyphs;
 interface MathBox {
   readonly widthPt: number;
   readonly heightPt: number;
@@ -44,6 +57,18 @@ interface MathGlyphMetrics {
   readonly inkAscentPt?: number;
   readonly inkDescentPt?: number;
 }
+interface MathStretchGlyph {
+  readonly glyphId: number;
+  readonly offsetPt: number;
+}
+interface MathStretchResult {
+  readonly kind: 'base' | 'variant' | 'assembly';
+  readonly sizePt: number;
+  readonly advanceWidthPt: number;
+  readonly inkAscentPt: number;
+  readonly inkDescentPt: number;
+  readonly placements: readonly MathStretchGlyph[];
+}
 interface MathFontMetrics {
   readonly ascentPerEm: number;
   readonly descentPerEm: number;
@@ -79,6 +104,7 @@ interface MathFontMetrics {
   readonly scriptScriptPercentScaleDown: number;
   readonly defaultRuleThicknessPt: number;
   glyph(codePoint: number, sizePt: number): MathGlyphMetrics | undefined;
+  stretch(codePoint: number, axis: MathStretchAxis, targetSizePt: number, sizePt: number): MathStretchResult | undefined;
 }
 //#endregion
-export { MathGlyphRun as a, MathStroke as c, MathGlyphMetrics as i, MathColor as n, MathLayoutItem as o, MathFontMetrics as r, MathRule as s, MathBox as t };
+export { MathGlyphMetrics as a, MathLayoutItem as c, MathStretchResult as d, MathStroke as f, MathFontMetrics as i, MathRule as l, MathBox as n, MathGlyphPlacement as o, MathColor as r, MathGlyphRun as s, MathAssembledGlyphs as t, MathStretchGlyph as u };

package/dist/math-types.d.cts

@@ -1,2 +1,3 @@
-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 };
+import { t as MathStretchAxis } from "./math-stretch-DXWjs8gL.cjs";
+import { a as MathGlyphMetrics, c as MathLayoutItem, d as MathStretchResult, f as MathStroke, i as MathFontMetrics, l as MathRule, n as MathBox, o as MathGlyphPlacement, r as MathColor, s as MathGlyphRun, t as MathAssembledGlyphs, u as MathStretchGlyph } from "./math-types-BZkWO5Ow.cjs";
+export { MathAssembledGlyphs, MathBox, MathColor, MathFontMetrics, MathGlyphMetrics, MathGlyphPlacement, MathGlyphRun, MathLayoutItem, MathRule, type MathStretchAxis, MathStretchGlyph, MathStretchResult, MathStroke };

package/dist/math-types.d.ts

@@ -1,2 +1,3 @@
-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 };
+import { t as MathStretchAxis } from "./math-stretch-Bwk_bxh1.js";
+import { a as MathGlyphMetrics, c as MathLayoutItem, d as MathStretchResult, f as MathStroke, i as MathFontMetrics, l as MathRule, n as MathBox, o as MathGlyphPlacement, r as MathColor, s as MathGlyphRun, t as MathAssembledGlyphs, u as MathStretchGlyph } from "./math-types-Bq7tyV4g.js";
+export { MathAssembledGlyphs, MathBox, MathColor, MathFontMetrics, MathGlyphMetrics, MathGlyphPlacement, MathGlyphRun, MathLayoutItem, MathRule, type MathStretchAxis, MathStretchGlyph, MathStretchResult, MathStroke };

package/dist/measure.d.cts

@@ -1,4 +1,4 @@
-import { t as FontRegistry } from "./font-registry-yby02snZ.cjs";
+import { t as FontRegistry } from "./font-registry-B5qL0Vi0.cjs";
 import { LayoutFont } from "document-schema.js";
 //#region src/measure.d.ts
 interface UnderlineMetrics {

package/dist/measure.d.ts

@@ -1,4 +1,4 @@
-import { t as FontRegistry } from "./font-registry-Cn7P9lAh.js";
+import { t as FontRegistry } from "./font-registry-mgdbNP8_.js";
 import { LayoutFont } from "document-schema.js";
 //#region src/measure.d.ts
 interface UnderlineMetrics {

package/dist/ot-layout-common.cjs

@@ -0,0 +1,95 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_sfnt = require("./sfnt.cjs");
+//#region src/ot-layout-common.ts
+function findRange(ranges, glyphId) {
+	let low = 0;
+	let high = ranges.length - 1;
+	while (low <= high) {
+		const mid = low + high >> 1;
+		const range = ranges[mid];
+		if (glyphId < range.startGlyphId) high = mid - 1;
+		else if (glyphId > range.endGlyphId) low = mid + 1;
+		else return range;
+	}
+}
+function pushGlyph(ranges, glyphId, value, valueStep) {
+	const previous = ranges[ranges.length - 1];
+	if (previous !== void 0 && glyphId === previous.endGlyphId + 1 && value === previous.value + (previous.endGlyphId - previous.startGlyphId + 1) * valueStep) {
+		ranges[ranges.length - 1] = {
+			startGlyphId: previous.startGlyphId,
+			endGlyphId: glyphId,
+			value: previous.value
+		};
+		return;
+	}
+	ranges.push({
+		startGlyphId: glyphId,
+		endGlyphId: glyphId,
+		value
+	});
+}
+const RANGE_RECORD_SIZE = 6;
+function parseRangeRecords(bytes, recordsOffset, recordCount) {
+	if (!require_sfnt.hasBytes(bytes, recordsOffset, recordCount * RANGE_RECORD_SIZE)) return;
+	const ranges = [];
+	for (let i = 0; i < recordCount; i++) {
+		const recordOffset = recordsOffset + i * RANGE_RECORD_SIZE;
+		const startGlyphId = require_sfnt.u16(bytes, recordOffset);
+		const endGlyphId = require_sfnt.u16(bytes, recordOffset + 2);
+		if (endGlyphId < startGlyphId) continue;
+		ranges.push({
+			startGlyphId,
+			endGlyphId,
+			value: require_sfnt.u16(bytes, recordOffset + 4)
+		});
+	}
+	ranges.sort((a, b) => a.startGlyphId - b.startGlyphId);
+	return ranges;
+}
+const COVERAGE_HEADER_SIZE = 4;
+function parseCoverage(bytes, coverageOffset) {
+	if (!require_sfnt.hasBytes(bytes, coverageOffset, COVERAGE_HEADER_SIZE)) return;
+	const format = require_sfnt.u16(bytes, coverageOffset);
+	const count = require_sfnt.u16(bytes, coverageOffset + 2);
+	let ranges;
+	if (format === 1) {
+		const glyphArrayOffset = coverageOffset + COVERAGE_HEADER_SIZE;
+		if (!require_sfnt.hasBytes(bytes, glyphArrayOffset, count * 2)) return;
+		ranges = [];
+		for (let i = 0; i < count; i++) pushGlyph(ranges, require_sfnt.u16(bytes, glyphArrayOffset + i * 2), i, 1);
+		ranges.sort((a, b) => a.startGlyphId - b.startGlyphId);
+	} else if (format === 2) ranges = parseRangeRecords(bytes, coverageOffset + COVERAGE_HEADER_SIZE, count);
+	if (ranges === void 0) return;
+	const resolved = ranges;
+	return {
+		coverageIndex(glyphId) {
+			const range = findRange(resolved, glyphId);
+			return range === void 0 ? void 0 : range.value + (glyphId - range.startGlyphId);
+		},
+		*entries() {
+			for (const range of resolved) for (let glyphId = range.startGlyphId; glyphId <= range.endGlyphId; glyphId++) yield [glyphId, range.value + (glyphId - range.startGlyphId)];
+		}
+	};
+}
+const CLASS_DEF_FORMAT_1_HEADER_SIZE = 6;
+const CLASS_DEF_FORMAT_2_HEADER_SIZE = 4;
+function parseClassDef(bytes, classDefOffset) {
+	if (!require_sfnt.hasBytes(bytes, classDefOffset, CLASS_DEF_FORMAT_2_HEADER_SIZE)) return;
+	const format = require_sfnt.u16(bytes, classDefOffset);
+	let ranges;
+	if (format === 1) {
+		if (!require_sfnt.hasBytes(bytes, classDefOffset, CLASS_DEF_FORMAT_1_HEADER_SIZE)) return;
+		const startGlyphId = require_sfnt.u16(bytes, classDefOffset + 2);
+		const glyphCount = require_sfnt.u16(bytes, classDefOffset + 4);
+		const classArrayOffset = classDefOffset + CLASS_DEF_FORMAT_1_HEADER_SIZE;
+		if (!require_sfnt.hasBytes(bytes, classArrayOffset, glyphCount * 2)) return;
+		ranges = [];
+		for (let i = 0; i < glyphCount; i++) pushGlyph(ranges, startGlyphId + i, require_sfnt.u16(bytes, classArrayOffset + i * 2), 0);
+	} else if (format === 2) ranges = parseRangeRecords(bytes, classDefOffset + CLASS_DEF_FORMAT_2_HEADER_SIZE, require_sfnt.u16(bytes, classDefOffset + 2));
+	if (ranges === void 0) return;
+	const resolved = ranges;
+	return (glyphId) => findRange(resolved, glyphId)?.value ?? 0;
+}
+//#endregion
+exports.parseClassDef = parseClassDef;
+exports.parseCoverage = parseCoverage;

package/dist/ot-layout-common.d.cts

@@ -0,0 +1,10 @@
+//#region src/ot-layout-common.d.ts
+interface CoverageTable {
+  coverageIndex(glyphId: number): number | undefined;
+  entries(): IterableIterator<readonly [number, number]>;
+}
+declare function parseCoverage(bytes: Uint8Array<ArrayBuffer>, coverageOffset: number): CoverageTable | undefined;
+type ClassDefTable = (glyphId: number) => number;
+declare function parseClassDef(bytes: Uint8Array<ArrayBuffer>, classDefOffset: number): ClassDefTable | undefined;
+//#endregion
+export { ClassDefTable, CoverageTable, parseClassDef, parseCoverage };

package/dist/ot-layout-common.d.ts

@@ -0,0 +1,10 @@
+//#region src/ot-layout-common.d.ts
+interface CoverageTable {
+  coverageIndex(glyphId: number): number | undefined;
+  entries(): IterableIterator<readonly [number, number]>;
+}
+declare function parseCoverage(bytes: Uint8Array<ArrayBuffer>, coverageOffset: number): CoverageTable | undefined;
+type ClassDefTable = (glyphId: number) => number;
+declare function parseClassDef(bytes: Uint8Array<ArrayBuffer>, classDefOffset: number): ClassDefTable | undefined;
+//#endregion
+export { ClassDefTable, CoverageTable, parseClassDef, parseCoverage };

package/dist/ot-layout-common.js

@@ -0,0 +1,93 @@
+import { hasBytes, u16 } from "./sfnt.js";
+//#region src/ot-layout-common.ts
+function findRange(ranges, glyphId) {
+	let low = 0;
+	let high = ranges.length - 1;
+	while (low <= high) {
+		const mid = low + high >> 1;
+		const range = ranges[mid];
+		if (glyphId < range.startGlyphId) high = mid - 1;
+		else if (glyphId > range.endGlyphId) low = mid + 1;
+		else return range;
+	}
+}
+function pushGlyph(ranges, glyphId, value, valueStep) {
+	const previous = ranges[ranges.length - 1];
+	if (previous !== void 0 && glyphId === previous.endGlyphId + 1 && value === previous.value + (previous.endGlyphId - previous.startGlyphId + 1) * valueStep) {
+		ranges[ranges.length - 1] = {
+			startGlyphId: previous.startGlyphId,
+			endGlyphId: glyphId,
+			value: previous.value
+		};
+		return;
+	}
+	ranges.push({
+		startGlyphId: glyphId,
+		endGlyphId: glyphId,
+		value
+	});
+}
+const RANGE_RECORD_SIZE = 6;
+function parseRangeRecords(bytes, recordsOffset, recordCount) {
+	if (!hasBytes(bytes, recordsOffset, recordCount * RANGE_RECORD_SIZE)) return;
+	const ranges = [];
+	for (let i = 0; i < recordCount; i++) {
+		const recordOffset = recordsOffset + i * RANGE_RECORD_SIZE;
+		const startGlyphId = u16(bytes, recordOffset);
+		const endGlyphId = u16(bytes, recordOffset + 2);
+		if (endGlyphId < startGlyphId) continue;
+		ranges.push({
+			startGlyphId,
+			endGlyphId,
+			value: u16(bytes, recordOffset + 4)
+		});
+	}
+	ranges.sort((a, b) => a.startGlyphId - b.startGlyphId);
+	return ranges;
+}
+const COVERAGE_HEADER_SIZE = 4;
+function parseCoverage(bytes, coverageOffset) {
+	if (!hasBytes(bytes, coverageOffset, COVERAGE_HEADER_SIZE)) return;
+	const format = u16(bytes, coverageOffset);
+	const count = u16(bytes, coverageOffset + 2);
+	let ranges;
+	if (format === 1) {
+		const glyphArrayOffset = coverageOffset + COVERAGE_HEADER_SIZE;
+		if (!hasBytes(bytes, glyphArrayOffset, count * 2)) return;
+		ranges = [];
+		for (let i = 0; i < count; i++) pushGlyph(ranges, u16(bytes, glyphArrayOffset + i * 2), i, 1);
+		ranges.sort((a, b) => a.startGlyphId - b.startGlyphId);
+	} else if (format === 2) ranges = parseRangeRecords(bytes, coverageOffset + COVERAGE_HEADER_SIZE, count);
+	if (ranges === void 0) return;
+	const resolved = ranges;
+	return {
+		coverageIndex(glyphId) {
+			const range = findRange(resolved, glyphId);
+			return range === void 0 ? void 0 : range.value + (glyphId - range.startGlyphId);
+		},
+		*entries() {
+			for (const range of resolved) for (let glyphId = range.startGlyphId; glyphId <= range.endGlyphId; glyphId++) yield [glyphId, range.value + (glyphId - range.startGlyphId)];
+		}
+	};
+}
+const CLASS_DEF_FORMAT_1_HEADER_SIZE = 6;
+const CLASS_DEF_FORMAT_2_HEADER_SIZE = 4;
+function parseClassDef(bytes, classDefOffset) {
+	if (!hasBytes(bytes, classDefOffset, CLASS_DEF_FORMAT_2_HEADER_SIZE)) return;
+	const format = u16(bytes, classDefOffset);
+	let ranges;
+	if (format === 1) {
+		if (!hasBytes(bytes, classDefOffset, CLASS_DEF_FORMAT_1_HEADER_SIZE)) return;
+		const startGlyphId = u16(bytes, classDefOffset + 2);
+		const glyphCount = u16(bytes, classDefOffset + 4);
+		const classArrayOffset = classDefOffset + CLASS_DEF_FORMAT_1_HEADER_SIZE;
+		if (!hasBytes(bytes, classArrayOffset, glyphCount * 2)) return;
+		ranges = [];
+		for (let i = 0; i < glyphCount; i++) pushGlyph(ranges, startGlyphId + i, u16(bytes, classArrayOffset + i * 2), 0);
+	} else if (format === 2) ranges = parseRangeRecords(bytes, classDefOffset + CLASS_DEF_FORMAT_2_HEADER_SIZE, u16(bytes, classDefOffset + 2));
+	if (ranges === void 0) return;
+	const resolved = ranges;
+	return (glyphId) => findRange(resolved, glyphId)?.value ?? 0;
+}
+//#endregion
+export { parseClassDef, parseCoverage };

package/dist/write.d.cts

@@ -1,5 +1,5 @@
-import { r as EmbeddedFaceSubstitution } from "./embedded-font-CLedn-mT.cjs";
-import { t as FontRegistry } from "./font-registry-yby02snZ.cjs";
+import { r as EmbeddedFaceSubstitution } from "./embedded-font-BU6Jgcof.cjs";
+import { t as FontRegistry } from "./font-registry-B5qL0Vi0.cjs";
 import { WinAnsiSubstitution } from "./winansi.cjs";
 import { PositionedFormula } from "./formula.cjs";
 import { LayoutDocument } from "document-schema.js";

package/dist/write.d.ts

@@ -1,5 +1,5 @@
-import { r as EmbeddedFaceSubstitution } from "./embedded-font-CbqkKgBl.js";
-import { t as FontRegistry } from "./font-registry-Cn7P9lAh.js";
+import { r as EmbeddedFaceSubstitution } from "./embedded-font-fREdbxnr.js";
+import { t as FontRegistry } from "./font-registry-mgdbNP8_.js";
 import { WinAnsiSubstitution } from "./winansi.js";
 import { PositionedFormula } from "./formula.js";
 import { LayoutDocument } from "document-schema.js";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pdf-codec",
-  "version": "1.7.0",
+  "version": "1.9.0",
   "description": "Hand-written, dependency-minimal PDF codec: parses arbitrary real-world PDFs and generates new ones, built on document-schema.js's LayoutDocument pivot and Zod 4 codecs.",
   "type": "module",
   "repository": {