@stll/folio-core 0.62.0 → 0.63.1

package/dist/fields/evaluateField.d.ts

@@ -17,9 +17,9 @@ type EvaluateFieldOptions = {
  * an unsupported or dangling field keeps its last-known cached text rather than
  * vanishing. Pure: all position-dependent inputs come from `ctx`.
  */
-declare function evaluateField(parsed: ParsedFieldInstruction, ctx: FieldContext, options?: EvaluateFieldOptions): string;
+export declare function evaluateField(parsed: ParsedFieldInstruction, ctx: FieldContext, options?: EvaluateFieldOptions): string;
 /** Parse `instruction` then evaluate it; convenience for callers holding the
  *  raw instruction string rather than a pre-parsed instruction. */
-declare function evaluateFieldInstruction(instruction: string, ctx: FieldContext, options?: EvaluateFieldOptions): string;
+export declare function evaluateFieldInstruction(instruction: string, ctx: FieldContext, options?: EvaluateFieldOptions): string;
 //#endregion
-export { evaluateField, evaluateFieldInstruction };
+export {};

package/dist/fields/fieldContext.d.ts

@@ -7,7 +7,7 @@ import { document_d_exports } from "../types/document.js";
  * (page numbers, bookmark pages, SEQ counters) are resolved against the current
  * layout so a field paints the same value its width was measured against.
  */
-type FieldContext = {
+export type FieldContext = {
   /** 1-indexed page the field is on (PAGE). */
   pageNumber: number;
   /** OOXML section-level format used when PAGE has no explicit format switch. */
@@ -26,5 +26,4 @@ type FieldContext = {
   /** Clock for DATE/TIME-family fields; passed in so evaluation stays pure. */
   now: Date;
 };
-//#endregion
-export { FieldContext };
+//#endregion

package/dist/fields/resolveFieldValues.d.ts

@@ -1,7 +1,7 @@
 import { FlowBlock, Page } from "../layout-engine/types.js";
 //#region src/fields/resolveFieldValues.d.ts
 /** Layout-derived inputs shared by every field, regardless of its position. */
-type SharedFieldInputs = {
+export type SharedFieldInputs = {
   totalPages: number;
   bookmarkPages: ReadonlyMap<string, number>;
   bookmarkText: ReadonlyMap<string, string>;
@@ -10,8 +10,8 @@ type SharedFieldInputs = {
   sectionPageCounts: ReadonlyMap<number, number>;
   now: Date;
 };
-type HeaderFooterFieldInputs = Pick<SharedFieldInputs, "bookmarkPages" | "bookmarkText" | "seqValues" | "sectionPageCounts">;
-type ResolvedFieldValues = {
+export type HeaderFooterFieldInputs = Pick<SharedFieldInputs, "bookmarkPages" | "bookmarkText" | "seqValues" | "sectionPageCounts">;
+export type ResolvedFieldValues = {
   /** Field run `pmStart` -> resolved display text. */
   values: Map<number, string>;
   /**
@@ -28,7 +28,7 @@ type ResolvedFieldValues = {
  * Feed `values` back into `measureBlocks({ fieldValues })` so fields measure at
  * their painted width.
  */
-declare function resolveFieldValues(blocks: readonly FlowBlock[], pages: readonly Page[], shared: SharedFieldInputs): ResolvedFieldValues;
+export declare function resolveFieldValues(blocks: readonly FlowBlock[], pages: readonly Page[], shared: SharedFieldInputs): ResolvedFieldValues;
 /**
  * Field values for measuring header/footer blocks, which are laid out once but
  * painted on every page with a different page number. Page-number fields
@@ -38,8 +38,7 @@ declare function resolveFieldValues(blocks: readonly FlowBlock[], pages: readonl
  * paint). `pageCount` is the document's page count — a prior render's count is a
  * fine estimate, since headers are measured before the body is re-laid-out.
  */
-declare function buildHeaderFooterFieldValues(blocks: readonly FlowBlock[], pageCount: number, now: Date, inputs?: Partial<HeaderFooterFieldInputs>): Map<number, string>;
+export declare function buildHeaderFooterFieldValues(blocks: readonly FlowBlock[], pageCount: number, now: Date, inputs?: Partial<HeaderFooterFieldInputs>): Map<number, string>;
 /** Whether two resolved-value maps are identical, for loop convergence. */
-declare function fieldValuesEqual(a: ReadonlyMap<number, string>, b: ReadonlyMap<number, string>): boolean;
-//#endregion
-export { HeaderFooterFieldInputs, ResolvedFieldValues, SharedFieldInputs, buildHeaderFooterFieldValues, fieldValuesEqual, resolveFieldValues };
+export declare function fieldValuesEqual(a: ReadonlyMap<number, string>, b: ReadonlyMap<number, string>): boolean;
+//#endregion

package/dist/fields/sectionPageCounts.d.ts

@@ -5,6 +5,5 @@ import { Page } from "../layout-engine/types.js";
  * to 0 for single-section documents), for resolving SECTIONPAGES. A field on a
  * page reads the count for that page's section.
  */
-declare function buildSectionPageCounts(pages: readonly Page[]): Map<number, number>;
-//#endregion
-export { buildSectionPageCounts };
+export declare function buildSectionPageCounts(pages: readonly Page[]): Map<number, number>;
+//#endregion

package/dist/fields/seqValues.d.ts

@@ -8,6 +8,5 @@ import { FlowBlock } from "../layout-engine/types.js";
  * advancing); every other SEQ advances its counter by one. Independent of
  * pagination, so it runs once per document, not per layout pass.
  */
-declare function buildSeqValues(blocks: readonly FlowBlock[]): Map<number, number>;
-//#endregion
-export { buildSeqValues };
+export declare function buildSeqValues(blocks: readonly FlowBlock[]): Map<number, number>;
+//#endregion

package/dist/fonts/FontFaceLifecycle.d.ts

@@ -0,0 +1,12 @@
+import { Subscribable } from "../managers/Subscribable.js";
+//#region src/fonts/FontFaceLifecycle.d.ts
+export declare class FontFaceLifecycle<Face> extends Subscribable<number> {
+  private readonly remove;
+  private state;
+  constructor(remove: (faces: readonly Face[]) => void);
+  beginReplacement(): (faces: readonly Face[]) => void;
+  clear(): void;
+  destroy(): void;
+  private requireActive;
+}
+//#endregion

package/dist/fonts/FontFaceLifecycle.js

@@ -0,0 +1,56 @@
+import { Subscribable } from "../managers/Subscribable.js";
+import { panic } from "better-result";
+//#region src/fonts/FontFaceLifecycle.ts
+var FontFaceLifecycle = class extends Subscribable {
+	remove;
+	state = {
+		type: "active",
+		generation: 0,
+		faces: []
+	};
+	constructor(remove) {
+		super(0);
+		this.remove = remove;
+	}
+	beginReplacement() {
+		const previous = this.requireActive();
+		const generation = previous.generation + 1;
+		this.state = {
+			type: "active",
+			generation,
+			faces: previous.faces
+		};
+		return (faces) => {
+			const current = this.state;
+			if (current.type === "disposed" || current.generation !== generation) {
+				const retained = new Set(current.type === "active" ? current.faces : []);
+				this.remove(faces.filter((face) => !retained.has(face)));
+				return;
+			}
+			const retained = new Set(faces);
+			this.state = {
+				type: "active",
+				generation,
+				faces: [...retained]
+			};
+			this.remove(current.faces.filter((face) => !retained.has(face)));
+			if (current.faces.length > 0 || retained.size > 0) this.setSnapshot(this.getSnapshot() + 1);
+		};
+	}
+	clear() {
+		this.beginReplacement()([]);
+	}
+	destroy() {
+		const current = this.state;
+		if (current.type === "disposed") return;
+		this.state = { type: "disposed" };
+		this.remove(current.faces);
+	}
+	requireActive() {
+		const current = this.state;
+		if (current.type === "disposed") panic("Cannot replace fonts after the font lifecycle has been destroyed.");
+		return current;
+	}
+};
+//#endregion
+export { FontFaceLifecycle };

package/dist/fonts/documentFontFacts.d.ts

@@ -0,0 +1,17 @@
+import { FontInfo, FontTable } from "@stll/docx-core/model";
+//#region src/fonts/documentFontFacts.d.ts
+type DocumentFontInfo = Readonly<Pick<FontInfo, "family" | "pitch"> & {
+  charset?: Readonly<NonNullable<FontInfo["charset"]>>;
+}>;
+export type DocumentFontFacts = OwnedDocumentFontFacts;
+declare class OwnedDocumentFontFacts {
+  #private;
+  readonly cacheIdentity: string;
+  constructor(fontsByName: Map<string, DocumentFontInfo>);
+  fontInfoOf(name: string): DocumentFontInfo | undefined;
+}
+export declare const buildDocumentFontFacts: (fontTable: FontTable | null | undefined) => DocumentFontFacts | undefined;
+export declare const documentFontFactsCacheIdentity: (facts: DocumentFontFacts | undefined) => string | undefined;
+export declare const documentFontInfoOf: (fontName: string, facts: DocumentFontFacts | undefined) => DocumentFontInfo | undefined;
+//#endregion
+export {};

package/dist/fonts/documentFontFacts.js

@@ -0,0 +1,41 @@
+import { boundedContentIdentity } from "../utils/boundedContentIdentity.js";
+import { canonicalJson } from "../utils/canonicalJson.js";
+//#region src/fonts/documentFontFacts.ts
+const normalizeFontName = (name) => name.trim().toLowerCase();
+var OwnedDocumentFontFacts = class {
+	#fontsByName;
+	cacheIdentity;
+	constructor(fontsByName) {
+		this.#fontsByName = fontsByName;
+		this.cacheIdentity = cacheIdentityForEntries(fontsByName);
+		Object.freeze(this);
+	}
+	fontInfoOf(name) {
+		return this.#fontsByName.get(normalizeFontName(name));
+	}
+};
+const buildDocumentFontFacts = (fontTable) => {
+	if (!fontTable?.fonts.length) return;
+	const fontsByName = /* @__PURE__ */ new Map();
+	for (const font of fontTable.fonts) for (const name of [font.name, font.altName ?? ""]) {
+		const normalized = normalizeFontName(name);
+		if (normalized && !fontsByName.has(normalized)) fontsByName.set(normalized, Object.freeze({
+			...font.family === void 0 ? {} : { family: font.family },
+			...font.pitch === void 0 ? {} : { pitch: font.pitch },
+			...font.charset === void 0 ? {} : { charset: Object.freeze({ ...font.charset }) }
+		}));
+	}
+	return new OwnedDocumentFontFacts(fontsByName);
+};
+const cacheIdentityForEntries = (facts) => {
+	const entries = [...facts].sort(([left], [right]) => {
+		if (left < right) return -1;
+		if (left > right) return 1;
+		return 0;
+	});
+	return boundedContentIdentity(canonicalJson(entries));
+};
+const documentFontFactsCacheIdentity = (facts) => facts?.cacheIdentity;
+const documentFontInfoOf = (fontName, facts) => facts?.fontInfoOf(fontName);
+//#endregion
+export { buildDocumentFontFacts, documentFontFactsCacheIdentity, documentFontInfoOf };

package/dist/fonts/embeddedFontFingerprint.d.ts

@@ -1,5 +1,4 @@
 //#region src/fonts/embeddedFontFingerprint.d.ts
 /** Callers replace owned maps on font changes; mutating a published map is unsupported. */
-declare const embeddedFontFingerprint: (families: ReadonlyMap<string, string>) => string;
-//#endregion
-export { embeddedFontFingerprint };
+export declare const embeddedFontFingerprint: (families: ReadonlyMap<string, string>) => string;
+//#endregion

package/dist/fonts/embeddedFontFingerprint.js

@@ -1,5 +1,6 @@
+import { boundedContentIdentity } from "../utils/boundedContentIdentity.js";
 //#region src/fonts/embeddedFontFingerprint.ts
-/** Immutable editor-owned lookups share content fingerprints without retaining disposed editors. */
+/** Immutable editor-owned lookups reuse cache-local identities without retaining disposed editors. */
 const fingerprints = /* @__PURE__ */ new WeakMap();
 /** Callers replace owned maps on font changes; mutating a published map is unsupported. */
 const embeddedFontFingerprint = (families) => {
@@ -10,7 +11,7 @@ const embeddedFontFingerprint = (families) => {
 		if (left > right) return 1;
 		return 0;
 	});
-	const fingerprint = JSON.stringify(entries);
+	const fingerprint = boundedContentIdentity(JSON.stringify(entries));
 	fingerprints.set(families, fingerprint);
 	return fingerprint;
 };

package/dist/fonts/embeddedFonts.d.ts

@@ -21,9 +21,9 @@
  * so the same original name in two different documents (or two loads of the
  * same document) never collides.
  */
-declare function scopeEmbeddedFontFamily(docNonce: string, originalFamily: string): string;
+export declare function scopeEmbeddedFontFamily(docNonce: string, originalFamily: string): string;
 /** A single de-obfuscated embedded font face, ready to register as `@font-face`. */
-type EmbeddedFont = {
+export type EmbeddedFont = {
   /**
    * Family name to register the face under (`@font-face`/`FontFace`).
    * Always a per-document SCOPED name (see {@link scopeEmbeddedFontFamily}) —
@@ -44,7 +44,7 @@ type EmbeddedFont = {
   subsetted: boolean;
 };
 /** Already-unzipped package parts the pure extractor needs. */
-type EmbeddedFontParts = {
+export type EmbeddedFontParts = {
   /** Raw `word/fontTable.xml`. */
   fontTableXml: string | null | undefined;
   /** Raw `word/_rels/fontTable.xml.rels`. */
@@ -62,7 +62,7 @@ type EmbeddedFontParts = {
  * that don't care about a specific value still get per-call isolation. Pass
  * an explicit value for deterministic tests.
  */
-declare function getEmbeddedFontFaces(parts: EmbeddedFontParts, docNonce?: string): EmbeddedFont[];
+export declare function getEmbeddedFontFaces(parts: EmbeddedFontParts, docNonce?: string): EmbeddedFont[];
 /**
  * Build the original DOCX font name → scoped registered family map for a set
  * of resolved embedded faces. Callers thread this into font resolution (see
@@ -70,13 +70,12 @@ declare function getEmbeddedFontFaces(parts: EmbeddedFontParts, docNonce?: strin
  * runs — which still carry the original name — keep resolving to the scoped
  * face that was actually registered on `document.fonts`.
  */
-declare function buildEmbeddedFontFamilyMap(faces: readonly EmbeddedFont[]): Map<string, string>;
+export declare function buildEmbeddedFontFamilyMap(faces: readonly EmbeddedFont[]): Map<string, string>;
 /**
  * Extract every embedded font face from a raw `.docx` buffer. Unzips the
  * package, then resolves + de-obfuscates the faces via
  * {@link getEmbeddedFontFaces}. Returns an empty list for documents with no
  * embedded fonts. See {@link getEmbeddedFontFaces} for `docNonce`.
  */
-declare function extractEmbeddedFonts(buffer: ArrayBuffer, docNonce?: string): Promise<EmbeddedFont[]>;
-//#endregion
-export { EmbeddedFont, EmbeddedFontParts, buildEmbeddedFontFamilyMap, extractEmbeddedFonts, getEmbeddedFontFaces, scopeEmbeddedFontFamily };
+export declare function extractEmbeddedFonts(buffer: ArrayBuffer, docNonce?: string): Promise<EmbeddedFont[]>;
+//#endregion

package/dist/fonts/fontAlternates.d.ts

@@ -1,8 +1,7 @@
 import { document_d_exports } from "../types/document.js";
 //#region src/fonts/fontAlternates.d.ts
-type FontAlternates = ReadonlyMap<string, string>;
+export type FontAlternates = ReadonlyMap<string, string>;
 /** Build a document-scoped primary-name → OOXML alternate-name lookup. */
-declare const buildFontAlternates: (fontTable: document_d_exports.FontTable | null | undefined) => FontAlternates;
-declare const getFontAlternate: (family: string | undefined, alternates: FontAlternates | undefined) => string | undefined;
-//#endregion
-export { FontAlternates, buildFontAlternates, getFontAlternate };
+export declare const buildFontAlternates: (fontTable: document_d_exports.FontTable | null | undefined) => FontAlternates;
+export declare const getFontAlternate: (family: string | undefined, alternates: FontAlternates | undefined) => string | undefined;
+//#endregion

package/dist/fonts/fontAlternates.js

@@ -1,4 +1,5 @@
 //#region src/fonts/fontAlternates.ts
+const MAX_ALTERNATE_NAME_LENGTH = 31;
 const normalizeFontName = (name) => name.trim().toLowerCase();
 /** Build a document-scoped primary-name → OOXML alternate-name lookup. */
 const buildFontAlternates = (fontTable) => {
@@ -6,7 +7,7 @@ const buildFontAlternates = (fontTable) => {
 	for (const font of fontTable?.fonts ?? []) {
 		const primary = normalizeFontName(font.name);
 		const alternate = font.altName?.trim();
-		if (!primary || !alternate || normalizeFontName(alternate) === primary) continue;
+		if (!primary || !alternate || alternate.length > MAX_ALTERNATE_NAME_LENGTH || normalizeFontName(alternate) === primary) continue;
 		alternates.set(primary, alternate);
 	}
 	return alternates;

package/dist/fonts/fontDeobfuscation.d.ts

@@ -18,13 +18,12 @@
  * Whether a string is a usable embedded-font obfuscation key: a 128-bit GUID,
  * with or without braces and hyphens.
  */
-declare function isValidFontKey(fontKey: string | undefined | null): boolean;
+export declare function isValidFontKey(fontKey: string | undefined | null): boolean;
 /**
  * De-obfuscate an embedded `.odttf` font into a usable OpenType/TrueType binary
  * by XOR-ing its first 32 bytes with the reversed `w:fontKey` GUID. Returns a
  * new array; the input is not mutated. Throws when `fontKey` is not a valid
  * 128-bit GUID (guard with {@link isValidFontKey} first).
  */
-declare function deobfuscateFont(data: Uint8Array, fontKey: string): Uint8Array<ArrayBuffer>;
-//#endregion
-export { deobfuscateFont, isValidFontKey };
+export declare function deobfuscateFont(data: Uint8Array, fontKey: string): Uint8Array<ArrayBuffer>;
+//#endregion

package/dist/fonts/fontDeobfuscation.js

@@ -22,12 +22,12 @@ const KEY_LENGTH = 16;
 */
 function fontKeyToReversedBytes(fontKey) {
 	const hex = fontKey.replace(/[^0-9a-fA-F]/gu, "");
-	if (hex.length !== KEY_LENGTH * 2) return null;
+	if (hex.length !== 32) return null;
 	const reversed = new Uint8Array(KEY_LENGTH);
 	for (let i = 0; i < KEY_LENGTH; i++) {
 		const byte = Number.parseInt(hex.slice(i * 2, i * 2 + 2), 16);
 		if (Number.isNaN(byte)) return null;
-		reversed[KEY_LENGTH - 1 - i] = byte;
+		reversed[15 - i] = byte;
 	}
 	return reversed;
 }
@@ -50,7 +50,11 @@ function deobfuscateFont(data, fontKey) {
 	if (!key) throw new Error(`Invalid embedded-font key: "${fontKey}"`);
 	const out = new Uint8Array(data);
 	const end = Math.min(HEADER_LENGTH, out.length);
-	for (let i = 0; i < end; i++) out[i] = (out[i] ?? 0) ^ (key[i % KEY_LENGTH] ?? 0);
+	for (let i = 0; i < end; i++) {
+		const source = out[i] ?? 0;
+		const keyByte = key[i % KEY_LENGTH] ?? 0;
+		out[i] = source ^ keyByte;
+	}
 	return out;
 }
 //#endregion

package/dist/fonts/fontsourceFaces.d.ts

@@ -1,12 +1,12 @@
 import { HeadlessFontSource } from "./headlessMeasure.js";
 //#region src/fonts/fontsourceFaces.d.ts
 /** Where `@fontsource` files come from: `null` when the package or file is absent. */
-type FontsourceFiles = {
+export type FontsourceFiles = {
   /** Bytes of `@fontsource/<packageName>/<relativePath>`. */
   readonly read: (packageName: string, relativePath: string) => Uint8Array | null;
 };
 /** Each bundled family and the `@fontsource` package that ships it. */
-declare const FONTSOURCE_PACKAGES: {
+export declare const FONTSOURCE_PACKAGES: {
   readonly Arimo: "arimo";
   readonly Caladea: "caladea";
   readonly Carlito: "carlito";
@@ -22,8 +22,8 @@ declare const FONTSOURCE_PACKAGES: {
  * backslash is escaped first, then the quote, and line terminators become hex
  * escapes, which CSS strings require.
  */
-declare const cssString: (value: string) => string;
-type FontsourceFontFaceCssOptions = {
+export declare const cssString: (value: string) => string;
+export type FontsourceFontFaceCssOptions = {
   /**
    * Families to declare beyond the names the faces answer to directly. Pass a
    * display list's own `fonts` families: a face reached through the fallback
@@ -31,7 +31,7 @@ type FontsourceFontFaceCssOptions = {
    */
   readonly families?: readonly string[];
 };
-type FontsourceFaces = {
+export type FontsourceFaces = {
   /** Binaries for the headless measurer and the PDF writer. */
   readonly source: HeadlessFontSource;
   /**
@@ -42,6 +42,5 @@ type FontsourceFaces = {
   readonly fontFaceCss: (options?: FontsourceFontFaceCssOptions) => string;
 };
 /** The `@fontsource` faces, read through `files` and cached per face. */
-declare const createFontsourceFaces: (files: FontsourceFiles) => FontsourceFaces;
-//#endregion
-export { FONTSOURCE_PACKAGES, FontsourceFaces, FontsourceFiles, FontsourceFontFaceCssOptions, createFontsourceFaces, cssString };
+export declare const createFontsourceFaces: (files: FontsourceFiles) => FontsourceFaces;
+//#endregion

package/dist/fonts/fontsourceFaces.js

@@ -4,6 +4,22 @@ import { parseFontFamilyList, resolveFontFamily } from "../utils/fontResolver.js
 import { decodeText } from "../utils/textEncoding.js";
 //#region src/fonts/fontsourceFaces.ts
 /**
+* Faces from the `@fontsource` packages, for a caller that measures and paints
+* without a browser's font stack: a PDF export, a server-rendered preview, a
+* paint harness.
+*
+* One table answers both consumers. The headless measurer and the PDF writer
+* load binaries through {@link FontsourceFaces.source}; a page painted by a
+* browser declares the same binaries through {@link FontsourceFaces.fontFaceCss},
+* each subset under the `unicode-range` `@fontsource` cut it with. Routing a
+* code point to one binary on both sides is what keeps the painted page the
+* page that was measured.
+*
+* The module reads no files itself: the caller supplies
+* {@link FontsourceFiles.read}, so it runs wherever the bytes can be found (a
+* package's `node_modules`, a repository checkout, a fetch in a browser).
+*/
+/**
 * The subsets served, in resolution priority: a code point two subsets cover
 * resolves to the earlier one on both sides.
 */

package/dist/fonts/headlessMeasure.d.ts

@@ -1,9 +1,9 @@
 import { MeasureProvider } from "../layout-engine/measure/measureProvider.js";
 import { Shaper } from "../shaping/shaper.js";
-import { Result } from "better-result";
+import { Result, TaggedErrorClass } from "better-result";
 //#region src/fonts/headlessMeasure.d.ts
 /** One concrete face, as a font source is asked for it. */
-type HeadlessFontRequest = {
+export type HeadlessFontRequest = {
   readonly family: string;
   readonly bold: boolean;
   readonly italic: boolean;
@@ -21,20 +21,20 @@ type HeadlessFontRequest = {
  * everything outside it. The list is in priority order, and a code point is
  * served by the first binary whose `cmap` covers it.
  */
-type HeadlessFontSource = {
+export type HeadlessFontSource = {
   /** Plain sfnt or WOFF binaries, empty when the source has no such face. */
   readonly load: (request: HeadlessFontRequest) => readonly Uint8Array[];
 };
 /** A face the source could not supply, measured with a stand-in instead. */
-type HeadlessFontSubstitution = {
+export type HeadlessFontSubstitution = {
   readonly requested: HeadlessFontRequest;
   readonly reason: string;
 };
-declare const HeadlessMeasureError_base: import("better-result").TaggedErrorClass<"HeadlessMeasureError">;
-declare class HeadlessMeasureError extends HeadlessMeasureError_base<{
+declare const HeadlessMeasureErrorBase: TaggedErrorClass<"HeadlessMeasureError">;
+export declare class HeadlessMeasureError extends HeadlessMeasureErrorBase<{
   message: string;
 }> {}
-type HeadlessMeasureOptions = {
+export type HeadlessMeasureOptions = {
   /**
    * The shaper to measure shaping scripts with.
    *
@@ -45,7 +45,7 @@ type HeadlessMeasureOptions = {
    */
   readonly shaper?: Shaper | null;
 };
-type HeadlessMeasureProvider = {
+export type HeadlessMeasureProvider = {
   readonly provider: MeasureProvider;
   /**
    * Faces measured with a stand-in, in first-request order. A caller that
@@ -59,18 +59,18 @@ type HeadlessMeasureProvider = {
  * face cache and its substitution log, both scoped to the returned object, so
  * two providers never contaminate each other.
  */
-declare const createHeadlessMeasureProvider: (source: HeadlessFontSource, options?: HeadlessMeasureOptions) => HeadlessMeasureProvider;
+export declare const createHeadlessMeasureProvider: (source: HeadlessFontSource, options?: HeadlessMeasureOptions) => HeadlessMeasureProvider;
 /**
  * Install a headless backend as the active provider. An explicit call, never a
  * module side effect, so importing this module cannot silently change how a
  * document measures.
  */
-declare const installHeadlessMeasureProvider: (source: HeadlessFontSource, options?: HeadlessMeasureOptions) => HeadlessMeasureProvider;
+export declare const installHeadlessMeasureProvider: (source: HeadlessFontSource, options?: HeadlessMeasureOptions) => HeadlessMeasureProvider;
 /**
  * Refuse to measure when a source cannot supply a face that the document
  * actually uses. Callers that would rather fail than paginate against a
  * stand-in call this after layout.
  */
-declare const assertNoSubstitutions: (headless: HeadlessMeasureProvider) => Result<void, HeadlessMeasureError>;
+export declare const assertNoSubstitutions: (headless: HeadlessMeasureProvider) => Result<void, HeadlessMeasureError>;
 //#endregion
-export { HeadlessFontRequest, HeadlessFontSource, HeadlessFontSubstitution, HeadlessMeasureError, HeadlessMeasureOptions, HeadlessMeasureProvider, assertNoSubstitutions, createHeadlessMeasureProvider, installHeadlessMeasureProvider };
+export {};

package/dist/fonts/headlessMeasure.js

@@ -23,7 +23,8 @@ import { Result, TaggedError } from "better-result";
 * That residue is measured rather than assumed, by the differential tests
 * beside this file and by the paint-equivalence harness.
 */
-var HeadlessMeasureError = class extends TaggedError("HeadlessMeasureError") {};
+const HeadlessMeasureErrorBase = TaggedError("HeadlessMeasureError");
+var HeadlessMeasureError = class extends HeadlessMeasureErrorBase {};
 /**
 * Ink-bounds probe characters. The canvas backend takes its ink ascent and
 * descent from `measureText("Hg")`, so this backend reads those same two

package/dist/fonts/sfnt/parse.d.ts

@@ -1,6 +1,6 @@
-import { Result } from "better-result";
+import { Result, TaggedErrorClass } from "better-result";
 //#region src/fonts/sfnt/parse.d.ts
-type SfntFont = {
+export type SfntFont = {
   readonly unitsPerEm: number;
   /** hhea ascender/descender/lineGap, in font units; descender is negative. */
   readonly ascender: number;
@@ -36,16 +36,16 @@ type SfntFont = {
   readonly glyphBoundsFor: (glyphId: number) => SfntGlyphBounds | null;
 };
 /** Ink extent of a single glyph, in font units. */
-type SfntGlyphBounds = {
+export type SfntGlyphBounds = {
   readonly xMin: number;
   readonly yMin: number;
   readonly xMax: number;
   readonly yMax: number;
 };
-declare const SfntParseError_base: import("better-result").TaggedErrorClass<"SfntParseError">;
-declare class SfntParseError extends SfntParseError_base<{
+declare const SfntParseErrorBase: TaggedErrorClass<"SfntParseError">;
+export declare class SfntParseError extends SfntParseErrorBase<{
   message: string;
 }> {}
-declare const parseSfnt: (bytes: Uint8Array) => Result<SfntFont, SfntParseError>;
+export declare const parseSfnt: (bytes: Uint8Array) => Result<SfntFont, SfntParseError>;
 //#endregion
-export { SfntFont, SfntGlyphBounds, SfntParseError, parseSfnt };
+export {};

package/dist/fonts/sfnt/parse.js

@@ -14,7 +14,8 @@ import { Result, TaggedError } from "better-result";
 * before it is read, so a truncated or lying font yields an `Err` rather than
 * a throw, and no field is ever `NaN`.
 */
-var SfntParseError = class extends TaggedError("SfntParseError") {};
+const SfntParseErrorBase = TaggedError("SfntParseError");
+var SfntParseError = class extends SfntParseErrorBase {};
 const fail = (message) => Result.err(new SfntParseError({ message }));
 /** Byte offsets inside `head`. */
 const HEAD = {
@@ -351,7 +352,8 @@ const decodeUtf16Be = (view, offset, length) => {
 	});
 };
 const decodeMacRomanAscii = (view, offset, length) => {
-	return decodeText(new Uint8Array(view.buffer, view.byteOffset + offset, length).filter((byte) => byte < 128), { encoding: "binary" });
+	const bytes = new Uint8Array(view.buffer, view.byteOffset + offset, length);
+	return decodeText(bytes.filter((byte) => byte < 128), { encoding: "binary" });
 };
 /**
 * name id 6, preferring the Windows UTF-16BE record over the Macintosh one.

package/dist/fonts/sfnt/subset.d.ts

@@ -1,11 +1,11 @@
 import { SfntFont } from "./parse.js";
-import { Result } from "better-result";
+import { Result, TaggedErrorClass } from "better-result";
 //#region src/fonts/sfnt/subset.d.ts
-declare const SubsetError_base: import("better-result").TaggedErrorClass<"SubsetError">;
-declare class SubsetError extends SubsetError_base<{
+declare const SubsetErrorBase: TaggedErrorClass<"SubsetError">;
+export declare class SubsetError extends SubsetErrorBase<{
   message: string;
 }> {}
-type TrueTypeSubset = {
+export type TrueTypeSubset = {
   /** Subset sfnt bytes. */
   readonly bytes: Uint8Array;
   /** Old glyph id -> new glyph id. Always maps 0 -> 0. */
@@ -15,6 +15,6 @@ type TrueTypeSubset = {
  * Build a `glyf`-flavoured subset containing `glyphIds` plus the components
  * they reference transitively, plus .notdef.
  */
-declare const subsetTrueType: (font: SfntFont, glyphIds: ReadonlySet<number>) => Result<TrueTypeSubset, SubsetError>;
+export declare const subsetTrueType: (font: SfntFont, glyphIds: ReadonlySet<number>) => Result<TrueTypeSubset, SubsetError>;
 //#endregion
-export { SubsetError, TrueTypeSubset, subsetTrueType };
+export {};

package/dist/fonts/sfnt/subset.js

@@ -16,7 +16,8 @@ import { Result, TaggedError, panic } from "better-result";
 * iterated in ascending numeric order and tables are written in tag order, so
 * nothing depends on a Set's or Map's insertion order.
 */
-var SubsetError = class extends TaggedError("SubsetError") {};
+const SubsetErrorBase = TaggedError("SubsetError");
+var SubsetError = class extends SubsetErrorBase {};
 const fail = (message) => Result.err(new SubsetError({ message }));
 /** .notdef is glyph 0 in every font and is always kept. */
 const NOTDEF_GLYPH_ID = 0;