fabricjs-document-engine 1.0.1 → 1.1.0

package/dist/pdf/export-pdf.js

@@ -0,0 +1,440 @@
+import { DocumentEngineError, isDocumentEngineError } from "../engine/errors.js";
+import { readObjectId } from "../fabric/object-ids.js";
+import { walkObjects } from "../fabric/walk-objects.js";
+import { withSvgOverrides } from "../export/svg/overrides.js";
+import { isTextOnPath, textOnPathToSVG } from "../export/svg/text-on-path.js";
+import { repairFabricSvg, withExportView } from "../export/render-export.js";
+import { embedSvgAssets } from "../export/svg/embed-assets.js";
+import { disposeObjects } from "../export/batch-render.js";
+import { jsPdfStyle, loadFonts, registerFonts, standardFamily } from "./fonts.js";
+import { layoutPage } from "./page-layout.js";
+import { decoratedTextToSVG, hasStraightDecorations } from "./text-decorations.js";
+//#region src/pdf/export-pdf.ts
+const RASTER_REASONS = {
+	shadow: "it has a shadow, which PDF vectors cannot draw",
+	blend: "it uses a blend mode, which PDF vectors cannot draw",
+	gradientStroke: "its outline is a gradient or pattern",
+	uniformStroke: "it keeps its outline width while scaled (strokeUniform)",
+	font: "its font has no TrueType file in fonts",
+	characters: "it uses characters the built-in PDF fonts do not have; add a TrueType font that has them"
+};
+function stop(signal) {
+	if (signal?.aborted) throw new DocumentEngineError("EXPORT_ABORTED", "The PDF export was cancelled");
+}
+async function loadPeers(needsSvg) {
+	let jsPDF;
+	try {
+		jsPDF = (await import("jspdf")).jsPDF;
+	} catch (error) {
+		throw new DocumentEngineError("PDF_UNAVAILABLE", "PDF export needs the jspdf package. Install it with: npm install jspdf svg2pdf.js", { cause: error });
+	}
+	if (needsSvg) try {
+		await import("svg2pdf.js");
+	} catch (error) {
+		throw new DocumentEngineError("PDF_UNAVAILABLE", "Vector and hybrid PDF export need the svg2pdf.js package. Install it with: npm install svg2pdf.js, or use mode: \"raster\".", { cause: error });
+	}
+	return jsPDF;
+}
+function isEngine(source) {
+	return typeof source.toDocument === "function" && "canvas" in source;
+}
+function isCanvas(source) {
+	const candidate = source;
+	return typeof candidate.getObjects === "function" && typeof candidate.toCanvasElement === "function";
+}
+function idsOf(object) {
+	const ids = [];
+	walkObjects([object], (child) => {
+		const id = readObjectId(child);
+		if (id !== void 0) ids.push(id);
+	});
+	return ids.slice(0, 1);
+}
+function familiesOf(object) {
+	const text = object;
+	const families = /* @__PURE__ */ new Set();
+	if (typeof text.fontFamily === "string") families.add(text.fontFamily);
+	for (const line of Object.values(text.styles ?? {})) for (const style of Object.values(line ?? {})) if (typeof style?.fontFamily === "string") families.add(style.fontFamily);
+	return [...families];
+}
+function resolvesTo(family, registered) {
+	const names = family.split(",").map((name) => name.trim().replace(/^['"]|['"]$/g, ""));
+	if (names.some((name) => registered.families.has(name.toLowerCase()))) return {
+		registered: true,
+		standard: false
+	};
+	return {
+		registered: false,
+		standard: names.some((name) => standardFamily(name) !== void 0)
+	};
+}
+/** Why an object cannot be drawn as PDF vectors, or undefined when it can. */
+function rasterReason(object, registered, missingFonts) {
+	let reason;
+	walkObjects([object], (child) => {
+		if (reason) return;
+		if (child.shadow) reason = "shadow";
+		else if (child.globalCompositeOperation && child.globalCompositeOperation !== "source-over") reason = "blend";
+		else if (typeof child.stroke === "object" && child.stroke !== null && child.strokeWidth > 0) reason = "gradientStroke";
+		else if (child.strokeUniform && child.stroke && child.strokeWidth > 0) {
+			const { x: scaleX, y: scaleY } = child.getObjectScaling();
+			if (Math.abs(scaleX - 1) > 1e-6 || Math.abs(scaleY - 1) > 1e-6) reason = "uniformStroke";
+		}
+		const text = child.text;
+		if (!reason && typeof text === "string") {
+			const families = familiesOf(child).map((family) => resolvesTo(family, registered));
+			const allRegistered = families.every((family) => family.registered);
+			if (!allRegistered && /[^\u0000-ÿ]/.test(text)) reason = "characters";
+			else if (!allRegistered && missingFonts === "rasterize" && families.some((family) => !family.registered && !family.standard)) reason = "font";
+		}
+	});
+	return reason;
+}
+function shadowPadding(object) {
+	let padding = 0;
+	walkObjects([object], (child) => {
+		const shadow = child.shadow;
+		if (shadow) padding = Math.max(padding, shadow.blur + Math.max(Math.abs(shadow.offsetX), Math.abs(shadow.offsetY)));
+	});
+	return padding + 2;
+}
+function usesBlendMode(object) {
+	let blends = false;
+	walkObjects([object], (child) => {
+		if (child.globalCompositeOperation && child.globalCompositeOperation !== "source-over") blends = true;
+	});
+	return blends;
+}
+/**
+* An object as a picture placed where it sits on the canvas. Usually the
+* object alone, so the vectors underneath show through. An object with a
+* blend mode mixes with what lies below it, so its picture includes
+* everything below it within its bounds, which covers those vectors exactly.
+*/
+function rasterMarkup(canvas, object, multiplier) {
+	object.setCoords();
+	const bounds = object.getBoundingRect();
+	const padding = shadowPadding(object);
+	const left = Math.max(0, Math.floor(bounds.left - padding));
+	const top = Math.max(0, Math.floor(bounds.top - padding));
+	const right = Math.min(canvas.getWidth(), Math.ceil(bounds.left + bounds.width + padding));
+	const bottom = Math.min(canvas.getHeight(), Math.ceil(bounds.top + bounds.height + padding));
+	if (right <= left || bottom <= top) return "";
+	const blends = usesBlendMode(object);
+	const stack = canvas.getObjects();
+	const position = stack.indexOf(object);
+	const saved = {
+		backgroundColor: canvas.backgroundColor,
+		backgroundImage: canvas.backgroundImage,
+		overlayColor: canvas.overlayColor,
+		overlayImage: canvas.overlayImage
+	};
+	if (!blends) {
+		canvas.backgroundColor = "";
+		canvas.backgroundImage = void 0;
+	}
+	canvas.overlayColor = "";
+	canvas.overlayImage = void 0;
+	let element;
+	try {
+		const filter = (candidate) => blends ? stack.indexOf(candidate) <= position : candidate === object;
+		element = canvas.toCanvasElement(multiplier, {
+			left,
+			top,
+			width: right - left,
+			height: bottom - top,
+			filter
+		});
+	} finally {
+		Object.assign(canvas, saved);
+	}
+	const url = element.toDataURL("image/png");
+	element.width = 0;
+	element.height = 0;
+	return `<image x="${left}" y="${top}" width="${right - left}" height="${bottom - top}" preserveAspectRatio="none" xlink:href="${url}" />\n`;
+}
+function quoteFamily(name) {
+	return /^[a-z-]+$/i.test(name) ? name : `"${name.replace(/"/g, "")}"`;
+}
+function resolveFamily(list, registered) {
+	const names = list.split(",").map((name) => name.trim().replace(/^['"]|['"]$/g, ""));
+	for (const name of names) {
+		const own = registered.families.get(name.toLowerCase());
+		if (own) return quoteFamily(own);
+	}
+	for (const name of names) {
+		const standard = standardFamily(name);
+		if (standard) return standard;
+	}
+	return "helvetica";
+}
+function weightOf(value) {
+	const number = Number(value);
+	return value === "bold" || value === "bolder" || Number.isFinite(number) && number >= 600 ? "bold" : "normal";
+}
+/**
+* Points every font at a font jsPDF has, and rounds weights to normal or
+* bold. svg2pdf matches family names exactly and otherwise falls back to
+* Times, and it looks for weights such as 500 as styles no font has.
+*/
+function normalizeFonts(root, registered) {
+	for (const element of [root, ...Array.from(root.getElementsByTagName("*"))]) {
+		const family = element.getAttribute("font-family");
+		if (family) element.setAttribute("font-family", resolveFamily(family, registered));
+		const weight = element.getAttribute("font-weight");
+		if (weight) element.setAttribute("font-weight", weightOf(weight));
+		const style = element.getAttribute("style");
+		if (style && /font-(family|weight)/.test(style)) element.setAttribute("style", style.replace(/font-family:\s*([^;]+)/g, (_, value) => `font-family: ${resolveFamily(value, registered)}`).replace(/font-weight:\s*([^;]+)/g, (_, value) => `font-weight: ${weightOf(value.trim())}`));
+	}
+}
+/** Warns once for each family and style the canvas uses that has no file of its own. */
+function warnSubstitutedStyles(canvas, registered, page, warnings, warned) {
+	if (registered.substituted.length === 0) return;
+	const missing = new Set(registered.substituted.map(({ family, style }) => `${family.toLowerCase()}|${style}`));
+	walkObjects(canvas.getObjects(), (object) => {
+		const text = object;
+		if (typeof text.text !== "string") return;
+		const uses = [{
+			family: text.fontFamily,
+			weight: text.fontWeight,
+			style: text.fontStyle
+		}];
+		for (const line of Object.values(text.styles ?? {})) for (const style of Object.values(line ?? {})) uses.push({
+			family: style?.fontFamily ?? text.fontFamily,
+			weight: style?.fontWeight ?? text.fontWeight,
+			style: style?.fontStyle ?? text.fontStyle
+		});
+		for (const use of uses) {
+			const family = registered.families.get(String(use.family ?? "").toLowerCase());
+			if (!family) continue;
+			const style = jsPdfStyle(use.weight, use.style);
+			const key = `${family.toLowerCase()}|${style}`;
+			if (!missing.has(key) || warned.has(key)) continue;
+			warned.add(key);
+			warnings.push({
+				code: "PDF_FONT_SUBSTITUTED",
+				message: `No ${style} file was given for "${family}", so its ${style} text uses another file of the same family`,
+				page,
+				objectIds: idsOf(object),
+				family
+			});
+		}
+	});
+}
+function clipTo(context, draw) {
+	const clip = context.layout.clip;
+	if (!clip) return draw();
+	const { document } = context;
+	document.saveGraphicsState();
+	document.rect(clip.x, clip.y, clip.width, clip.height, null);
+	document.clip();
+	document.discardPath();
+	const finish = () => {
+		document.restoreGraphicsState();
+	};
+	const drawn = draw();
+	if (drawn instanceof Promise) return drawn.finally(finish);
+	finish();
+}
+async function drawRasterPage(canvas, context) {
+	const { layout, options } = context;
+	const multiplier = layout.scale * (options.dpi ?? 300) / 72;
+	const element = withExportView(canvas, options.background ?? "keep", "png", () => canvas.toCanvasElement(multiplier));
+	try {
+		await clipTo(context, () => {
+			context.document.addImage(element, "PNG", layout.x, layout.y, layout.width, layout.height, void 0, "FAST");
+		});
+	} finally {
+		element.width = 0;
+		element.height = 0;
+	}
+}
+async function drawVectorPage(canvas, context) {
+	const { layout, options, page, warnings, registered } = context;
+	const mode = options.mode ?? "hybrid";
+	const missingFonts = options.missingFonts ?? (mode === "hybrid" ? "rasterize" : "substitute");
+	const multiplier = layout.scale * (options.dpi ?? 300) / 72;
+	const width = canvas.getWidth();
+	const height = canvas.getHeight();
+	const svg = withExportView(canvas, options.background ?? "keep", "svg", () => {
+		const rasters = /* @__PURE__ */ new Map();
+		for (const object of canvas.getObjects()) {
+			const reason = rasterReason(object, registered, missingFonts);
+			if (!reason) continue;
+			if (mode === "hybrid") {
+				rasters.set(object, rasterMarkup(canvas, object, multiplier));
+				warnings.push({
+					code: "PDF_RASTERIZED",
+					message: `An object was drawn as a picture at ${options.dpi ?? 300} dpi because ${RASTER_REASONS[reason]}`,
+					page,
+					objectIds: idsOf(object)
+				});
+			} else warnings.push({
+				code: reason === "font" || reason === "characters" ? "PDF_FONT_SUBSTITUTED" : "PDF_UNSUPPORTED",
+				message: `An object may look different in the PDF because ${RASTER_REASONS[reason]}`,
+				page,
+				objectIds: idsOf(object)
+			});
+		}
+		const writerFor = (object) => {
+			const raster = rasters.get(object);
+			if (raster !== void 0) return () => raster;
+			if (isTextOnPath(object)) return (reviver) => textOnPathToSVG(object, reviver);
+			if (hasStraightDecorations(object)) return (reviver) => decoratedTextToSVG(object, reviver);
+		};
+		return withSvgOverrides(canvas, writerFor, () => canvas.toSVG({
+			viewBox: {
+				x: 0,
+				y: 0,
+				width,
+				height
+			},
+			width: String(width),
+			height: String(height)
+		})).result;
+	});
+	const embedded = await embedSvgAssets(repairFabricSvg(svg), canvas, {
+		textOnPath: "vector",
+		embedImages: true,
+		maxEmbeddedImageBytes: Number.MAX_SAFE_INTEGER,
+		embedFonts: {}
+	}, options.signal);
+	stop(options.signal);
+	for (const warning of embedded.warnings) if (warning.code === "IMAGE_NOT_EMBEDDED") warnings.push({
+		code: "IMAGE_NOT_EMBEDDED",
+		message: warning.message,
+		page,
+		objectIds: warning.objectIds,
+		url: warning.url
+	});
+	const root = new DOMParser().parseFromString(embedded.svg, "image/svg+xml").documentElement;
+	normalizeFonts(root, registered);
+	await clipTo(context, async () => {
+		await context.document.svg(root, {
+			x: layout.x,
+			y: layout.y,
+			width: layout.width,
+			height: layout.height
+		});
+	});
+}
+/**
+* Exports one or more pages as a PDF. Each source becomes one page: an
+* engine's canvas, a Fabric canvas, or a saved document, which is drawn on
+* an off-screen canvas that is freed after its page.
+*/
+async function exportPdf(sources, options = {}) {
+	const list = Array.isArray(sources) ? [...sources] : [sources];
+	if (list.length === 0) throw new DocumentEngineError("INVALID_EXPORT_OPTIONS", "exportPdf needs at least one page");
+	const dpi = options.dpi ?? 300;
+	if (!(Number.isFinite(dpi) && dpi > 0 && dpi <= 1200)) throw new DocumentEngineError("INVALID_EXPORT_OPTIONS", "dpi must be between 1 and 1200");
+	const mode = options.mode ?? "hybrid";
+	if (![
+		"vector",
+		"raster",
+		"hybrid"
+	].includes(mode)) throw new DocumentEngineError("INVALID_EXPORT_OPTIONS", "mode must be \"vector\", \"raster\" or \"hybrid\"");
+	if (typeof document === "undefined") throw new DocumentEngineError("PDF_UNAVAILABLE", "PDF export needs a browser DOM");
+	stop(options.signal);
+	const jsPDF = await loadPeers(mode !== "raster");
+	const fonts = await loadFonts(options.fonts ?? [], options.signal);
+	stop(options.signal);
+	let pdf;
+	let registered = {
+		families: /* @__PURE__ */ new Map(),
+		substituted: []
+	};
+	const warnings = [];
+	const warnedStyles = /* @__PURE__ */ new Set();
+	let renderer;
+	try {
+		for (let index = 0; index < list.length; index += 1) {
+			stop(options.signal);
+			const source = list[index];
+			let canvas;
+			if (isEngine(source)) canvas = source.canvas;
+			else if (isCanvas(source)) canvas = source;
+			else {
+				renderer ?? (renderer = await createRenderer(options));
+				await renderer.engine.loadDocument(source, {
+					signal: options.signal,
+					discardUnsavedChanges: true
+				});
+				canvas = renderer.canvas;
+			}
+			const layout = layoutPage({
+				width: canvas.getWidth(),
+				height: canvas.getHeight()
+			}, options);
+			const format = [layout.pageWidth, layout.pageHeight];
+			if (!pdf) {
+				pdf = new jsPDF({
+					unit: "pt",
+					format,
+					orientation: layout.orientation,
+					compress: true,
+					putOnlyUsedFonts: true
+				});
+				registered = registerFonts(pdf, fonts);
+			} else pdf.addPage(format, layout.orientation);
+			warnSubstitutedStyles(canvas, registered, index + 1, warnings, warnedStyles);
+			const context = {
+				document: pdf,
+				layout,
+				options,
+				registered,
+				page: index + 1,
+				warnings
+			};
+			if (mode === "raster") await drawRasterPage(canvas, context);
+			else await drawVectorPage(canvas, context);
+			if (renderer && canvas === renderer.canvas) disposeObjects(renderer.canvas);
+		}
+		stop(options.signal);
+		const { metadata } = options;
+		pdf.setProperties({
+			creator: metadata?.creator ?? "fabricjs-document-engine",
+			...metadata
+		});
+		return {
+			blob: pdf.output("blob"),
+			pageCount: list.length,
+			warnings
+		};
+	} catch (error) {
+		if (isDocumentEngineError(error)) throw error;
+		if (options.signal?.aborted) throw new DocumentEngineError("EXPORT_ABORTED", "The PDF export was cancelled", { cause: error });
+		const reason = error instanceof Error ? error.message : String(error);
+		throw new DocumentEngineError("PDF_FAILED", `The PDF could not be made: ${reason}`, { cause: error });
+	} finally {
+		await renderer?.release();
+	}
+}
+async function createRenderer(options) {
+	const [{ StaticCanvas }, { createDocumentEngine }] = await Promise.all([import("fabric"), import("../engine/create-document-engine.js")]);
+	const element = document.createElement("canvas");
+	const canvas = new StaticCanvas(element, {
+		renderOnAddRemove: false,
+		enableRetinaScaling: false
+	});
+	const engine = createDocumentEngine({
+		canvas,
+		customObjects: options.customObjects,
+		assets: options.assets,
+		limits: options.limits,
+		history: { limit: 1 }
+	});
+	return {
+		canvas,
+		engine,
+		release: async () => {
+			disposeObjects(canvas);
+			engine.destroy();
+			await canvas.dispose();
+			element.width = 0;
+			element.height = 0;
+		}
+	};
+}
+//#endregion
+export { exportPdf };

package/dist/pdf/fonts.cjs

@@ -0,0 +1,115 @@
+const require_errors = require("../engine/errors.cjs");
+//#region src/pdf/fonts.ts
+const STANDARD = {
+	helvetica: "helvetica",
+	"helvetica neue": "helvetica",
+	arial: "helvetica",
+	verdana: "helvetica",
+	"sans-serif": "helvetica",
+	"system-ui": "helvetica",
+	times: "times",
+	"times new roman": "times",
+	georgia: "times",
+	serif: "times",
+	courier: "courier",
+	"courier new": "courier",
+	monospace: "courier"
+};
+/** Families the built-in PDF fonts can stand in for. They cover Latin-1 letters only. */
+function standardFamily(family) {
+	return STANDARD[family.trim().replace(/^['"]|['"]$/g, "").toLowerCase()];
+}
+function isBold(weight) {
+	if (weight === "bold" || weight === "bolder") return true;
+	const number = Number(weight);
+	return Number.isFinite(number) && number >= 600;
+}
+function jsPdfStyle(weight, style) {
+	const bold = isBold(weight);
+	const italic = style === "italic" || style === "oblique";
+	return bold && italic ? "bolditalic" : bold ? "bold" : italic ? "italic" : "normal";
+}
+async function bytesOf(source, signal) {
+	if (typeof source === "string") {
+		const response = await fetch(source, { signal });
+		if (!response.ok) throw new Error(`HTTP ${response.status} for ${source}`);
+		return new Uint8Array(await response.arrayBuffer());
+	}
+	if (source instanceof Uint8Array) return source;
+	if (source instanceof ArrayBuffer) return new Uint8Array(source);
+	return new Uint8Array(await source.arrayBuffer());
+}
+function binaryString(bytes) {
+	let binary = "";
+	const chunk = 32768;
+	for (let index = 0; index < bytes.length; index += chunk) binary += String.fromCharCode(...bytes.subarray(index, index + chunk));
+	return binary;
+}
+function refuseFormat(family, bytes) {
+	const tag = String.fromCharCode(...bytes.subarray(0, 4));
+	const kind = tag === "wOF2" ? "WOFF2" : tag === "wOFF" ? "WOFF" : tag === "OTTO" ? "OpenType with CFF outlines" : void 0;
+	if (kind) throw new require_errors.DocumentEngineError("PDF_FAILED", `The font "${family}" is ${kind}. PDF export needs a TrueType (.ttf) file, which most font sites offer next to the web formats.`);
+}
+/** Downloads every font once, so each PDF document can register them without fetching again. */
+async function loadFonts(fonts, signal) {
+	return Promise.all(fonts.map(async (font) => {
+		let bytes;
+		try {
+			bytes = await bytesOf(font.source, signal);
+		} catch (error) {
+			if (signal?.aborted) throw error;
+			const reason = error instanceof Error ? error.message : String(error);
+			throw new require_errors.DocumentEngineError("PDF_FAILED", `The font "${font.family}" could not be read: ${reason}`, { cause: error });
+		}
+		refuseFormat(font.family, bytes);
+		return {
+			family: font.family,
+			style: jsPdfStyle(font.weight ?? "normal", font.style ?? "normal"),
+			binary: binaryString(bytes)
+		};
+	}));
+}
+/**
+* Adds the fonts to a jsPDF document. A style with no file of its own uses
+* the closest one given, so bold text in a family with only a regular file
+* stays in that family instead of falling back to Times.
+*/
+function registerFonts(document, fonts) {
+	const families = /* @__PURE__ */ new Map();
+	const byFamily = /* @__PURE__ */ new Map();
+	fonts.forEach((font) => {
+		const styles = byFamily.get(font.family) ?? /* @__PURE__ */ new Map();
+		styles.set(font.style, font);
+		byFamily.set(font.family, styles);
+	});
+	const substituted = [];
+	let fileNumber = 0;
+	for (const [family, styles] of byFamily) {
+		families.set(family.toLowerCase(), family);
+		for (const style of [
+			"normal",
+			"bold",
+			"italic",
+			"bolditalic"
+		]) {
+			const own = styles.get(style);
+			const font = own ?? styles.get(style === "bolditalic" ? "bold" : "normal") ?? styles.get("normal") ?? styles.get("bold") ?? styles.get("italic") ?? styles.get("bolditalic");
+			if (!own) substituted.push({
+				family,
+				style
+			});
+			const fileName = `font-${fileNumber++}.ttf`;
+			document.addFileToVFS(fileName, font.binary);
+			document.addFont(fileName, family, style);
+		}
+	}
+	return {
+		families,
+		substituted
+	};
+}
+//#endregion
+exports.jsPdfStyle = jsPdfStyle;
+exports.loadFonts = loadFonts;
+exports.registerFonts = registerFonts;
+exports.standardFamily = standardFamily;

package/dist/pdf/fonts.d.cts

@@ -0,0 +1,12 @@
+//#region src/pdf/fonts.d.ts
+export type PdfFontStyle = "normal" | "italic";
+export interface PdfFont {
+  /** The font family exactly as the canvas uses it, such as `Inter`. */
+  family: string;
+  /** A TrueType (.ttf) file: its URL, or its bytes. */
+  source: string | ArrayBuffer | Uint8Array | Blob;
+  /** `normal` or `bold`, or a number such as 700. Weights from 600 count as bold. Default `normal`. */
+  weight?: "normal" | "bold" | number;
+  style?: PdfFontStyle;
+}
+//#endregion

package/dist/pdf/fonts.d.ts

@@ -0,0 +1,12 @@
+//#region src/pdf/fonts.d.ts
+export type PdfFontStyle = "normal" | "italic";
+export interface PdfFont {
+  /** The font family exactly as the canvas uses it, such as `Inter`. */
+  family: string;
+  /** A TrueType (.ttf) file: its URL, or its bytes. */
+  source: string | ArrayBuffer | Uint8Array | Blob;
+  /** `normal` or `bold`, or a number such as 700. Weights from 600 count as bold. Default `normal`. */
+  weight?: "normal" | "bold" | number;
+  style?: PdfFontStyle;
+}
+//#endregion

package/dist/pdf/fonts.js

@@ -0,0 +1,112 @@
+import { DocumentEngineError } from "../engine/errors.js";
+//#region src/pdf/fonts.ts
+const STANDARD = {
+	helvetica: "helvetica",
+	"helvetica neue": "helvetica",
+	arial: "helvetica",
+	verdana: "helvetica",
+	"sans-serif": "helvetica",
+	"system-ui": "helvetica",
+	times: "times",
+	"times new roman": "times",
+	georgia: "times",
+	serif: "times",
+	courier: "courier",
+	"courier new": "courier",
+	monospace: "courier"
+};
+/** Families the built-in PDF fonts can stand in for. They cover Latin-1 letters only. */
+function standardFamily(family) {
+	return STANDARD[family.trim().replace(/^['"]|['"]$/g, "").toLowerCase()];
+}
+function isBold(weight) {
+	if (weight === "bold" || weight === "bolder") return true;
+	const number = Number(weight);
+	return Number.isFinite(number) && number >= 600;
+}
+function jsPdfStyle(weight, style) {
+	const bold = isBold(weight);
+	const italic = style === "italic" || style === "oblique";
+	return bold && italic ? "bolditalic" : bold ? "bold" : italic ? "italic" : "normal";
+}
+async function bytesOf(source, signal) {
+	if (typeof source === "string") {
+		const response = await fetch(source, { signal });
+		if (!response.ok) throw new Error(`HTTP ${response.status} for ${source}`);
+		return new Uint8Array(await response.arrayBuffer());
+	}
+	if (source instanceof Uint8Array) return source;
+	if (source instanceof ArrayBuffer) return new Uint8Array(source);
+	return new Uint8Array(await source.arrayBuffer());
+}
+function binaryString(bytes) {
+	let binary = "";
+	const chunk = 32768;
+	for (let index = 0; index < bytes.length; index += chunk) binary += String.fromCharCode(...bytes.subarray(index, index + chunk));
+	return binary;
+}
+function refuseFormat(family, bytes) {
+	const tag = String.fromCharCode(...bytes.subarray(0, 4));
+	const kind = tag === "wOF2" ? "WOFF2" : tag === "wOFF" ? "WOFF" : tag === "OTTO" ? "OpenType with CFF outlines" : void 0;
+	if (kind) throw new DocumentEngineError("PDF_FAILED", `The font "${family}" is ${kind}. PDF export needs a TrueType (.ttf) file, which most font sites offer next to the web formats.`);
+}
+/** Downloads every font once, so each PDF document can register them without fetching again. */
+async function loadFonts(fonts, signal) {
+	return Promise.all(fonts.map(async (font) => {
+		let bytes;
+		try {
+			bytes = await bytesOf(font.source, signal);
+		} catch (error) {
+			if (signal?.aborted) throw error;
+			const reason = error instanceof Error ? error.message : String(error);
+			throw new DocumentEngineError("PDF_FAILED", `The font "${font.family}" could not be read: ${reason}`, { cause: error });
+		}
+		refuseFormat(font.family, bytes);
+		return {
+			family: font.family,
+			style: jsPdfStyle(font.weight ?? "normal", font.style ?? "normal"),
+			binary: binaryString(bytes)
+		};
+	}));
+}
+/**
+* Adds the fonts to a jsPDF document. A style with no file of its own uses
+* the closest one given, so bold text in a family with only a regular file
+* stays in that family instead of falling back to Times.
+*/
+function registerFonts(document, fonts) {
+	const families = /* @__PURE__ */ new Map();
+	const byFamily = /* @__PURE__ */ new Map();
+	fonts.forEach((font) => {
+		const styles = byFamily.get(font.family) ?? /* @__PURE__ */ new Map();
+		styles.set(font.style, font);
+		byFamily.set(font.family, styles);
+	});
+	const substituted = [];
+	let fileNumber = 0;
+	for (const [family, styles] of byFamily) {
+		families.set(family.toLowerCase(), family);
+		for (const style of [
+			"normal",
+			"bold",
+			"italic",
+			"bolditalic"
+		]) {
+			const own = styles.get(style);
+			const font = own ?? styles.get(style === "bolditalic" ? "bold" : "normal") ?? styles.get("normal") ?? styles.get("bold") ?? styles.get("italic") ?? styles.get("bolditalic");
+			if (!own) substituted.push({
+				family,
+				style
+			});
+			const fileName = `font-${fileNumber++}.ttf`;
+			document.addFileToVFS(fileName, font.binary);
+			document.addFont(fileName, family, style);
+		}
+	}
+	return {
+		families,
+		substituted
+	};
+}
+//#endregion
+export { jsPdfStyle, loadFonts, registerFonts, standardFamily };