@docx-editor.dev/core/editor

applyTableChromePickfunctionSource ↗

Build the engine command for one table chrome pick and the draft state after it. Target picks apply the current complete spec; none clears the active target only.

declare function applyTableChromePick(draft: TableChromeDraft, slot: TableChromeSlotId, value: unknown): TableChromePick | null;

applyThemeShadefunctionSource ↗

Blend toward black. keep is the fraction of the base colour retained (OOXML themeShade byte).

declare function applyThemeShade(hex: string, keep: number): string;

applyThemeTintfunctionSource ↗

Blend toward white. keep is the fraction of the base colour retained (OOXML themeTint byte).

declare function applyThemeTint(hex: string, keep: number): string;

blankDocumentBytesfunctionSource ↗

A Word-faithful blank document, freshly zipped per call (the caller may hand the bytes to a loader that takes ownership). Calibri 11pt and Word's Normal paragraph spacing are authored in w:docDefaults, US Letter geometry in the section — a New document behaves like Word's, and saving it produces a file Word opens identically.

declare function blankDocumentBytes(): Uint8Array;

canExecuteImageCommandfunctionSource ↗

Whether an insert or replace would be accepted — the can half of the can-before-exec pair.

Refuses in suggesting mode, since an image property edit has no tracked-change representation.

declare function canExecuteImageCommand(command: Extract<EditorCommand, {
    type: 'insertImage' | 'replaceImage';
}>, surface: PaginatedSurface | null): CanResult;

captureImageMutationPreconditionsfunctionSource ↗

Snapshot the state an image mutation was planned against: mount generation, package revision, and the selection anchor.

Taken at the START of a drag so the commit can be checked against it with [isStaleImageInteractionCommit](isStaleImageInteractionCommit). A pointer gesture spans many frames, and a document that moved underneath it must not have the gesture's final coordinates applied to it.

declare function captureImageMutationPreconditions(editor: Pick<DocxEditorInstance, 'surface' | 'mountGeneration'>): ImageMutationPreconditions | null;

chromeControlCountfunctionSource ↗

Total controls, so a parity test can assert none were dropped.

declare function chromeControlCount(): number;

chromeMenuSlotsfunctionSource ↗

Every slot a menu places, in menu order, submenus flattened. What a parity test asserts against, and what a host enumerates to know which capabilities the menu bar reaches.

declare function chromeMenuSlots(): readonly ChromeSlotId[];

chromeProbeForSlotfunctionSource ↗

The probe a slot uses to ask "would the engine honour this right now?" when its real command needs an argument the slot itself cannot supply.

text.link is the case: whether this selection could become a link is the engine's question, but WHICH link is a URL field's. Chrome that owns a link UI (React's ToolbarLink) asks with this and dispatches through that UI.

DELIBERATELY NOT in SLOT_COMMANDS. Enabled state has one source, and putting the probe there would enable the control in EVERY adapter — including Vue, which has grown no link UI, where the result is an enabled button whose click can only be refused. A dead button is the worse lie: file.save was a disabled control for a capability that works, and this would be an enabled control for one that is not reachable. Vue's slot therefore keeps reporting the honest "not wired to an editor command" until its popover lands.

declare function chromeProbeForSlot(slotId: ChromeSlotId): EditorCommand | null;

chromeSlotIdfunctionSource ↗

The slot id of one control within its group. Only meaningful for entries of CHROME_GROUPS — the cast is sound because every group/control pair in the registry is, by construction, a member of the ChromeSlotId union.

declare function chromeSlotId(group: {
    readonly id: string;
}, control: {
    readonly id: string;
}): ChromeSlotId;

commandForSlotfunctionSource ↗

The public editor command behind one chrome slot, or null when the slot is not wired to a command yet (parity-only chrome, or save — which is not a command). The single source of command truth for both adapters.

declare function commandForSlot(slotId: ChromeSlotId): EditorCommand | null;

commandForSlotValuefunctionSource ↗

The engine command for a VALUE-TYPED slot carrying the picked value, or null for a slot that does not take a value.

Two families: the run-property pickers (font.family, font.size, text.color, text.highlight) resolve to setMarkAttr, and styles.style resolves to setParagraphStyle — a paragraph styleId, not a mark. Either way the value is validated by the engine's own gate (can refuses a malformed one with invalidArgs; a styleId the document does not define is refused at exec), so a host can pass user input through unmodified.

declare function commandForSlotValue(slotId: ChromeSlotId, value: unknown): EditorCommand | null;

commandForTableChromeSlotValuefunctionSource ↗

Build an engine command for one table chrome slot using the caller's draft state.

declare function commandForTableChromeSlotValue(slotId: TableChromeSlotId, value: unknown, draft: TableChromeDraft): EditorCommand | null;

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;

computeImageResizeResultfunctionSource ↗

Resolve one resize frame from the pointer's current position.

Handles rotation and flips by mapping the SCREEN-space handle back to the drawing's local axes first: dragging the visually-right handle of a 90°-rotated image must change its stored height, and a flipped image's handles move in the opposite direction from where they appear.

declare function computeImageResizeResult(options: {
    readonly handle: ImageResizeHandle;
    readonly startWidthEmu: number;
    readonly startHeightEmu: number;
    readonly startBounds: {
        readonly x: number;
        readonly y: number;
        readonly width: number;
        readonly height: number;
    };
    readonly startPosition: DrawingPositionInput | null;
    readonly anchorFrameOrigin?: AnchorFrameOrigin | null;
    readonly deltaXPt: number;
    readonly deltaYPt: number;
    readonly transform: DrawingTransform;
    readonly preserveAspect: boolean;
    readonly kind: 'inline' | 'anchored';
}): ImageResizeResult;

computeMovedImagePositionfunctionSource ↗

The position a move drag produces, preserving the anchoring the file already used.

A frame-mode position keeps its relativeToH/relativeToV bases and only shifts the offsets it actually had — writing an offset the file omitted would re-anchor the drawing to a different reference and move it somewhere the drag never pointed.

declare function computeMovedImagePosition(start: DrawingPositionInput, deltaXPt: number, deltaYPt: number): DrawingPositionInput;

computeResizedImageExtentEmufunctionSource ↗

The extent a resize drag produces, in EMU.

Computed from the drag's START extent rather than the previous frame's, so a drag that reverses direction lands exactly where it began instead of accumulating rounding error.

preserveAspect behaves the way Word's handles do: a corner handle scales by whichever axis moved further, while an edge handle drives the other axis from the original ratio. Both axes are floored at one point, so a drag past the opposite edge cannot invert the image.

declare function computeResizedImageExtentEmu(startWidthEmu: number, startHeightEmu: number, handle: ImageResizeHandle, deltaWidthPt: number, deltaHeightPt: number, preserveAspect: boolean): {
    readonly cx: number;
    readonly cy: number;
};

createBrowserAutomationHostfunctionSource ↗

An automation host over a live editor.

The editor keeps its own lifetime: dispose() on the returned host releases the change subscription this adapter took and leaves the editor mounted and editable.

declare function createBrowserAutomationHost(editor: DocxEditorInstance): AutomationHost;

createDocxEditorfunctionSource ↗

Build an editor: the full Editor contract over a paginated surface.

Construction is separate from mounting. Pass a container and the document mounts immediately; omit it and nothing touches the DOM until attach(el) — the provider-first shape. detach() remounts from the saved bytes, which resets undo and the caret.

snapshot() is version-cached: the same reference until state actually moves, with reference-stable sub-objects, so it is safe as a useSyncExternalStore source.

declare function createDocxEditor(config: DocxEditorConfig): DocxEditorInstance;

```ts
const editor = createDocxEditor({ document: bytes, modules: [reviewModule()] });
editor.attach(element);
editor.on('change', () => setDirty(true));
```

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

createImageOverlayScrollPortfunctionSource ↗

An [ImageOverlayScrollPort](ImageOverlayScrollPort) over a real scroll container.

Reports the delta the element ACTUALLY scrolled, converted back to points — at the end of the document that is less than asked for, and the overlay must not move the image further than the page travelled.

declare function createImageOverlayScrollPort(scroller: HTMLElement, paintScale: number): {
    scrollBy(deltaYPoints: number): number;
};

createLayoutShapingfunctionSource ↗

Adapt the published byte-source contract to the private deterministic layout snapshot.

declare function createLayoutShaping(configuration: FontConfiguration, instrumentation?: LayoutShapingInstrumentation): Promise<LayoutShapingOptions>;

cropPercentFromCropPermillefunctionSource ↗

Permille crop → UI percent.

declare function cropPercentFromCropPermille(crop: ImageCropPermille): ImageCropPercent;

cropPercentFromPermillefunctionSource ↗

OOXML permille → UI percent.

declare function cropPercentFromPermille(permille: number): number;

cropPercentFromSourceCropfunctionSource ↗

Projection fraction (0–1) → UI percent (0–100).

declare function cropPercentFromSourceCrop(crop: SourceCrop): ImageCropPercent;

cropPermilleFromCropPercentfunctionSource ↗

UI percent crop → permille for tree ops / a:srcRect.

declare function cropPermilleFromCropPercent(crop: ImageCropPercent): ImageCropPermille;

cropPermilleFromPercentfunctionSource ↗

UI percent → OOXML permille.

declare function cropPermilleFromPercent(percent: number): number;

cssPixelsToLayoutPointsfunctionSource ↗

CSS pixels back to layout points — what a pointer event's coordinates must go through.

declare function cssPixelsToLayoutPoints(pixels: number, paintScale: number): number;

defaultChromeGroupsfunctionSource ↗

The groups of the DEFAULT toolbar arrangement, in bar order: every group that is not contextual. This is the registry's default bar — undo/redo through the editing-mode picker — and what both adapters render when the host composes nothing. Contextual slots (image.*, table.insert, file.save) remain available for explicit composition.

declare function defaultChromeGroups(): readonly ChromeGroup[];

defaultTableLabelfunctionSource ↗

The English label for a furniture-insertion control.

The FALLBACK, for a host that has not wired its own translator — adapters pass their useTranslation result instead so the control follows the app's locale.

declare function defaultTableLabel(key: TableInteractionLabelKey): string;

disposeLayoutShapingfunctionSource ↗

Release a shaping environment's native resources.

The shaper holds WASM memory that garbage collection cannot reclaim on its own, so a host that builds shaping options must dispose them when the editor goes away. Safe on a shaper that has no dispose.

declare function disposeLayoutShaping(shaping: LayoutShapingOptions): void;

dragIndentfunctionSource ↗

The indent a drag of handle to positionTwips produces.

Clamps differ from the MARGIN drags this ruler also carries, and deliberately:

- Indents may go NEGATIVE, pulling text into the margin, which Word allows. The floor is the sheet edge, not the margin. - There is no minimum text width. The 720-twip floor the margin drags use mirrors an engine refusal that does not exist for indents, and enforcing one here would make a narrow pull-quote unreachable. Left and right markers may MEET; they may not cross. - The left box needs a first-line clamp of its own. It does not move firstLine, so on a hanging paragraph dragging the box left can push the first-line marker off the sheet while the box itself is still in range. The drag stops when the LEADING marker lands.

declare function dragIndent(handle: RulerIndentHandle, positionTwips: number, indent: RulerIndent, page: RulerPageMetrics, options?: RulerDragOptions): RulerIndent;

emuToOverlayPointsfunctionSource ↗

EMU to points. Unrounded, so overlay geometry keeps sub-point precision during a drag.

declare function emuToOverlayPoints(emu: number): number;

executeImageCommandfunctionSource ↗

Run an insert or replace, re-checking the same gates [canExecuteImageCommand](canExecuteImageCommand) applies.

Async because image bytes must be decoded to derive their natural extent before the drawing can be projected — the one editor command that cannot complete synchronously.

declare function executeImageCommand(editor: DocxEditorInstance, command: Extract<EditorCommand, {
    type: 'insertImage' | 'replaceImage';
}>): Promise<ExecResult>;

finalizeImageOverlayInteractionfunctionSource ↗

Recompute the committed overlay result from release pointer coordinates.

declare function finalizeImageOverlayInteraction(options: {
    readonly session: ImageInteractionSession;
    readonly deltaXPt: number;
    readonly deltaYPt: number;
    readonly accumulatedScrollPt: number;
    readonly aspectLocked: boolean;
    readonly shiftKey: boolean;
    readonly anchorFrameOrigin: AnchorFrameOrigin | null;
}): FinalizedImageOverlayInteraction;

formattingBarChromeGroupsfunctionSource ↗

The formatting-bar groups for one editor snapshot: the default bar, plus the contextual image group when a drawing is selected. Insertion without a selection is not in the packaged chrome at all — a host that wants it places image.insert itself, through DocxEditor.Toolbar.ImageInsert or DocxEditor.Menu.ImageInsert.

declare function formattingBarChromeGroups(image: ImageContext | null): readonly ChromeGroup[];

generateRulerTicksfunctionSource ↗

Ticks across one page dimension, matching the legacy cadence: eighth-inch minors with labelled inches, or millimetre minors with labelled centimetres.

declare function generateRulerTicks(lengthPx: number, unit: RulerUnit): RulerTick[];

handlePositionfunctionSource ↗

Where a handle sits, in twips from the page's LEFT SHEET EDGE (not the margin).

declare function handlePosition(handle: RulerIndentHandle, indent: RulerIndent, page: RulerPageMetrics): number;

isStaleImageInteractionCommitfunctionSource ↗

Whether a drag's commit should be refused because the document moved under it — the refusal to return, or null when the commit is still valid.

Checks the mount generation and both revisions captured by [captureImageMutationPreconditions](captureImageMutationPreconditions). A gesture spans many frames, so this is the one place that decides its coordinates still describe the document they were measured against.

declare function isStaleImageInteractionCommit(editor: Pick<DocxEditorInstance, 'surface' | 'mountGeneration'>, session: ImageInteractionSession): ExecResult | null;

isTableChromeSlotfunctionSource ↗

Whether a chrome slot is one of the table-only ones. Narrows the type.

declare function isTableChromeSlot(slot: ChromeSlotId): slot is TableChromeSlotId;

layoutPointsToCssPixelsfunctionSource ↗

Layout points to CSS pixels. Pair with [surfacePaintScale](surfacePaintScale) for the current zoom.

declare function layoutPointsToCssPixels(points: number, paintScale: number): number;

loadFontsfunctionSource ↗

Fetch app-specified font URLs into verified, cache-backed FontSources.

Fetches ONLY the URLs listed — never a default host or engine-chosen CDN — and never rejects for a per-source failure: the result carries every admitted source and a typed entry for every drop. Compose the result with composeFontConfiguration.

declare function loadFonts(request: LoadFontsRequest): Promise<LoadFontsResult>;

lowerColorValueForBorderfunctionSource ↗

Lower a public colour for table border ops. Theme colours require a resolved literal for paint; auto preserves OOXML automatic semantics with a black render fallback.

declare function lowerColorValueForBorder(color: ColorValue, themeColors: readonly DocumentThemeColorEntry[]): ColorLowerResult;

lowerColorValueForFillfunctionSource ↗

Lower a public colour for cell fill. auto refuses because the cascade literal cannot be named honestly at commit time.

declare function lowerColorValueForFill(color: ColorValue, themeColors: readonly DocumentThemeColorEntry[]): ColorLowerResult;

mountPaginatedSurfacefunctionSource ↗

Mount a paginated surface over DOCX bytes.

Returns a typed rejection rather than throwing: a failure here is a property of the file, and a host must be able to tell "not a package" from "no body" without parsing an error message.

declare function mountPaginatedSurface(container: HTMLElement, bytes: Uint8Array, options?: PaginatedSurfaceOptions): OpenPaginatedResult;

overlayFrameToSheetCssPixelsfunctionSource ↗

Page-content frame → sheet-space CSS pixels (matches paintSelectionOverlay).

declare function overlayFrameToSheetCssPixels(layout: SemanticLayout, frame: OverlayFrameRect, coordinates: SurfaceOverlayCoordinates): {
    readonly left: number;
    readonly top: number;
    readonly width: number;
    readonly height: number;
};

pointsToEmufunctionSource ↗

Points to EMU, rounded — EMUs are integral in the file.

declare function pointsToEmu(points: number): number;

positionInputFromPropertiesCommandfunctionSource ↗

Extract the position input from an image-properties command, or null when it carries none.

declare function positionInputFromPropertiesCommand(command: {
    readonly horizontalEmu?: number;
    readonly verticalEmu?: number;
    readonly relativeToH?: string;
    readonly relativeToV?: string;
}, selected: {
    readonly position?: DrawingPositionInput | null;
} | null): DrawingPositionInput;

probeTableChromeCommandfunctionSource ↗

Probe command for Editor.can — uses the draft's active target and a well-formed value.

declare function probeTableChromeCommand(slot: TableChromeSlotId, draft?: TableChromeDraft): EditorCommand | null;

propertiesCommandHasPositionFieldsfunctionSource ↗

Whether an image-properties command carries any positioning fields at all.

declare function propertiesCommandHasPositionFields(command: {
    readonly horizontalEmu?: number;
    readonly verticalEmu?: number;
    readonly relativeToH?: string;
    readonly relativeToV?: string;
}): boolean;

resizePreservesAspectfunctionSource ↗

Whether this handle drag should preserve aspect ratio.

declare function resizePreservesAspect(handle: ImageResizeHandle, aspectLocked: boolean, shiftKey: boolean): boolean;

resolveColorValueToCssfunctionSource ↗

Resolve any public colour to a CSS #RRGGBB string for chrome display.

declare function resolveColorValueToCss(color: ColorValue | undefined | null, themeColors: readonly DocumentThemeColorEntry[], defaultHex?: string): string;

resolveEditorModulesfunctionSource ↗

Resolve construction-time modules into the registry the instance dispatches over.

declare function resolveEditorModules(modules: readonly EditorModule[] | undefined): EditorModuleRegistry;

resolveImageResourceLimitsfunctionSource ↗

Resolve caller overrides into frozen image limits; hard ceilings cannot be raised.

declare function resolveImageResourceLimits(overrides?: Partial<ImageResourceLimits>): ImageResourceLimits;

resolveSvgIntrinsicSizefunctionSource ↗

Intrinsic size of an SVG, resolved the way a browser sizes one: absolute width/height first, then viewBox for the missing axis or ratio, then the CSS 300x150 default.

This is metadata for insert and reset-to-natural-size only. Layout uses the authored wp:extent and the browser rasterizes into that box, so nothing here sizes an allocation and an out-of-range value is clamped rather than refused.

declare function resolveSvgIntrinsicSize(bytes: Uint8Array, limits: ImageResourceLimits): ValidatedRasterHeader | null;

resolveThemeColorHexfunctionSource ↗

Resolve a theme colour to literal hex. When both tint and shade are present, ECMA-376 §17.3.2.6 / §17.3.4 / §17.3.5 require tint precedence — shade is ignored for paint.

declare function resolveThemeColorHex(color: Extract<ColorValue, {
    kind: 'theme';
}>, themeColors: readonly DocumentThemeColorEntry[]): {
    ok: true;
    hex: string;
} | {
    ok: false;
    reason: string;
};

rulerPageBoxfunctionSource ↗

The first page's box, which the rulers measure against.

declare function rulerPageBox(pages: readonly {
    readonly index: number;
    readonly box: {
        width: number;
        height: number;
    };
}[]): {
    width: number;
    height: number;
} | null;

runSavefunctionSource ↗

Save goes straight to Editor.save() — it is not a command.

declare function runSave(editor: Editor | null): Promise<ArrayBuffer>;

runTableChromeCommandfunctionSource ↗

Run one table chrome pick with explicit draft state; returns the post-pick draft on success.

declare function runTableChromeCommand(editor: Editor | null, slot: TableChromeSlotId, value: unknown, draft: TableChromeDraft): RunTableChromeCommandResult;

runTableCommandfunctionSource ↗

Run a table command: planner-backed can first, then exec only when allowed.

declare function runTableCommand(editor: Editor | null, command: EditorCommand): ExecResult;

runToolbarCommandfunctionSource ↗

Run a toolbar control: can first, then exec only if it said yes. Returns the engine's refusal untouched when it said no, so a caller cannot mistake a declined command for a no-op.

declare function runToolbarCommand(editor: Editor | null, id: ChromeSlotId, 
value?: unknown): ExecResult;

selectedDrawingOverlayTargetOffunctionSource ↗

The painted geometry of the selected drawing, for the resize/move overlay — or null.

Stricter than [selectedImageStateOf](selectedImageStateOf): it also requires a COLLAPSED selection, because a range that merely contains a drawing is a text selection, and drawing handles over it would claim an object the user did not single out.

declare function selectedDrawingOverlayTargetOf(surface: PaginatedSurface | null): SelectedDrawingOverlayTarget | null;

selectedImageStateOffunctionSource ↗

The selected image and what may be done to it, or null when nothing image-like is selected.

Null covers more than "no selection": a placeholder graphic, a drawing the file marks hidden, and one whose select lock is set all read as no selection, because chrome that offered resize handles on them would promise an edit the store is about to refuse.

declare function selectedImageStateOf(surface: PaginatedSurface | null): SelectedImageState | null;

snapTwipsfunctionSource ↗

Round to the ruler's grid, or to the twip when the drag is precise.

declare function snapTwips(value: number, unit: RulerUnit, precise: boolean): number;

sniffImageMimefunctionSource ↗

Signature sniffing — authoritative over declared content type.

declare function sniffImageMime(bytes: Uint8Array): RenderableImageMime | PreservedImageMime | 'unknown';

sourceCropFromCropPercentfunctionSource ↗

UI percent (0–100) → projection fraction (0–1).

declare function sourceCropFromCropPercent(crop: ImageCropPercent): SourceCrop;

surfaceExtentfunctionSource ↗

How wide and tall the paginated surface should be.

When materialize is set — virtualization is active — width follows only those pages so a distant landscape section does not stretch a portrait viewport. Without it (print, export, tests with no scroller) every page contributes, which is the safe reading.

declare function surfaceExtent(layout: SemanticLayout, materialize: ReadonlySet<number> | undefined): SurfaceExtent;

surfacePaintScalefunctionSource ↗

Points → CSS pixels at the given zoom (matches mountPaginatedSurface / semantic paint).

declare function surfacePaintScale(zoom: number): number;

tableChromeIconPathsfunctionSource ↗

Material Symbol paths for one table chrome icon name.

declare function tableChromeIconPaths(name: keyof typeof GENERATED_ICON_PATHS): readonly string[];

tableChromeLabelKeyForTargetfunctionSource ↗

The i18n key naming one border target, for a trigger that shows the active scope.

Falls back to the "all" key rather than throwing: a label is chrome, and a missing one should not take the toolbar down.

declare function tableChromeLabelKeyForTarget(target: TableBorderEdgeTarget): string;

tableChromeToolbarStatefunctionSource ↗

Enabled state for one table chrome slot using explicit draft state.

declare function tableChromeToolbarState(editor: Editor | null, slot: TableChromeSlotId, draft?: TableChromeDraft): ToolbarCommandState;

tableChromeVisiblefunctionSource ↗

Contextual table chrome is visible when the engine reports table context.

declare function tableChromeVisible(table: TableContext | null | undefined): boolean;

tableCommandStatefunctionSource ↗

Planner-backed can/plan pair — production gate for table commands. Task 9 maps chrome slots.

declare function tableCommandState(command: EditorCommand, surface: PaginatedSurface): {
    readonly can: CanResult;
    readonly plan: TableCommandPlan;
};

tableCommandToolbarStatefunctionSource ↗

Enabled state for a table command when the caller holds the paginated surface.

Uses the same planner-backed tableCommandState as Editor.can/gateTableCommand. Chrome slot mapping for table controls is Task 9 — this helper is the shared can-before-exec seam for arbitrary table commands.

declare function tableCommandToolbarState(surface: PaginatedSurface | null, command: EditorCommand): Pick<ToolbarCommandState, 'enabled' | 'disabledReason'>;

toEditorFontErrorfunctionSource ↗

Normalize anything thrown during font work into an [EditorFontError](EditorFontError).

One error type reaches consumers whether the failure came from resolution, admission or shaping, so a host branches on code rather than on which layer happened to throw.

declare function toEditorFontError(error: unknown): EditorFontError;

toolbarCommandStatefunctionSource ↗

Ask the engine whether one control should be enabled.

declare function toolbarCommandState(editor: Editor | null, id: ChromeSlotId): ToolbarCommandState;

toolbarCommandStatesfunctionSource ↗

Enabled state for several controls in one pass.

declare function toolbarCommandStates(editor: Editor | null, ids: readonly ChromeSlotId[]): readonly ToolbarCommandState[];

validateDrawingPositionInputfunctionSource ↗

Validate a position input, refusing offsets or bases outside what OOXML allows.

declare function validateDrawingPositionInput(position: DrawingPositionInput): boolean;

validateImageCropPercentfunctionSource ↗

Whether a crop is expressible: every edge finite and in range, and opposite edges not overlapping.

Opposite edges matter — a left plus right crop summing past 100% describes a negative width, which DrawingML has no way to store.

declare function validateImageCropPercent(crop: ImageCropPercent): boolean;

validateRasterHeaderfunctionSource ↗

Validate a raster image's header structurally and report its real MIME type and extent.

Content type is a CLAIM; this is what makes it a fact. A file declaring image/png over JPEG bytes is caught here rather than at decode.

declare function validateRasterHeader(bytes: Uint8Array, mime: SupportedImageMime): ValidatedRasterHeader | null;

validateSetImagePositionCommandfunctionSource ↗

Validate a set-position command before it reaches the store.

declare function validateSetImagePositionCommand(command: {
    readonly horizontalEmu?: number;
    readonly verticalEmu?: number;
    readonly relativeToH?: string;
    readonly relativeToV?: string;
}, mode: 'frame' | 'simple'): boolean;

validateThemeModifierfunctionSource ↗

Clamp and validate an OOXML theme modifier fraction (0, 1].

declare function validateThemeModifier(value: unknown): value is number;

AnchorFrameOrigininterfaceSource ↗

Where an anchored drawing's positioning frame begins, in layout points.

An anchored drawing's offsets are relative to a base the file names (page, margin, column, …), so a move drag needs that base's origin to turn a pointer delta into a stored offset.

interface AnchorFrameOrigin

ChromeControlinterfaceSource ↗

One toolbar control as the registry describes it — what it renders as, never whether it is enabled.

Enabled state has exactly ONE source, toolbarCommandState, which asks the engine. A descriptor carrying its own disabled flag would be a second answer that goes stale the moment the engine wires the slot.

interface ChromeControl<Id extends string = string>

ChromeGroupinterfaceSource ↗

One toolbar group: the taxonomy both adapters derive their default arrangement FROM.

Never hand-list controls in an adapter — a default toolbar is built by walking CHROME_GROUPS, so a slot added here appears in React and Vue without either being edited.

interface ChromeGroup<Id extends string = string, ControlId extends string = string>

ChromeMenuinterfaceSource ↗

One menu of the menu bar.

interface ChromeMenu

ChromeMenuItemEntryinterfaceSource ↗

A row that runs one chrome slot.

interface ChromeMenuItemEntry

ChromeMenuSeparatorEntryinterfaceSource ↗

A horizontal rule between groups of rows.

interface ChromeMenuSeparatorEntry

ChromeMenuSubmenuEntryinterfaceSource ↗

A row that opens a nested panel of rows (Insert › Break).

It carries its own label and icon rather than a slot, because a submenu PARENT has no command: clicking it opens the panel. Giving it a slot would mint a public id for a control that can never be enabled, and toolbarCommandState would have to invent an answer about it.

interface ChromeMenuSubmenuEntry

DocxEditorConfiginterfaceSource ↗

Everything [createDocxEditor](createDocxEditor) accepts. Every field is optional.

container is the one that changes the shape of the whole lifecycle: omitting it produces an instance that does no DOM work until attach(el), which is what lets a provider own the editor before any component has rendered a mount point.

interface DocxEditorConfig

DocxEditorInstanceinterfaceSource ↗

The concrete facade type: the full Editor contract plus the instance-only surface.

surface, stateVersion, attach and detach live HERE rather than on Editor: they are what a store binding and a mounting host need, not what document commands need. Production adapters program against Editor for everything else.

interface DocxEditorInstance extends Editor

DrawingPositionInputinterfaceSource ↗

An anchored drawing's position: offsets, and the frames they are relative to.

The relative-to bases matter as much as the offsets. Writing an offset without preserving its base re-anchors the drawing against a different reference and moves it somewhere nobody asked.

interface DrawingPositionInput

EditorModuleinterfaceSource ↗

One registered capability module. Registration is construction-time (createDocxEditor({ modules })) and immutable for the instance's lifetime.

interface EditorModule

EditorModuleRegistryinterfaceSource ↗

The resolved registry the editor instance holds: at most one review contribution (first registration wins), all custom node definitions in registration order.

interface EditorModuleRegistry

FinalizedImageOverlayInteractioninterfaceSource ↗

The committed result of a whole drag, recomputed from the release coordinates.

Recomputed rather than accumulated from the per-frame previews, so rounding applied once per frame cannot add up into a final extent that differs from where the pointer actually stopped.

interface FinalizedImageOverlayInteraction extends ImageResizeResult

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 — Word's own 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

FontLoadFailureinterfaceSource ↗

One face that did not load, with whatever evidence the failure produced.

Non-fatal: [LoadFontsResult](LoadFontsResult) still carries every source that succeeded, and the affected family falls back to the engine's fixed measurement.

interface FontLoadFailure

FontMeasurementStateinterfaceSource ↗

Which measurer the current document's layout runs on, and whether shaped resolution is still in flight. Returned by [DocxEditorInstance.fontMeasurement](DocxEditorInstance.fontMeasurement).

interface FontMeasurementState

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

FontUrlSourceinterfaceSource ↗

One URL to fetch and the face it claims to be.

interface FontUrlSource

HyperlinkActivationinterfaceSource ↗

A click on a painted link, after native navigation was refused.

interface HyperlinkActivation

HyperlinkChromeHandlersinterfaceSource ↗

The host chrome that answers the engine's hyperlink gestures.

A CLICK on an external link and Ctrl/Cmd+K both mean "the user wants the link UI", and the engine deliberately does not know what that looks like. Registered rather than passed at construction because the chrome mounts after the editor does, and it survives a document reload — the surface is rebuilt, the handlers are not.

interface HyperlinkChromeHandlers

HyperlinkOpsinterfaceSource ↗

Reading and writing hyperlinks on the surface.

Every href that leaves here has already been through sanitizeHref — targets come from files, so javascript:, data: and vbscript: are dropped at the parse boundary rather than trusted to be filtered by whoever renders them.

interface HyperlinkOps

ImageCropPercentinterfaceSource ↗

Crop edge in UI percent (0–100).

interface ImageCropPercent

ImageCropPermilleinterfaceSource ↗

Crop edge in OOXML permille (0–100000).

interface ImageCropPermille

ImageDecodePortinterfaceSource ↗

The injected image decoder.

A port rather than a direct Image/createImageBitmap call, so a worker or server runtime supplies its own and the engine never reaches for a browser global.

interface ImageDecodePort

ImageInteractionSessioninterfaceSource ↗

One in-flight image drag: where it started, and everything needed to decide at commit time whether the document still describes what the gesture was planned against.

Both revisions are captured because they move independently — layout can re-flow without the package changing, and vice versa.

interface ImageInteractionSession

ImageOverlayScrollPortinterfaceSource ↗

How an image drag scrolls the page when it reaches the viewport edge.

Returns the delta ACTUALLY applied rather than the one requested, because a drag at the end of the document cannot scroll further and the overlay must not move the image by a distance the page did not travel.

interface ImageOverlayScrollPort

ImageResizeResultinterfaceSource ↗

One resize frame: the extent to store, and the box to draw while the pointer is still down.

Both, because they are different spaces — the extent is EMU for the file, the preview is points for the overlay — and computing them separately would let the handle drift from the rectangle it is dragging.

interface ImageResizeResult

ImageResourceLimitsinterfaceSource ↗

Trust-boundary caps specific to image decoding and embedding.

interface ImageResourceLimits

LoadFontsRequestinterfaceSource ↗

What to fetch, and under what limits.

Only sources is required. Each carries its own expected hash, so bytes are trusted by CONTENT rather than by origin — a swapped asset fails admission even from a trusted host.

interface LoadFontsRequest

LoadFontsResultinterfaceSource ↗

What one loadFonts call produced: the faces that arrived, plus the ones that did not.

A FontConfigurationFragment, so it composes straight into composeFontConfiguration alongside other font sources. Partial success is the normal case — compose it even with failures present.

interface LoadFontsResult extends FontConfigurationFragment

OverlayFrameRectinterfaceSource ↗

A rectangle in one page's content frame, in layout points.

interface OverlayFrameRect

PaginatedSurfaceinterfaceSource ↗

The mounted, painted, editable document — the layer createDocxEditor builds its contract on.

The painted pages ARE the editable surface: they are contenteditable, but the DOM is a picture. Browser mutations are prevented and re-expressed as tree ops, and selection maps only through data-paragraph-id/data-start, never through DOM node identity.

Every write goes through the guarded mutation path on this object. Reaching past it into session to apply ops directly bypasses the layout invalidation and the caret bookkeeping.

interface PaginatedSurface

PaginatedSurfaceOptionsinterfaceSource ↗

How a paginated surface opens. Every field is optional.

measurer is the injection seam that keeps layout DOM-free — supply one to lay a document out on a server, or leave it off in a browser to get the canvas measurer.

interface PaginatedSurfaceOptions

PaginatedSurfaceStateinterfaceSource ↗

Everything observable about the surface right now, as one immutable value.

revision is the change token: it moves whenever anything else here does, which is what lets snapshot() hand back the same reference until state actually changes.

interface PaginatedSurfaceState

ReviewModelInputinterfaceSource ↗

What the review queue derivation reads: one story part plus its comment parts.

interface ReviewModelInput

ReviewModuleContributioninterfaceSource ↗

What a review module contributes: the queue derivation, and the revision display modes the editor may enter beyond the free tier's final-state projection.

interface ReviewModuleContribution

RulerDragOptionsinterfaceSource ↗

How a ruler drag resolves: which grid it snaps to, and whether it snaps at all.

interface RulerDragOptions

RulerIndentinterfaceSource ↗

A paragraph's indent as the ruler works with it. Twips; firstLine signed.

interface RulerIndent

RulerPageMetricsinterfaceSource ↗

The page the handles are placed against. Twips.

interface RulerPageMetrics

RulerTickinterfaceSource ↗

One tick on the ruler: where it sits, how tall it is, and its label if it carries one.

interface RulerTick

RunTableChromeCommandResultinterfaceSource ↗

Result of [runTableChromeCommand](runTableChromeCommand): engine outcome plus post-pick draft on success.

interface RunTableChromeCommandResult

SectionPropertiesinterfaceSource ↗

One section's resolved w:sectPr, as layout needs it.

Resolved, not raw: defaults the file omitted are filled in here (an absent w:type is nextPage), so layout never has to know which attributes were authored and which were inherited.

interface SectionProperties

SelectedDrawingOverlayTargetinterfaceSource ↗

The painted geometry of the selected drawing, plus what the overlay is allowed to do to it.

Carries BOTH the painted rect (points, for hit-testing and handle placement) and the stored extent (EMU, for writing back), so the overlay never has to convert between the two spaces to decide what it is looking at.

interface SelectedDrawingOverlayTarget

SelectedImageStateinterfaceSource ↗

Canonical selected-image read model shared by [EditorSnapshot.image](EditorSnapshot.image) and [Editor.getSelectedImage](Editor.getSelectedImage).

interface SelectedImageState

SemanticPositioninterfaceSource ↗

A caret position in the model.

interface SemanticPosition

SemanticSelectioninterfaceSource ↗

A selection as two semantic positions — never as DOM nodes.

anchor is where the selection started and head is where it currently ends, so head before anchor is an ordinary backwards selection rather than an error. Collapsed when the two are equal, which is what a caret is.

interface SemanticSelection

SurfaceExtentinterfaceSource ↗

Surface sizing derived from layout records, in layout points (not CSS pixels).

interface SurfaceExtent

SurfaceFormattinginterfaceSource ↗

What the selection is currently formatted as.

A value is present only when EVERY span in the selection agrees on it: a selection running from 11pt into 14pt has no font size, and a toolbar should show a blank rather than pick one of the two and imply the whole selection is that.

interface SurfaceFormatting

SurfaceHyperlinkinterfaceSource ↗

A hyperlink as the surface reports it: its identity, where it sits, and the SANITIZED target. href: null is an inert link — a refused scheme or a dangling relationship — which a UI shows and offers to edit but must never offer to open.

interface SurfaceHyperlink

SurfaceNavigationinterfaceSource ↗

Moving the caret and the viewport: to a position, to a bookmark, or out to an external target.

[SurfaceNavigation.openExternal](SurfaceNavigation.openExternal) is THE external-activation call site, and it refuses anything but an already-sanitized href. Routing an authored target through some other path is how a document gets to choose where a click goes.

interface SurfaceNavigation

SurfaceOverlayCoordinatesinterfaceSource ↗

What an overlay needs to place itself over the painted pages: the zoom scale, and where each page sits horizontally.

Per-page X offsets rather than one origin, because pages are centred independently and a narrower page in a mixed-size document does not start where its neighbours do.

interface SurfaceOverlayCoordinates

TableBorderStyleOptioninterfaceSource ↗

One entry in the border-style picker, with the CSS class that draws its preview line.

interface TableBorderStyleOption

TableBorderTargetOptioninterfaceSource ↗

One entry in the border-target picker: which edges it addresses, its icon, and its label key.

interface TableBorderTargetOption

TableBorderWidthOptioninterfaceSource ↗

One entry in the border-width picker.

interface TableBorderWidthOption

TableChromeDraftinterfaceSource ↗

UI draft: last active edge scope and the complete border spec to reapply.

interface TableChromeDraft

TableChromePickinterfaceSource ↗

What one table-chrome selection produced: the command to run, and the draft to remember.

Both halves matter. A border picker is stateful — choosing "dashed" and then "outside" must apply a dashed outside border — so each pick returns the COMPLETE spec to execute alongside the draft the next pick builds on.

interface TableChromePick

TextMeasurerinterfaceSource ↗

Text measurement, injected.

A real implementation shapes with the resolved font; the tests supply a deterministic one. Layout never reads the DOM, so this is the only way width and height enter it.

interface TextMeasurer

ToolbarCommandStateinterfaceSource ↗

Whether one control is enabled, and the engine's reason when it is not.

interface ToolbarCommandState

ChromeControlIdtypeSource ↗

Every control id in the chrome, as a literal union. Unique WITHIN a group, not globally (image.insert / table.insert) — key consumers on [ChromeSlotId](ChromeSlotId).

type ChromeControlId = ChromeSlotId extends `${string}.${infer C}` ? C : never;

ChromeControlStatetypeSource ↗

HOW a control reaches the engine — never WHETHER it is enabled.

Enabled state has exactly one source: toolbarCommandState(editor, slot), which asks Editor.can. The registry is static data and cannot know what the engine will honour at this selection, in this document, at this moment.

There used to be a fourth member, parityOnly, meaning "visible but permanently disabled". It was a second, static answer to the question Editor.can already answers, and it went stale the moment the engine wired underline, strike, the four alignments, the list commands and the four value slots: the registry still said parity-only, React ignored it and ran them, and Vue believed it and rendered twelve WORKING commands permanently disabled. A slot the engine has not wired needs no registry flag — commandForSlot answers null and toolbarCommandState disables the control with the engine's own words ("not wired to an editor command").

type ChromeControlState = 
/**
 * Dispatched as one fixed engine command: enabled when
 * `Editor.can(commandForSlot(slot))` succeeds, a click runs
 * `runToolbarCommand(editor, slot)`. The command is resolved from the SLOT id
 * through `commandForSlot` in toolbar-commands.ts — the one command table both
 * adapters share. A slot with no row there is simply not wired YET, and says so
 * through the engine rather than through this descriptor.
 */
{
    readonly kind: 'command';
}
/**
 * Dispatched with a PICKED value: `commandForSlotValue(slot, value)`. Enabled when
 * the engine would honour a well-formed value right now (`toolbarCommandState`
 * probes for exactly that), so the control needs chrome that produces a value — a
 * font list, a size, a colour — before a click means anything.
 *
 * A distinct kind because 'command' cannot describe it: there is no fixed command
 * to hand `Editor.can`, and a bare click has nothing to send.
 */
 | {
    readonly kind: 'value';
}
/** `Editor.save()` — not a command (see `runSave`). */
 | {
    readonly kind: 'save';
}
/**
 * `Editor.load()` — not a command either, and the exact twin of `save`: bytes cross the
 * boundary between the host and the engine, and only the host can produce them. The
 * control needs chrome that reads a file (a picker, a drop target) before a click means
 * anything, so a bare click has nothing to send — the same reason `save` is not `command`.
 *
 * A fourth kind rather than reusing `save` because the two dispatch in opposite
 * directions, and an adapter branching on `kind` must be able to tell them apart. Unlike
 * the deleted `parityOnly`, this one IS named by a control (`file.open`).
 */
 | {
    readonly kind: 'load';
};

ChromeGroupIdtypeSource ↗

Every group id in the chrome, as a literal union. Stable public API; renaming a group id is a breaking change.

type ChromeGroupId = 'history' | 'zoom' | 'styles' | 'font' | 'text' | 'script' | 'alignment' | 'list' | 'format' | 'review' | 'contentControl' | 'image' | 'table' | 'file' | 'insert';

ChromeMenuEntrytypeSource ↗

One row of a chrome menu.

type ChromeMenuEntry = ChromeMenuItemEntry | ChromeMenuSubmenuEntry | ChromeMenuSeparatorEntry;

ChromeMenuIdtypeSource ↗

Every menu id, as a literal union. Stable public API; renaming one is a breaking change, exactly like a group or slot id.

type ChromeMenuId = 'file' | 'format' | 'insert' | 'help';

ChromeSlotIdtypeSource ↗

The public slot vocabulary: ${groupId}.${controlId} for every control that actually exists — text.bold, font.family, alignment.left. THE stable contract a host composes against and commandForSlot resolves; renaming a slot is a breaking change.

type ChromeSlotId = 'history.undo' | 'history.redo' | 'zoom.level' | 'styles.style' | 'font.family' | 'font.size' | 'text.bold' | 'text.italic' | 'text.underline' | 'text.strike' | 'text.color' | 'text.highlight' | 'text.link' | 'script.super' | 'script.sub' | 'alignment.left' | 'alignment.center' | 'alignment.right' | 'alignment.justify' | 'list.bullet' | 'list.numbered' | 'list.outdent' | 'list.indent' | 'list.lineSpacing' | 'format.clear' | 'review.comments' | 'review.editingMode' | 'contentControl.showAll' | 'contentControl.formFill' | 'contentControl.inspector' | 'contentControl.remove' | 'image.insert' | 'image.properties' | 'image.wrap' | 'image.altText' | 'table.insert' | 'table.borderTarget' | 'table.borderColor' | 'table.borderStyle' | 'table.borderWidth' | 'table.cellFill' | 'file.open' | 'file.save' | 'file.pageSetup' | 'insert.footnote' | 'insert.endnote' | 'insert.pageNumber' | 'insert.totalPages' | 'insert.sectionPages' | 'insert.pageXofY' | 'insert.pageBreak' | 'insert.sectionBreakNextPage' | 'insert.sectionBreakContinuous' | 'insert.toc';

CollectReviewItemstypeSource ↗

Derives the review queue — every pending revision decision and comment thread — from one story part plus its comment parts. Implemented by the pro review module; the free engine has no implementation and reports an empty queue.

type CollectReviewItems = (input: ReviewModelInput) => readonly ReviewItem[];

ColorLowerResulttypeSource ↗

A public colour lowered for a border or fill op, or the reason it could not be.

Refusals happen because paint needs a literal: a theme colour the document's theme does not define has no hex to draw, and inventing one would show a border in a colour the file never named.

type ColorLowerResult = {
    readonly ok: true;
    readonly color: TreeDocColorValue;
} | ColorLowerRefusal;

FontLoadFailureReasontypeSource ↗

Why one font did not load.

Distinguished rather than collapsed to "failed" because the responses differ: networkError and httpError are worth retrying, while hashMismatch and malformed mean the bytes were not what the source claimed and retrying will fetch the same wrong thing.

type FontLoadFailureReason = 'networkError' | 'httpError' | 'hashMismatch' | 'overLimit' | 'emptyResponse'
/** The declared face itself is unusable (empty family, out-of-range weight); nothing was fetched. */
 | 'invalidRequest'
/** The bytes are not a font at all — most often an HTML error page served with 200. */
 | 'malformed';

FontResolvertypeSource ↗

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

Called once per load, AFTER the file is parsed and mounted, with the families it declares; whatever it returns composes exactly like a statically supplied fragment. 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>;

ImageContexttypeSource ↗

The selected image and what may be done to it — the imageContext query's answer.

An alias of SelectedImageState, kept as its own name because it is the query's result type and chrome is written against it.

type ImageContext = SelectedImageState;

ImageResizeHandletypeSource ↗

Which of the eight resize handles a drag started from, by compass direction.

type ImageResizeHandle = 'n' | 'ne' | 'e' | 'se' | 's' | 'sw' | 'w' | 'nw';

ImageWrapTargettypeSource ↗

Nine Word wrap menu targets (inline plus eight floating modes).

type ImageWrapTarget = 'inline' | 'square' | 'squareLeft' | 'squareRight' | 'tight' | 'through' | 'topAndBottom' | 'behind' | 'inFront';

NavigationCommandtypeSource ↗

One caret movement, in Word's own vocabulary.

Visual rather than logical where the two differ: left means left on screen, which in right-to-left text is forward through the string.

type NavigationCommand = 'left' | 'right' | 'up' | 'down' | 'wordLeft' | 'wordRight' | 'lineStart' | 'lineEnd' | 'documentStart' | 'documentEnd' | 'pageUp' | 'pageDown';

OpenPaginatedResulttypeSource ↗

What opening a document produced: a mounted surface, or a refusal.

A result rather than a throw, because every refusal here comes from FILE input — a package the bounded reader rejected, a part that exceeded a limit — and a malformed upload should surface as a message the host can show rather than an exception it has to catch.

type OpenPaginatedResult = {
    readonly ok: true;
    readonly surface: PaginatedSurface;
} | {
    readonly ok: false;
    readonly reason: string;
    readonly detail?: string;
};

RenderableImageMimetypeSource ↗

Every mime the painter can hand to an <img>.

type RenderableImageMime = SupportedImageMime | VectorImageMime;

RulerIndentHandletypeSource ↗

The four handles Word's ruler carries.

hanging and left sit at the SAME position and differ only in what a drag takes with them — the box moves the whole paragraph, the triangle leaves the first line where it is.

type RulerIndentHandle = 'firstLine' | 'hanging' | 'left' | 'right';

RulerUnittypeSource ↗

Which measurement system the ruler shows. Drives both tick cadence and drag snapping.

type RulerUnit = 'inch' | 'cm';

SupportedImageMimetypeSource ↗

Raster media the decode port measures and any authoring path may write.

BMP and WebP are here for the same reason the other three are: an <img> decodes them natively, so they need a signature and a structural header and nothing else. BMP is what older documents carry; WebP is what current Word writes.

type SupportedImageMime = 'image/png' | 'image/jpeg' | 'image/gif' | 'image/bmp' | 'image/webp';

TableBorderTargetValuetypeSource ↗

Border target picker value — concrete scopes plus clear (none).

type TableBorderTargetValue = TableBorderEdgeTarget | 'none';

TableChromeSlotIdtypeSource ↗

The chrome slots that only exist while the caret is inside a table.

A subset of ChromeSlotId, so these names are public API on the same terms — renaming one is a breaking change.

type TableChromeSlotId = 'table.borderTarget' | 'table.borderColor' | 'table.borderStyle' | 'table.borderWidth' | 'table.cellFill';

TableInteractionLabelKeytypeSource ↗

Furniture insertion controls (Task 8) share this label seam.

type TableInteractionLabelKey = 'table.insertRowBelow' | 'table.insertColumnRight';

VectorImageMimetypeSource ↗

Vector media painted straight from validated bytes. An <img> renders SVG in the browser's secure static mode — no script, no external subresource loads — so there is no decode step and no raster buffer sized by a file-supplied number.

type VectorImageMime = 'image/svg+xml';

BROWSER_AUTOMATION_CAPABILITIESconstSource ↗

What a browser host can do.

selection, scrolling and layout are true because a mounted editor genuinely has a caret, a scroll container and paginated layout — a consumer may branch on them. The DOCUMENT operations behave identically to the headless host regardless; the extra capabilities widen what may be asked later, never what an existing operation means.

BROWSER_AUTOMATION_CAPABILITIES: AutomationCapabilities

CHROME_GROUPSconstSource ↗

The complete chrome, in bar order. Literal-typed (as const) so the slot-id vocabulary below is derived from the data and cannot drift from it.

Taxonomy taste: ids are short, lowercaseCamel, and never repeat their group's name (alignment.left, not alignment.alignLeft; font.family, not font.fontFamily).

CHROME_GROUPS: readonly [{
    readonly id: "history";
    readonly labelKey: "formattingBar.groups.history";
    readonly controls: readonly [{
        readonly id: "undo";
        readonly labelKey: "formattingBar.undoShortcut";
        readonly paths: readonly string[];
        readonly state: {
            readonly kind: "command";
        };
    }, {
        readonly id: "redo";
        readonly labelKey: "formattingBar.redoShortcut";
        readonly paths: readonly string[];
        readonly state: {
            readonly kind: "command";
        };
    }];
}, {
    readonly id: "zoom";
    readonly labelKey: "formattingBar.groups.zoom";
    readonly controls: readonly [{
        readonly id: "level";
        readonly shape: "stepper";
        readonly valueText: "100%";
        readonly labelKey: "formattingBar.groups.zoom";
        readonly paths: null;
        readonly valueKey: "zoom.zoomLevel";
        readonly state: {
            readonly kind: "command";
        };
    }];
}, {
    readonly id: "styles";
    readonly labelKey: "formattingBar.groups.styles";
    readonly controls: readonly [{
        readonly id: "style";
        readonly shape: "dropdown";
        readonly labelKey: "styles.selectAriaLabel";
        readonly paths: null;
        readonly valueKey: "styles.normalText";
        readonly state: {
            readonly kind: "value";
        };
    }];
}, {
    readonly id: "font";
    readonly labelKey: "formattingBar.groups.font";
    readonly controls: readonly [{
        readonly id: "family";
        readonly shape: "dropdown";
        readonly labelKey: "font.selectAriaLabel";
        readonly paths: null;
        readonly valueKey: "font.sansSerif";
        readonly state: {
            readonly kind: "value";
        };
    }, {
        readonly id: "size";
        readonly shape: "stepper";
        readonly valueText: "11";
        readonly labelKey: "fontSize.listLabel";
        readonly paths: null;
        readonly valueKey: "fontSize.label";
        readonly state: {
            readonly kind: "value";
        };
    }];
}, {
    readonly id: "text";
    readonly labelKey: "formattingBar.groups.textFormatting";
    readonly controls: readonly [{
        readonly id: "bold";
        readonly labelKey: "formattingBar.boldShortcut";
        readonly paths: readonly string[];
        readonly state: {
            readonly kind: "command";
        };
    }, {
        readonly id: "italic";
        readonly labelKey: "formattingBar.italicShortcut";
        readonly paths: readonly string[];
        readonly state: {
            readonly kind: "command";
        };
    }, {
        readonly id: "underline";
        readonly labelKey: "formattingBar.underlineShortcut";
        readonly paths: readonly string[];
        readonly state: {
            readonly kind: "command";
        };
    }, {
        readonly id: "strike";
        readonly labelKey: "formattingBar.strikethrough";
        readonly paths: readonly string[];
        readonly state: {
            readonly kind: "command";
        };
    }, {
        readonly id: "color";
        readonly shape: "colorSplit";
        readonly swatch: "#ff0000";
        readonly labelKey: "formattingBar.fontColor";
        readonly paths: readonly string[];
        readonly state: {
            readonly kind: "value";
        };
    }, {
        readonly id: "highlight";
        readonly shape: "colorSplit";
        readonly swatch: "#ffff00";
        readonly labelKey: "formattingBar.highlightColor";
        readonly paths: readonly string[];
        readonly state: {
            readonly kind: "value";
        };
    }, {
        readonly id: "link";
        readonly labelKey: "formattingBar.insertLinkShortcut";
        readonly paths: readonly string[];
        readonly state: {
            readonly kind: "command";
        };
    }];
}, {
    readonly id: "script";
    readonly labelKey: "formattingBar.groups.script";
    readonly controls: readonly [{
        readonly id: "super";
        readonly labelKey: "formattingBar.superscript";
        readonly paths: readonly string[];
        readonly state: {
            readonly kind: "command";
        };
    }, {
        readonly id: "sub";
        readonly labelKey: "formattingBar.subscript";
        readonly paths: readonly string[];
        readonly state: {
            readonly kind: "command";
        };
    }];
}, {
    readonly id: "alignment";
    readonly labelKey: "formattingBar.groups.alignment";
    readonly controls: readonly [{
        readonly id: "left";
        readonly labelKey: "alignment.alignLeft";
        readonly paths: readonly string[];
        readonly state: {
            readonly kind: "command";
        };
    }, {
        readonly id: "center";
        readonly labelKey: "alignment.center";
        readonly paths: readonly string[];
        readonly state: {
            readonly kind: "command";
        };
    }, {
        readonly id: "right";
        readonly labelKey: "alignment.alignRight";
        readonly paths: readonly string[];
        readonly state: {
            readonly kind: "command";
        };
    }, {
        readonly id: "justify";
        readonly labelKey: "alignment.justify";
        readonly paths: readonly string[];
        readonly state: {
            readonly kind: "command";
        };
    }];
}, {
    readonly id: "list";
    readonly labelKey: "formattingBar.groups.listFormatting";
    readonly controls: readonly [{
        readonly id: "bullet";
        readonly labelKey: "lists.bulletList";
        readonly paths: readonly string[];
        readonly state: {
            readonly kind: "command";
        };
    }, {
        readonly id: "numbered";
        readonly labelKey: "lists.numberedList";
        readonly paths: readonly string[];
        readonly state: {
            readonly kind: "command";
        };
    }, {
        readonly id: "outdent";
        readonly labelKey: "lists.decreaseIndent";
        readonly paths: readonly string[];
        readonly state: {
            readonly kind: "command";
        };
    }, {
        readonly id: "indent";
        readonly labelKey: "lists.increaseIndent";
        readonly paths: readonly string[];
        readonly state: {
            readonly kind: "command";
        };
    }, {
        readonly id: "lineSpacing";
        readonly shape: "dropdown";
        readonly labelKey: "lineSpacing.label";
        readonly paths: readonly string[];
        readonly state: {
            readonly kind: "command";
        };
    }];
}, {
    readonly id: "format";
    readonly labelKey: "formattingBar.clearFormatting";
    readonly controls: readonly [{
        readonly id: "clear";
        readonly labelKey: "formattingBar.clearFormatting";
        readonly paths: readonly string[];
        readonly state: {
            readonly kind: "command";
        };
    }];
}, {
    readonly id: "review";
    readonly labelKey: "formattingBar.commentsAndChanges";
    readonly controls: readonly [{
        readonly id: "comments";
        readonly shape: "icon";
        readonly labelKey: "formattingBar.commentsAndChanges";
        readonly paths: readonly string[];
        readonly state: {
            readonly kind: "command";
        };
    }, {
        readonly id: "editingMode";
        readonly shape: "dropdown";
        readonly labelKey: "editingMode.label";
        readonly valueKey: "editingMode.editing";
        readonly paths: readonly string[];
        readonly state: {
            readonly kind: "command";
        };
    }];
}, {
    readonly id: "contentControl";
    readonly labelKey: "contentControl.group";
    readonly contextual: true;
    readonly controls: readonly [{
        readonly id: "showAll";
        readonly labelKey: "contentControl.showAll";
        readonly paths: readonly string[];
        readonly state: {
            readonly kind: "command";
        };
    }, {
        readonly id: "formFill";
        readonly labelKey: "contentControl.formFill";
        readonly paths: readonly string[];
        readonly state: {
            readonly kind: "command";
        };
    }, {
        readonly id: "inspector";
        readonly labelKey: "contentControl.inspector";
        readonly paths: readonly string[];
        readonly state: {
            readonly kind: "command";
        };
    }, {
        readonly id: "remove";
        readonly labelKey: "contentControl.remove";
        readonly paths: readonly string[];
        readonly state: {
            readonly kind: "command";
        };
    }];
}, {
    readonly id: "image";
    readonly labelKey: "formattingBar.groups.image";
    readonly contextual: true;
    readonly controls: readonly [{
        readonly id: "insert";
        readonly labelKey: "toolbar.image";
        readonly paths: readonly string[];
        readonly state: {
            readonly kind: "command";
        };
    }, {
        readonly id: "properties";
        readonly labelKey: "formattingBar.imagePropertiesShortcut";
        readonly paths: readonly string[];
        readonly state: {
            readonly kind: "command";
        };
    }, {
        readonly id: "wrap";
        readonly shape: "dropdown";
        readonly labelKey: "formattingBar.imageWrap";
        readonly paths: readonly string[];
        readonly valueKey: "imageWrap.inline";
        readonly state: {
            readonly kind: "value";
        };
    }, {
        readonly id: "altText";
        readonly shape: "dropdown";
        readonly labelKey: "formattingBar.altText";
        readonly paths: null;
        readonly valueKey: "imageProperties.altText";
        readonly state: {
            readonly kind: "value";
        };
    }];
}, {
    readonly id: "table";
    readonly labelKey: "formattingBar.groups.table";
    readonly contextual: true;
    readonly controls: readonly [{
        readonly id: "insert";
        readonly labelKey: "toolbar.table";
        readonly paths: readonly string[];
        readonly state: {
            readonly kind: "command";
        };
    }, {
        readonly id: "borderTarget";
        readonly shape: "dropdown";
        readonly labelKey: "table.borders.tooltip";
        readonly paths: readonly string[];
        readonly state: {
            readonly kind: "value";
        };
    }, {
        readonly id: "borderColor";
        readonly shape: "colorSplit";
        readonly swatch: "#000000";
        readonly labelKey: "table.borderColor";
        readonly paths: readonly string[];
        readonly state: {
            readonly kind: "value";
        };
    }, {
        readonly id: "borderStyle";
        readonly shape: "dropdown";
        readonly labelKey: "table.borders.styleAriaLabel";
        readonly paths: readonly string[];
        readonly state: {
            readonly kind: "value";
        };
    }, {
        readonly id: "borderWidth";
        readonly shape: "dropdown";
        readonly labelKey: "table.borderWidth";
        readonly paths: readonly string[];
        readonly state: {
            readonly kind: "value";
        };
    }, {
        readonly id: "cellFill";
        readonly shape: "colorSplit";
        readonly swatch: "#ffffff";
        readonly labelKey: "table.cellFillColor";
        readonly paths: readonly string[];
        readonly state: {
            readonly kind: "value";
        };
    }];
}, {
    readonly id: "file";
    readonly labelKey: "toolbar.file";
    readonly contextual: true;
    readonly controls: readonly [{
        readonly id: "open";
        readonly labelKey: "toolbar.open";
        readonly paths: readonly string[];
        readonly state: {
            readonly kind: "load";
        };
    }, {
        readonly id: "save";
        readonly labelKey: "toolbar.saveShortcut";
        readonly paths: readonly string[];
        readonly state: {
            readonly kind: "save";
        };
    }, {
        readonly id: "pageSetup";
        readonly labelKey: "toolbar.pageSetup";
        readonly paths: readonly string[];
        readonly state: {
            readonly kind: "command";
        };
    }];
}, {
    readonly id: "insert";
    readonly labelKey: "toolbar.insert";
    readonly contextual: true;
    readonly controls: readonly [{
        readonly id: "footnote";
        readonly labelKey: "toolbar.insertFootnote";
        readonly paths: readonly string[];
        readonly state: {
            readonly kind: "command";
        };
    }, {
        readonly id: "endnote";
        readonly labelKey: "toolbar.insertEndnote";
        readonly paths: readonly string[];
        readonly state: {
            readonly kind: "command";
        };
    }, {
        readonly id: "pageNumber";
        readonly labelKey: "headerFooter.insertPageNumber";
        readonly paths: readonly string[];
        readonly state: {
            readonly kind: "command";
        };
    }, {
        readonly id: "totalPages";
        readonly labelKey: "headerFooter.insertTotalPages";
        readonly paths: readonly string[];
        readonly state: {
            readonly kind: "command";
        };
    }, {
        readonly id: "sectionPages";
        readonly labelKey: "headerFooter.insertSectionPages";
        readonly paths: readonly string[];
        readonly state: {
            readonly kind: "command";
        };
    }, {
        readonly id: "pageXofY";
        readonly labelKey: "headerFooter.insertPageXofY";
        readonly paths: readonly string[];
        readonly state: {
            readonly kind: "command";
        };
    }, {
        readonly id: "pageBreak";
        readonly labelKey: "toolbar.pageBreak";
        readonly paths: readonly string[];
        readonly state: {
            readonly kind: "command";
        };
    }, {
        readonly id: "sectionBreakNextPage";
        readonly labelKey: "toolbar.sectionBreakNextPage";
        readonly paths: readonly string[];
        readonly state: {
            readonly kind: "command";
        };
    }, {
        readonly id: "sectionBreakContinuous";
        readonly labelKey: "toolbar.sectionBreakContinuous";
        readonly paths: readonly string[];
        readonly state: {
            readonly kind: "command";
        };
    }, {
        readonly id: "toc";
        readonly labelKey: "toolbar.tableOfContents";
        readonly paths: readonly string[];
        readonly state: {
            readonly kind: "command";
        };
    }];
}]

CHROME_MENUSconstSource ↗

The menu bar the chrome shows above the toolbar, in bar order: File, Format, Insert, Help.

CHROME_MENUS: readonly ChromeMenu[]

CHROME_UNAVAILABLE_KEYconstSource ↗

i18n key for the tooltip on a control an ADAPTER renders but cannot drive yet — a value slot in a toolbar that has grown no picker for it, say. It is never the reason a control is disabled: when the ENGINE refuses, the tooltip is the engine's own disabledReason, never an adapter paraphrase.

CHROME_UNAVAILABLE_KEY = "formattingBar.unavailableInPreview"

DEFAULT_IMAGE_RESOURCE_LIMITSconstSource ↗

The image caps in force when a host configures none. Conservative and finite.

DEFAULT_IMAGE_RESOURCE_LIMITS: ImageResourceLimits

DEFAULT_TABLE_CHROME_DRAFTconstSource ↗

The draft a table's border chrome starts from: a 1pt black single border on every edge.

DEFAULT_TABLE_CHROME_DRAFT: TableChromeDraft

DRAWING_REL_FROM_HconstSource ↗

Legal relativeFrom bases for a horizontal offset (page, margin, column, character, …).

DRAWING_REL_FROM_H: readonly string[]

DRAWING_REL_FROM_VconstSource ↗

Legal relativeFrom bases for a vertical offset (page, margin, paragraph, line, …).

DRAWING_REL_FROM_V: readonly string[]

EMU_PER_POINTconstSource ↗

EMUs per point. DrawingML stores extents in EMU; layout works in points.

EMU_PER_POINT = 12700

IMAGE_OVERLAY_NUDGE_PTconstSource ↗

How far one arrow-key press nudges a selected image, in points.

IMAGE_OVERLAY_NUDGE_PT = 1

IMAGE_OVERLAY_NUDGE_SHIFT_PTconstSource ↗

How far Shift+arrow nudges a selected image, in points.

IMAGE_OVERLAY_NUDGE_SHIFT_PT = 10

IMAGE_WRAP_TARGETSconstSource ↗

Every text-wrap mode a drawing may be set to, including inline.

IMAGE_WRAP_TARGETS: readonly ImageWrapTarget[]

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

PX_PER_CMconstSource ↗

Painted pixels per centimetre, derived from [PX_PER_INCH](PX_PER_INCH).

PX_PER_CM: number

PX_PER_INCHconstSource ↗

The engine paints at 96 px per inch (twips / 15, 1440 twips per inch).

PX_PER_INCH = 96

SNAP_TWIPS_CMconstSource ↗

The centimetre ruler's grid is the millimetre.

SNAP_TWIPS_CM: number

SNAP_TWIPS_INCHconstSource ↗

Word snaps ruler drags to the eighth-inch grid its ticks already draw.

SNAP_TWIPS_INCH: number

TABLE_BORDER_STYLE_OPTIONSconstSource ↗

The border-style picker's entries.

TABLE_BORDER_STYLE_OPTIONS: readonly TableBorderStyleOption[]

TABLE_BORDER_TARGET_OPTIONSconstSource ↗

The border-target picker's entries, in Word's own order, ending with clear.

TABLE_BORDER_TARGET_OPTIONS: readonly TableBorderTargetOption[]

TABLE_BORDER_WIDTH_OPTIONSconstSource ↗

Widths in eighths of a point — Word-like presets.

TABLE_BORDER_WIDTH_OPTIONS: readonly TableBorderWidthOption[]

TABLE_CHROME_SLOT_IDSconstSource ↗

Every [TableChromeSlotId](TableChromeSlotId), for iteration and for [isTableChromeSlot](isTableChromeSlot).

TABLE_CHROME_SLOT_IDS: readonly TableChromeSlotId[]

TWIPS_PER_CMconstSource ↗

Twips per centimetre, as Word rounds them.

TWIPS_PER_CM = 567

TWIPS_PER_INCHconstSource ↗

Twips per inch, as OOXML defines them.

TWIPS_PER_INCH = 1440

WORD_DEFAULT_FONTconstSource ↗

Word's document default when nothing else says otherwise: Calibri at 11pt.

WORD_DEFAULT_FONT: FontConfiguration['defaultFont']