@pptx-editor.dev/core/editor

animationEffectLabelKeyfunctionSource ↗

The i18n key of an effect's name: its preset, else its class.

declare function animationEffectLabelKey(effect: Pick<AnimationEffect, 'preset' | 'effectClass'>): `panel.animations.presets.${AnimationPreset}` | `panel.animations.classes.${AnimationEffect['effectClass']}`;

animationListPartsfunctionSource ↗

The effects that the pane lists as the main sequence, and the others.

declare function animationListParts(effects: readonly AnimationEffect[]): {
    readonly main: readonly AnimationEffect[];
    readonly other: readonly AnimationEffect[];
};

animationStartLabelfunctionSource ↗

When an effect starts, for its row (see [AnimationStartLabel](AnimationStartLabel)).

declare function animationStartLabel(effect: Pick<AnimationEffect, 'sequence' | 'step' | 'trigger' | 'triggerShapeName'>): AnimationStartLabel;

bindHistoryGroupfunctionSource ↗

Bind the native gesture events of element. A native color change commits the value. Range and repeat controls end on pointer release or cancel, or on key release, also outside the element. A control with no terminal event ends on the next activation, Escape, blur, or disposal. A terminal event closes the group after it propagates, so the final value joins the same group.

declare function bindHistoryGroup(editor: HistoryGroupHost, element: HTMLElement, config: HistoryGroupBindingOptions): HistoryGroupBinding;

canQueryLocalFontsfunctionSource ↗

Whether the browser offers the Local Font Access API.

declare function canQueryLocalFonts(): boolean;

chartAxisTitleLabelsfunctionSource ↗

The labels of the two axis title fields: category and value, or X and Y.

declare function chartAxisTitleLabels(format: ChartFormat): {
    readonly category: 'chartFormat.categoryAxisTitle' | 'chartFormat.xAxisTitle';
    readonly value: 'chartFormat.valueAxisTitle' | 'chartFormat.yAxisTitle';
};

chartColorCommandfunctionSource ↗

The setChartColor command of a pick in the color field of series or point index.

declare function chartColorCommand(index: number, pick: ColorPick): EditorCommand | null;

chartColorPickfunctionSource ↗

The pick of a color field for one series or point: auto for its automatic color.

chartColorPick: (entry: ChartColorEntry) => ColorPick

chartPaneCommandfunctionSource ↗

The setChartData command of one change to the chart's current data, or why the typed text is refused. Every series and category keeps its source, so formatting stays with it. A value that is the same as before still gives a command; the pane skips unchanged fields.

declare function chartPaneCommand(data: ChartData, change: ChartPaneChange): ChartPaneResult;

chartPaneNumericXfunctionSource ↗

Whether the categories of data are numbers that the tab checks: the X values of a scatter chart, unless the chart names them as text.

declare function chartPaneNumericX(data: Pick<ChartData, 'kind' | 'categories'>): boolean;

chartSeriesNotefunctionSource ↗

The note of a pie chart with more than one series: it draws the first one only.

declare function chartSeriesNote(format: ChartFormat, seriesCount: number): 'chartFormat.pieFirstSeries' | null;

chartTitleCommandfunctionSource ↗

The setChartFormat command of a typed title: an empty or blank title turns the title (or the axis title) off. Null when the text is what the chart shows already.

declare function chartTitleCommand(format: ChartFormat, field: 'title' | 'categoryAxisTitle' | 'valueAxisTitle', text: string): EditorCommand | null;

chartTypeChangeNotefunctionSource ↗

The note after a type change, when the new type drops what the user set: the colors move between series and points, or the axes and their titles go. Undo restores them. Null when the new type keeps everything.

declare function chartTypeChangeNote(before: ChartFormat, after: ChartFormat): 'chartFormat.typeChangeRemoved' | null;

chartTypeHintfunctionSource ↗

The hint before a type change: the chart has colors or axis titles that some types cannot keep. Null when it has none.

declare function chartTypeHint(format: ChartFormat): 'chartFormat.typeChangeHint' | null;

chartValueTextfunctionSource ↗

A value as its field shows it: empty for no value.

chartValueText: (v: number | null | undefined) => string

chromeControlForSlotfunctionSource ↗

The registry entry behind a slot, or null for an id the registry does not hold.

declare function chromeControlForSlot(slot: ChromeSlotId): ChromeControl | null;

chromeOfferedControlfunctionSource ↗

The control a slot shows in this build: its registry entry without the options whose result does not paint, and without an option group that has no option left. Pass editor to keep the rows that remove an effect the selection has (No Reflection, No Glow, No Soft Edges): removing an effect needs no renderer, so a community build can remove an effect that is in the file. No Shadow always stays, and it also removes an inner shadow. With the @pptx-editor.dev/pro/drawing module installed, or for a slot with no such option, it is the control itself. The same choices give the same object. The adapters read it again on each editor change and after each install (subscribeDrawingRenderers), so their menus follow the selection. A custom control does the same.

declare function chromeOfferedControl(slot: ChromeSlotId, control: ChromeControl, editor?: Pick<Editor, 'can'> | null): ChromeControl;

chromeOptionCheckedfunctionSource ↗

Whether a dropdown option is checked: the slot's value is the option, or, for a slot whose options have groups (Shape Effects), one of its space-separated choices. Use it in a host's own menu: chromeOptionChecked(cmd.value, 'shadow.outerTop').

declare function chromeOptionChecked(value: unknown, option: string): boolean;

chromeSlotIdsfunctionSource ↗

Every slot id, derived from the registry.

declare function chromeSlotIds(): ChromeSlotId[];

chromeSlotIsTogglefunctionSource ↗

Whether a slot's control is a two-state toggle that carries aria-pressed. It reads the registry's toggle flag, so an adapter never hand-lists the toggle slots.

declare function chromeSlotIsToggle(slot: ChromeSlotId): boolean;

collaborationPortfunctionSource ↗

The port over one store. Exported for the pro package's tests and for headless hosts.

declare function collaborationPort(store: PptxDocumentStore): CollaborationDocumentPort;

commandForSlotfunctionSource ↗

The fixed command behind a command slot, or null.

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

commandForSlotValuefunctionSource ↗

The command a value slot dispatches for a picked value, or null when the value is invalid. Most slots take the value of one of their options. font.size takes a number of points, or { step: 1 } / { step: -1 } for Increase and Decrease Font Size (the size list). The table border slots draw with the border pen of editor (tableBorderPen), or with the default pen when no editor is given.

declare function commandForSlotValue(slot: ChromeSlotId, value: unknown, editor?: Editor | null): EditorCommand | null;

commentInitialsfunctionSource ↗

The avatar text of a comment: its own initials (up to three characters), else the first letters of the first two words of the author's name, else "?".

declare function commentInitials(comment: {
    readonly initials: string;
    readonly author: string;
}): string;

compilefunctionSource ↗

Compile a command against a fresh batch over the store's package (or ctx.base). Throws CommandRefusal. A batch marked armedCaret holds a format armed at a caret for the text typed next: the editor keeps it as session state (caret-arm.ts) and commits it only with that text, so a host that compiles commands itself must not commit such a batch alone.

declare function compile(ctx: CommandContext, command: EditorCommand): {
    batch: OpBatch;
    effect: CommandEffect;
};

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;

createBrowserAutomationHostfunctionSource ↗

An automation host over a live editor. Each batch writes to the editor's store as one undo step; selection operations read and move the reader's selection. The host does not save: the editor owns its document.

declare function createBrowserAutomationHost(editor: PptxEditorInstance): AutomationHost;

createCollaborationStatusTrackerfunctionSource ↗

Create a status tracker.

declare function createCollaborationStatusTracker(initial?: CollaborationStatus): CollaborationStatusTracker;

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$1;
} | {
    readonly failure: FontLoadFailure;
};

createPptxEditorfunctionSource ↗

Create an editor. Load a document with options.document or load(bytes).

declare function createPptxEditor(options?: PptxEditorOptions): PptxEditorInstance;

currentSlideSummaryfunctionSource ↗

The slides entry of the slide or template on the canvas. In the slide master view, currentSlide is a template index, not a position in slides, so slides[currentSlide] is undefined there: read the current entry with this function.

declare function currentSlideSummary(snapshot: Pick<EditorSnapshot, 'currentSlide' | 'slides'>): SlideSummary | undefined;

customFontsfunctionSource ↗

Supply application fonts without manual resolver wiring.

Loads all listed faces when the editor resolves fonts, including families the document does not use yet. This makes company fonts available in the font picker for new documents. Faces supplied by earlier origins are skipped by family, weight, and style; family matching ignores case. URLs always come from sources, never from document text.

Uses [loadFonts](loadFonts) for validation, optional hash checks, and browser caching. The editor registers the returned bytes under private aliases. This function does not change the document's selected fonts or register page-wide family names.

Constructing the resolver does not fetch. Cancellation of the document load rejects with signal.reason, without warnings or onFailure calls. Other face failures are reported once per resolution, and successful faces remain available to the editor.

ts const fonts = useFonts( customFonts({ sources: companyFontFiles, onFailure: reportFontFailure }), packagedFonts(), googleFonts(), );

Use [loadFonts](loadFonts) directly to load every listed face eagerly.

declare function customFonts(options: CustomFontsOptions): CustomFontsResolver;

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

drawingClipboardPayloadfunctionSource ↗

Turn a DrawingML clipboard package into this editor's shape clipboard payload, to paste with the paste command. The package is the bytes of the system clipboard type in [DRAWING_CLIPBOARD_TYPES](DRAWING_CLIPBOARD_TYPES), which presentation applications write for copied shapes. Shapes, pictures, connectors, groups, and tables convert; charts, diagrams, and embedded objects need parts that do not travel and stay behind. Returns null when the bytes are not such a package, hold no shape that converts, or exceed the limits of a paste. The bytes are untrusted: the package reads within size limits, and the paste validates the payload again.

declare function drawingClipboardPayload(bytes: Uint8Array): ClipboardPayload | null;

editorHostDocumentfunctionSource ↗

The document that editor's slide is mounted in: an iframe's when the host mounted the editor there, else the page's own. Before the slide mounts, the page's document. Null with no DOM, as during server rendering.

declare function editorHostDocument(editor: object): Document | null;

embeddedFontSourcesfunctionSource ↗

Decode the presentation's embedded fonts in memory, honoring embedding permissions.

declare function embeddedFontSources(pkg: PptxPackage): {
    sources: FontSource[];
    refused: string[];
};

exportSlidePngfunctionSource ↗

Slide index as a PNG of options.width pixels (default 1920), drawn from the editor's own paint. It waits for the slide's EMF and WMF pictures (session.picturesReady); one that is not ready after options.picturesTimeoutMs (default 30 seconds) draws as the placeholder. To know whether every picture draws, await picturesReady first. Rejects with a CommandRefusal (errors.exportSize, errors.exportFailed).

declare function exportSlidePng(session: DocumentSession, index: number, options?: SlideImageOptions): Promise<Blob>;

exportSlidesPngZipfunctionSource ↗

Every slide as a PNG in one ZIP archive (slide-01.png, slide-02.png, …), written by the package's bounded ZIP writer.

declare function exportSlidesPngZip(session: DocumentSession, options?: SlideImageOptions): Promise<Uint8Array>;

exportSlideSvgfunctionSource ↗

Slide index as a standalone SVG document. See the file comment for the fonts it holds. An EMF or WMF picture exports as the placeholder until it has converted: await session.picturesReady(index) first.

declare function exportSlideSvg(session: DocumentSession, index: number, options?: SlideImageOptions): string;

fitSlideToScreenfunctionSource ↗

Fit a slide into a screen, keeping its aspect ratio, centered. The box edges fall on whole device pixels (dpr), so the slide is sharp and the bars do not bleed.

declare function fitSlideToScreen(screenWidth: number, screenHeight: number, slideWidth: number, slideHeight: number, dpr?: number): SlideshowFit;

formattingBarChromeGroupsfunctionSource ↗

The groups the formatting bar shows: every group that is not contextual, without the controls marked defaultToolbar: false, and the contextual image group while every selected element is a picture (EditorSnapshot.image), as DOCX Editor's bar adds its image group for a selected drawing. The same array comes back for the same answer.

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

galleryFormatfunctionSource ↗

The bullet format of a gallery key, or undefined for a key the gallery does not have.

declare function galleryFormat(gallery: readonly ListGalleryItem[], key: unknown): BulletFormat | null | undefined;

galleryKeyOffunctionSource ↗

The gallery key of a bullet format: none for no list, undefined when the gallery has no such item.

declare function galleryKeyOf(gallery: readonly ListGalleryItem[], state: BulletFormatRead | null | undefined): string | undefined;

imageMimefunctionSource ↗

The image MIME type a part name maps to, or undefined when the browser cannot draw it.

declare function imageMime(partName: string): string | undefined;

isCollaborationFailureCodefunctionSource ↗

True when value is a [CollaborationFailureCode](CollaborationFailureCode) member.

declare function isCollaborationFailureCode(value: string): value is CollaborationFailureCode;

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;

isTableChromeSlotfunctionSource ↗

Whether a slot is one of the table-only ones, as DOCX Editor's isTableChromeSlot.

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

linkKindOffunctionSource ↗

The kind of a link draft: mailto: is email, #custom-show- a custom show, any other # form a slide, ./ and ../ a file, else a web address.

declare function linkKindOf(url: string): LinkKind;

listenPaneRequestsfunctionSource ↗

Listen for requests to show a side panel tab for editor. A mounted side panel listens and turns to the tab. Listen in your host too, to show the side panel when it is closed. While at least one listener is registered, the toolbar's Selection pane and Format shape controls are on. Returns the function that stops listening.

declare function listenPaneRequests(editor: object, open: (pane: SidePanelTab, request: PaneRequest) => void): () => void;

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. Cancellation instead rejects with signal.reason. Compose the result with composeFontConfiguration.

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

mailtoPartsfunctionSource ↗

The address, subject, and other fields of a mailto: draft; any other draft gives none.

declare function mailtoParts(url: string): MailtoParts;

mailtoUrlfunctionSource ↗

The mailto: draft of an address, a subject, and the other fields of the link. The address and the subject are percent-encoded where needed, so their text cannot add other fields. An empty address gives an empty draft, which Apply cannot send.

declare function mailtoUrl(address: string, subject: string, rest?: string): string;

namedFamiliesfunctionSource ↗

Every family the deck names for measured text: run fonts, symbol fonts, bullet fonts, and the theme's font scheme. Cached per part identity, so an edit rescans only the parts it changed. After an edit that keeps the slide list, the count of the last package changes by the changed parts only, so a keystroke walks no other part. The result is the one a full pass gives.

declare function namedFamilies(pkg: PptxPackage): string[];

nextChartCategoryLabelfunctionSource ↗

The label of a new category: the next X value of a scatter chart with number X values, else fallback.

declare function nextChartCategoryLabel(data: Pick<ChartData, 'kind' | 'categories'>, fallback: string): string;

normalizeFontResolverResultfunctionSource ↗

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

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

notesTextfunctionSource ↗

Speaker notes of slide index as plain text (paragraphs and line breaks as newlines).

declare function notesText(pkg: PptxPackage, index: number): string;

onEditorEventfunctionSource ↗

Call handler each time event happens on editor. Returns the unsubscribe function. The adapters' useEditorEvent hooks use it; a host without an adapter can call it too.

declare function onEditorEvent<E extends keyof PptxEditorEvents>(editor: EventSource, event: E, handler: PptxEditorEvents[E]): () => void;

```ts
const off = onEditorEvent(editor, 'rejection', (rejection) => console.warn(rejection.reason));
```

onEditorHostChangefunctionSource ↗

Call listener each time editor's slide moves to another document, as DOCX Editor's hostChange event. Returns the function that stops.

declare function onEditorHostChange(editor: object, listener: () => void): () => void;

openFailureReportfunctionSource ↗

Plain text that describes a refused open, for a person to copy and send with a support request: the code, the reason, the editor version, the browser, and the time. It holds no file content and no file name. The text is in English, for the support team that reads it, whatever the editor's locale. **Copy details** in PptxEditor.OpenFailure copies it.

declare function openFailureReport(failure: DocumentOpenFailure, context?: OpenFailureReportContext): string;

openPresentationfunctionSource ↗

Open .pptx bytes. Never throws for a malformed file: it returns the typed reason.

declare function openPresentation(bytes: Uint8Array, options?: OpenOptions): Promise<{
    ok: true;
    session: DocumentSession;
} | {
    ok: false;
    error: OpenError;
}>;

paintSlideshowSlidefunctionSource ↗

Paint slide index of a session for the show: an <svg> without editing hooks, with its text and the alt text of its pictures for assistive technology. The caller sizes it (see fitSlideToScreen). Returns null for a slide that does not exist.

declare function paintSlideshowSlide(doc: Document, session: DocumentSession, index: number, options?: SlideshowPaintOptions): SVGSVGElement | null;

parseChartValuefunctionSource ↗

The number a value field holds, null when it is empty, or undefined for other text.

declare function parseChartValue(text: string): number | null | undefined;

parseSecondsfunctionSource ↗

Seconds typed in a field, as milliseconds, or null when the text is not a number of seconds from 0 to 3,600. A comma is a decimal separator.

declare function parseSeconds(text: string): number | null;

queryLocalFontSourcesfunctionSource ↗

Read the regular, bold, italic, and bold italic faces of families from the computer. Must be called from a user gesture (a click). Font collections (.ttc) are skipped.

declare function queryLocalFontSources(families: readonly string[]): Promise<LocalFontsOutcome>;

readCommentThreadsfunctionSource ↗

The comment threads of a slide part, in file order: its legacy comments (ECMA-376 Part 1, 19.4), then its threaded comments. For hosts and modules that read a package without an editor. Text and names come from the file: show them as text.

declare function readCommentThreads(pkg: PptxPackage, slidePart: string): readonly CommentThread[];

registerCommentDraftfunctionSource ↗

Register the function that opens a new comment draft for editor. A mounted comments pane registers one; the New comment row of the canvas context menus calls the latest. A request made at most a second before, while no pane was mounted, reaches the opener now: the host showed the pane for it. Returns the function that unregisters.

declare function registerCommentDraft(editor: object, open: () => void): () => void;

requestCommentDraftfunctionSource ↗

Ask for a new comment draft. A mounted comments pane opens it. Otherwise the request asks for the **Comments** tab (requestPane), and the pane that mounts within a second opens it. Returns false when nothing can answer.

declare function requestCommentDraft(editor: object): boolean;

requestPanefunctionSource ↗

Ask to show the side panel tab pane for editor. Every listener hears it; the host decides what an answer means. Returns false when nothing listens. A listener that throws does not stop the others; the first error is thrown after all of them ran.

declare function requestPane(editor: object, pane: SidePanelTab, options?: {
    readonly focus?: boolean;
}): boolean;

resolveEditorModulesfunctionSource ↗

Resolve construction-time modules. The first module of each kind wins: two review or two collaboration modules is a configuration mistake, and merging them would leave neither author able to say which one runs. The second is ignored, not thrown, as in DOCX Editor.

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

reviewAuthorSlotColorfunctionSource ↗

The slot's color, as the token reference that every surface resolves through CSS.

declare function reviewAuthorSlotColor(slot: number): string;

ribbonContextActivefunctionSource ↗

Whether a contextual tab's context holds for snapshot.

declare function ribbonContextActive(snapshot: RibbonSelection, context: RibbonContext): boolean;

ribbonTabGroupsfunctionSource ↗

The groups of tab that the registry holds, in the tab's order. A picked group keeps only the picked controls. An id or a control the registry does not hold is skipped.

declare function ribbonTabGroups(tab: RibbonTab, groups?: readonly ChromeGroup[]): ChromeGroup[];

ribbonTabsfunctionSource ↗

The tabs to show for snapshot, with their groups: every tab with groups, and a contextual tab only while its context holds. The Quick Access Toolbar comes first.

declare function ribbonTabs(snapshot: RibbonSelection, groups?: readonly ChromeGroup[]): RibbonTabLayout[];

runToolbarCommandfunctionSource ↗

Run a slot's command (or its value command). Options come last, as in DOCX Editor: pass { historyGroup } to make the steps of one gesture (a slider drag) one undo step. A slot without a value takes undefined as its value.

declare function runToolbarCommand<K extends ChromeSlotId>(editor: Editor | null, id: K, value?: ToolbarSlotValue<K>, options?: EditorExecOptions): CommandResult;

```ts
const drag = editor.beginHistoryGroup();
runToolbarCommand(editor, 'font.size', 20, { historyGroup: drag });
runToolbarCommand(editor, 'font.size', 24, { historyGroup: drag });
drag.end(); // one undo step
```

safeParticipantColorfunctionSource ↗

The participant color if it is a plain hex color; anything else falls back to CSS.

declare function safeParticipantColor(value: string | undefined): string | undefined;

secondsTextfunctionSource ↗

Milliseconds as seconds for a field: two decimals at most, no trailing zeros.

declare function secondsText(ms: number): string;

shapePreviewfunctionSource ↗

The preview of a preset, from its spec geometry. Null for an unknown preset.

declare function shapePreview(preset: string): ShapePreview | null;

slideLinkChoicesfunctionSource ↗

The slide targets the form lists: the four jumps, then each slide by number.

declare function slideLinkChoices(slideCount: number): readonly string[];

slideLinkLabelfunctionSource ↗

The words for a slide link, such as "Slide 3" or "Next slide"; '' for any other draft.

declare function slideLinkLabel(t: Translate, url: string): string;

slideshowLinkAtfunctionSource ↗

The hyperlink under a slide point (EMU), as a URL safe to open, or null. Only text links (a:hlinkClick on a run) count. An external target passes sanitizeHref, which withholds any scheme other than http(s), mailto, tel, and ftp; a relative path (a link to another file) and a program link give null. A custom show link gives null: the show does not run it. A link to a slide of the deck comes back in its # form (#slide-3, #next-slide), for followSlideshowLink.

declare function slideshowLinkAt(session: DocumentSession, index: number, x: number, y: number): string | null;

slideshowShortcutfunctionSource ↗

The show a key starts, by the slide show shortcuts: F5 and Ctrl/Cmd+Shift+Enter from the start; Shift+F5 and Ctrl/Cmd+Enter from the current slide. Null for any other key.

declare function slideshowShortcut(event: SlideshowKey): 'start' | 'current' | null;

substituteFamiliesForfunctionSource ↗

The substitute families a deck needs: every typeface it names, plus the Arial fallback.

declare function substituteFamiliesFor(pkg: PptxPackage): DefaultFamily[];

tableBorderPenfunctionSource ↗

The border pen of editor (snapshot.tableBorderPen), or the default pen.

declare function tableBorderPen(editor: Editor | null | undefined): TableBorderPen;

tableChromeVisiblefunctionSource ↗

Contextual table chrome shows while the engine reports a table, as DOCX Editor's.

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

textClipboardParagraphsfunctionSource ↗

DrawingML paragraphs for the pasteText command, from clipboard HTML or plain text: HTML keeps its formatting as a paste from another application does. Use it to paste text from your own code. HTML is read up to 4 MB and 5,000 paragraphs; nothing in it runs or loads. Returns an empty array when there is no text.

declare function textClipboardParagraphs(source: {
    readonly html?: string;
    readonly text?: string;
}): ClipboardNode[];

toolbarCommandStatefunctionSource ↗

Enabled and active state of a slot: the ONE source of truth for both.

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

transitionKindLabelKeyfunctionSource ↗

The i18n key of a transition kind.

transitionKindLabelKey: (kind: SlideTransitionState["kind"]) => `panel.animations.kinds.${SlideTransitionState["kind"]}`

translateKeyOrTextfunctionSource ↗

Translate a key that arrives as a plain string, such as an engine refusal reason. A string that is not a catalog key shows as itself, as the translator shows any gap. Use it to show useEditorCommand(slotId).disabledReason in your own chrome.

declare function translateKeyOrText(t: Translate, key: string, params?: TranslationParams): string;

withFontOriginfunctionSource ↗

Add a font origin after the host's current fonts, as the next origin in first-wins order. The host's faces keep precedence; the added origin answers only for what they leave open. Pass the result to setFonts, for example editor.setFonts(withFontOrigin(editor.fonts, sources )).

declare function withFontOrigin(current: EditorFontsOption | undefined, added: FontOrigin): EditorFontsOption;

CommandRefusalclassSource ↗

Thrown inside a command builder to abort the whole transaction with a reason.

declare class CommandRefusal extends Error

DocumentSessionclassSource ↗

declare class DocumentSession

EditorFontErrorclassSource ↗

Typed adapter error reported both through onFontError and accessible alert UI.

declare class EditorFontError extends Error

OpBatchclassSource ↗

declare class OpBatch

SlideshowControllerclassSource ↗

Navigation state of one slide show. Create one per show; it ends itself (done) on Escape or after the end screen.

declare class SlideshowController

AltTextinterfaceSource ↗

The alt text of an element (p:cNvPr).

interface AltText

AnimationEffect_2interface

One effect of a slide, in the order the slide plays it.

interface AnimationEffect

BulletFormatMixedinterfaceSource ↗

What the selected paragraphs share when their bullet formats differ, so the Bullets and Numbering dialog opens on their list's tab and shows the values they have in common.

interface BulletFormatMixed

BulletsDialogFieldsinterfaceSource ↗

Every field of the form. '' is a blank: the selected paragraphs differ.

interface BulletsDialogFields

ChartColorEntryinterfaceSource ↗

The color of one series, or of one data point of a pie or doughnut chart.

interface ChartColorEntry

ChartDatainterfaceSource ↗

The data of one chart: its categories and its series.

interface ChartData

ChartDataCategoryinterfaceSource ↗

One category (or X value) of a chart.

interface ChartDataCategory

ChartDataSeriesinterfaceSource ↗

One series of a chart.

interface ChartDataSeries

ChartFormatinterfaceSource ↗

The type and elements of a chart, as chartFormat reads them. A field is null when the chart type has no such element: a pie chart has no axes.

interface ChartFormat

ChartFormatChangeinterfaceSource ↗

The chart elements that setChartFormat changes. An absent field keeps its value. A title of null removes the title; a string sets its text and keeps its formatting.

interface ChartFormatChange

ChromeControlinterfaceSource ↗

One toolbar control.

interface ChromeControl

ChromeGroupinterfaceSource ↗

One toolbar group.

interface ChromeGroup

ChromeMenuinterfaceSource ↗

One menu of the menu bar.

interface ChromeMenu

ChromeMenuItemEntryinterfaceSource ↗

A row that runs one chrome slot.

interface ChromeMenuItemEntry

ChromeMenuSeparatorEntryinterfaceSource ↗

A line between groups of rows.

interface ChromeMenuSeparatorEntry

ChromeMenuSubmenuEntryinterfaceSource ↗

A row that opens a nested panel of rows. It has no command of its own.

interface ChromeMenuSubmenuEntry

ClipboardNodeinterfaceSource ↗

A serialized element, structurally the store's NodeSpec.

interface ClipboardNode

ClipboardPayloadinterfaceSource ↗

The clipboard format for shapes (application/x-pptx-editor+json).

interface ClipboardPayload

ClipboardRelationshipinterfaceSource ↗

A relationship a copied shape uses, with the bytes of its target. A chart, a diagram, or an embedded object carries its own relationships in relationships. A web link carries its address in target and no bytes. A link to a slide names the slide part and carries no bytes; paste keeps it only in the presentation it came from.

interface ClipboardRelationship

CollaborationDocumentPortinterfaceSource ↗

What the editor gives a collaboration session: the document as ops in and ops out. The session owns transport, ordering, and conflict handling; the port never reads the DOM or the clock.

interface CollaborationDocumentPort

CollaborationFailureinterfaceSource ↗

One collaboration failure: a typed code plus optional free-form detail.

interface CollaborationFailure

CollaborationIdentityinterfaceSource ↗

Human or automation identity attached to authored collaboration transactions.

interface CollaborationIdentity

CollaborationLocalTransactioninterfaceSource ↗

One committed local change, as the replica sends it to its peers: an edit, an undo, or a redo. A state-based replica (the pro Yjs binding) diffs before and after over parts; an op-based one sends ops, which only edits carry.

interface CollaborationLocalTransaction

CollaborationModuleContributioninterfaceSource ↗

What a collaboration module contributes: the session the editor attaches.

interface CollaborationModuleContribution

CollaborationParticipantinterfaceSource ↗

One participant in a collaboration room.

interface CollaborationParticipant extends CollaborationIdentity

CollaborationRemoteSelectioninterfaceSource ↗

A peer's selection, mapped onto this replica's node ids.

interface CollaborationRemoteSelection

CollaborationSelectionMoveinterfaceSource ↗

How a remote change moved this replica's published selection: to is from re-read through the room's relative positions, after DOCX Editor's CollaborationSelectionMove.

interface CollaborationSelectionMove

CollaborationStatusSnapshotinterfaceSource ↗

Cached status read, as in DOCX Editor. Same reference until one of its fields changes.

interface CollaborationStatusSnapshot

CollaborationStatusTrackerinterfaceSource ↗

A session's status state.

interface CollaborationStatusTracker

ColumnsDialogFieldsinterfaceSource ↗

Every field of the form, as typed text. '' is a blank: the selected shapes differ.

interface ColumnsDialogFields

CommandContextinterfaceSource ↗

Editor state a command compiles against.

interface CommandContext

CommandEffectinterfaceSource ↗

What a compiled command does to editor state besides the document.

interface CommandEffect

CommentAuthorInputinterfaceSource ↗

Who writes a comment or a reply. Absent, the editor's author option (setAuthor) applies, then the collaboration identity. Without a name, the command is refused (disabled.noCommentAuthor).

interface CommentAuthorInput

CommentExpectinterfaceSource ↗

What a host showed of a comment, for a command that acts on it: pass the comment's author, date, text, and identity as the snapshot gave them. The editor refuses the command (errors.commentChanged) when the comment at commentId has another author or date.

A twin shares its GUID, author, and creation time with another comment of the slide, or, in the legacy format, its author and index. A twin's id holds its place among its twins (~<n>, or -<n> for a legacy comment). For an id with a place, the editor also compares the text (errors.commentChanged), and refuses the command when the comment has no twin left (errors.noComment): the id may have named the twin that is gone.

Without identity, an id with a place is also refused when another twin has the same text (errors.commentAmbiguous), and when it named another comment since the last snapshot (errors.commentChanged, until the next snapshot). With identity, the editor checks it instead. So a collaborator's edit of a comment without a twin never refuses yours.

Always pass identity. Without it, after the next snapshot, an old id can reach another twin with the same author, date, and text.

interface CommentExpect

CommentSnapshotinterfaceSource ↗

The comment fields of the editor snapshot (EditorSnapshot).

interface CommentSnapshot

CommentTextRangeinterfaceSource ↗

A range of a shape's text, with the points that a text selection (EditorSelection) uses. A snapshot gives start before end. addComment takes the two points in either order.

interface CommentTextRange

CommentThreadinterfaceSource ↗

A comment and its replies (EditorSnapshot.comments).

interface CommentThread extends SlideComment

ComposeFontOriginsOptionsinterfaceSource ↗

Diagnostics hook for ordered font-origin composition.

interface ComposeFontOriginsOptions

ConnectionTargetinterfaceSource ↗

A connection site of a shape: the shape's node id and the site's index.

interface ConnectionTarget

ConnectorRouteinterfaceSource ↗

A connector's route and the shapes its ends glue to. Each field is optional: an absent field keeps the connector's current value.

interface ConnectorRoute

CustomFontsOptionsinterfaceSource ↗

Options for loading application fonts when the editor resolves its font configuration.

interface CustomFontsOptions extends Omit<LoadFontsRequest, 'signal'>

CustomShowSummaryinterfaceSource ↗

A custom show of the deck (p:custShow, ECMA-376 Part 1, 19.2.1.7), for links.

interface CustomShowSummary

DateTimeStateinterfaceSource ↗

The date that the slides show (EditorSnapshot.dateTime).

interface DateTimeState

DiagramNodeStateinterfaceSource ↗

One node of the selected diagram, in outline order.

interface DiagramNodeState

DocumentOpenFailureinterfaceSource ↗

A file the editor refused to open. It carries a stable code only, never the file's content or name. Each refusal is a new object, so a host can tell a second refusal of the same file from the first.

interface DocumentOpenFailure

DocumentSearchFindOptionsinterfaceSource ↗

Options of find.

interface DocumentSearchFindOptions extends FindOptions

DocumentSearchStateinterfaceSource ↗

The state of a find session.

interface DocumentSearchState

EditorinterfaceSource ↗

The editor contract adapters render.

interface Editor

EditorCaretinterfaceSource ↗

The caret: the text box that holds it, and a paragraph and an offset in that text box, as DOCX Editor's EditorCaret. cell names the table cell when the text box is a table, and diagramNode names the data model node when the text box is a diagram shape.

interface EditorCaret

EditorCollaborationSessioninterfaceSource ↗

A ready collaboration session, created by the host before mount. The member names follow DOCX Editor's EditorCollaborationSession; selection, history, and journal members arrive with the collaboration change.

interface EditorCollaborationSession

EditorFontSubstitutioninterfaceSource ↗

A family the deck names that renders with another face.

interface EditorFontSubstitution

EditorModuleinterfaceSource ↗

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

interface EditorModule

EditorModuleRegistryinterfaceSource ↗

The resolved modules an editor instance dispatches over.

interface EditorModuleRegistry

EditorRejectioninterfaceSource ↗

A refused edit: the i18n key of the reason and an optional detail.

interface EditorRejection

EditorRemovalinterfaceSource ↗

A Delete that the user can undo: what it removed and how many.

interface EditorRemoval

EditorSnapshotinterfaceSource ↗

interface EditorSnapshot extends CommentSnapshot

FindMatchinterfaceSource ↗

One match of a find. Offsets are UTF-16 offsets in the paragraph.

interface FindMatch

FindOptionsinterfaceSource ↗

How find compares text.

interface FindOptions

FontConfigurationinterfaceSource ↗

Public font source configuration sampled when an adapter mounts. It must be immutable for that editor lifetime; remount the adapter to replace bytes or substitutions atomically.

interface FontConfiguration

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

FontDialogFieldsinterfaceSource ↗

Every field of the form. '' is a blank: the selected runs disagree.

interface FontDialogFields

FontFaceRequestinterfaceSource ↗

A concrete font face requested by authored document content.

interface FontFaceRequest

FontFormatCommandinterfaceSource ↗

The fields of the Font dialog (Font and Character Spacing tabs), as setFontFormat takes them. An omitted field keeps each run's value. The same shape as ParagraphFormatCommand.

interface FontFormatCommand

FontFormatReadinterfaceSource ↗

The selected text as the Font dialog reads it: resolved values. A field is null when the selected runs disagree (disagrees says which), so a control can show a blank.

interface FontFormatRead

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 open deck's layout runs on, and whether the host's fonts are still on the way. Returned by [PptxEditorInstance.fontMeasurement](PptxEditorInstance.fontMeasurement), as in DOCX Editor.

interface FontMeasurementState

FontOriginFailureinterfaceSource ↗

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

interface FontOriginFailure

FontPickerGroupinterfaceSource ↗

One group of the font picker, with its i18n heading key (toolbar.fontGroups.theme, toolbar.fontGroups.document, toolbar.fontGroups.all).

interface FontPickerGroup

FontPickerRowinterfaceSource ↗

One row of the font picker, as useFontFamily().groups gives it. Pass value to useFontFamily().setValue.

interface FontPickerRow

FontReportinterfaceSource ↗

Summary of the fonts a session uses, for the settings panel and the report.

interface FontReport

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 ↗

Immutable, byte-backed font face supplied to layout and browser paint.

interface FontSource

FontSourceSubstitutioninterfaceSource ↗

An explicit authored-font substitution. No implicit platform fallback is performed.

interface FontSourceSubstitution

FontSubstitutioninterfaceSource ↗

A family the deck names that measures with another face.

interface FontSubstitution

FontUrlSourceinterfaceSource ↗

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

interface FontUrlSource

GradientFillinterfaceSource ↗

A gradient fill as the chrome edits it.

interface GradientFill

HeaderFooterTargetsinterfaceSource ↗

The slides that setSlideNumbers, setFooter, and setDateTime act on.

interface HeaderFooterTargets

HistoryGroupinterfaceSource ↗

The engine-owned identity of one gesture. Create it with Editor.beginHistoryGroup().

Every command that names one open handle becomes part of one undo step. Undo, redo, and a command with another handle (or none) close the step, so a later command with the handle starts a new one. A selection change, and a command that the editor refuses before it writes, leave the step open. Redo restores the selection after the last command of the step.

interface HistoryGroup

HistoryGroupBindinginterfaceSource ↗

Dispose when the element or editor changes.

interface HistoryGroupBinding

HistoryGroupBindingOptionsinterfaceSource ↗

Native event policy for one continuous control gesture.

interface HistoryGroupBindingOptions

HistoryGroupOptionsinterfaceSource ↗

Options for a command that can join an explicit history group.

interface HistoryGroupOptions

```ts
const resize = editor.beginHistoryGroup();
editor.exec({ type: 'setTableGrid', columns: [914400, 914400] }, { historyGroup: resize });
editor.exec({ type: 'setTableGrid', columns: [1828800, 914400] }, { historyGroup: resize });
resize.end();
editor.exec({ type: 'undo' }); // reverts both commands
```

HostFacesinterfaceSource ↗

Host faces from the fonts option and its shims, after the embedded faces: the faces under their own family, and host substitutions (FontSourceSubstitution) registered under the requested family with the target family they draw.

interface HostFaces

HyperlinkPopupActionsinterfaceSource ↗

The actions of the link popup, as DOCX Editor's UseHyperlinkPopupResult.

interface HyperlinkPopupActions

HyperlinkPopupLinkinterfaceSource ↗

The link a popup shows.

interface HyperlinkPopupLink

HyperlinkPopupStateinterfaceSource ↗

The link popup's state.

interface HyperlinkPopupState

ImageAdjustmentsinterfaceSource ↗

Picture corrections, color, and transparency, as the Picture Format tab sets them.

interface ImageAdjustments

ImageCropPercentinterfaceSource ↗

The crop of each edge of a picture, in percent of the image (a:srcRect), after DOCX Editor's ImageCropPercent: a positive value removes that part of the image. Unlike DOCX Editor's 0 to 100, a value may be negative: it adds space on that side as padding (Fit writes it).

interface ImageCropPercent

ImagePropertiesinterfaceSource ↗

The Format Picture values, as DOCX Editor's setImageProperties names them. The size is the size on the slide, as the Size fields show it (SelectedImageState.widthEmu; inside a scaled group it differs from the file's a:ext), and keeps the top-left corner of the unrotated box; the crop keeps the image fixed on the slide.

interface ImageProperties

ImageRasterFontinterfaceSource ↗

One face that the SVG of a picture names: family is the name in its font-family attributes and @font-face rules, and name is the family the presentation asked for.

interface ImageRasterFont

ImageRasterRequestinterfaceSource ↗

What a rasterizer draws: a standalone SVG document of width by height pixels from the editor's own paint. Pictures are inline as data URLs. Each face is inline as an @font-face rule too, and listed in fonts for a rasterizer that does not read CSS fonts. Glyphs carry their x positions from layout, so a rasterizer never breaks a line again.

interface ImageRasterRequest

ListGalleryIteminterfaceSource ↗

One gallery item: its key, and the bullet format it applies (null turns the list off).

interface ListGalleryItem<K extends string = string>

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

LoadOptionsinterfaceSource ↗

Options of Editor.load.

interface LoadOptions

MailtoPartsinterfaceSource ↗

The fields of an email link the form edits, and the fields it keeps as they are.

interface MailtoParts

NewChartDatainterfaceSource ↗

The data of a new chart: its categories (or X values) and its series.

interface NewChartData

NotesParagraphinterfaceSource ↗

One paragraph of the speaker notes.

interface NotesParagraph

NotesRuninterfaceSource ↗

A run of the speaker notes with its character formatting.

interface NotesRun

OpBatchOptionsinterfaceSource ↗

Options for an OpBatch.

interface OpBatchOptions

OpenFailureReportContextinterfaceSource ↗

What openFailureReport adds besides the failure.

interface OpenFailureReportContext

OpenOptionsinterfaceSource ↗

Options for opening a presentation.

interface OpenOptions

PaneRequestinterfaceSource ↗

How a side panel answers a request: whether it moves the focus to the tab.

interface PaneRequest

ParagraphDialogFieldsinterfaceSource ↗

Every field of the form, as the controls hold it. '' is a blank: the selection disagrees and the user has not chosen.

interface ParagraphDialogFields

ParagraphFormatCommandinterfaceSource ↗

The fields of the Paragraph dialog, as setParagraphFormat takes them. An omitted field keeps the paragraph's value. null removes the paragraph's own value, so it takes the inherited value again (from the layout, the master, or the shape's list style); a zero is a value and blocks the inherited one.

interface ParagraphFormatCommand

ParagraphFormatReadinterfaceSource ↗

The selected paragraphs as the Paragraph dialog reads them. A field is null when the paragraphs disagree (disagrees says which), so a control can show a blank. Values are resolved: inherited values count.

interface ParagraphFormatRead

ParagraphLineSpacinginterfaceSource ↗

Line spacing as the Paragraph dialog sets it: a multiple of single spacing (a:spcPct), or exact points (a:spcPts). DOCX Editor's rule names; a:lnSpc has no "at least".

interface ParagraphLineSpacing

PatternFillinterfaceSource ↗

A preset pattern fill (a:pattFill) as the chrome edits it.

interface PatternFill

PictureStatusinterfaceSource ↗

The state of one EMF or WMF picture part (session.pictureStatus).

interface PictureStatus

PicturesWaitinterfaceSource ↗

How session.picturesReady waits.

interface PicturesWait

PptxEditorEventsinterfaceSource ↗

The events useEditorEvent subscribes to, and what each handler receives.

interface PptxEditorEvents

PptxEditorInstanceinterfaceSource ↗

The editor instance: the Editor contract plus engine extras.

interface PptxEditorInstance extends Editor

PptxEditorOptionsinterfaceSource ↗

Options for createPptxEditor.

interface PptxEditorOptions extends Omit<OpenOptions, 'fonts'>

PptxFindinterfaceSource ↗

Find and replace on an editor. Each call takes the query and options, so the find bar owns them. A step selects its match: text on a slide or in a table cell as a text selection, and speaker notes by going to the slide.

interface PptxFind

RenderThumbnailOptionsinterfaceSource ↗

Options of renderThumbnail.

interface RenderThumbnailOptions

ReviewAuthorInfointerfaceSource ↗

One review author, resolved: who, which ramp slot, and what they draw in.

interface ReviewAuthorInfo

ReviewIteminterfaceSource ↗

One entry of the review queue.

interface ReviewItem

ReviewModelInputinterfaceSource ↗

What a review module reads to build its queue.

interface ReviewModelInput

ReviewModuleContributioninterfaceSource ↗

What a review module contributes.

interface ReviewModuleContribution

ReviewPaneOptionsinterfaceSource ↗

The comment view settings of a review module. Every field is optional.

interface ReviewPaneOptions

RibbonGroupPickinterfaceSource ↗

Some controls of one registry group, in the given order.

interface RibbonGroupPick

RibbonTabinterfaceSource ↗

One ribbon tab: its title and its groups, in order. A tab names each group once: the bar keys its groups by id.

interface RibbonTab

RibbonTabLayoutinterfaceSource ↗

A tab as the ribbon shows it now: its entry and its registered groups.

interface RibbonTabLayout

SelectedChartStateinterfaceSource ↗

The selected chart, while exactly one chart frame is selected.

interface SelectedChartState

SelectedDiagramStateinterfaceSource ↗

The selected diagram, while one diagram frame is selected or holds the caret.

interface SelectedDiagramState

SelectedEquationStateinterfaceSource ↗

The selected equation: one text box with one equation is selected.

interface SelectedEquationState

SelectedImageStateinterfaceSource ↗

The selected pictures, as the picture controls show them: the values are the first picture's.

interface SelectedImageState

SelectionFormatinterfaceSource ↗

Formatting at the selection, for toolbar state.

interface SelectionFormat

SelectionGeometryinterfaceSource ↗

The selected element's geometry, for the Format panel. EMU and degrees.

interface SelectionGeometry

ShapeCategoryinterfaceSource ↗

One gallery category.

interface ShapeCategory

ShapeEffectsStateinterfaceSource ↗

The effects of the selected element as the chrome shows them. A shadow or reflection that is not a gallery preset reads other. Sizes are in points; 0 is no effect.

interface ShapeEffectsState

ShapePreviewinterfaceSource ↗

A gallery preview: SVG path data in a 0…100 box.

interface ShapePreview

ShapeStyleChoiceinterfaceSource ↗

One cell of the Shape Styles gallery.

interface ShapeStyleChoice

ShapeSummaryinterfaceSource ↗

One element of the current slide, as the selection pane lists it.

interface ShapeSummary