pdf-codec 1.3.0 → 1.4.0

package/dist/font-read.cjs

@@ -0,0 +1,199 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_afm_widths = require("./afm-widths-BoeTOK2r.cjs");
+const require_cmap = require("./cmap.cjs");
+const require_objects = require("./objects.cjs");
+const require_filters = require("./filters.cjs");
+const require_fonts = require("./fonts.cjs");
+const require_font_style = require("./font-style.cjs");
+//#region src/font-read.ts
+const ITALIC_FLAG_BIT = 64;
+const FORCE_BOLD_FLAG_BIT = 1 << 18;
+const REPLACEMENT_CHARACTER = "�";
+function styleFlagsFromDescriptor(descriptor) {
+	const flags = descriptor !== void 0 ? require_objects.asNumber(require_objects.dictGet(descriptor, "Flags")) : void 0;
+	return {
+		forceBold: flags !== void 0 ? (flags & FORCE_BOLD_FLAG_BIT) !== 0 : void 0,
+		italicFlag: flags !== void 0 ? (flags & ITALIC_FLAG_BIT) !== 0 : void 0,
+		italicAngle: descriptor !== void 0 ? require_objects.asNumber(require_objects.dictGet(descriptor, "ItalicAngle")) : void 0
+	};
+}
+function glyphNameToUnicodeWithUniFallback(name) {
+	const direct = require_afm_widths.glyphNameToUnicode(name);
+	if (direct !== void 0) return direct;
+	const uniMatch = /^uni([0-9A-Fa-f]{4,6})$/.exec(name);
+	return uniMatch?.[1] !== void 0 ? Number.parseInt(uniMatch[1], 16) : void 0;
+}
+function readDifferencesMap(differences) {
+	const map = /* @__PURE__ */ new Map();
+	if (differences === void 0) return map;
+	let currentCode = 0;
+	for (const el of differences) if (el.kind === "number") currentCode = el.value;
+	else if (el.kind === "name") {
+		map.set(currentCode, el.name);
+		currentCode++;
+	}
+	return map;
+}
+function readToUnicodeCMap(fontDict, context) {
+	const stream = context.resolver.resolve(require_objects.dictGet(fontDict, "ToUnicode"));
+	if (stream?.kind !== "stream") return;
+	const decoded = require_filters.decodeStream(stream.raw, stream.dict, context.sink);
+	return require_cmap.parseToUnicodeCMap(decoded.bytes, context.sink);
+}
+function buildSimpleFont(fontDict, context) {
+	const baseFont = require_objects.asName(require_objects.dictGet(fontDict, "BaseFont")) ?? "Helvetica";
+	const descriptor = context.resolver.resolveDict(require_objects.dictGet(fontDict, "FontDescriptor"));
+	const { baseFamily, bold, italic } = require_font_style.styleFromBaseFontName(baseFont, styleFlagsFromDescriptor(descriptor));
+	const widthsArr = require_objects.asArray(require_objects.dictGet(fontDict, "Widths"));
+	const firstChar = require_objects.asNumber(require_objects.dictGet(fontDict, "FirstChar")) ?? 0;
+	const missingWidth = (descriptor !== void 0 ? require_objects.asNumber(require_objects.dictGet(descriptor, "MissingWidth")) : void 0) ?? 0;
+	let widthOf;
+	if (widthsArr !== void 0) widthOf = (code) => require_objects.asNumber(widthsArr[code - firstChar]) ?? missingWidth;
+	else {
+		const standardMatch = require_fonts.resolveStandardFont(baseFamily, bold, italic);
+		widthOf = (code) => require_afm_widths.widthOfCode(standardMatch.standardName, code);
+		if (!standardMatch.matched) context.sink({
+			code: "pdf/font-widths-missing",
+			severity: "warning",
+			message: `font "${baseFont}" has no /Widths array and does not match a standard-14 family; falling back to Helvetica metrics`
+		});
+	}
+	const toUnicode = readToUnicodeCMap(fontDict, context);
+	const encodingObj = require_objects.dictGet(fontDict, "Encoding");
+	const encodingDict = context.resolver.resolveDict(encodingObj);
+	const baseEncodingName = require_objects.asName(encodingDict !== void 0 ? require_objects.dictGet(encodingDict, "BaseEncoding") : encodingObj);
+	if (baseEncodingName !== void 0 && baseEncodingName !== "WinAnsiEncoding") context.sink({
+		code: "char/encoding-approximated",
+		severity: "info",
+		message: `base encoding "${baseEncodingName}" has no dedicated table here and is approximated as WinAnsiEncoding`
+	});
+	const differencesMap = readDifferencesMap(encodingDict !== void 0 ? require_objects.asArray(require_objects.dictGet(encodingDict, "Differences")) : void 0);
+	const decodeToUnicode = (codes) => {
+		let out = "";
+		let unmapped = 0;
+		for (const code of codes) {
+			const viaToUnicode = toUnicode?.lookup(code);
+			if (viaToUnicode !== void 0) {
+				out += viaToUnicode;
+				continue;
+			}
+			const name = differencesMap.get(code) ?? require_afm_widths.winAnsiGlyphName(code);
+			const unicode = name !== void 0 ? glyphNameToUnicodeWithUniFallback(name) : void 0;
+			if (unicode !== void 0) {
+				out += String.fromCharCode(unicode);
+				continue;
+			}
+			unmapped++;
+			out += REPLACEMENT_CHARACTER;
+		}
+		if (unmapped > 0) context.sink({
+			code: "text/unmapped-encoding",
+			severity: unmapped > codes.length / 2 ? "warning" : "info",
+			message: `${String(unmapped)} of ${String(codes.length)} character code(s) in font "${baseFont}" could not be mapped to Unicode`
+		});
+		return out;
+	};
+	return {
+		composite: false,
+		family: baseFamily,
+		bold,
+		italic,
+		widthOf,
+		decodeToUnicode
+	};
+}
+function readCidWidths(w) {
+	const map = /* @__PURE__ */ new Map();
+	if (w === void 0) return map;
+	let i = 0;
+	while (i < w.length) {
+		const first = require_objects.asNumber(w[i]);
+		if (first === void 0) {
+			i++;
+			continue;
+		}
+		const next = w[i + 1];
+		if (next?.kind === "array") {
+			next.items.forEach((item, offset) => {
+				const width = require_objects.asNumber(item);
+				if (width !== void 0) map.set(first + offset, width);
+			});
+			i += 2;
+		} else {
+			const last = require_objects.asNumber(next);
+			const width = require_objects.asNumber(w[i + 2]);
+			if (last !== void 0 && width !== void 0) for (let cid = first; cid <= last; cid++) map.set(cid, width);
+			i += 3;
+		}
+	}
+	return map;
+}
+const DEFAULT_CID_WIDTH = 1e3;
+function buildCompositeFont(fontDict, context) {
+	const baseFont = require_objects.asName(require_objects.dictGet(fontDict, "BaseFont")) ?? "Helvetica";
+	const descendants = require_objects.asArray(require_objects.dictGet(fontDict, "DescendantFonts"));
+	const descendantDict = descendants !== void 0 ? context.resolver.resolveDict(descendants[0]) : void 0;
+	const descriptor = descendantDict !== void 0 ? context.resolver.resolveDict(require_objects.dictGet(descendantDict, "FontDescriptor")) : void 0;
+	const { baseFamily, bold, italic } = require_font_style.styleFromBaseFontName(baseFont, styleFlagsFromDescriptor(descriptor));
+	const dw = descendantDict !== void 0 ? require_objects.asNumber(require_objects.dictGet(descendantDict, "DW")) ?? DEFAULT_CID_WIDTH : DEFAULT_CID_WIDTH;
+	const widthMap = readCidWidths(descendantDict !== void 0 ? require_objects.asArray(require_objects.dictGet(descendantDict, "W")) : void 0);
+	const widthOf = (cid) => widthMap.get(cid) ?? dw;
+	const toUnicode = readToUnicodeCMap(fontDict, context);
+	const decodeToUnicode = (codes) => {
+		let out = "";
+		let glyphCount = 0;
+		let unmapped = 0;
+		for (let i = 0; i + 1 < codes.length; i += 2) {
+			glyphCount++;
+			const cid = (codes[i] ?? 0) << 8 | (codes[i + 1] ?? 0);
+			const mapped = toUnicode?.lookup(cid);
+			if (mapped !== void 0) {
+				out += mapped;
+				continue;
+			}
+			unmapped++;
+			out += REPLACEMENT_CHARACTER;
+		}
+		if (unmapped > 0) context.sink({
+			code: "text/unmapped-encoding",
+			severity: unmapped > glyphCount / 2 ? "warning" : "info",
+			message: `${String(unmapped)} of ${String(glyphCount)} character code(s) in font "${baseFont}" could not be mapped to Unicode (no /ToUnicode CMap, or an incomplete one)`
+		});
+		return out;
+	};
+	return {
+		composite: true,
+		family: baseFamily,
+		bold,
+		italic,
+		widthOf,
+		decodeToUnicode
+	};
+}
+function createFontResolver(context) {
+	const cache = /* @__PURE__ */ new Map();
+	const resolve = (fontResourceName, resources) => {
+		const fontsDict = context.resolver.resolveDict(require_objects.dictGet(resources, "Font"));
+		const fontDict = fontsDict !== void 0 ? context.resolver.resolveDict(require_objects.dictGet(fontsDict, fontResourceName)) : void 0;
+		if (fontDict === void 0) return;
+		if (cache.has(fontDict)) return cache.get(fontDict);
+		const resolved = require_objects.asName(require_objects.dictGet(fontDict, "Subtype")) === "Type0" ? buildCompositeFont(fontDict, context) : buildSimpleFont(fontDict, context);
+		cache.set(fontDict, resolved);
+		return resolved;
+	};
+	return {
+		metrics: { glyphAdvance(fontResourceName, resources, codes, byteOffset) {
+			const font = resolve(fontResourceName, resources);
+			if (font === void 0) return;
+			const byteLengthConsumed = font.composite ? 2 : 1;
+			const code = font.composite ? (codes[byteOffset] ?? 0) << 8 | (codes[byteOffset + 1] ?? 0) : codes[byteOffset] ?? 0;
+			return {
+				widthPer1000: font.widthOf(code),
+				byteLengthConsumed
+			};
+		} },
+		resolve
+	};
+}
+//#endregion
+exports.createFontResolver = createFontResolver;

package/dist/font-read.d.cts

@@ -0,0 +1,23 @@
+import { PdfDiagnosticSink } from "./diagnostics.cjs";
+import { PdfDict } from "./objects.cjs";
+import { FontMetricsPort, PdfObjectResolver } from "./interpret.cjs";
+//#region src/font-read.d.ts
+interface PdfFont {
+  readonly composite: boolean;
+  readonly family: string;
+  readonly bold: boolean;
+  readonly italic: boolean;
+  widthOf(code: number): number;
+  decodeToUnicode(codes: Uint8Array<ArrayBuffer>): string;
+}
+interface FontReadContext {
+  readonly resolver: PdfObjectResolver;
+  readonly sink: PdfDiagnosticSink;
+}
+interface FontResolverService {
+  readonly metrics: FontMetricsPort;
+  readonly resolve: (fontResourceName: string, resources: PdfDict) => PdfFont | undefined;
+}
+declare function createFontResolver(context: FontReadContext): FontResolverService;
+//#endregion
+export { FontReadContext, FontResolverService, PdfFont, createFontResolver };

package/dist/font-read.d.ts

@@ -0,0 +1,23 @@
+import { PdfDiagnosticSink } from "./diagnostics.js";
+import { PdfDict } from "./objects.js";
+import { FontMetricsPort, PdfObjectResolver } from "./interpret.js";
+//#region src/font-read.d.ts
+interface PdfFont {
+  readonly composite: boolean;
+  readonly family: string;
+  readonly bold: boolean;
+  readonly italic: boolean;
+  widthOf(code: number): number;
+  decodeToUnicode(codes: Uint8Array<ArrayBuffer>): string;
+}
+interface FontReadContext {
+  readonly resolver: PdfObjectResolver;
+  readonly sink: PdfDiagnosticSink;
+}
+interface FontResolverService {
+  readonly metrics: FontMetricsPort;
+  readonly resolve: (fontResourceName: string, resources: PdfDict) => PdfFont | undefined;
+}
+declare function createFontResolver(context: FontReadContext): FontResolverService;
+//#endregion
+export { FontReadContext, FontResolverService, PdfFont, createFontResolver };

package/dist/font-read.js

@@ -0,0 +1,198 @@
+import { a as winAnsiGlyphName, i as glyphNameToUnicode, n as widthOfCode } from "./afm-widths-Dxucrg7D.js";
+import { parseToUnicodeCMap } from "./cmap.js";
+import { asArray, asName, asNumber, dictGet } from "./objects.js";
+import { decodeStream } from "./filters.js";
+import { resolveStandardFont } from "./fonts.js";
+import { styleFromBaseFontName } from "./font-style.js";
+//#region src/font-read.ts
+const ITALIC_FLAG_BIT = 64;
+const FORCE_BOLD_FLAG_BIT = 1 << 18;
+const REPLACEMENT_CHARACTER = "�";
+function styleFlagsFromDescriptor(descriptor) {
+	const flags = descriptor !== void 0 ? asNumber(dictGet(descriptor, "Flags")) : void 0;
+	return {
+		forceBold: flags !== void 0 ? (flags & FORCE_BOLD_FLAG_BIT) !== 0 : void 0,
+		italicFlag: flags !== void 0 ? (flags & ITALIC_FLAG_BIT) !== 0 : void 0,
+		italicAngle: descriptor !== void 0 ? asNumber(dictGet(descriptor, "ItalicAngle")) : void 0
+	};
+}
+function glyphNameToUnicodeWithUniFallback(name) {
+	const direct = glyphNameToUnicode(name);
+	if (direct !== void 0) return direct;
+	const uniMatch = /^uni([0-9A-Fa-f]{4,6})$/.exec(name);
+	return uniMatch?.[1] !== void 0 ? Number.parseInt(uniMatch[1], 16) : void 0;
+}
+function readDifferencesMap(differences) {
+	const map = /* @__PURE__ */ new Map();
+	if (differences === void 0) return map;
+	let currentCode = 0;
+	for (const el of differences) if (el.kind === "number") currentCode = el.value;
+	else if (el.kind === "name") {
+		map.set(currentCode, el.name);
+		currentCode++;
+	}
+	return map;
+}
+function readToUnicodeCMap(fontDict, context) {
+	const stream = context.resolver.resolve(dictGet(fontDict, "ToUnicode"));
+	if (stream?.kind !== "stream") return;
+	const decoded = decodeStream(stream.raw, stream.dict, context.sink);
+	return parseToUnicodeCMap(decoded.bytes, context.sink);
+}
+function buildSimpleFont(fontDict, context) {
+	const baseFont = asName(dictGet(fontDict, "BaseFont")) ?? "Helvetica";
+	const descriptor = context.resolver.resolveDict(dictGet(fontDict, "FontDescriptor"));
+	const { baseFamily, bold, italic } = styleFromBaseFontName(baseFont, styleFlagsFromDescriptor(descriptor));
+	const widthsArr = asArray(dictGet(fontDict, "Widths"));
+	const firstChar = asNumber(dictGet(fontDict, "FirstChar")) ?? 0;
+	const missingWidth = (descriptor !== void 0 ? asNumber(dictGet(descriptor, "MissingWidth")) : void 0) ?? 0;
+	let widthOf;
+	if (widthsArr !== void 0) widthOf = (code) => asNumber(widthsArr[code - firstChar]) ?? missingWidth;
+	else {
+		const standardMatch = resolveStandardFont(baseFamily, bold, italic);
+		widthOf = (code) => widthOfCode(standardMatch.standardName, code);
+		if (!standardMatch.matched) context.sink({
+			code: "pdf/font-widths-missing",
+			severity: "warning",
+			message: `font "${baseFont}" has no /Widths array and does not match a standard-14 family; falling back to Helvetica metrics`
+		});
+	}
+	const toUnicode = readToUnicodeCMap(fontDict, context);
+	const encodingObj = dictGet(fontDict, "Encoding");
+	const encodingDict = context.resolver.resolveDict(encodingObj);
+	const baseEncodingName = asName(encodingDict !== void 0 ? dictGet(encodingDict, "BaseEncoding") : encodingObj);
+	if (baseEncodingName !== void 0 && baseEncodingName !== "WinAnsiEncoding") context.sink({
+		code: "char/encoding-approximated",
+		severity: "info",
+		message: `base encoding "${baseEncodingName}" has no dedicated table here and is approximated as WinAnsiEncoding`
+	});
+	const differencesMap = readDifferencesMap(encodingDict !== void 0 ? asArray(dictGet(encodingDict, "Differences")) : void 0);
+	const decodeToUnicode = (codes) => {
+		let out = "";
+		let unmapped = 0;
+		for (const code of codes) {
+			const viaToUnicode = toUnicode?.lookup(code);
+			if (viaToUnicode !== void 0) {
+				out += viaToUnicode;
+				continue;
+			}
+			const name = differencesMap.get(code) ?? winAnsiGlyphName(code);
+			const unicode = name !== void 0 ? glyphNameToUnicodeWithUniFallback(name) : void 0;
+			if (unicode !== void 0) {
+				out += String.fromCharCode(unicode);
+				continue;
+			}
+			unmapped++;
+			out += REPLACEMENT_CHARACTER;
+		}
+		if (unmapped > 0) context.sink({
+			code: "text/unmapped-encoding",
+			severity: unmapped > codes.length / 2 ? "warning" : "info",
+			message: `${String(unmapped)} of ${String(codes.length)} character code(s) in font "${baseFont}" could not be mapped to Unicode`
+		});
+		return out;
+	};
+	return {
+		composite: false,
+		family: baseFamily,
+		bold,
+		italic,
+		widthOf,
+		decodeToUnicode
+	};
+}
+function readCidWidths(w) {
+	const map = /* @__PURE__ */ new Map();
+	if (w === void 0) return map;
+	let i = 0;
+	while (i < w.length) {
+		const first = asNumber(w[i]);
+		if (first === void 0) {
+			i++;
+			continue;
+		}
+		const next = w[i + 1];
+		if (next?.kind === "array") {
+			next.items.forEach((item, offset) => {
+				const width = asNumber(item);
+				if (width !== void 0) map.set(first + offset, width);
+			});
+			i += 2;
+		} else {
+			const last = asNumber(next);
+			const width = asNumber(w[i + 2]);
+			if (last !== void 0 && width !== void 0) for (let cid = first; cid <= last; cid++) map.set(cid, width);
+			i += 3;
+		}
+	}
+	return map;
+}
+const DEFAULT_CID_WIDTH = 1e3;
+function buildCompositeFont(fontDict, context) {
+	const baseFont = asName(dictGet(fontDict, "BaseFont")) ?? "Helvetica";
+	const descendants = asArray(dictGet(fontDict, "DescendantFonts"));
+	const descendantDict = descendants !== void 0 ? context.resolver.resolveDict(descendants[0]) : void 0;
+	const descriptor = descendantDict !== void 0 ? context.resolver.resolveDict(dictGet(descendantDict, "FontDescriptor")) : void 0;
+	const { baseFamily, bold, italic } = styleFromBaseFontName(baseFont, styleFlagsFromDescriptor(descriptor));
+	const dw = descendantDict !== void 0 ? asNumber(dictGet(descendantDict, "DW")) ?? DEFAULT_CID_WIDTH : DEFAULT_CID_WIDTH;
+	const widthMap = readCidWidths(descendantDict !== void 0 ? asArray(dictGet(descendantDict, "W")) : void 0);
+	const widthOf = (cid) => widthMap.get(cid) ?? dw;
+	const toUnicode = readToUnicodeCMap(fontDict, context);
+	const decodeToUnicode = (codes) => {
+		let out = "";
+		let glyphCount = 0;
+		let unmapped = 0;
+		for (let i = 0; i + 1 < codes.length; i += 2) {
+			glyphCount++;
+			const cid = (codes[i] ?? 0) << 8 | (codes[i + 1] ?? 0);
+			const mapped = toUnicode?.lookup(cid);
+			if (mapped !== void 0) {
+				out += mapped;
+				continue;
+			}
+			unmapped++;
+			out += REPLACEMENT_CHARACTER;
+		}
+		if (unmapped > 0) context.sink({
+			code: "text/unmapped-encoding",
+			severity: unmapped > glyphCount / 2 ? "warning" : "info",
+			message: `${String(unmapped)} of ${String(glyphCount)} character code(s) in font "${baseFont}" could not be mapped to Unicode (no /ToUnicode CMap, or an incomplete one)`
+		});
+		return out;
+	};
+	return {
+		composite: true,
+		family: baseFamily,
+		bold,
+		italic,
+		widthOf,
+		decodeToUnicode
+	};
+}
+function createFontResolver(context) {
+	const cache = /* @__PURE__ */ new Map();
+	const resolve = (fontResourceName, resources) => {
+		const fontsDict = context.resolver.resolveDict(dictGet(resources, "Font"));
+		const fontDict = fontsDict !== void 0 ? context.resolver.resolveDict(dictGet(fontsDict, fontResourceName)) : void 0;
+		if (fontDict === void 0) return;
+		if (cache.has(fontDict)) return cache.get(fontDict);
+		const resolved = asName(dictGet(fontDict, "Subtype")) === "Type0" ? buildCompositeFont(fontDict, context) : buildSimpleFont(fontDict, context);
+		cache.set(fontDict, resolved);
+		return resolved;
+	};
+	return {
+		metrics: { glyphAdvance(fontResourceName, resources, codes, byteOffset) {
+			const font = resolve(fontResourceName, resources);
+			if (font === void 0) return;
+			const byteLengthConsumed = font.composite ? 2 : 1;
+			const code = font.composite ? (codes[byteOffset] ?? 0) << 8 | (codes[byteOffset + 1] ?? 0) : codes[byteOffset] ?? 0;
+			return {
+				widthPer1000: font.widthOf(code),
+				byteLengthConsumed
+			};
+		} },
+		resolve
+	};
+}
+//#endregion
+export { createFontResolver };

package/dist/font-style.cjs

@@ -0,0 +1,35 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+//#region src/font-style.ts
+const SUBSET_TAG_PATTERN = /^[A-Z]{6}\+/;
+const KNOWN_STYLE_SUFFIXES = [
+	"BoldItalic",
+	"BoldOblique",
+	"Bold",
+	"Italic",
+	"Oblique",
+	"Regular"
+];
+function stripStyleSuffix(name) {
+	for (const suffix of KNOWN_STYLE_SUFFIXES) {
+		const commaPattern = new RegExp(`,${suffix}$`, "i");
+		const hyphenPattern = new RegExp(`-${suffix}$`, "i");
+		if (commaPattern.test(name)) return name.replace(commaPattern, "");
+		if (hyphenPattern.test(name)) return name.replace(hyphenPattern, "");
+	}
+	return name;
+}
+function styleFromBaseFontName(baseFont, flags) {
+	const withoutSubset = baseFont.replace(SUBSET_TAG_PATTERN, "");
+	const lower = withoutSubset.toLowerCase();
+	const nameBold = lower.includes("bold");
+	const nameItalic = /italic|oblique/.test(lower);
+	const bold = nameBold || (flags?.forceBold ?? false);
+	const italic = nameItalic || (flags?.italicFlag ?? false) || flags?.italicAngle !== void 0 && flags.italicAngle !== 0;
+	return {
+		baseFamily: stripStyleSuffix(withoutSubset),
+		bold,
+		italic
+	};
+}
+//#endregion
+exports.styleFromBaseFontName = styleFromBaseFontName;

package/dist/font-style.d.cts

@@ -0,0 +1,14 @@
+//#region src/font-style.d.ts
+interface FontStyleFlags {
+  readonly forceBold?: boolean;
+  readonly italicFlag?: boolean;
+  readonly italicAngle?: number;
+}
+interface FontNameStyle {
+  readonly baseFamily: string;
+  readonly bold: boolean;
+  readonly italic: boolean;
+}
+declare function styleFromBaseFontName(baseFont: string, flags?: FontStyleFlags): FontNameStyle;
+//#endregion
+export { FontNameStyle, FontStyleFlags, styleFromBaseFontName };

package/dist/font-style.d.ts

@@ -0,0 +1,14 @@
+//#region src/font-style.d.ts
+interface FontStyleFlags {
+  readonly forceBold?: boolean;
+  readonly italicFlag?: boolean;
+  readonly italicAngle?: number;
+}
+interface FontNameStyle {
+  readonly baseFamily: string;
+  readonly bold: boolean;
+  readonly italic: boolean;
+}
+declare function styleFromBaseFontName(baseFont: string, flags?: FontStyleFlags): FontNameStyle;
+//#endregion
+export { FontNameStyle, FontStyleFlags, styleFromBaseFontName };

package/dist/font-style.js

@@ -0,0 +1,34 @@
+//#region src/font-style.ts
+const SUBSET_TAG_PATTERN = /^[A-Z]{6}\+/;
+const KNOWN_STYLE_SUFFIXES = [
+	"BoldItalic",
+	"BoldOblique",
+	"Bold",
+	"Italic",
+	"Oblique",
+	"Regular"
+];
+function stripStyleSuffix(name) {
+	for (const suffix of KNOWN_STYLE_SUFFIXES) {
+		const commaPattern = new RegExp(`,${suffix}$`, "i");
+		const hyphenPattern = new RegExp(`-${suffix}$`, "i");
+		if (commaPattern.test(name)) return name.replace(commaPattern, "");
+		if (hyphenPattern.test(name)) return name.replace(hyphenPattern, "");
+	}
+	return name;
+}
+function styleFromBaseFontName(baseFont, flags) {
+	const withoutSubset = baseFont.replace(SUBSET_TAG_PATTERN, "");
+	const lower = withoutSubset.toLowerCase();
+	const nameBold = lower.includes("bold");
+	const nameItalic = /italic|oblique/.test(lower);
+	const bold = nameBold || (flags?.forceBold ?? false);
+	const italic = nameItalic || (flags?.italicFlag ?? false) || flags?.italicAngle !== void 0 && flags.italicAngle !== 0;
+	return {
+		baseFamily: stripStyleSuffix(withoutSubset),
+		bold,
+		italic
+	};
+}
+//#endregion
+export { styleFromBaseFontName };

package/dist/fonts.cjs

@@ -0,0 +1,124 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+//#region src/fonts.ts
+const FAMILY_BY_NORMALIZED_NAME = /* @__PURE__ */ new Map([
+	["helvetica", "helvetica"],
+	["helveticaneue", "helvetica"],
+	["arial", "helvetica"],
+	["arialnarrow", "helvetica"],
+	["arialblack", "helvetica"],
+	["calibri", "helvetica"],
+	["aptos", "helvetica"],
+	["aptosdisplay", "helvetica"],
+	["segoeui", "helvetica"],
+	["tahoma", "helvetica"],
+	["verdana", "helvetica"],
+	["trebuchetms", "helvetica"],
+	["centurygothic", "helvetica"],
+	["franklingothicbook", "helvetica"],
+	["gillsans", "helvetica"],
+	["futura", "helvetica"],
+	["roboto", "helvetica"],
+	["opensans", "helvetica"],
+	["lato", "helvetica"],
+	["montserrat", "helvetica"],
+	["poppins", "helvetica"],
+	["inter", "helvetica"],
+	["notosans", "helvetica"],
+	["dejavusans", "helvetica"],
+	["sourcesanspro", "helvetica"],
+	["sansserif", "helvetica"],
+	["liberationsans", "helvetica"],
+	["nimbussans", "helvetica"],
+	["times", "times"],
+	["timesnewroman", "times"],
+	["liberationserif", "times"],
+	["nimbusroman", "times"],
+	["georgia", "times"],
+	["cambria", "times"],
+	["constantia", "times"],
+	["garamond", "times"],
+	["bookantiqua", "times"],
+	["palatino", "times"],
+	["palatinolinotype", "times"],
+	["bookmanoldstyle", "times"],
+	["century", "times"],
+	["centuryschoolbook", "times"],
+	["minionpro", "times"],
+	["merriweather", "times"],
+	["notoserif", "times"],
+	["dejavuserif", "times"],
+	["serif", "times"],
+	["courier", "courier"],
+	["couriernew", "courier"],
+	["liberationmono", "courier"],
+	["nimbusmono", "courier"],
+	["consolas", "courier"],
+	["monaco", "courier"],
+	["menlo", "courier"],
+	["lucidaconsole", "courier"],
+	["andalemono", "courier"],
+	["cascadiacode", "courier"],
+	["cascadiamono", "courier"],
+	["sfmono", "courier"],
+	["jetbrainsmono", "courier"],
+	["firacode", "courier"],
+	["sourcecodepro", "courier"],
+	["notosansmono", "courier"],
+	["dejavusansmono", "courier"],
+	["monospace", "courier"]
+]);
+const DEFAULT_FAMILY = "helvetica";
+function normalizeFamilyName(raw) {
+	return raw.toLowerCase().replace(/[^a-z0-9]/g, "");
+}
+function resolveFontFamily(rawFamily) {
+	const normalized = normalizeFamilyName(rawFamily);
+	const exact = FAMILY_BY_NORMALIZED_NAME.get(normalized);
+	if (exact !== void 0) return {
+		family: exact,
+		matched: true
+	};
+	if (normalized.includes("mono")) return {
+		family: "courier",
+		matched: true
+	};
+	if (normalized.includes("serif") && !normalized.includes("sansserif")) return {
+		family: "times",
+		matched: true
+	};
+	return {
+		family: DEFAULT_FAMILY,
+		matched: false
+	};
+}
+const VARIANTS = {
+	helvetica: {
+		regular: "Helvetica",
+		bold: "Helvetica-Bold",
+		italic: "Helvetica-Oblique",
+		boldItalic: "Helvetica-BoldOblique"
+	},
+	times: {
+		regular: "Times-Roman",
+		bold: "Times-Bold",
+		italic: "Times-Italic",
+		boldItalic: "Times-BoldItalic"
+	},
+	courier: {
+		regular: "Courier",
+		bold: "Courier-Bold",
+		italic: "Courier-Oblique",
+		boldItalic: "Courier-BoldOblique"
+	}
+};
+function resolveStandardFont(family, bold, italic) {
+	const { family: standardFamily, matched } = resolveFontFamily(family);
+	const variants = VARIANTS[standardFamily];
+	return {
+		standardName: bold && italic ? variants.boldItalic : bold ? variants.bold : italic ? variants.italic : variants.regular,
+		matched
+	};
+}
+//#endregion
+exports.resolveFontFamily = resolveFontFamily;
+exports.resolveStandardFont = resolveStandardFont;

package/dist/fonts.d.cts

@@ -0,0 +1,15 @@
+import { r as StandardFontName } from "./afm-widths-DyDq56Ph.cjs";
+//#region src/fonts.d.ts
+type StandardFamily = 'helvetica' | 'times' | 'courier';
+interface FontFamilyResolution {
+  readonly family: StandardFamily;
+  readonly matched: boolean;
+}
+declare function resolveFontFamily(rawFamily: string): FontFamilyResolution;
+interface ResolvedFont {
+  readonly standardName: StandardFontName;
+  readonly matched: boolean;
+}
+declare function resolveStandardFont(family: string, bold: boolean, italic: boolean): ResolvedFont;
+//#endregion
+export { FontFamilyResolution, ResolvedFont, resolveFontFamily, resolveStandardFont };