@pptx-editor.dev/core/layout

adjustForHandlefunction

The values of the guides that handle index moves, which put it nearest to point (shape-local EMU), each within its handle range. Undefined when the shape has no such handle. Values are whole guide units, as a:gd stores them.

declare function adjustForHandle(preset: string, w: number, h: number, adjust: ReadonlyMap<string, number>, index: number, point: {
    readonly x: number;
    readonly y: number;
}): Map<string, number> | undefined;

applyfunctionSource ↗

Apply a matrix to a point.

declare function apply(m: Matrix, x: number, y: number): {
    x: number;
    y: number;
};

autonumberTextfunctionSource ↗

The marker text for item n (1-based) of a scheme. A value that ST_TextAutonumberScheme does not list falls back to n..

declare function autonumberText(scheme: string, n: number): string;

baselineOffsetPtfunctionSource ↗

Distance from the line box top to the baseline (points), before rounding.

declare function baselineOffsetPt(sizePt: number, lineHeight: number, metrics: FaceMetrics): number;

baselineOffsetPtfunctionSource ↗

Deprecated. The spacing is ignored: the line height decides. Call without it.

Distance from the line box top to the baseline (points), before rounding.

declare function baselineOffsetPt(sizePt: number, lineHeight: number, metrics: FaceMetrics, spacing: {
    pct: number;
} | {
    pts: number;
}): number;

boxMatrixfunctionSource ↗

Box-local → parent: rotate and flip around the box center, then place at the offset.

declare function boxMatrix(x: Xfrm, withFlip?: boolean, extraRotation?: number): Matrix;

breakOpportunitiesfunctionSource ↗

Break opportunities in text. eaLineBreak applies the East Asian line breaking rules (a:pPr/@eaLnBrk, on by default); latinLineBreak allows a break between any two characters (a:pPr/@latinLnBrk). kinsoku replaces the built-in lists of those rules.

declare function breakOpportunities(text: string, eaLineBreak?: boolean, latinLineBreak?: boolean, kinsoku?: KinsokuLists): Uint8Array;

composeFontConfigurationfunctionSource ↗

Merge a base and any number of fragments into one frozen FontConfiguration.

A bare fragment IS a valid base, so the single-origin case is one argument: composeFontConfiguration(await loadDefaultFonts()). Pass extra fragments to layer origins, and set epoch/maxFontBytes/defaultFont on the base only when you need something other than the documented defaults.

- Sources dedupe first-wins by (family, weight, style), in argument order — base before fragments, earlier fragments before later ones. - Substitutions dedupe first-wins by their from face, in the same order, and every substitution whose from face has a direct source anywhere in the composition is dropped: a real face always beats a stand-in. - The result is frozen (arrays included); the byte arrays themselves are the callers' and are not copied here — the resource snapshot takes its own defensive copy.

declare function composeFontConfiguration(base: FontConfigurationBase, ...fragments: readonly FontConfigurationFragment[]): FontConfiguration;

composeFontOriginsfunctionSource ↗

Resolve a list of [FontOrigin](FontOrigin)s against one document's needs and merge them, first-wins in list order.

Origins resolve IN ORDER, one after another, and each is told which faces the ones before it can already paint ([FontResolutionRequest.resolvedFaces](FontResolutionRequest.resolvedFaces)). Sequential rather than a Promise.all, and that is a real cost — one extra origin's latency on the critical path — bought deliberately: composition is first-wins, so a later origin's copy of a face an earlier one supplied can never be used, and fetching it anyway spends the bytes twice and tells a font host which families the document uses for a result that gets thrown away. Order origins cheapest-first.

A resolver that ignores resolvedFaces still composes correctly; it just spends more.

ONE ORIGIN CANNOT SINK THE REST. An origin that throws, answers null, or answers something malformed is reported and skipped whole, and the origins around it still compose — an app that listed a flaky network origin behind a bundled one keeps the bundled faces. Skipped WHOLE: an answer is read completely before any of it is committed, so a half-ingested origin can never reach composition.

The result carries NO epoch: it is a fragment for the engine to stamp with the load sequence. A fixed epoch from here would label every document's byte set as the same one. undefined means no origin contributed anything, which is a normal answer — the document stays on the fixed measurer.

declare function composeFontOrigins(origins: readonly FontOrigin[], request: FontResolutionRequest, options?: ComposeFontOriginsOptions): Promise<FontConfigurationFragment | undefined>;

configuredDefaultFontFamilyfunctionSource ↗

The face a run with no authored font is measured and reported as: the configured default when it names a valid family, Calibri otherwise.

declare function configuredDefaultFontFamily(configuration?: FontCatalogConfiguration): string;

connectionSitesfunctionSource ↗

The connection sites of a geometry spec at a size (EMU), in a:cxnLst order. Evaluated paths have none.

declare function connectionSites(spec: GeometrySpec, w: number, h: number): ConnectionSite[];

createFixedMeasurerfunctionSource ↗

A deterministic measurer for tests and for hosts without fonts: every code unit is 0.5 em, spaces 0.25 em, and every glyph outline is a box. Never use it for fidelity work.

declare function createFixedMeasurer(): TextMeasurer;

createHarfBuzzMeasurerfunctionSource ↗

Create a measurer over a set of faces. Registration order matters only for ties: the first face registered for a family/style wins.

Face ids are unique for each measurer (pptx-f<measurer>-<face>), so the faces of two documents never share a name, for example in a rasterizer's font registry.

declare function createHarfBuzzMeasurer(sources: readonly FontSource[]): TextMeasurer & {
    readonly faces: readonly RegisteredFace[];
};

deferFontsfunctionSource ↗

Load an origin's faces after the document first paints, instead of before.

The editor opens the document with the faces the other origins supply, then lays it out again when these arrive. Use it for faces that are large or slow to fetch. Leave an origin unwrapped to install its faces with the document's other waiting fonts: a large document (over about 512 KB of uncompressed content) waits up to 2 seconds for them before its first paint.

ts const fonts = [packagedFonts(), deferFonts(myBrandFonts())];

A document export that receives this origin waits for its faces, so exported pages use them. The faces never change the configuration settings, such as defaultFont or maxFontBytes: those come from the origins that answer at once, so the document does not change its default font after it paints.

declare function deferFonts(origin: FontOrigin): MarkedFontResolver;

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>;

drawingCapabilitiesfunctionSource ↗

What the installed drawing renderers paint, read at the time of the call. The chrome reads it when it renders, to offer only the controls whose result paints. Unlike a paint, this query does not count as a use, so an install after it logs no warning.

declare function drawingCapabilities(): DrawingCapabilities;

drawingRenderersVersionfunctionSource ↗

A number that each installDrawingRenderers call increases. An adapter reads it with [subscribeDrawingRenderers](subscribeDrawingRenderers) (for example through useSyncExternalStore), so the choices it shows refresh after an install.

declare function drawingRenderersVersion(): number;

eastAsianFallbackFamiliesfunctionSource ↗

The East Asian fallback faces in the order for a language (a BCP 47 tag): the faces of its script first (Simplified Chinese for Hans, Traditional Chinese for Hant, Korean for Hang), so the text draws with its own glyph forms. Japanese and no language: EAST_ASIAN_FALLBACK_FAMILIES.

declare function eastAsianFallbackFamilies(lang?: string): readonly string[];

evaluateFormulafunction

Evaluate one guide formula against the variables defined so far.

declare function evaluateFormula(fmla: string, vars: ReadonlyMap<string, number>): number;

evaluateGeometryfunctionSource ↗

Evaluate a geometry spec at a size (EMU).

declare function evaluateGeometry(spec: GeometrySpec, w: number, h: number): EvaluatedGeometry;

fontSubstitutesfunctionSource ↗

The substitutes of family. A deck names any family, so only own keys count: a family named constructor has none.

declare function fontSubstitutes(family: string): readonly string[];

hasCharactersfunctionSource ↗

Whether a text layout holds a character. An empty text body still lays out one line, so the caret of a press in it has a position and a height; that line shows nothing, so diagnostics, effect silhouettes, and paint bounds treat the body as no text.

declare function hasCharacters(layout: TextLayout): boolean;

initializeHarfBuzzfunctionSource ↗

Load and verify the HarfBuzz runtime. Idempotent.

declare function initializeHarfBuzz(): Promise<void>;

invertfunctionSource ↗

Invert an affine matrix.

declare function invert(m: Matrix): Matrix;

isFontResolverfunctionSource ↗

Whether a value is a function marked by [defineFontResolver](defineFontResolver).

False for an unmarked function, which callers read as a zero-argument loader. Calling a resolver that way reads request.defaultFamily off undefined and throws, so the callers that make this choice say so rather than swallowing it — and the type-level mark on [MarkedFontResolver](MarkedFontResolver) is there to stop it reaching runtime at all.

declare function isFontResolver(value: unknown): value is MarkedFontResolver;

isHarfBuzzReadyfunctionSource ↗

Whether initializeHarfBuzz() has completed.

declare function isHarfBuzzReady(): boolean;

isIdeographicfunctionSource ↗

Whether a code point is an East Asian character that breaks per character.

declare function isIdeographic(cp: number): boolean;

isMetricCompatiblefunctionSource ↗

Whether measuring family with substitute keeps the original's advance widths.

declare function isMetricCompatible(family: string, substitute: string): boolean;

layoutSlidefunctionSource ↗

Lay out a resolved slide.

declare function layoutSlide(slide: ResolvedSlide, measurer: TextMeasurer): SlideLayout;

layoutTablefunctionSource ↗

Lay out a table. substitutions collects font substitutions for the report.

declare function layoutTable(table: ResolvedTable, measurer: TextMeasurer, substitutions?: Set<string>): TableLayout;

layoutTextfunctionSource ↗

Lay out one text body inside a box (shape-local EMU).

declare function layoutText(body: ResolvedTextBody, rect: {
    x: number;
    y: number;
    width: number;
    height: number;
}, measurer: TextMeasurer): TextLayout;

lineHeightPtfunctionSource ↗

Line box height (points) for a line whose largest font is sizePt. Exact spacing rounds to a whole point; reduction (lnSpcReduction) is subtracted from a percentage.

declare function lineHeightPt(sizePt: number, spacing: {
    pct: number;
} | {
    pts: number;
}, reduction: number): number;

multiplyfunctionSource ↗

m × n: apply n first, then m.

declare function multiply(m: Matrix, n: Matrix): Matrix;

normalizeFontResolverResultfunctionSource ↗

Normalize an on-demand resolver answer that covers none of the requested families.

declare function normalizeFontResolverResult(result: FontConfigurationBase | null | undefined): FontConfigurationBase | undefined;

paragraphSpacingPtfunctionSource ↗

Paragraph spacing (spcBef/spcAft) in points. Points round to a whole point, as exact line spacing does. Percent is of 1.2 × the first run size and does not round.

declare function paragraphSpacingPt(spacing: {
    pct: number;
} | {
    pts: number;
}, sizePt: number): number;

presetAdjustmentsfunction

The adjust values of a preset in a:avLst order, each with the range of its adjust handle (ECMA-376 Part 1, 20.1.9.1 ahLst), evaluated at the size w by h (EMU) with the shape's own values. A range that names a guide needs a size: at zero size only literal ranges apply. Undefined for a preset that the engine does not know.

declare function presetAdjustments(preset: string, w: number, h: number, adjust: ReadonlyMap<string, number>): PresetAdjustment[] | undefined;

presetHandlesfunction

The adjust handles of a preset at the size w by h (EMU) with the shape's own adjust values, in a:ahLst order. Empty for a preset with no handles or one the engine does not know, and for a shape of no size.

declare function presetHandles(preset: string, w: number, h: number, adjust: ReadonlyMap<string, number>): PresetHandle[];

presetNamesfunction

Every preset name the evaluator can draw.

declare function presetNames(): string[];

runGlyphsfunctionSource ↗

The characters of a glyph run in source order, each with the left edge of its cell. In a run that reads right to left (GlyphRun.rtl), unit i draws in cell n - 1 - i, and a character with a mirror image (UAX #9 L4, such as a bracket) draws as that mirror. A surrogate pair is one character. For readers that place each glyph at its own position.

declare function runGlyphs(run: Pick<GlyphRun, 'text' | 'x' | 'rtl'>): RunGlyph[];

setHarfBuzzWasmUrlfunctionSource ↗

Point the text shaper at an externally hosted copy of harfbuzz.wasm.

Needed only under bundlers that do not emit new URL(..., import.meta.url) assets. esbuild and Bun are the common ones, and so is any build that inlines dynamic imports, such as a library bundle. There, the build succeeds and the shaper fails at runtime with an error that names this function; this function is the fix. Webpack, Turbopack and Vite emit the binary on their own, and passing a URL there simply overrides theirs.

ts import { setHarfBuzzWasmUrl } from '@pptx-editor.dev/core/layout'; setHarfBuzzWasmUrl('/static/harfbuzz.wasm');

Pass a URL your application controls. It is fetched and instantiated as WebAssembly, so never derive it from user input, a query parameter, or remote configuration. Serving it cross-origin needs that origin in your connect-src CSP directive, and WebAssembly needs wasm-unsafe-eval in script-src either way.

Call it before the first editor is created. The runtime reads the location once and caches the result, so a call afterwards warns and does nothing: fix the call site and reload. The file to serve is exported as @pptx-editor.dev/core/harfbuzz.wasm, and it must be the copy from the installed package version, because the runtime refuses a version mismatch at load rather than shaping with unverified metrics.

declare function setHarfBuzzWasmUrl(url: string | URL): void;

sha256FontBytesfunctionSource ↗

Synchronous platform-neutral SHA-256 used before font bytes cross into a shaping implementation.

sha256FontBytes: (bytes: Uint8Array) => string

subscribeDrawingRenderersfunctionSource ↗

Call listener after each installDrawingRenderers call. Returns the function that stops the calls. Like [drawingCapabilities](drawingCapabilities), a subscription does not count as a use, so it logs no warning.

declare function subscribeDrawingRenderers(listener: () => void): () => void;

FontResolutionErrorclassSource ↗

A face that could not be admitted, carrying whatever evidence the refusal produced.

RETURNED rather than thrown by FontResourceSnapshot.resolve, because a missing face is an ordinary condition — layout falls back and carries on. It extends Error so a caller that would rather throw can.

declare class FontResolutionError extends Error

BulletPictureinterfaceSource ↗

The picture of a picture bullet, as paint draws it.

interface BulletPicture

CellLayoutinterfaceSource ↗

One drawn cell: its box in the frame and its text.

interface CellLayout

ComposeFontOriginsOptionsinterfaceSource ↗

Diagnostics hook for ordered font-origin composition.

interface ComposeFontOriginsOptions

ConnectionSiteinterface

One connection site of a geometry, in shape-local EMU.

interface ConnectionSite

DrawingCapabilitiesinterfaceSource ↗

What the installed drawing renderers paint in this process.

interface DrawingCapabilities

EvaluatedGeometryinterface

Evaluated geometry: paths and the text rectangle (shape-local EMU).

interface EvaluatedGeometry

FaceMetricsinterfaceSource ↗

Face metrics in em units (font size = 1). Ascent and descent are positive.

interface FaceMetrics

FontConfigurationBaseinterfaceSource ↗

The base of a composition: everything a FontConfiguration carries, all optional. Omitted fields take the documented defaults (epoch 0, maxFontBytes at the engine hard maximum, defaultFont Calibri at 11pt — the default face and size).

interface FontConfigurationBase extends FontConfigurationFragment

FontConfigurationFragmentinterfaceSource ↗

A partial font configuration one origin contributes: sources, substitutions, or both. loadDefaultFonts() (the substitute package) and loadFonts() (the fetch helper) both return this shape, so every origin composes through composeFontConfiguration the same way.

interface FontConfigurationFragment

FontOriginFailureinterfaceSource ↗

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

interface FontOriginFailure

FontRequestinterfaceSource ↗

A font request from a run.

interface FontRequest

FontResolutionRequestinterfaceSource ↗

What the document turned out to need, handed to an on-demand resolver.

The families are the ones the file actually names — already name-validated and capped, so a resolver may treat them as a list to look up, never as URLs or paths to build.

interface FontResolutionRequest

FontResolverMarkinterfaceSource ↗

The type-level half of the mark: what [defineFontResolver](defineFontResolver) adds to a function's type so a FontOrigin list can REQUIRE it.

Declared with a string key so @docx-editor.dev/fonts can declare an identical interface and have the two unify without importing anything from the engine. Set at runtime as well as in the type — non-enumerable, so it stays out of Object.keys and out of a host's own spread.

interface FontResolverMark

FontSourceinterfaceSource ↗

One font face the host makes available: family name, style, and sfnt bytes.

interface FontSource

GeometryPathinterface

One evaluated path with its fill mode and stroke flag.

interface GeometryPath

GlyphRuninterfaceSource ↗

One positioned glyph run on a line.

interface GlyphRun

ItemPlacementinterfaceSource ↗

Where an item sits: its parent space → slide, and its box → the file's coordinates.

interface ItemPlacement

KinsokuListsinterfaceSource ↗

Kinsoku lists: characters that may not start a line, and characters that may not end one.

interface KinsokuLists

LineinterfaceSource ↗

One laid-out line.

interface Line

LineBidiinterfaceSource ↗

The visual order of a line's units (Line.bidi).

interface LineBidi

LineMarkinterfaceSource ↗

A shape that an equation draws itself: a fraction rule, a radical sign, a stretched delimiter, a brace, or an arrow. Paint fills it (nonzero) with the run's fill.

interface LineMark

PresetAdjustmentinterface

One adjust value of a preset (a:avLst/a:gd), with the range of the handle that moves it.

interface PresetAdjustment

PresetHandleinterface

One adjust handle of a shape, in shape-local EMU, with the guides it moves.

interface PresetHandle

PresetShapeDefinitioninterface

One preset shape: adjust defaults, guides, text rectangle, and paths.

interface PresetShapeDefinition

RegisteredFaceinterfaceSource ↗

A registered face: the source plus the internal id paint uses.

interface RegisteredFace extends FontSource

ResolvedFaceinterfaceSource ↗

The face that measures and paints a request.

interface ResolvedFace

RunGlyphinterfaceSource ↗

One character of a glyph run, at its place on the line.

interface RunGlyph

SlideLayoutinterfaceSource ↗

A laid-out slide.

interface SlideLayout

SourceMapinterfaceSource ↗

Maps a group child's laid-out box back to the file: x_file = x / sx + ox, cx_file = cx / sx. Null for top-level elements, whose boxes are the file's.

interface SourceMap

TableLayoutinterfaceSource ↗

A laid-out table. columnX and rowY hold every grid line, first to last.

interface TableLayout

TextLayoutinterfaceSource ↗

Text layout result, in the text box's own frame.

interface TextLayout

TextMeasurerinterfaceSource ↗

The measurer port.

interface TextMeasurer

WarpedRuninterfaceSource ↗

The warped paths of one glyph run: its glyphs, its bars, and its highlight.

interface WarpedRun

FontByteValidatortypeSource ↗

The injected check that bytes really are a font.

Injected because it is the shaper that knows — HarfBuzz can open a face and read its tables, and this layer must not duplicate that judgement. Every byte reaching it is file input.

type FontByteValidator = (bytes: Uint8Array, faceIndex: number) => FontValidationResult;

FontCatalogConfigurationtypeSource ↗

A configuration in either public spelling — full or fragment-with-defaults.

type FontCatalogConfiguration = FontConfiguration | FontConfigurationBase;

FontOrigintypeSource ↗

ONE font origin, in the one shape every origin takes: a finished configuration, a fragment, a promise for either, or a marked resolver that answers per document.

The point of the union is that packagedFonts(), googleFonts(), await defaultFonts() and a hand-built { sources } are all the same kind of thing, so a list of them needs no ordering rule beyond "first wins".

The resolver arm is [MarkedFontResolver](MarkedFontResolver), not bare FontResolver: a list may also hold a zero-argument loader, and only the mark separates the two.

type FontOrigin = FontConfiguration | FontConfigurationFragment | MarkedFontResolver | Promise<FontConfiguration | FontConfigurationFragment | undefined> | undefined;

FontResolutionErrorCodetypeSource ↗

Why a face was not admitted.

forbidden and hashMismatch are adversarial signals rather than ordinary failures: the first is a face the host declared off-limits, the second is bytes that are not what their source claimed.

type FontResolutionErrorCode = 'missing' | 'forbidden' | 'overLimit' | 'malformed' | 'hashMismatch';

FontResolvertypeSource ↗

Resolve fonts once the document's needs are known, instead of ahead of them.

Called after the file is mounted and again when editing requests a new family. Results compose with previously supplied faces; resolvedFaces identifies that coverage. Returning nothing is a valid answer — it means "I cover none of this", and the document stays on the fixed measurer.

A resolver that fetches makes opening a document perform network requests. That is a real change in posture and it must stay the APP's decision: the engine never supplies one, and the families here are file-derived, so a resolver must look them up in a set it shipped rather than interpolate them into a URL.

type FontResolver = (request: FontResolutionRequest) => FontConfiguration | FontConfigurationFragment | undefined | Promise<FontConfiguration | FontConfigurationFragment | undefined>;

FontValidationResulttypeSource ↗

Whether bytes parse as a usable font, with a diagnostic when they do not.

type FontValidationResult = {
    readonly valid: true;
} | {
    readonly valid: false;
    readonly diagnostic: string;
};

LayoutItemtypeSource ↗

One positioned element. matrix maps the element's local box to slide EMU.

type LayoutItem = ItemPlacement & ({
    readonly kind: 'shape';
    readonly element: ResolvedShape;
    readonly matrix: Matrix;
    readonly geometry: EvaluatedGeometry;
    readonly paintLine?: ResolvedLine;
    readonly text?: TextLayout;
    readonly textMatrix?: Matrix;
} | {
    readonly kind: 'picture';
    readonly element: ResolvedPicture;
    readonly matrix: Matrix;
    readonly geometry: EvaluatedGeometry;
    readonly paintLine?: ResolvedLine;
} | {
    readonly kind: 'group';
    readonly element: ResolvedGroup;
    readonly matrix: Matrix;
    readonly children: readonly LayoutItem[];
} | {
    readonly kind: 'frame';
    readonly element: ResolvedGraphicFrame;
    readonly matrix: Matrix;
    readonly table?: TableLayout;
    readonly poster?: Extract<LayoutItem, {
        kind: 'picture';
    }>;
    readonly drawing?: readonly LayoutItem[];
    readonly chart?: readonly LayoutItem[];
});

MarkedFontResolvertypeSource ↗

A [FontResolver](FontResolver) that has been through [defineFontResolver](defineFontResolver).

This, not bare FontResolver, is what a FontOrigin list accepts. The mark is the only thing separating a resolver from a zero-argument loader, and getting that wrong loses every font silently, so the type asks for it up front.

type MarkedFontResolver<T extends FontResolver = FontResolver> = T & FontResolverMark;

MatrixtypeSource ↗

An affine matrix [a, b, c, d, e, f] (SVG convention). EMU units.

type Matrix = readonly [number, number, number, number, number, number];

PathCommandtype

One evaluated path command, absolute shape-local EMU. Arcs are already cubic Béziers.

type PathCommand = {
    readonly op: 'M' | 'L';
    readonly x: number;
    readonly y: number;
} | {
    readonly op: 'C';
    readonly x1: number;
    readonly y1: number;
    readonly x2: number;
    readonly y2: number;
    readonly x: number;
    readonly y: number;
} | {
    readonly op: 'Q';
    readonly x1: number;
    readonly y1: number;
    readonly x: number;
    readonly y: number;
} | {
    readonly op: 'Z';
};

boundedStructuralFontValidatorconstSource ↗

Bounded minimum sfnt/TTC check; Task 4 supplies full parser-backed validation.

boundedStructuralFontValidator: FontByteValidator

DEFAULT_FALLBACK_FAMILYconstSource ↗

The face used when nothing else matches.

DEFAULT_FALLBACK_FAMILY = "Liberation Sans"

DEFAULT_FONTconstSource ↗

The document default font when nothing else says otherwise: Calibri at 11pt.

DEFAULT_FONT: FontConfiguration['defaultFont']

EAST_ASIAN_FALLBACK_FAMILIESconstSource ↗

The faces that draw East Asian text whose own family is missing, in order, when the host supplies one, for Japanese text or text with no language: the pan-CJK face of @docx-editor.dev/fonts-cjk (Noto Sans CJK JP), the regional Noto Sans faces of googleFonts({ cjk: true }), and the Noto Sans CJK faces a system may have. They cover the text, not the original's metrics. eastAsianFallbackFamilies gives the order for a language.

EAST_ASIAN_FALLBACK_FAMILIES: readonly string[]

FONT_RESOLVER_BRANDconstSource ↗

The runtime marker defineFontResolver sets and [isFontResolver](isFontResolver) reads.

Exported because a package mirroring the font contract structurally still has to mark the resolvers it builds. A package in that position sets Symbol.for('docx-editor.dev/font-resolver') itself; this constant is the same symbol, named, for everyone who can import it.

FONT_RESOLVER_BRAND: unique symbol

FONT_RESOLVER_MARK_KEYconstSource ↗

The namespaced key carrying the type-level half of the mark, and the runtime property name that backs it.

A plain string rather than a symbol on purpose: @docx-editor.dev/fonts has no runtime or type dependency on the engine, so it declares the same mark itself, and two unique symbols in two packages would not unify. Two identical string keys do.

FONT_RESOLVER_MARK_KEY = "docx-editor.dev/font-resolver"

FONT_SUBSTITUTESconstSource ↗

Metric-compatible substitutes for faces that cannot ship (from @docx-editor.dev/fonts), and close open alternatives for common presentation faces. Keys are lower case.

FONT_SUBSTITUTES: Readonly<Record<string, readonly string[]>>

HARD_MAX_AGGREGATE_FONT_BYTESconstSource ↗

Most bytes all admitted faces may total, whatever a caller configures.

HARD_MAX_AGGREGATE_FONT_BYTES: number

HARD_MAX_FONT_BYTESconstSource ↗

Largest single face this engine will ever admit, whatever a caller configures.

A CEILING, not a default: a host may set a smaller maxFontBytes, but nothing can raise it past this. Font bytes come from files, and an unbounded face is a memory-exhaustion vector.

HARD_MAX_FONT_BYTES: number

HARD_MAX_FONT_SOURCESconstSource ↗

Most faces one snapshot may hold, whatever a caller configures.

HARD_MAX_FONT_SOURCES = 256

HARFBUZZ_VERSIONconstSource ↗

The HarfBuzz build the engine measures with. A different runtime is refused.

HARFBUZZ_VERSION = "15.0.0"

HOST_SUBSTITUTE_ORIGINconstSource ↗

The origin of a host substitution's face: the face of another family, registered under the family that the deck names.

HOST_SUBSTITUTE_ORIGIN = "host-substitute"

IDENTITYconstSource ↗

IDENTITY: Matrix

MAX_RESOLVER_FAMILIESconstSource ↗

Ceiling on the families one document can put in front of a resolver.

A resolver typically turns each family into up to four faces, and the resource snapshot refuses more than HARD_MAX_FONT_SOURCES (256) sources — so 64 families is the point past which a document could no longer be served anyway. Capping here means a file declaring thousands of distinct w:rFonts cannot fan a resolver out across thousands of lookups (or fetches) before that limit is ever reached.

MAX_RESOLVER_FAMILIES = 64

METRIC_COMPATIBLEconstSource ↗

Substitutes built to match the original's advance widths (@docx-editor.dev/fonts): line breaks match the original font, only glyph shapes differ. Every other substitution can change line breaks. Keys are lower case.

METRIC_COMPATIBLE: Readonly<Record<string, string>>

PICTURE_BULLET_SCALEconstSource ↗

The height of a picture bullet over its bullet size: measured on reference PDFs, where the picture is 0.7 times the bullet size high, whatever the text's face, and keeps its aspect.

PICTURE_BULLET_SCALE = 0.7

SCRIPT_SIZE_SCALEconstSource ↗

Superscript/subscript (baseline ≠ 0) shrink runs to this fraction (measured).

SCRIPT_SIZE_SCALE: number

SINGLE_LINE_FACTORconstSource ↗

Line pitch multiplier for 100% spacing.

SINGLE_LINE_FACTOR = 1.2

SMALL_CAPS_SCALEconstSource ↗

Small caps render lowercase letters at this fraction of the size.

SMALL_CAPS_SCALE = 0.8

WORD_DEFAULT_FONTconstSource ↗

Deprecated. Use [DEFAULT_FONT](DEFAULT_FONT).

The DOCX Editor default font, under the name DOCX Editor's font-composition.ts exports. This module keeps the copied API equal to DOCX Editor's, so the name stays; it is the same value as [DEFAULT_FONT](DEFAULT_FONT).

WORD_DEFAULT_FONT: FontConfiguration['defaultFont']