reamkit 0.1.0-alpha.0 → 1.0.1

package/README.md

@@ -18,75 +18,152 @@ Runtime dependencies are minimal: `fflate` (ZIP/Deflate) and `fast-xml-parser`.
 
 ## Usage
 
-Give it the document bytes, get the PDF bytes back. No fonts to wire up — an open
+Parse once into the format-neutral interlayer, convert to any target. The
+format (docx/xlsx) is sniffed from the bytes; no fonts to wire up — an open
 substitute font (Roboto for sans, Tinos for serif, Cousine for monospace — the
 same families LibreOffice substitutes) is fetched automatically based on the
 document's referenced fonts:
 
 ```ts
-import { convertDocxToPdf } from 'reamkit';
+import { Ream } from 'reamkit';
 
 // e.g. from an <input type="file"> or a fetch() — anything that yields bytes.
-const docx = new Uint8Array(await file.arrayBuffer());
+const bytes = new Uint8Array(await file.arrayBuffer());
 
-const pdf = await convertDocxToPdf(docx); // async — fetches a font if needed
+const doc = Ream.parse(bytes);            // docx or xlsx — sniffed
+const pdf = await doc.convert('pdf');     // async — fetches a font if needed
+const svg = await doc.convert('svg');     // same parse, different target
 
 // Hand the bytes to the browser: preview, download, upload, …
 const url = URL.createObjectURL(new Blob([pdf], { type: 'application/pdf' }));
 window.open(url);
 ```
 
-Excel works the same way via `convertXlsxToPdf`. The input/output are plain
-`Uint8Array`s, so wiring this to files, the network, or disk is up to you.
+`doc.flow` exposes the parsed document tree, `doc.format` the detected format,
+and `doc.convertWithReport(...)` returns `{ bytes, losses }` (pass
+`strict: true` to throw on the first conversion loss instead). Input/output
+are plain `Uint8Array`s, so wiring this to files, the network, or disk is up
+to you.
 
-### Bring your own fonts (synchronous, no network)
+### Bring your own fonts (no network)
 
-To embed specific fonts — or to avoid the network entirely — pass the font bytes
-in and use the synchronous variant:
+To embed specific fonts — or to avoid the network entirely — pass the font
+bytes in. `convert` then does zero I/O:
 
 ```ts
-import { convertDocxToPdfSync } from 'reamkit';
-
 const fonts = {
   regular: new Uint8Array(await fetch('/fonts/MyFont-Regular.ttf').then((r) => r.arrayBuffer())),
   bold: new Uint8Array(await fetch('/fonts/MyFont-Bold.ttf').then((r) => r.arrayBuffer())),
+  // italic, boldItalic — optional; missing faces degrade gracefully
 };
-const pdf = convertDocxToPdfSync(docx, { fonts });
+
+const pdf = await Ream.parse(bytes).convert('pdf', { fonts });
+```
+
+### Font resolution chain
+
+For finer control, chain font providers — first byte answer wins. A remote or
+local winner is recorded as a `substituted` loss in the report:
+
+```ts
+import { Ream, callerFontProvider, localFontProvider, remoteFontProvider } from 'reamkit';
+
+const pdf = await doc.convert('pdf', {
+  fontProviders: [
+    callerFontProvider(myFonts), // your bytes — highest priority
+    localFontProvider(),         // system fonts (Chromium Local Font Access,
+                                 //   embedding-restricted fonts are never used)
+    remoteFontProvider(),        // open substitute set from CDN, last resort
+  ],
+});
 ```
 
-The async `convertDocxToPdf` also accepts `fonts` (then it does no network I/O),
-plus `fontFamily` to force a substitute and `fontFetch` to inject a custom
-fetch implementation.
+Fonts the document itself embeds (`w:embed`, including obfuscated `.odttf`)
+are always used first — glyph-exact, no substitution.
 
-### Options
+### Archival PDF/A + embedded source
 
-Both converters accept (beyond `fonts` / `fontBytes`):
+The whole PDF/A family is supported (1a/1b, 2a/2b/2u, 3a/3b/3u —
+veraPDF-validated). PDF/A-3 can carry the source document inside the PDF:
 
-- `info` — PDF `/Info` metadata (`title`, `author`, `subject`, …). Also read
-  automatically from the document's `docProps/core.xml`.
-- `pdfA: 'PDF/A-1b'` — emit an archival PDF/A-1b file (embedded sRGB
-  OutputIntent, XMP, deterministic `/ID`, subset-tagged fonts, no transparency).
-- `hyphenator` — a Liang hyphenator (see below) for nicer justified text.
+```ts
+const { bytes: pdfa, losses } = await doc.convertWithReport('pdf', {
+  fonts,
+  pdfA: 'PDF/A-3b',
+  embedSource: true, // the parsed .docx/.xlsx rides along as /AF Source
+});
+```
+
+### Digital signatures
+
+PKCS#7 detached signatures (ISO 32000 §12.8) via WebCrypto — RSA or ECDSA,
+optional PAdES and RFC 3161 timestamping:
+
+```ts
+const signed = await doc.convert('pdf', {
+  fonts,
+  signature: { certificate: certDer, privateKey: cryptoKey },
+});
+```
+
+### Strict mode and the loss report
+
+Every conversion can report what was dropped, degraded or substituted. For
+compliance-critical flows, make any loss fatal:
+
+```ts
+const { bytes, losses } = await doc.convertWithReport('pdf', { fonts });
+// losses: [{ severity: 'substituted', feature: 'fonts.substitution', … }]
+
+await doc.convert('pdf', { fonts, strict: true }); // throws ConversionLossError on the first loss
+```
+
+### Inspect the interlayer
+
+`parse` produces a format-neutral document tree (the interlayer) before any
+rendering — inspect or analyze it without converting:
+
+```ts
+const doc = Ream.parse(bytes);
+doc.format;     // 'docx' | 'xlsx'
+doc.flow.body;  // paragraphs / tables / images / charts …
+doc.losses;     // read-time losses
+```
 
 ### Hyphenation (optional)
 
 ```ts
 import { getHyphenator } from 'reamkit';
 const hyphenator = await getHyphenator('en-us'); // or 'ru'
-const pdf = await convertDocxToPdf(docx, { hyphenator });
+const pdf = await doc.convert('pdf', { fonts, hyphenator });
 ```
 
-### Advanced
+### More options
+
+`convert` accepts (beyond the above): `info` (PDF `/Info` metadata — also read
+automatically from the document's `docProps/core.xml`), `attachments`
+(PDF/A-3 associated files), `tagged` (logical structure without full PDF/A),
+`pageWidth`/`pageHeight`/margins overrides.
+
+### Lower-level APIs
 
-`renderStyledPdf` drives the layout engine directly. The typed document model is
-available from the `reamkit/document-model` subpath.
+- `docxReader` / `xlsxReader`, `svgWriter` — the `@experimental` reader/writer
+  interfaces of the interlayer, for building custom pipelines (and keeping
+  unused formats out of your bundle); `layoutStyledDocument` produces the
+  frozen page model (`PageItem` pages in a top-left `Pt` frame) they consume.
+- `renderStyledPdf` drives the layout engine directly; the typed document
+  model is on the `reamkit/document-model` subpath.
 
 ## Scope
 
-Implemented: WordprocessingML text/styles/tables/lists/sections/headers-footers/
-images, SpreadsheetML grids/number-formats/dates, Type0+CIDFontType2 font
-embedding with subsetting, Knuth-Plass line breaking, Liang hyphenation,
-OpenType ligatures + kerning, BiDi (UAX #9), and PDF/A-1b.
+Implemented: WordprocessingML text/styles/tables/lists/multi-section
+layout/headers-footers/images/tracked changes, SpreadsheetML grids,
+number formats and the print model (gridlines, print area, fit-to-page,
+repeated titles, page breaks), DrawingML shapes and charts, OMML math,
+Type0+CIDFontType2 embedding with subsetting, Knuth-Plass line breaking,
+Liang hyphenation, OpenType ligatures/kerning + Arabic cursive joining,
+BiDi (UAX #9), tagged PDF, PDF/A-1/2/3 (a/b/u), digital signatures
+(PKCS#7/ECDSA/PAdES/RFC 3161), SVG page preview.
 
 See `handoff.md` for the full feature matrix and known limitations.
 

package/dist/esm/{bidi → core/bidi}/algorithm.js

@@ -1,5 +1,5 @@
 import { bidiClass } from "./char-types.js";
-//#region src/bidi/algorithm.ts
+//#region src/core/bidi/algorithm.ts
 var MAX_DEPTH = 125;
 function matchingPDI(types, openIdx) {
 	let depth = 1;

package/dist/esm/{bidi → core/bidi}/char-types.js

@@ -1,4 +1,4 @@
-//#region src/bidi/char-types.ts
+//#region src/core/bidi/char-types.ts
 var SINGLE = new Map([
 	[9, "S"],
 	[10, "B"],

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

@@ -12,3 +12,5 @@ export declare function analyzeString(text: string, dir?: Direction): StringBidi
 export declare function hasBidiCharacters(text: string): boolean;
 export declare function reverseByCodePoint(text: string): string;
 export declare function reorderTokens(tokenLevels: ReadonlyArray<number>): Array<number>;
+export { segmentLevels } from './segments.js';
+export type { BidiSegment } from './segments.js';

package/dist/esm/{bidi → core/bidi}/index.js

@@ -1,6 +1,7 @@
 import "./char-types.js";
 import { computeBidi } from "./algorithm.js";
-//#region src/bidi/index.ts
+import "./segments.js";
+//#region src/core/bidi/index.ts
 function analyzeString(text, dir = "auto") {
 	const codePoints = [];
 	for (const ch of text) codePoints.push(ch.codePointAt(0));

package/dist/esm/core/bidi/segments.d.ts

@@ -0,0 +1,6 @@
+export interface BidiSegment {
+    readonly text: string;
+    readonly object?: boolean;
+    readonly rtl?: boolean;
+}
+export declare function segmentLevels(segments: ReadonlyArray<BidiSegment>, baseDir: 'ltr' | 'rtl'): Array<number>;

package/dist/esm/core/bidi/segments.js

@@ -0,0 +1,41 @@
+import { computeBidi } from "./algorithm.js";
+//#region src/core/bidi/segments.ts
+var OBJECT_REPLACEMENT = 65532;
+var RLE = 8235;
+var PDF_FMT = 8236;
+var LRE = 8234;
+function segmentLevels(segments, baseDir) {
+	const bidiCps = [];
+	const realIndexOfBidi = [];
+	let realCount = 0;
+	for (const seg of segments) {
+		const isObject = seg.object === true;
+		const wrap = seg.rtl ? RLE : baseDir === "rtl" && !isObject ? LRE : 0;
+		if (wrap) {
+			bidiCps.push(wrap);
+			realIndexOfBidi.push(-1);
+		}
+		if (isObject) {
+			bidiCps.push(OBJECT_REPLACEMENT);
+			realIndexOfBidi.push(realCount);
+			realCount++;
+		} else for (const ch of seg.text) {
+			bidiCps.push(ch.codePointAt(0));
+			realIndexOfBidi.push(realCount);
+			realCount++;
+		}
+		if (wrap) {
+			bidiCps.push(PDF_FMT);
+			realIndexOfBidi.push(-1);
+		}
+	}
+	const { levels } = computeBidi(bidiCps, baseDir);
+	const realLevels = new Array(realCount).fill(baseDir === "rtl" ? 1 : 0);
+	for (let i = 0; i < bidiCps.length; i++) {
+		const ri = realIndexOfBidi[i];
+		if (ri >= 0) realLevels[ri] = levels[i];
+	}
+	return realLevels;
+}
+//#endregion
+export { segmentLevels };

package/dist/esm/core/bytes.d.ts

@@ -0,0 +1 @@
+export declare function bytesInclude(haystack: Uint8Array, needle: string): boolean;

package/dist/esm/core/bytes.js

@@ -0,0 +1,11 @@
+//#region src/core/bytes.ts
+function bytesInclude(haystack, needle) {
+	const n = new TextEncoder().encode(needle);
+	outer: for (let i = 0; i + n.length <= haystack.length; i++) {
+		for (let j = 0; j < n.length; j++) if (haystack[i + j] !== n[j]) continue outer;
+		return true;
+	}
+	return false;
+}
+//#endregion
+export { bytesInclude };

package/dist/esm/core/converter/facade.d.ts

@@ -0,0 +1,45 @@
+import { ConvertDocxOptions } from '../../word/docx-to-pdf.js';
+import { DocumentReader } from '../ir/adapters.js';
+import { FlowDoc } from '../ir/flow.js';
+import { FontProvider } from '../fonts/provider.js';
+import { Loss, LossReport } from '../ir/index.js';
+import { FontBytesByVariant } from '../font/index.js';
+export interface ConvertOptions extends ConvertDocxOptions {
+    /** Target format: 'pdf' (default) or 'svg' (page-stack preview). */
+    readonly to?: 'pdf' | 'svg';
+    /**
+     * Strict mode (handoff v1 §5): throw ConversionLossError on the first
+     * recorded loss instead of returning it in the report.
+     */
+    readonly strict?: boolean;
+    /**
+     * Font resolution chain (ir-design §8). When set (and no caller `fonts`),
+     * the facade resolves the default font set through these providers — e.g.
+     * [localFontProvider(), remoteFontProvider()] — and reports a 'substituted'
+     * loss when anything below a caller/embedded answer wins. Local Font Access
+     * stays strictly opt-in via this option (it can trigger a permission
+     * prompt), which is why nothing wires it in by default.
+     */
+    readonly fontProviders?: ReadonlyArray<FontProvider>;
+}
+export interface ConvertResult {
+    readonly bytes: Uint8Array;
+    readonly losses: LossReport;
+}
+export interface Converter {
+    /** The registered readers, in sniffing order. */
+    readonly readers: ReadonlyArray<DocumentReader<FlowDoc>>;
+    /** Detect the input format by reader sniffing; undefined when unknown. */
+    detect: (bytes: Uint8Array) => DocumentReader<FlowDoc> | undefined;
+    convert: (bytes: Uint8Array, options?: ConvertOptions) => Promise<ConvertResult>;
+}
+export interface CreateConverterOptions {
+    /** Override / extend the reader registry (defaults to docx + xlsx). */
+    readonly readers?: ReadonlyArray<DocumentReader<FlowDoc>>;
+}
+export declare const DEFAULT_READERS: ReadonlyArray<DocumentReader<FlowDoc>>;
+export declare function createConverter(opts?: CreateConverterOptions): Converter;
+export declare function resolveFontsViaChain(providers: ReadonlyArray<FontProvider>): Promise<{
+    fonts?: FontBytesByVariant;
+    loss?: Loss;
+}>;

package/dist/esm/core/converter/facade.js

@@ -0,0 +1,89 @@
+import { FontRegistry } from "../font/font-registry.js";
+import { FEATURES } from "../ir/features.js";
+import { ConversionLossError } from "../ir/loss.js";
+import { layoutStyledDocument } from "../../layout/styled-layout.js";
+import { docxReader } from "../../word/docx-reader.js";
+import { xlsxReader } from "../../excel/xlsx-reader.js";
+import { chainProviders } from "../fonts/provider.js";
+import { flowRenderOptions } from "./project.js";
+import { writeSvg } from "../../svg/svg-writer.js";
+import { convertDocxToPdf } from "../../word/docx-to-pdf.js";
+import { convertXlsxToPdf } from "../../excel/xlsx-to-pdf.js";
+//#region src/core/converter/facade.ts
+var DEFAULT_READERS = [docxReader, xlsxReader];
+function createConverter(opts = {}) {
+	const readers = opts.readers ?? DEFAULT_READERS;
+	const detect = (bytes) => readers.find((r) => r.sniff(bytes));
+	const convert = async (bytes, options = {}) => {
+		const { to = "pdf", strict = false, fontProviders, ...rest } = options;
+		const reader = detect(bytes);
+		if (!reader) throw new Error("Unrecognized input format (no registered reader sniffs these bytes)");
+		const losses = [];
+		let conv = rest;
+		if (fontProviders && fontProviders.length > 0 && !rest.fonts && !rest.fontBytes) {
+			const { fonts, loss } = await resolveFontsViaChain(fontProviders);
+			if (fonts) conv = {
+				...rest,
+				fonts
+			};
+			if (loss) losses.push(loss);
+		}
+		if (to === "svg") {
+			const fonts = conv.fonts ?? (conv.fontBytes ? { regular: conv.fontBytes } : void 0);
+			if (!fonts) throw new Error("to: 'svg' requires options.fonts/fontBytes or fontProviders");
+			const { doc: flow } = reader.read(bytes);
+			const svg = writeSvg(layoutStyledDocument(flow.body, {
+				registry: FontRegistry.fromBytes(fonts),
+				...flowRenderOptions(flow)
+			}));
+			losses.push(...svg.losses);
+			if (strict && losses.length > 0) throw new ConversionLossError(losses[0]);
+			return {
+				bytes: svg.bytes,
+				losses
+			};
+		}
+		const pdf = reader.id === "xlsx" ? await convertXlsxToPdf(bytes, conv) : await convertDocxToPdf(bytes, conv);
+		if (strict && losses.length > 0) throw new ConversionLossError(losses[0]);
+		return {
+			bytes: pdf,
+			losses
+		};
+	};
+	return {
+		readers,
+		detect,
+		convert
+	};
+}
+async function resolveFontsViaChain(providers) {
+	const chain = chainProviders(providers);
+	const ask = (bold, italic) => chain.resolve({
+		bold,
+		italic
+	});
+	const [regular, bold, italic, boldItalic] = await Promise.all([
+		ask(false, false),
+		ask(true, false),
+		ask(false, true),
+		ask(true, true)
+	]);
+	if (regular.kind !== "bytes") return {};
+	const fonts = {
+		regular: regular.bytes,
+		...bold.kind === "bytes" ? { bold: bold.bytes } : {},
+		...italic.kind === "bytes" ? { italic: italic.bytes } : {},
+		...boldItalic.kind === "bytes" ? { boldItalic: boldItalic.bytes } : {}
+	};
+	const loss = regular.providerId === "remote" || regular.providerId === "local" ? {
+		severity: "substituted",
+		feature: FEATURES.fontsSubstitution,
+		detail: `document fonts rendered with ${regular.faceName} (provider: ${regular.providerId})`
+	} : void 0;
+	return {
+		fonts,
+		...loss ? { loss } : {}
+	};
+}
+//#endregion
+export { DEFAULT_READERS, createConverter, resolveFontsViaChain };

package/dist/esm/core/converter/index.d.ts

@@ -0,0 +1,4 @@
+export { convertDocxToPdf, convertDocxToPdfSync, detectDocxFontFamily } from '../../word/docx-to-pdf.js';
+export type { ConvertDocxOptions } from '../../word/docx-to-pdf.js';
+export { convertXlsxToPdf, convertXlsxToPdfSync } from '../../excel/xlsx-to-pdf.js';
+export type { ConvertXlsxOptions } from '../../excel/xlsx-to-pdf.js';

package/dist/esm/core/converter/project.d.ts

@@ -0,0 +1,4 @@
+import { FlowDoc } from '../ir/flow.js';
+import { StyledRenderOptions } from '../../pdf/index.js';
+export type FlowRenderOptions = Omit<StyledRenderOptions, 'registry'>;
+export declare function flowRenderOptions(flow: FlowDoc): FlowRenderOptions;

package/dist/esm/core/converter/project.js

@@ -0,0 +1,17 @@
+import { EMPTY_STYLE_SHEET } from "../style-cascade/resolver.js";
+import "../style-cascade/index.js";
+//#region src/core/converter/project.ts
+function flowRenderOptions(flow) {
+	return {
+		styles: EMPTY_STYLE_SHEET,
+		...flow.sections.length > 0 ? { sections: flow.sections } : {},
+		...flow.section ? { section: flow.section } : {},
+		...flow.headersFooters ? { headersFooters: flow.headersFooters } : {},
+		resources: flow.resources,
+		...flow.charts ? { charts: flow.charts } : {},
+		...flow.embeddedFonts ? { embeddedFonts: flow.embeddedFonts } : {},
+		...flow.language ? { language: flow.language } : {}
+	};
+}
+//#endregion
+export { flowRenderOptions };

package/dist/esm/core/converter/ream.d.ts

@@ -0,0 +1,35 @@
+import { ConvertResult } from './facade.js';
+import { FontBytesByVariant } from '../font/index.js';
+import { FetchLike } from '../fonts/index.js';
+import { FontProvider } from '../fonts/provider.js';
+import { Loss } from '../ir/index.js';
+import { DocumentReader } from '../ir/adapters.js';
+import { FlowDoc } from '../ir/flow.js';
+import { SignatureOptions, StyledRenderOptions } from '../../pdf/index.js';
+export type ReamTarget = 'pdf' | 'svg';
+export interface ReamParseOptions {
+    readonly readers?: ReadonlyArray<DocumentReader>;
+}
+export interface ReamConvertOptions extends Omit<StyledRenderOptions, 'registry' | 'styles'> {
+    readonly fonts?: FontBytesByVariant;
+    readonly fontBytes?: Uint8Array;
+    readonly fontFamily?: string;
+    readonly fontFetch?: FetchLike;
+    readonly fontProviders?: ReadonlyArray<FontProvider>;
+    readonly strict?: boolean;
+    readonly embedSource?: boolean;
+    readonly signature?: SignatureOptions;
+}
+export declare class Ream {
+    readonly flow: FlowDoc;
+    readonly losses: ReadonlyArray<Loss>;
+    private readonly source;
+    private readonly readerId;
+    private constructor();
+    static parse(bytes: Uint8Array, options?: ReamParseOptions): Ream;
+    get format(): string;
+    convert(to: ReamTarget, options?: ReamConvertOptions): Promise<Uint8Array>;
+    convertWithReport(to: ReamTarget, options?: ReamConvertOptions): Promise<ConvertResult>;
+    private resolveFonts;
+    private enforceStrict;
+}

package/dist/esm/core/converter/ream.js

@@ -0,0 +1,101 @@
+import { fetchFontSet } from "../fonts/remote-fonts.js";
+import { FontRegistry } from "../font/font-registry.js";
+import { ConversionLossError } from "../ir/loss.js";
+import { layoutStyledDocument } from "../../layout/styled-layout.js";
+import { signPdf } from "../../pdf/signature.js";
+import { renderStyledPdf } from "../../pdf/styled-page-renderer.js";
+import "../../pdf/index.js";
+import { flowRenderOptions } from "./project.js";
+import { writeSvg } from "../../svg/svg-writer.js";
+import { resolveDocxAutoFonts } from "../../word/docx-to-pdf.js";
+import { DEFAULT_READERS, resolveFontsViaChain } from "./facade.js";
+//#region src/core/converter/ream.ts
+var SOURCE_MIME = {
+	docx: "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
+	xlsx: "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet"
+};
+var Ream = class Ream {
+	constructor(flow, losses, source, readerId) {
+		this.flow = flow;
+		this.losses = losses;
+		this.source = source;
+		this.readerId = readerId;
+	}
+	static parse(bytes, options = {}) {
+		const readers = options.readers ?? DEFAULT_READERS;
+		const reader = readers.find((r) => r.sniff(bytes));
+		if (!reader) throw new Error(`Unrecognized document format (readers: ${readers.map((r) => r.id).join(", ")})`);
+		const { doc, losses } = reader.read(bytes);
+		return new Ream(doc, losses, bytes, reader.id);
+	}
+	get format() {
+		return this.readerId;
+	}
+	async convert(to, options = {}) {
+		return (await this.convertWithReport(to, options)).bytes;
+	}
+	async convertWithReport(to, options = {}) {
+		const losses = [...this.losses];
+		const { fonts, registriesByFamily } = await this.resolveFonts(options, losses);
+		const registry = FontRegistry.fromBytes(fonts);
+		if (to === "svg") {
+			const svg = writeSvg(layoutStyledDocument(this.flow.body, {
+				registry,
+				...flowRenderOptions(this.flow)
+			}));
+			losses.push(...svg.losses);
+			this.enforceStrict(options, losses);
+			return {
+				bytes: svg.bytes,
+				losses
+			};
+		}
+		const { fonts: _a, fontBytes: _b, fontFamily: _c, fontFetch: _d, fontProviders: _e, strict: _f, embedSource, signature, info: callerInfo, attachments: callerAttachments, ...renderOptions } = options;
+		const info = this.flow.info || callerInfo ? {
+			...this.flow.info,
+			...callerInfo
+		} : void 0;
+		const attachments = [...callerAttachments ?? []];
+		if (embedSource && options.pdfA?.startsWith("PDF/A-3")) attachments.push({
+			name: `source.${this.readerId}`,
+			bytes: this.source,
+			mimeType: SOURCE_MIME[this.readerId] ?? "application/octet-stream",
+			relationship: "Source",
+			description: "Source document"
+		});
+		let pdf = renderStyledPdf(this.flow.body, {
+			registry,
+			...registriesByFamily ? { registriesByFamily } : {},
+			...flowRenderOptions(this.flow),
+			...info ? { info } : {},
+			...attachments.length > 0 ? { attachments } : {},
+			...signature ? { signaturePlaceholder: signature } : {},
+			...renderOptions
+		});
+		if (signature) pdf = await signPdf(pdf, signature);
+		this.enforceStrict(options, losses);
+		return {
+			bytes: pdf,
+			losses
+		};
+	}
+	async resolveFonts(options, losses) {
+		const explicit = options.fonts ?? (options.fontBytes ? { regular: options.fontBytes } : void 0);
+		if (explicit) return { fonts: explicit };
+		if (options.fontProviders && options.fontProviders.length > 0) {
+			const { fonts, loss } = await resolveFontsViaChain(options.fontProviders);
+			if (loss) losses.push(loss);
+			if (fonts) return { fonts };
+		}
+		if (this.readerId === "docx") return resolveDocxAutoFonts(this.source, options);
+		return { fonts: await fetchFontSet({
+			...options.fontFamily ? { family: options.fontFamily } : {},
+			...options.fontFetch ? { fetch: options.fontFetch } : {}
+		}) };
+	}
+	enforceStrict(options, losses) {
+		if (options.strict && losses.length > 0) throw new ConversionLossError(losses[0]);
+	}
+};
+//#endregion
+export { Ream };

package/dist/esm/{crypto → core/crypto}/asn1.js

@@ -1,4 +1,4 @@
-//#region src/crypto/asn1.ts
+//#region src/core/crypto/asn1.ts
 var textEncoder = new TextEncoder();
 function concat(arrays) {
 	let total = 0;

package/dist/esm/{crypto → core/crypto}/cms.js

@@ -1,5 +1,5 @@
 import { certIssuerAndSerial, cmsTime, concat, explicit, integer, nullValue, octetString, oid, seq, set, setOfBody, tlv } from "./asn1.js";
-//#region src/crypto/cms.ts
+//#region src/core/crypto/cms.ts
 var OID = {
 	sha256: "2.16.840.1.101.3.4.2.1",
 	rsaEncryption: "1.2.840.113549.1.1.1",

package/dist/esm/core/document-model/index.d.ts

@@ -0,0 +1 @@
+export type { AbstractNumbering, Alignment, Border, BorderStyle, BodyElement, CellBorders, CellMerge, DocumentInfo, CellMargins, CellProperties, CellShading, Chart, ChartBlock, ChartDataPoint, ChartSeries, ChartType, CustomGeometry, CustomPathCmd, DocumentModel, FontFamilyMap, HeaderFooterReference, HeaderFooterType, ImageBlock, InlineImage, MathAccent, MathBar, MathDelimiter, MathEqArray, MathFraction, MathFunc, MathGroupChr, MathLimit, MathMatrix, MathNary, MathNode, MathRadical, MathRow, MathRun, MathScript, Numbering, NumberingFormat, NumberingInstance, NumberingLevel, NumberingReference, PageMargins, PageSize, Paragraph, ParagraphProperties, Run, RunProperties, RowProperties, Section, SectionProperties, ShapeBlock, ShapeDash, ShapeFill, ShapeFillKind, ShapeGeometry, ShapeLine, ShapeTextBody, ShapeTransform, Style, StyleSheet, StyleType, Table, TableCell, TableProperties, TableRow, UnderlineStyle, VerticalAlign, } from './types.js';