@stll/folio-core 0.32.2 → 0.33.0

package/dist/display-list/build/buildDisplayList.js

@@ -0,0 +1,283 @@
+import { HIT_REGION_KINDS } from "../primitives.js";
+import { AuthorColorTable } from "./buildContext.js";
+import { DOC_CANVAS } from "./colors.js";
+import { collectFloatingImages, pageGeometryOf } from "./floatingImages.js";
+import { FontTable } from "./fontTable.js";
+import { paintPageFurniture } from "./furniture.js";
+import { ImageTable, paintImageFragment } from "./imagePrimitives.js";
+import { paintColumnSeparators, paintPageBackground } from "./pageFurniture.js";
+import { paintParagraphFragment } from "./paragraphPrimitives.js";
+import { blockRegion, createPageComposer } from "./regions.js";
+import { paintTableFragment } from "./tablePrimitives.js";
+import { paintTextBoxFragment } from "./textBoxPrimitives.js";
+import { UNSUPPORTED_CONSTRUCT, UnsupportedCollector } from "./unsupported.js";
+//#region src/display-list/build/buildDisplayList.ts
+/** Document-wide gaps are attributed to the first page, the only one certain to exist. */
+const FIRST_PAGE_INDEX = 0;
+/**
+* Every feature a source document can have that a `Layout` does not record and
+* that nothing on a page betrays, with the reason it paints nothing when the
+* caller supplies neither the construct nor a flag denying it. The list is the
+* single source of truth: {@link DocumentFeatures} is derived from it, so a
+* feature added here cannot be left without a flag or without a reason.
+*
+* Footnote bodies and header/footer stories are deliberately absent: a page
+* that carries them says so itself (`footnoteIds`, `headerFooterRefs`), so
+* their gaps are reported per page from the layout rather than from a
+* document-wide flag the caller would have to remember to set.
+*/
+const DOCUMENT_FEATURE_GAPS = [["pageBorders", "w:pgBorders reach the painter through render options, not through Layout, and none were supplied to the builder"], ["watermark", "watermarks reach the painter through render options, not through Layout, and none was supplied to the builder"]];
+const paragraphTextOf = (block) => block.runs.map((run) => run.kind === "text" ? run.text : "").join("").trim();
+/**
+* Resolve everything that needs the whole document before any page is painted:
+* where each bookmark lands (a `#name` hyperlink cannot become a page target
+* until then) and the heading outline.
+*/
+const collectDocumentTargets = (layout, blockLookup) => {
+	const bookmarkTargets = /* @__PURE__ */ new Map();
+	const outline = [];
+	for (const [pageIndex, page] of layout.pages.entries()) for (const fragment of page.fragments) {
+		if (fragment.kind !== "paragraph") continue;
+		const block = blockLookup.get(String(fragment.blockId))?.block;
+		if (block?.kind !== "paragraph") continue;
+		for (const name of block.bookmarks ?? []) if (!bookmarkTargets.has(name)) bookmarkTargets.set(name, {
+			kind: "page",
+			pageIndex,
+			yPx: fragment.y
+		});
+		const level = block.attrs?.outlineLevel;
+		if (level !== void 0 && fragment.continuesFromPrev !== true) {
+			const title = paragraphTextOf(block);
+			if (title.length > 0) outline.push({
+				title,
+				level,
+				pageIndex,
+				yPx: fragment.y
+			});
+		}
+	}
+	return {
+		bookmarkTargets,
+		outline
+	};
+};
+const bordersOfNeighbour = (entry) => entry?.block.kind === "paragraph" ? entry.block.attrs?.borders : void 0;
+const paintFragment = ({ fragment, entry, context, composer, prevEntry, nextEntry }) => {
+	const { block, measure } = entry;
+	const mismatch = () => {
+		context.unsupported.report(UNSUPPORTED_CONSTRUCT.measureMismatch, context.pageIndex, `${fragment.kind} fragment ${String(fragment.blockId)} has a ${block.kind} block and a ${measure.kind} measure`);
+	};
+	switch (fragment.kind) {
+		case "paragraph": {
+			if (block.kind !== "paragraph" || measure.kind !== "paragraph") {
+				mismatch();
+				return;
+			}
+			const prevBorders = bordersOfNeighbour(prevEntry);
+			const nextBorders = bordersOfNeighbour(nextEntry);
+			paintParagraphFragment({
+				fragment,
+				block,
+				measure,
+				context,
+				composer,
+				...prevBorders === void 0 ? {} : { prevBorders },
+				...nextBorders === void 0 ? {} : { nextBorders }
+			});
+			return;
+		}
+		case "table":
+			if (block.kind === "table" && measure.kind === "table") {
+				paintTableFragment({
+					fragment,
+					block,
+					measure,
+					context,
+					composer,
+					paintTextBox: paintTextBoxFragment
+				});
+				return;
+			}
+			mismatch();
+			return;
+		case "image":
+			if (block.kind === "image") {
+				composer.push(paintImageFragment(fragment, block, context));
+				return;
+			}
+			mismatch();
+			return;
+		case "textBox":
+			if (block.kind === "textBox" && measure.kind === "textBox") {
+				paintTextBoxFragment({
+					composer,
+					fragment,
+					block,
+					measure,
+					context
+				});
+				return;
+			}
+			mismatch();
+			return;
+		default: {
+			const unreachable = fragment;
+			context.unsupported.report(UNSUPPORTED_CONSTRUCT.fragmentKind, context.pageIndex, `fragment kind ${JSON.stringify(unreachable)} has no builder`);
+		}
+	}
+};
+const buildPage = ({ page, pageIndex, totalPages, blockLookup, pageBackground, bookmarkTargets, fonts, images, unsupported, authorColors, furniture }) => {
+	const links = [];
+	const context = {
+		fonts,
+		images,
+		unsupported,
+		authorColors,
+		links,
+		bookmarkTargets,
+		story: { kind: "body" },
+		pageIndex,
+		pageNumber: page.logicalNumber,
+		totalPages
+	};
+	const entries = page.fragments.map((fragment) => blockLookup.get(String(fragment.blockId)));
+	const geometry = pageGeometryOf(page);
+	const placedFloats = /* @__PURE__ */ new Set();
+	const behindFloats = [];
+	const frontFloats = [];
+	for (const [index, fragment] of page.fragments.entries()) {
+		const block = entries[index]?.block;
+		if (fragment.kind !== "paragraph" || block?.kind !== "paragraph") continue;
+		for (const placement of collectFloatingImages({
+			block,
+			fragmentYPx: fragment.y,
+			geometry,
+			context,
+			placed: placedFloats
+		})) (placement.behindDoc ? behindFloats : frontFloats).push(...placement.primitives);
+	}
+	const { behind, above } = paintPageFurniture({
+		page,
+		furniture,
+		context
+	});
+	const composer = createPageComposer();
+	composer.push([
+		paintPageBackground(page, pageBackground),
+		...behind,
+		...behindFloats
+	]);
+	composer.region({
+		kind: HIT_REGION_KINDS.pageContent,
+		rect: {
+			xPx: page.margins.left,
+			yPx: page.margins.top,
+			widthPx: page.size.w - page.margins.left - page.margins.right,
+			heightPx: page.size.h - page.margins.top - page.margins.bottom
+		}
+	}, () => {
+		for (const [index, fragment] of page.fragments.entries()) {
+			const entry = entries[index];
+			if (!entry) {
+				unsupported.report(UNSUPPORTED_CONSTRUCT.missingBlock, pageIndex, `no block lookup entry for ${fragment.kind} fragment ${String(fragment.blockId)}`);
+				continue;
+			}
+			composer.region(blockRegion({
+				fragment,
+				kind: FRAGMENT_REGION_KIND[fragment.kind],
+				context
+			}), () => {
+				paintFragment({
+					fragment,
+					entry,
+					context,
+					composer,
+					prevEntry: entries[index - 1],
+					nextEntry: entries[index + 1]
+				});
+			});
+		}
+	});
+	composer.push(frontFloats);
+	composer.push(paintColumnSeparators(page));
+	above(composer);
+	return {
+		pageNumber: page.number,
+		widthPx: page.size.w,
+		heightPx: page.size.h,
+		orientation: page.orientation ?? (page.size.w > page.size.h ? "landscape" : "portrait"),
+		primitives: composer.primitives(),
+		regions: composer.regions(),
+		links
+	};
+};
+/** Which kind of region a fragment paints into. */
+const FRAGMENT_REGION_KIND = {
+	paragraph: HIT_REGION_KINDS.paragraph,
+	table: HIT_REGION_KINDS.table,
+	image: HIT_REGION_KINDS.image,
+	textBox: HIT_REGION_KINDS.textBox
+};
+/** Whether the caller handed over the construct this document-wide gap names. */
+const SUPPLIED_BY = {
+	pageBorders: (furniture) => furniture.pageBorders !== void 0,
+	watermark: (furniture) => furniture.watermark !== void 0 || furniture.watermarkByHeaderRId !== void 0
+};
+const createDisplayListBuilder = ({ layout, blockLookup, metadata, pageBackground, documentFeatures, embeddedFonts, ...furniture }) => {
+	const fonts = new FontTable(embeddedFonts ?? []);
+	const images = new ImageTable();
+	const unsupported = new UnsupportedCollector();
+	const authorColors = new AuthorColorTable();
+	const { bookmarkTargets, outline } = collectDocumentTargets(layout, blockLookup);
+	if (layout.pages.length > 0) for (const [feature, detail] of DOCUMENT_FEATURE_GAPS) {
+		if (SUPPLIED_BY[feature](furniture)) continue;
+		if (documentFeatures !== void 0 && !documentFeatures[feature]) continue;
+		unsupported.report(UNSUPPORTED_CONSTRUCT[feature], FIRST_PAGE_INDEX, detail);
+	}
+	const built = /* @__PURE__ */ new Map();
+	const pageAt = (pageIndex) => {
+		const existing = built.get(pageIndex);
+		if (existing !== void 0) return existing;
+		const page = layout.pages[pageIndex];
+		if (page === void 0) return;
+		const display = buildPage({
+			page,
+			pageIndex,
+			totalPages: layout.pages.length,
+			blockLookup,
+			pageBackground: pageBackground ?? DOC_CANVAS,
+			bookmarkTargets,
+			fonts,
+			images,
+			unsupported,
+			authorColors,
+			furniture
+		});
+		built.set(pageIndex, display);
+		return display;
+	};
+	return {
+		pageCount: layout.pages.length,
+		pageAt,
+		snapshot: () => ({
+			pages: [...built.entries()].sort(([left], [right]) => left - right).map(([, page]) => page),
+			fonts: fonts.snapshot(),
+			images: images.snapshot(),
+			outline,
+			metadata: metadata ?? {},
+			unsupported: unsupported.snapshot()
+		})
+	};
+};
+/**
+* The whole document's display list. Every page is built, so the tables, the
+* outline and the gap report are complete; an editor that paints a window of
+* pages uses {@link createDisplayListBuilder} instead.
+*/
+const buildDisplayList = (options) => {
+	const builder = createDisplayListBuilder(options);
+	for (let pageIndex = 0; pageIndex < builder.pageCount; pageIndex += 1) builder.pageAt(pageIndex);
+	return builder.snapshot();
+};
+//#endregion
+export { buildDisplayList, createDisplayListBuilder };

package/dist/display-list/build/colors.d.ts

@@ -0,0 +1,20 @@
+import { DisplayColor } from "../types.js";
+//#region src/display-list/build/colors.d.ts
+/**
+ * The editor's document custom properties, materialised. A PDF has no theme
+ * and no stylesheet: `--doc-canvas` is the paper, `--doc-canvas-text` the ink,
+ * `--suggestion-color` the AI-proposal hue (`renderParagraph.ts`'s
+ * `SUGGESTION_COLOR_CSS` fallback).
+ */
+declare const DOC_CANVAS: DisplayColor;
+declare const DOC_CANVAS_TEXT: DisplayColor;
+declare const SUGGESTION_COLOR: DisplayColor;
+declare const TRANSPARENT: DisplayColor;
+/**
+ * Resolve an authored CSS colour. Returns `undefined` for a value this module
+ * cannot turn into concrete channels (`color-mix()`, `oklch()`, an unknown
+ * name) so the caller can report it rather than paint a guess.
+ */
+declare const parseDisplayColor: (color: string | undefined) => DisplayColor | undefined;
+//#endregion
+export { DOC_CANVAS, DOC_CANVAS_TEXT, SUGGESTION_COLOR, TRANSPARENT, parseDisplayColor };

package/dist/display-list/build/colors.js

@@ -0,0 +1,136 @@
+import { BLACK, WHITE } from "../primitives.js";
+//#region src/display-list/build/colors.ts
+/**
+* CSS colour → {@link DisplayColor}.
+*
+* The display list's contract is that colours are already resolved: a backend
+* never sees a custom property, a named OOXML highlight, or `currentColor`.
+* Every such value is collapsed here, at the one place that still knows what
+* the editor's stylesheet means.
+*/
+/**
+* The editor's document custom properties, materialised. A PDF has no theme
+* and no stylesheet: `--doc-canvas` is the paper, `--doc-canvas-text` the ink,
+* `--suggestion-color` the AI-proposal hue (`renderParagraph.ts`'s
+* `SUGGESTION_COLOR_CSS` fallback).
+*/
+const DOC_CANVAS = WHITE;
+const DOC_CANVAS_TEXT = BLACK;
+const SUGGESTION_COLOR = {
+	r: 109,
+	g: 59,
+	b: 214,
+	a: 1
+};
+const TRANSPARENT = {
+	r: 0,
+	g: 0,
+	b: 0,
+	a: 0
+};
+/** Word's automatic-colour keywords (`w:color w:val="auto"`). */
+const AUTOMATIC_COLOR_VALUES = /* @__PURE__ */ new Set([
+	"auto",
+	"windowtext",
+	"currentcolor",
+	"inherit"
+]);
+/**
+* OOXML's named highlight palette (§17.18.40) plus the CSS basic colours the
+* bridge can pass through. Kept small on purpose: the bridge resolves named
+* highlights to hex before layout, so this is a safety net for the values that
+* still arrive as names.
+*
+* A `Map`, not an object: the key is an authored string, and an object lookup
+* would answer `constructor`, `toString` or `__proto__` from the prototype and
+* hand a function to {@link parseHex}.
+*/
+const NAMED_COLORS = /* @__PURE__ */ new Map([
+	["black", "#000000"],
+	["blue", "#0000ff"],
+	["cyan", "#00ffff"],
+	["darkblue", "#000080"],
+	["darkcyan", "#008080"],
+	["darkgray", "#808080"],
+	["darkgrey", "#808080"],
+	["darkgreen", "#008000"],
+	["darkmagenta", "#800080"],
+	["darkred", "#800000"],
+	["darkyellow", "#808000"],
+	["gray", "#808080"],
+	["grey", "#808080"],
+	["green", "#00ff00"],
+	["lightgray", "#c0c0c0"],
+	["lightgrey", "#c0c0c0"],
+	["magenta", "#ff00ff"],
+	["red", "#ff0000"],
+	["silver", "#c0c0c0"],
+	["white", "#ffffff"],
+	["yellow", "#ffff00"]
+]);
+const DOC_CUSTOM_PROPERTIES = {
+	"--doc-canvas": DOC_CANVAS,
+	"--doc-canvas-text": DOC_CANVAS_TEXT,
+	"--suggestion-color": SUGGESTION_COLOR
+};
+const HEX_PATTERN = /^#?(?:[0-9a-f]{3,4}|[0-9a-f]{6}|[0-9a-f]{8})$/iu;
+const RGB_PATTERN = /^rgba?\(\s*([\d.]+%?)\s*[, ]\s*([\d.]+%?)\s*[, ]\s*([\d.]+%?)\s*(?:[,/]\s*([\d.]+%?)\s*)?\)$/iu;
+const VAR_PATTERN = /^var\(\s*(--[\w-]+)\s*(?:,\s*(.+))?\)$/iu;
+const clampChannel = (value) => Math.min(255, Math.max(0, Math.round(value)));
+const clampAlpha = (value) => Math.min(1, Math.max(0, value));
+const parseHex = (raw) => {
+	const hex = raw.replace(/^#/u, "");
+	const expand = (part) => Number.parseInt(part.repeat(2), 16);
+	if (hex.length === 3 || hex.length === 4) return {
+		r: expand(hex[0]),
+		g: expand(hex[1]),
+		b: expand(hex[2]),
+		a: hex.length === 4 ? expand(hex[3]) / 255 : 1
+	};
+	if (hex.length === 6 || hex.length === 8) return {
+		r: Number.parseInt(hex.slice(0, 2), 16),
+		g: Number.parseInt(hex.slice(2, 4), 16),
+		b: Number.parseInt(hex.slice(4, 6), 16),
+		a: hex.length === 8 ? Number.parseInt(hex.slice(6, 8), 16) / 255 : 1
+	};
+};
+const parseComponent = (raw, scale) => raw.endsWith("%") ? Number.parseFloat(raw) / 100 * scale : Number.parseFloat(raw);
+const parseRgb = (raw) => {
+	const match = RGB_PATTERN.exec(raw);
+	if (!match) return;
+	const r = clampChannel(parseComponent(match[1], 255));
+	const g = clampChannel(parseComponent(match[2], 255));
+	const b = clampChannel(parseComponent(match[3], 255));
+	const alphaRaw = match[4];
+	return {
+		r,
+		g,
+		b,
+		a: alphaRaw === void 0 ? 1 : clampAlpha(parseComponent(alphaRaw, 1))
+	};
+};
+/**
+* Resolve an authored CSS colour. Returns `undefined` for a value this module
+* cannot turn into concrete channels (`color-mix()`, `oklch()`, an unknown
+* name) so the caller can report it rather than paint a guess.
+*/
+const parseDisplayColor = (color) => {
+	if (color === void 0) return;
+	const trimmed = color.trim();
+	if (trimmed.length === 0) return;
+	const lower = trimmed.toLowerCase();
+	if (lower === "transparent" || lower === "none") return TRANSPARENT;
+	if (AUTOMATIC_COLOR_VALUES.has(lower)) return DOC_CANVAS_TEXT;
+	const varMatch = VAR_PATTERN.exec(trimmed);
+	if (varMatch) {
+		const known = DOC_CUSTOM_PROPERTIES[varMatch[1].toLowerCase()];
+		if (known) return known;
+		return parseDisplayColor(varMatch[2]);
+	}
+	const named = NAMED_COLORS.get(lower);
+	if (named !== void 0) return parseHex(named);
+	if (HEX_PATTERN.test(trimmed)) return parseHex(trimmed);
+	return parseRgb(lower);
+};
+//#endregion
+export { DOC_CANVAS, DOC_CANVAS_TEXT, SUGGESTION_COLOR, TRANSPARENT, parseDisplayColor };

package/dist/display-list/build/floatingImages.d.ts

@@ -0,0 +1,24 @@
+import { ImageRun, Page, ParagraphBlock } from "../../layout-engine/types.js";
+import { PageGeometry } from "../../layout-painter/anchoredImagePosition.js";
+import { DisplayPrimitive } from "../types.js";
+import { BuildContext } from "./buildContext.js";
+//#region src/display-list/build/floatingImages.d.ts
+declare const pageGeometryOf: (page: Page) => PageGeometry;
+type FloatingImagePlacement = {
+  readonly run: ImageRun;
+  /** `w:wrap behind` paints under the body text; everything else paints over it. */
+  readonly behindDoc: boolean;
+  readonly primitives: readonly DisplayPrimitive[];
+};
+type CollectFloatingImagesOptions = {
+  readonly block: ParagraphBlock;
+  /** The paragraph fragment's y, page-absolute. */
+  readonly fragmentYPx: number;
+  readonly geometry: PageGeometry;
+  readonly context: BuildContext;
+  /** Runs already placed on this page, so a split paragraph cannot double-paint. */
+  readonly placed: Set<ImageRun>;
+};
+declare const collectFloatingImages: ({ block, fragmentYPx, geometry, context, placed }: CollectFloatingImagesOptions) => readonly FloatingImagePlacement[];
+//#endregion
+export { CollectFloatingImagesOptions, FloatingImagePlacement, collectFloatingImages, pageGeometryOf };

package/dist/display-list/build/floatingImages.js

@@ -0,0 +1,41 @@
+import { isFloatingImageRun } from "../../layout-engine/types.js";
+import { resolveAnchoredImagePosition } from "../../layout-painter/anchoredImagePosition.js";
+import { paintImage } from "./imagePrimitives.js";
+//#region src/display-list/build/floatingImages.ts
+const pageGeometryOf = (page) => ({
+	pageWidth: page.size.w,
+	pageHeight: page.size.h,
+	marginLeft: page.margins.left,
+	marginTop: page.margins.top,
+	marginRight: page.margins.right,
+	marginBottom: page.margins.bottom,
+	...page.authoredMargins === void 0 ? {} : { authoredMargins: page.authoredMargins },
+	contentWidth: page.size.w - page.margins.left - page.margins.right,
+	contentHeight: page.size.h - page.margins.top - page.margins.bottom
+});
+const collectFloatingImages = ({ block, fragmentYPx, geometry, context, placed }) => {
+	const placements = [];
+	for (const run of block.runs) {
+		if (run.kind !== "image" || !isFloatingImageRun(run) || placed.has(run)) continue;
+		placed.add(run);
+		const anchor = resolveAnchoredImagePosition(run, fragmentYPx - geometry.marginTop, geometry);
+		placements.push({
+			run,
+			behindDoc: run.wrapType === "behind",
+			primitives: paintImage({
+				source: run,
+				rect: {
+					xPx: geometry.marginLeft + anchor.x,
+					yPx: geometry.marginTop + anchor.y,
+					widthPx: run.width,
+					heightPx: run.height
+				},
+				context,
+				label: "floating image"
+			})
+		});
+	}
+	return placements;
+};
+//#endregion
+export { collectFloatingImages, pageGeometryOf };

package/dist/display-list/build/fontTable.d.ts

@@ -0,0 +1,31 @@
+import { EmbeddedFont } from "../../fonts/embeddedFonts.js";
+import { DisplayFontFace, DisplayFontRef } from "../types.js";
+import { FontStyle } from "../../layout-engine/measure/measureTypes.js";
+//#region src/display-list/build/fontTable.d.ts
+type FontFaceRequest = {
+  readonly fontFamily: string;
+  readonly alternateFontFamily?: string;
+  readonly bold?: boolean;
+  readonly italic?: boolean;
+  /**
+   * The style the run measures with. The face's font-box ratios come from the
+   * measurer, not from a table of our own, so a backend places a baseline
+   * where the engine placed it.
+   */
+  readonly measureStyle: FontStyle;
+};
+declare class FontTable {
+  private readonly faces;
+  private readonly indexByKey;
+  private readonly embeddedByKey;
+  /**
+   * `embeddedFonts` are the package's own faces (`fonts/embeddedFonts.ts`).
+   * Without them a face the measurer used but no host can supply travels as a
+   * family name a backend has no way to resolve.
+   */
+  constructor(embeddedFonts?: readonly EmbeddedFont[]);
+  intern({ fontFamily, alternateFontFamily, bold, italic, measureStyle }: FontFaceRequest): DisplayFontRef;
+  snapshot(): readonly DisplayFontFace[];
+}
+//#endregion
+export { FontFaceRequest, FontTable };

package/dist/display-list/build/fontTable.js

@@ -0,0 +1,97 @@
+import { ptToPx } from "../../layout-engine/measure/measureHelpers.js";
+import { getFontMetrics } from "../../layout-engine/measure/measureProvider.js";
+import { resolveFontFamily } from "../../utils/fontResolver.js";
+//#region src/display-list/build/fontTable.ts
+const CSS_NORMAL_WEIGHT = 400;
+const CSS_BOLD_WEIGHT = 700;
+const GENERIC_FAMILIES = {
+	serif: "serif",
+	"sans-serif": "sans-serif",
+	monospace: "monospace",
+	cursive: "cursive",
+	fantasy: "fantasy"
+};
+const DEFAULT_GENERIC = "sans-serif";
+const splitFallbackStack = (cssFallback) => cssFallback.split(",").map((entry) => entry.trim().replace(/^["']|["']$/gu, ""));
+/**
+* The category `resolveFontFamily` chose. It is the last CSS generic in the
+* stack it built, which is where `detectFontCategory` puts it; reading it back
+* is cheaper and less brittle than re-deriving the category from the name.
+*/
+const genericOf = (stack) => {
+	for (let index = stack.length - 1; index >= 0; index -= 1) {
+		const generic = GENERIC_FAMILIES[stack[index].toLowerCase()];
+		if (generic !== void 0) return generic;
+	}
+	return DEFAULT_GENERIC;
+};
+const faceKey = (family, weight, italic) => `${family.toLowerCase()} ${weight} ${italic ? "i" : "r"}`;
+/**
+* Package faces keyed by every family name a run can resolve to.
+*
+* `resolveFontFamily` substitutes the scoped `folio-embedded-{nonce}-{name}`
+* family only while the document's embedded-family map is installed; a build
+* that never installed it resolves the same run to the authored name. Both
+* names therefore key the same face, and the bytes are interned by id so one
+* face's binary appears once however many names reach it.
+*/
+const indexEmbeddedFonts = (faces) => {
+	const byId = /* @__PURE__ */ new Map();
+	const byKey = /* @__PURE__ */ new Map();
+	for (const face of faces) {
+		const id = `${face.family}:${face.weight}:${face.style}`;
+		const embedded = byId.get(id) ?? {
+			id,
+			bytes: face.bytes
+		};
+		byId.set(id, embedded);
+		const italic = face.style === "italic";
+		byKey.set(faceKey(face.family, face.weight, italic), embedded);
+		byKey.set(faceKey(face.originalFamily, face.weight, italic), embedded);
+	}
+	return byKey;
+};
+var FontTable = class {
+	faces = [];
+	indexByKey = /* @__PURE__ */ new Map();
+	embeddedByKey;
+	/**
+	* `embeddedFonts` are the package's own faces (`fonts/embeddedFonts.ts`).
+	* Without them a face the measurer used but no host can supply travels as a
+	* family name a backend has no way to resolve.
+	*/
+	constructor(embeddedFonts = []) {
+		this.embeddedByKey = indexEmbeddedFonts(embeddedFonts);
+	}
+	intern({ fontFamily, alternateFontFamily, bold, italic, measureStyle }) {
+		const stack = splitFallbackStack(resolveFontFamily(fontFamily, alternateFontFamily).cssFallback);
+		const family = stack.at(0) ?? fontFamily;
+		const weight = bold ? CSS_BOLD_WEIGHT : CSS_NORMAL_WEIGHT;
+		const isItalic = italic === true;
+		const key = faceKey(family, weight, isItalic);
+		const existing = this.indexByKey.get(key);
+		if (existing !== void 0) return existing;
+		const metrics = getFontMetrics(measureStyle);
+		const fontSizePx = ptToPx(measureStyle.fontSize ?? metrics.fontSize);
+		const scale = fontSizePx > 0 ? 1 / fontSizePx : 0;
+		const index = this.faces.length;
+		const embedded = this.embeddedByKey.get(key);
+		this.faces.push({
+			family,
+			weight,
+			italic: isItalic,
+			generic: genericOf(stack),
+			fallbacks: stack.slice(1).filter((entry) => GENERIC_FAMILIES[entry.toLowerCase()] === void 0),
+			fontBoxAscentRatio: metrics.fontBoxAscent * scale,
+			fontBoxDescentRatio: metrics.fontBoxDescent * scale,
+			...embedded === void 0 ? {} : { embedded }
+		});
+		this.indexByKey.set(key, index);
+		return index;
+	}
+	snapshot() {
+		return this.faces;
+	}
+};
+//#endregion
+export { FontTable };