reamkit 0.1.0-alpha.0 → 1.0.0

package/dist/esm/{document-model → core/document-model}/types.d.ts

@@ -1,3 +1,4 @@
+import { NativeBag, Pt, ResourceId } from '../ir/index.js';
 export type Alignment = 'left' | 'right' | 'center' | 'both' | 'distribute';
 export type UnderlineStyle = 'none' | 'single' | 'double' | 'thick' | 'dotted' | 'dottedHeavy' | 'dash' | 'dashHeavy' | 'wave';
 export type VerticalAlign = 'baseline' | 'superscript' | 'subscript';
@@ -13,7 +14,7 @@ export interface RunProperties {
     readonly italic?: boolean;
     readonly underline?: UnderlineStyle;
     readonly strike?: boolean;
-    readonly fontSizeHalfPoints?: number;
+    readonly fontSizePt?: Pt;
     readonly colorHex?: string;
     readonly fontFamily?: FontFamilyMap;
     readonly verticalAlign?: VerticalAlign;
@@ -23,13 +24,13 @@ export interface RunProperties {
 export interface ParagraphProperties {
     readonly styleId?: string;
     readonly alignment?: Alignment;
-    readonly spacingBeforeTwips?: number;
-    readonly spacingAfterTwips?: number;
-    readonly spacingLineTwips?: number;
+    readonly spacingBefore?: Pt;
+    readonly spacingAfter?: Pt;
+    readonly spacingLine?: Pt;
     readonly spacingLineRule?: 'auto' | 'exact' | 'atLeast';
-    readonly indentLeftTwips?: number;
-    readonly indentRightTwips?: number;
-    readonly indentFirstLineTwips?: number;
+    readonly indentLeft?: Pt;
+    readonly indentRight?: Pt;
+    readonly indentFirstLine?: Pt;
     readonly runProperties?: RunProperties;
     readonly numbering?: NumberingReference;
     readonly pageBreakBefore?: boolean;
@@ -37,9 +38,9 @@ export interface ParagraphProperties {
     readonly outlineLevel?: number;
 }
 export interface InlineImage {
-    readonly imageId: string;
-    readonly widthEmu: number;
-    readonly heightEmu: number;
+    readonly resource?: ResourceId;
+    readonly width: Pt;
+    readonly height: Pt;
 }
 export type MathNode = MathRow | MathRun | MathFraction | MathScript | MathRadical | MathNary | MathFunc | MathLimit | MathDelimiter | MathMatrix | MathAccent | MathBar | MathGroupChr | MathEqArray;
 export interface MathRow {
@@ -122,6 +123,7 @@ export interface MathEqArray {
     readonly rows: ReadonlyArray<MathNode>;
 }
 export interface Run {
+    readonly native?: NativeBag;
     readonly text: string;
     readonly properties: RunProperties;
     readonly inlineImage?: InlineImage;
@@ -129,6 +131,7 @@ export interface Run {
     readonly pageBreak?: boolean;
 }
 export interface Paragraph {
+    readonly native?: NativeBag;
     readonly properties: ParagraphProperties;
     readonly runs: ReadonlyArray<Run>;
 }
@@ -174,7 +177,7 @@ export interface StyleSheet {
 export type BorderStyle = 'none' | 'single' | 'double' | 'thick' | 'dotted' | 'dashed';
 export interface Border {
     readonly style: BorderStyle;
-    readonly sizeEighthPt?: number;
+    readonly width?: Pt;
     readonly colorHex?: string;
 }
 export interface CellBorders {
@@ -186,31 +189,33 @@ export interface CellBorders {
     readonly insideV?: Border;
 }
 export interface CellMargins {
-    readonly topTwips?: number;
-    readonly rightTwips?: number;
-    readonly bottomTwips?: number;
-    readonly leftTwips?: number;
+    readonly top?: Pt;
+    readonly right?: Pt;
+    readonly bottom?: Pt;
+    readonly left?: Pt;
 }
 export interface CellShading {
     readonly colorHex: string;
 }
+export type CellMerge = 'start' | 'middle' | 'end';
 export interface CellProperties {
-    readonly widthTwips?: number;
-    readonly gridSpan?: number;
-    readonly vMerge?: 'restart' | 'continue';
+    readonly width?: Pt;
+    readonly colSpan?: number;
+    readonly merge?: CellMerge;
     readonly borders?: CellBorders;
     readonly margins?: CellMargins;
     readonly shading?: CellShading;
 }
 export interface RowProperties {
-    readonly heightTwips?: number;
+    readonly height?: Pt;
     readonly heightRule?: 'auto' | 'atLeast' | 'exact';
     readonly cantSplit?: boolean;
     readonly isHeader?: boolean;
     readonly pageBreakBefore?: boolean;
 }
 export interface TableProperties {
-    readonly widthTwips?: number;
+    readonly widthPt?: Pt;
+    readonly widthFraction?: number;
     readonly widthType?: 'auto' | 'dxa' | 'pct' | 'nil';
     readonly layout?: 'auto' | 'fixed';
     readonly defaultCellMargins?: CellMargins;
@@ -226,14 +231,15 @@ export interface TableRow {
     readonly cells: ReadonlyArray<TableCell>;
 }
 export interface Table {
+    readonly native?: NativeBag;
     readonly properties: TableProperties;
-    readonly grid: ReadonlyArray<number>;
+    readonly grid: ReadonlyArray<Pt>;
     readonly rows: ReadonlyArray<TableRow>;
 }
 export interface ImageBlock {
-    readonly imageId: string;
-    readonly widthEmu: number;
-    readonly heightEmu: number;
+    readonly resource?: ResourceId;
+    readonly width: Pt;
+    readonly height: Pt;
     readonly paragraphProperties: ParagraphProperties;
     readonly altText?: string;
 }
@@ -286,7 +292,7 @@ export interface ShapeFill {
 }
 export type ShapeDash = 'solid' | 'dot' | 'dash' | 'dashDot' | 'lgDash' | 'lgDashDot' | 'sysDash' | 'sysDot';
 export interface ShapeLine {
-    readonly widthEmu?: number;
+    readonly width?: Pt;
     readonly colorHex?: string;
     readonly dash?: ShapeDash;
     readonly cap?: 'flat' | 'round' | 'square';
@@ -299,15 +305,15 @@ export interface ShapeTransform {
 }
 export interface ShapeTextBody {
     readonly content: ReadonlyArray<BodyElement>;
-    readonly insetLeftEmu?: number;
-    readonly insetTopEmu?: number;
-    readonly insetRightEmu?: number;
-    readonly insetBottomEmu?: number;
+    readonly insetLeft?: Pt;
+    readonly insetTop?: Pt;
+    readonly insetRight?: Pt;
+    readonly insetBottom?: Pt;
     readonly anchor?: 't' | 'ctr' | 'b';
 }
 export interface ShapeBlock {
-    readonly widthEmu: number;
-    readonly heightEmu: number;
+    readonly width: Pt;
+    readonly height: Pt;
     readonly geometry: ShapeGeometry;
     readonly fill: ShapeFill;
     readonly line?: ShapeLine;
@@ -344,8 +350,8 @@ export interface Chart {
 }
 export interface ChartBlock {
     readonly chartRelId: string;
-    readonly widthEmu: number;
-    readonly heightEmu: number;
+    readonly width: Pt;
+    readonly height: Pt;
     readonly paragraphProperties: ParagraphProperties;
     readonly altText?: string;
 }
@@ -366,17 +372,17 @@ export type BodyElement = {
     readonly chart: ChartBlock;
 };
 export interface PageSize {
-    readonly widthTwips: number;
-    readonly heightTwips: number;
+    readonly width: Pt;
+    readonly height: Pt;
     readonly orientation?: 'portrait' | 'landscape';
 }
 export interface PageMargins {
-    readonly topTwips: number;
-    readonly rightTwips: number;
-    readonly bottomTwips: number;
-    readonly leftTwips: number;
-    readonly headerTwips?: number;
-    readonly footerTwips?: number;
+    readonly top: Pt;
+    readonly right: Pt;
+    readonly bottom: Pt;
+    readonly left: Pt;
+    readonly header?: Pt;
+    readonly footer?: Pt;
 }
 export type HeaderFooterType = 'default' | 'first' | 'even';
 export interface HeaderFooterReference {
@@ -401,3 +407,13 @@ export interface DocumentModel {
     readonly numbering?: Numbering;
     readonly section?: SectionProperties;
 }
+export interface DocumentInfo {
+    readonly title?: string;
+    readonly author?: string;
+    readonly subject?: string;
+    readonly keywords?: string;
+    readonly creator?: string;
+    readonly producer?: string;
+    readonly creationDate?: Date;
+    readonly modificationDate?: Date;
+}

package/dist/esm/{ooxml → core}/drawingml/chart-parser.d.ts

@@ -1,3 +1,3 @@
-import { Chart } from '../../document-model/index.js';
+import { Chart } from '../document-model/index.js';
 import { ColorResolver } from './colors.js';
 export declare function parseChart(chartXml: Uint8Array, resolveColor: ColorResolver): Chart | null;

package/dist/esm/{ooxml → core}/drawingml/chart-parser.js

@@ -1,6 +1,7 @@
-import { poAttr, poChildren, poFindByPath, poFindDescendant, poIntAttr, poIs, poTag, poText, poVal } from "../wordproc/po-helpers.js";
+import { poAttr, poChildren, poFindByPath, poFindDescendant, poIntAttr, poIs, poTag, poText, poVal } from "../po-helpers.js";
+import { resolveColorNode } from "./colors.js";
 import { XMLParser } from "fast-xml-parser";
-//#region src/ooxml/drawingml/chart-parser.ts
+//#region src/core/drawingml/chart-parser.ts
 var decoder = new TextDecoder("utf-8");
 var parser = new XMLParser({
 	ignoreAttributes: false,
@@ -109,35 +110,11 @@ function fillColorOf(spPr, resolveColor) {
 	const lnFill = ln ? poChildren(ln).find((c) => poIs(c, "a:solidFill")) : void 0;
 	return lnFill ? colorFromSolidFill(lnFill, resolveColor) : void 0;
 }
-function colorMods(colorNode) {
-	const mods = [];
-	for (const c of poChildren(colorNode)) for (const kind of [
-		"lumMod",
-		"lumOff",
-		"shade",
-		"tint",
-		"alpha"
-	]) if (poIs(c, `a:${kind}`)) {
-		const v = poIntAttr(c, "val");
-		if (v !== void 0) mods.push({
-			kind,
-			val: v / 1e5
-		});
-	}
-	return mods;
-}
 function colorFromSolidFill(solid, resolveColor) {
 	for (const c of poChildren(solid)) {
-		const isSrgb = poIs(c, "a:srgbClr");
-		if (!isSrgb && !poIs(c, "a:schemeClr")) continue;
-		const v = poAttr(c, "val");
-		if (!v) continue;
-		const mods = colorMods(c);
-		const raw = isSrgb ? { srgb: v } : { scheme: v };
-		return resolveColor(mods.length > 0 ? {
-			...raw,
-			mods
-		} : raw);
+		if (!poIs(c, "a:srgbClr") && !poIs(c, "a:schemeClr")) continue;
+		if (!poAttr(c, "val")) continue;
+		return resolveColorNode(c, resolveColor);
 	}
 }
 function collectAT(node) {

package/dist/esm/{ooxml → core}/drawingml/colors.d.ts

@@ -1,3 +1,4 @@
+import { PoNode } from '../po-helpers.js';
 export interface ColorMod {
     readonly kind: 'lumMod' | 'lumOff' | 'shade' | 'tint' | 'alpha';
     readonly val: number;
@@ -15,3 +16,5 @@ export declare const DEFAULT_THEME_PALETTE: ReadonlyMap<string, string>;
 export declare function resolveSchemeName(name: string): string;
 export declare function makeColorResolver(palette: ReadonlyMap<string, string>): ColorResolver;
 export declare const defaultColorResolver: ColorResolver;
+export declare function readColorMods(colorNode: PoNode): Array<ColorMod>;
+export declare function resolveColorNode(c: PoNode, resolveColor: ColorResolver): string | undefined;

package/dist/esm/{ooxml → core}/drawingml/colors.js

@@ -1,4 +1,5 @@
-//#region src/ooxml/drawingml/colors.ts
+import { poAttr, poChildren, poIntAttr, poIs } from "../po-helpers.js";
+//#region src/core/drawingml/colors.ts
 function clamp01(x) {
 	return x < 0 ? 0 : x > 1 ? 1 : x;
 }
@@ -121,5 +122,34 @@ function makeColorResolver(palette) {
 	};
 }
 var defaultColorResolver = makeColorResolver(DEFAULT_THEME_PALETTE);
+function readColorMods(colorNode) {
+	const mods = [];
+	for (const c of poChildren(colorNode)) for (const kind of [
+		"lumMod",
+		"lumOff",
+		"shade",
+		"tint",
+		"alpha"
+	]) if (poIs(c, `a:${kind}`)) {
+		const v = poIntAttr(c, "val");
+		if (v !== void 0) mods.push({
+			kind,
+			val: v / 1e5
+		});
+	}
+	return mods;
+}
+function resolveColorNode(c, resolveColor) {
+	const isSrgb = poIs(c, "a:srgbClr");
+	if (!isSrgb && !poIs(c, "a:schemeClr")) return void 0;
+	const v = poAttr(c, "val");
+	if (!v) return void 0;
+	const mods = readColorMods(c);
+	const raw = isSrgb ? { srgb: v } : { scheme: v };
+	return resolveColor(mods.length > 0 ? {
+		...raw,
+		mods
+	} : raw);
+}
 //#endregion
-export { DEFAULT_THEME_PALETTE, defaultColorResolver, makeColorResolver };
+export { DEFAULT_THEME_PALETTE, defaultColorResolver, makeColorResolver, resolveColorNode };

package/dist/esm/{ooxml → core}/drawingml/theme-parser.js

@@ -1,6 +1,6 @@
-import { poAttr, poChildren, poFindByPath, poIs, poTag } from "../wordproc/po-helpers.js";
+import { poAttr, poChildren, poFindByPath, poIs, poTag } from "../po-helpers.js";
 import { XMLParser } from "fast-xml-parser";
-//#region src/ooxml/drawingml/theme-parser.ts
+//#region src/core/drawingml/theme-parser.ts
 var decoder = new TextDecoder("utf-8");
 var parser = new XMLParser({
 	ignoreAttributes: false,

package/dist/esm/{font → core/font}/arabic-joining.js

@@ -1,4 +1,4 @@
-//#region src/font/arabic-joining.ts
+//#region src/core/font/arabic-joining.ts
 var RIGHT_JOINING = new Set([
 	1570,
 	1571,

package/dist/esm/{font → core/font}/binary-reader.js

@@ -1,4 +1,4 @@
-//#region src/font/binary-reader.ts
+//#region src/core/font/binary-reader.ts
 var BigEndianReader = class {
 	constructor(data, offset = 0) {
 		this.data = data;

package/dist/esm/{font → core/font}/font-registry.d.ts

@@ -1,5 +1,6 @@
 import { ParsedTtf } from './ttf-parser.js';
 export type FontVariant = 'regular' | 'bold' | 'italic' | 'boldItalic';
+export declare function pickVariant(has: (variant: FontVariant) => boolean, bold: boolean, italic: boolean): FontVariant | undefined;
 export interface FontBytesByVariant {
     readonly regular: Uint8Array;
     readonly bold?: Uint8Array;

package/dist/esm/{font → core/font}/font-registry.js

@@ -1,5 +1,13 @@
 import { parseTtf } from "./ttf-parser.js";
-//#region src/font/font-registry.ts
+//#region src/core/font/font-registry.ts
+function pickVariant(has, bold, italic) {
+	return (bold && italic ? [
+		"boldItalic",
+		"bold",
+		"italic",
+		"regular"
+	] : bold ? ["bold", "regular"] : italic ? ["italic", "regular"] : ["regular"]).find(has);
+}
 var FontRegistry = class FontRegistry {
 	constructor(fonts) {
 		this.fonts = fonts;
@@ -13,20 +21,13 @@ var FontRegistry = class FontRegistry {
 		return new FontRegistry(map);
 	}
 	resolveByStyle(bold, italic) {
-		const candidates = bold && italic ? [
-			"boldItalic",
-			"bold",
-			"italic",
-			"regular"
-		] : bold ? ["bold", "regular"] : italic ? ["italic", "regular"] : ["regular"];
-		for (const v of candidates) {
-			const parsed = this.fonts.get(v);
-			if (parsed) return {
-				variant: v,
-				parsed
-			};
-		}
-		throw new Error("FontRegistry has no regular font");
+		const variant = pickVariant((v) => this.fonts.has(v), bold, italic);
+		const parsed = variant ? this.fonts.get(variant) : void 0;
+		if (!variant || !parsed) throw new Error("FontRegistry has no regular font");
+		return {
+			variant,
+			parsed
+		};
 	}
 	entries() {
 		return this.fonts.entries();
@@ -36,4 +37,4 @@ var FontRegistry = class FontRegistry {
 	}
 };
 //#endregion
-export { FontRegistry };
+export { FontRegistry, pickVariant };

package/dist/esm/{font → core/font}/index.d.ts

@@ -3,5 +3,6 @@ export type { ParsedTtf, TtfTableInfo } from './ttf-parser.js';
 export { subsetTtf, glyphClosure } from './ttf-subset.js';
 export { FontRegistry } from './font-registry.js';
 export type { FontVariant, FontBytesByVariant } from './font-registry.js';
+export { pickVariant } from './font-registry.js';
 export { parseGposKerning, parseGsubLigatures, shapeText } from './opentype-layout.js';
 export type { KerningMap, LigatureMap, ShapedRun } from './opentype-layout.js';

package/dist/esm/{font → core/font}/opentype-layout.js

@@ -1,6 +1,6 @@
 import { BigEndianReader } from "./binary-reader.js";
 import { assignArabicForms } from "./arabic-joining.js";
-//#region src/font/opentype-layout.ts
+//#region src/core/font/opentype-layout.ts
 var EMPTY_JOINING_FORMS = {
 	init: /* @__PURE__ */ new Map(),
 	medi: /* @__PURE__ */ new Map(),

package/dist/esm/{font → core/font}/ttf-parser.js

@@ -1,6 +1,6 @@
 import { BigEndianReader } from "./binary-reader.js";
 import { parseGposKerning, parseGsubArabicForms, parseGsubLigatures } from "./opentype-layout.js";
-//#region src/font/ttf-parser.ts
+//#region src/core/font/ttf-parser.ts
 var SFNT_TRUETYPE = 65536;
 var SFNT_OPENTYPE_CFF = 1330926671;
 function parseTtf(raw) {

package/dist/esm/{font → core/font}/ttf-subset.js

@@ -1,4 +1,4 @@
-//#region src/font/ttf-subset.ts
+//#region src/core/font/ttf-subset.ts
 var HEAD_CHECKSUM_ADJUSTMENT_OFFSET = 8;
 var HEAD_INDEX_TO_LOC_FORMAT_OFFSET = 50;
 var MAGIC_HEAD_CHECKSUM = 2981146554;

package/dist/esm/core/fonts/provider.d.ts

@@ -0,0 +1,60 @@
+import { FetchLike } from './remote-fonts.js';
+import { FontBytesByVariant, FontRegistry } from '../font/index.js';
+export interface FontRequest {
+    /** Family name as the document references it (e.g. "Times New Roman"). */
+    readonly family?: string;
+    readonly bold: boolean;
+    readonly italic: boolean;
+}
+export type FontAnswer = {
+    readonly kind: 'bytes';
+    readonly bytes: Uint8Array;
+    /** Face the bytes actually are (for substitution reporting). */
+    readonly faceName: string;
+    /** Which provider answered (chain bookkeeping). */
+    readonly providerId: string;
+} | {
+    readonly kind: 'none';
+};
+export declare const NO_FONT: FontAnswer;
+export interface FontProvider {
+    /** 'embedded' | 'caller' | 'local' | 'remote' | custom ids. */
+    readonly id: string;
+    resolve: (req: FontRequest) => Promise<FontAnswer>;
+}
+/** First byte-level answer wins; 'none' falls through to the next provider. */
+export declare function chainProviders(providers: ReadonlyArray<FontProvider>): FontProvider;
+/**
+ * Caller-supplied bytes — answers every family (the caller chose these fonts
+ * deliberately). Falls back through bold/italic → regular like the registry.
+ */
+export declare function callerFontProvider(fonts: FontBytesByVariant): FontProvider;
+/**
+ * Fonts embedded in the source document itself (docx fontTable), keyed by the
+ * normalized family name — an exact-name match, never a substitution.
+ */
+export declare function embeddedDocFontProvider(embedded: ReadonlyMap<string, FontRegistry>): FontProvider;
+/**
+ * Open CDN substitutes (Roboto / Tinos / Cousine — the LibreOffice mapping).
+ * Always answers; the chain reports it as a substitution.
+ */
+export declare function remoteFontProvider(options?: {
+    readonly fetch?: FetchLike;
+}): FontProvider;
+/**
+ * OS/2 fsType embedding permissions (OpenType §OS/2). Returns undefined when
+ * the table is absent/corrupt. The licensing nibble: 0 = installable,
+ * 2 = RESTRICTED (no embedding), 4 = preview & print, 8 = editable.
+ */
+export declare function readOs2FsType(bytes: Uint8Array): number | undefined;
+/** True when the fsType licensing nibble forbids embedding entirely. */
+export declare function isEmbeddingRestricted(fsType: number | undefined): boolean;
+/**
+ * System fonts via the Local Font Access API (Chromium 103+, permission
+ * prompt). OPT-IN by design: never wired in implicitly. Returns 'none' when
+ * the API is unavailable (Node, Safari, Firefox), the family is not installed,
+ * or the face's OS/2 fsType marks embedding as restricted — embedding a
+ * restricted font into a PDF would violate its license, so the chain falls
+ * through to a substitute instead.
+ */
+export declare function localFontProvider(): FontProvider;

package/dist/esm/core/fonts/provider.js

@@ -0,0 +1,163 @@
+import { fetchFontSet, resolveFamilyKey } from "./remote-fonts.js";
+import { pickVariant } from "../font/font-registry.js";
+//#region src/core/fonts/provider.ts
+var NO_FONT = { kind: "none" };
+/** First byte-level answer wins; 'none' falls through to the next provider. */
+function chainProviders(providers) {
+	return {
+		id: "chain",
+		resolve: async (req) => {
+			for (const p of providers) {
+				const answer = await p.resolve(req);
+				if (answer.kind !== "none") return answer;
+			}
+			return NO_FONT;
+		}
+	};
+}
+function variantFor(req) {
+	if (req.bold && req.italic) return "boldItalic";
+	if (req.bold) return "bold";
+	if (req.italic) return "italic";
+	return "regular";
+}
+/**
+* Caller-supplied bytes — answers every family (the caller chose these fonts
+* deliberately). Falls back through bold/italic → regular like the registry.
+*/
+function callerFontProvider(fonts) {
+	return {
+		id: "caller",
+		resolve: (req) => {
+			const v = variantFor(req);
+			const bytes = fonts[pickVariant((x) => fonts[x] !== void 0, req.bold, req.italic) ?? "regular"] ?? fonts.regular;
+			return Promise.resolve({
+				kind: "bytes",
+				bytes,
+				faceName: `caller:${v}`,
+				providerId: "caller"
+			});
+		}
+	};
+}
+/**
+* Fonts embedded in the source document itself (docx fontTable), keyed by the
+* normalized family name — an exact-name match, never a substitution.
+*/
+function embeddedDocFontProvider(embedded) {
+	return {
+		id: "embedded",
+		resolve: (req) => {
+			const name = req.family?.trim().toLowerCase();
+			const registry = name ? embedded.get(name) : void 0;
+			if (!registry) return Promise.resolve(NO_FONT);
+			const { parsed } = registry.resolveByStyle(req.bold, req.italic);
+			return Promise.resolve({
+				kind: "bytes",
+				bytes: parsed.raw,
+				faceName: req.family,
+				providerId: "embedded"
+			});
+		}
+	};
+}
+/**
+* Open CDN substitutes (Roboto / Tinos / Cousine — the LibreOffice mapping).
+* Always answers; the chain reports it as a substitution.
+*/
+function remoteFontProvider(options = {}) {
+	const cache = /* @__PURE__ */ new Map();
+	return {
+		id: "remote",
+		resolve: async (req) => {
+			const family = resolveFamilyKey(req.family ?? "");
+			let set = cache.get(family);
+			if (!set) {
+				set = fetchFontSet({
+					family,
+					...options.fetch ? { fetch: options.fetch } : {}
+				});
+				cache.set(family, set);
+			}
+			const fonts = await set;
+			return {
+				kind: "bytes",
+				bytes: fonts[pickVariant((x) => fonts[x] !== void 0, req.bold, req.italic) ?? "regular"] ?? fonts.regular,
+				faceName: family,
+				providerId: "remote"
+			};
+		}
+	};
+}
+/**
+* OS/2 fsType embedding permissions (OpenType §OS/2). Returns undefined when
+* the table is absent/corrupt. The licensing nibble: 0 = installable,
+* 2 = RESTRICTED (no embedding), 4 = preview & print, 8 = editable.
+*/
+function readOs2FsType(bytes) {
+	if (bytes.length < 12) return void 0;
+	const u16 = (o) => bytes[o] << 8 | bytes[o + 1];
+	const u32 = (o) => u16(o) * 65536 + u16(o + 2);
+	const numTables = u16(4);
+	for (let i = 0; i < numTables; i++) {
+		const rec = 12 + i * 16;
+		if (rec + 16 > bytes.length) return void 0;
+		if (String.fromCharCode(bytes[rec], bytes[rec + 1], bytes[rec + 2], bytes[rec + 3]) !== "OS/2") continue;
+		const offset = u32(rec + 8);
+		if (offset + 10 > bytes.length) return void 0;
+		return u16(offset + 8);
+	}
+}
+/** True when the fsType licensing nibble forbids embedding entirely. */
+function isEmbeddingRestricted(fsType) {
+	if (fsType === void 0) return false;
+	return (fsType & 15) === 2;
+}
+/**
+* System fonts via the Local Font Access API (Chromium 103+, permission
+* prompt). OPT-IN by design: never wired in implicitly. Returns 'none' when
+* the API is unavailable (Node, Safari, Firefox), the family is not installed,
+* or the face's OS/2 fsType marks embedding as restricted — embedding a
+* restricted font into a PDF would violate its license, so the chain falls
+* through to a substitute instead.
+*/
+function localFontProvider() {
+	const query = globalThis.queryLocalFonts;
+	return {
+		id: "local",
+		resolve: async (req) => {
+			if (!query || !req.family) return NO_FONT;
+			let faces;
+			try {
+				faces = await query();
+			} catch {
+				return NO_FONT;
+			}
+			const family = req.family.trim().toLowerCase();
+			const wantBold = req.bold;
+			const wantItalic = req.italic;
+			const candidates = faces.filter((f) => f.family.trim().toLowerCase() === family);
+			if (candidates.length === 0) return NO_FONT;
+			const styleMatches = (f) => {
+				const s = f.style.toLowerCase();
+				return s.includes("bold") === wantBold && (s.includes("italic") || s.includes("oblique")) === wantItalic;
+			};
+			const face = candidates.find(styleMatches) ?? candidates[0];
+			try {
+				const blob = await face.blob();
+				const bytes = new Uint8Array(await blob.arrayBuffer());
+				if (isEmbeddingRestricted(readOs2FsType(bytes))) return NO_FONT;
+				return {
+					kind: "bytes",
+					bytes,
+					faceName: face.fullName,
+					providerId: "local"
+				};
+			} catch {
+				return NO_FONT;
+			}
+		}
+	};
+}
+//#endregion
+export { NO_FONT, callerFontProvider, chainProviders, embeddedDocFontProvider, isEmbeddingRestricted, localFontProvider, readOs2FsType, remoteFontProvider };

package/dist/esm/{fonts → core/fonts}/remote-fonts.js

@@ -1,4 +1,4 @@
-//#region src/fonts/remote-fonts.ts
+//#region src/core/fonts/remote-fonts.ts
 var CDN_BASE = "https://cdn.jsdelivr.net/npm/@expo-google-fonts";
 var VARIANT_SUFFIX = {
 	regular: "400Regular",