@docx-editor.dev/docx-to-pdf

createFontSourcefunctionSource ↗

Turn font bytes you ALREADY hold into a FontSource — a file input, IndexedDB, a bundler import. loadFonts covers URLs; this covers everything else, so no caller has to hand-assemble the record or reach for a hashing helper.

Returns a typed failure instead of throwing when the descriptor or the bytes are unusable, matching loadFonts: one bad face degrades itself, never its neighbours.

declare function createFontSource(bytes: Uint8Array, request: FontFaceRequest & {
    readonly faceIndex?: number;
}, options?: {
    readonly id?: string;
    readonly maxFontBytes?: number;
}): {
    readonly source: FontSource;
} | {
    readonly failure: FontLoadFailure;
};

defineFontResolverfunctionSource ↗

Mark a function as an on-demand [FontResolver](FontResolver).

Wrap every resolver you put in a fonts list — useFonts(...), useDocxSource's fonts option, composeFontOrigins. The fonts PROP needs no marking, because a function there is always a resolver; a list also accepts the older zero-argument loader form ({ fonts: defaultFonts }), and this is what keeps the two apart.

Returns the same function object, mutated, so the mark survives being passed around and a marked resolver stays === to itself. It does NOT survive .bind() or being wrapped: both make a new function object. Re-mark the result.

ts const brandFonts = defineFontResolver(async ({ families }) => ({ sources: await loadMine(families), }));

Throws a TypeError on a frozen or sealed function, which cannot take the mark. That is deliberate: returning it unmarked would compile — the return TYPE says marked — and then lose every font at runtime.

declare function defineFontResolver<T extends FontResolver>(resolve: T): MarkedFontResolver<T>;

exportPdffunctionSource ↗

Convert DOCX bytes. Disposes its session after success or failure.

declare function exportPdf(source: Uint8Array, options?: PdfExportOptions): Promise<PdfExportResult>;

exportPdfFromfunctionSource ↗

Encode a caller-owned font-backed session without reopening the document. Does not dispose the session. The caller must dispose it after all exports. Cancellation stops this export; the session's signal controls shared resource work.

declare function exportPdfFrom(session: PdfExportSession, options?: PdfProjectionOptions): Promise<PdfExportResult>;

openDocumentForExportfunctionSource ↗

Open a reusable PDF session over immutable DOCX bytes. Pass the session to exportPdfFrom or Markdown's exportMarkdownFrom. The caller must dispose the session. Its signal controls the entire session lifetime.

declare function openDocumentForExport(source: Uint8Array, options?: OpenPdfDocumentForExportOptions): Promise<OpenPdfDocumentForExportResult>;

ExportResourceErrorclassSource ↗

Bounded failure from a headless export session.

declare class ExportResourceError extends Error

PdfDocumentOpenErrorclassSource ↗

Core refused the input package.

declare class PdfDocumentOpenError extends Error

PdfEncodingErrorclassSource ↗

PDF encoding failed after a document was opened.

declare class PdfEncodingError extends Error

PdfFidelityErrorclassSource ↗

Requested content could not be represented faithfully.

declare class PdfFidelityError extends Error

PdfOutputLimitErrorclassSource ↗

Encoded output exceeds the configured byte limit.

declare class PdfOutputLimitError extends PdfEncodingError

PdfPageLimitErrorclassSource ↗

Layout exceeds the configured page limit.

declare class PdfPageLimitError extends RangeError

PdfWorkLimitErrorclassSource ↗

Content exceeds a processing budget.

declare class PdfWorkLimitError extends Error

ExportDroppedEmbeddedFontinterface

One document-embedded face the export mapper refused before composition.

interface ExportDroppedEmbeddedFont

ExportFontFaceResolutioninterface

One paintable face in an export font-resolution report.

interface ExportFontFaceResolution

ExportFontFamilyResolutioninterface

Coverage of one family Core layout may request.

interface ExportFontFamilyResolution

ExportFontResolutionReportinterface

Exporter-neutral evidence for the font policy behind one layout session.

interface ExportFontResolutionReport

FontOriginFailureinterface

A failed font origin or a partial failure in an otherwise usable fragment.

interface FontOriginFailure

FontRequestinterface

A face, as something asks for it: family plus the two axes this engine admits.

Only static weights and slants. Variable-font axes are deliberately outside this vocabulary — the shaper refuses variation axes, and a variable file admitted here would render bold at regular weight.

interface FontRequest

FontSubstitutioninterface

A request that was answered by a DIFFERENT face than the one asked for.

Recorded rather than silently applied, because a substitution changes measurement: it is part of the shaping fingerprint, so a cached run shaped against a substitute is never reused for the real face.

interface FontSubstitution

PdfDiagnosticinterfaceSource ↗

A bounded explanation of content the PDF cannot reproduce.

interface PdfDiagnostic

PdfExportOptionsinterfaceSource ↗

Node conversion controls. Font substitution follows Core's independent fontPolicy.

interface PdfExportOptions extends Omit<OpenFontBackedDocumentForExportOptions, 'fonts' | 'measurer' | 'producer' | 'reuseAcrossRevisions'>

PdfExportResultinterfaceSource ↗

Result owns its bytes; mutating them does not affect a session or subsequent export.

interface PdfExportResult

PdfExportTimingsinterfaceSource ↗

Elapsed milliseconds for each conversion phase.

interface PdfExportTimings

HeadlessDocumentRejectiontype

A bad package is data, not an exceptional control path.

type HeadlessDocumentRejection = OoxmlPackageRejection | 'no-main-document-tree';

OpenPdfDocumentForExportOptionstypeSource ↗

Font and layout controls for a reusable immutable-byte session.

type OpenPdfDocumentForExportOptions = Omit<PdfExportOptions, 'comments' | 'fidelityPolicy' | 'timeoutMs' | 'maxOutputBytes' | 'maxPages'>;

OpenPdfDocumentForExportResulttypeSource ↗

Open result with the same success/refusal shape as Markdown sessions.

type OpenPdfDocumentForExportResult = OpenFontBackedDocumentForExportResult;

PdfExportSessiontypeSource ↗

Session that retains the admitted fonts and glyph capabilities needed by PDF output.

type PdfExportSession = FontBackedExportCapabilities;

PdfFontOrigintypeSource ↗

A font configuration or document-aware resolver.

type PdfFontOrigin = FontOrigin;

PdfFontsSourcetypeSource ↗

Ordered font configurations or resolvers. Earlier sources take priority.

type PdfFontsSource = PdfFontOrigin | readonly PdfFontOrigin[];

PdfProjectionOptionstypeSource ↗

Output controls for a caller-owned PDF session.

type PdfProjectionOptions = Pick<PdfExportOptions, 'comments' | 'fidelityPolicy' | 'timeoutMs' | 'maxOutputBytes' | 'maxPages' | 'signal' | 'displayMode'>;

RevisionDisplayModetype

Which revisions layout resolves before producing pages.

- all-markup shows both halves of every change. - proposed shows what the document becomes if every change is accepted. - original shows what it was before any of them.

The last two are specified as equal to accept-all and reject-all OUTPUT, which is what makes them testable, without either applying an op.

type RevisionDisplayMode = 'all-markup' | 'proposed' | 'original';