fika-editor 3.0.0 → 3.0.1

package/dist/types/utils/math.d.ts

@@ -0,0 +1,90 @@
+/**
+ * Shared MathLive typesetting helpers.
+ *
+ * LaTeX is the single source of truth for in-text math. It is carried on a
+ * canonical wrapper element:
+ *
+ *   <span class="fika-math" data-latex="\frac{1}{2}" data-display="false">…markup…</span>
+ *
+ * The inner markup is MathLive's `convertLatexToMarkup` output, preserved in the
+ * stored HTML so the static render paths (`v-html`) and ProseMirror round-trips
+ * never need to re-typeset existing content. MathLive (JS + `static.css` +
+ * `fonts.css`) is lazy-loaded the first time math actually appears or an editor
+ * opens, so decks without math never pull it into the bundle.
+ */
+export declare const MATH_CLASS = "fika-math";
+type ConvertLatexToMarkup = (latex: string, options?: {
+    defaultMode?: 'inline-math' | 'math' | 'text';
+}) => string;
+type ConvertLatexToMathMl = (latex: string, options?: {
+    generateID?: boolean;
+}) => string;
+interface MathliveModule {
+    convertLatexToMarkup: ConvertLatexToMarkup;
+    convertLatexToMathMl: ConvertLatexToMathMl;
+    initVirtualKeyboardInCurrentBrowsingContext?: () => void;
+    MathfieldElement: {
+        fontsDirectory: string | null;
+        soundsDirectory: string | null;
+    };
+}
+/**
+ * MathLive's default keyboard container is `document.body`. When shown it
+ * writes `padding-bottom` onto the body so page content scrolls above the
+ * keys. Fika's canvas is `height: 100%` of that body, so the padding
+ * shrinks the slide and the viewport observer refits it smaller.
+ *
+ * Dock the keyboard in a fixed overlay instead — MathLive skips the padding
+ * whenever `container !== document.body`.
+ */
+export declare function dockMathVirtualKeyboard(): void;
+/**
+ * Reactive flag flipped to `true` once MathLive has loaded. Reading it inside a
+ * render (e.g. table `formatText`) registers a dependency so the math re-renders
+ * the moment the engine becomes available.
+ */
+export declare const mathReady: {
+    value: boolean;
+};
+/** Lazily import MathLive and configure it for a bundled (offline) font setup. */
+export declare function ensureMathliveReady(): Promise<MathliveModule>;
+/** Escape a string for safe inclusion in a double-quoted HTML attribute. */
+export declare function escapeLatexAttr(latex: string): string;
+/**
+ * Render `latex` to the canonical `span.fika-math` wrapper HTML string. Must
+ * only be called once {@link ensureMathliveReady} has resolved (the markdown
+ * pipeline and editor await it; tables fall back to literal source until ready).
+ */
+export declare function renderMathToHtml(latex: string, display?: boolean): string;
+/**
+ * Build a real `span.fika-math` DOM node for the given latex/markup. Used by
+ * the ProseMirror schema `toDOM` so the editor DOM (and the innerHTML persisted
+ * on edit) is the same canonical wrapper the parser reads back.
+ */
+export declare function buildMathElement(latex: string, html: string, display?: boolean): HTMLSpanElement;
+/** Engine adapter that lets `markdown-it-texmath` typeset via MathLive. */
+export declare const texmathEngine: {
+    renderToString(latex: string, options?: {
+        displayMode?: boolean;
+    }): string;
+};
+/**
+ * Sync MathML conversion — only valid after {@link ensureMathliveReady} has resolved.
+ * Throws if MathLive is not loaded yet.
+ */
+export declare function convertLatexToMathMlSync(latex: string): string;
+/** Unscaled font-size used when measuring and painting standalone formula elements. */
+export declare const LATEX_ELEMENT_FONT_SIZE = 36;
+/**
+ * Typeset a standalone formula element. Same MathLive/KaTeX-font pipeline as
+ * inline math — not the old hfmath stroke paths.
+ */
+export declare function renderLatexElementHtml(latex: string): string;
+/** Natural box of a formula at {@link LATEX_ELEMENT_FONT_SIZE}, plus padding. */
+export declare function measureLatexElement(latex: string): Promise<{
+    width: number;
+    height: number;
+}>;
+/** True when an HTML string already contains rendered/wrapped math. */
+export declare function htmlContainsMath(html: string): boolean;
+export {};

package/dist/types/utils/mediaFile.d.ts

@@ -0,0 +1,14 @@
+import { type FikaMediaKind, type FikaMediaSizeLimit } from '../configs/mediaUpload';
+export type MediaRejectReason = 'type' | 'size' | 'kind' | 'tooMany';
+export interface MediaFileRejection {
+    file: File;
+    reason: MediaRejectReason;
+    maxSize?: number;
+}
+export declare function getFileExtension(file: File): string;
+export declare function detectMediaKind(file: File): FikaMediaKind | null;
+export declare function getKindMaxFileSize(kind: FikaMediaKind, limit?: FikaMediaSizeLimit): number | undefined;
+export declare function getAcceptAttribute(): string;
+export declare function validateMediaFile(file: File): MediaFileRejection | null;
+export declare function formatBytes(bytes: number): string;
+export declare function maxSizeLabel(): string;

package/dist/types/utils/mediaLayout.d.ts

@@ -0,0 +1,24 @@
+export interface MediaBox {
+    width: number;
+    height: number;
+}
+export declare const DEFAULT_VIDEO_SIZE: MediaBox;
+export declare const DEFAULT_AUDIO_SIZE: MediaBox;
+export declare const COMPACT_AUDIO_MAX_PX = 96;
+export declare const isCompactAudioBox: (width: number, height: number) => boolean;
+export declare const mediaPlayerHostId: (elementId: string) => string;
+export interface MediaPlacement extends MediaBox {
+    left: number;
+    top: number;
+}
+/**
+ * Symmetric row counts that read as a simple shape on a slide:
+ * pair, triangle, square, hexagon-like, etc.
+ */
+export declare const mediaRowPattern: (count: number) => number[];
+export declare const fitBox: (srcW: number, srcH: number, maxW: number, maxH: number) => MediaBox;
+/**
+ * Place boxes in a centered, symmetric bouquet. Items keep their aspect
+ * ratio and are not grouped — callers should select at most one afterwards.
+ */
+export declare const layoutMediaBoxes: (boxes: MediaBox[], canvasWidth: number, canvasHeight: number) => MediaPlacement[];

package/dist/types/utils/mediaPoster.d.ts

@@ -0,0 +1,12 @@
+export interface SynthesizeMediaPosterOptions {
+    kind: 'video' | 'audio';
+    src: string;
+    color?: string;
+    signal?: AbortSignal;
+}
+export declare const captureVideoPoster: (video: HTMLVideoElement | null, opts?: {
+    acceptBlank?: boolean;
+}) => string | null;
+export declare const synthesizeVideoPoster: (src: string, signal?: AbortSignal) => Promise<string | null>;
+export declare const synthesizeAudioPoster: (src: string, color?: string, signal?: AbortSignal) => Promise<string | null>;
+export declare const synthesizeMediaPoster: (opts: SynthesizeMediaPosterOptions) => Promise<string | null>;

package/dist/types/utils/mermaid.d.ts

@@ -0,0 +1,18 @@
+type MermaidAPI = {
+    initialize: (config: Record<string, unknown>) => void;
+    render: (id: string, code: string) => Promise<{
+        svg: string;
+    }>;
+};
+type DOMPurifyAPI = {
+    sanitize: (dirty: string, config?: Record<string, unknown>) => string;
+};
+export declare class MermaidRenderSuperseded extends Error {
+    constructor();
+}
+export declare const isMermaidRenderSuperseded: (err: unknown) => boolean;
+export declare const whenMermaidReady: () => Promise<[MermaidAPI, DOMPurifyAPI]>;
+export declare const prefetchMermaid: () => void;
+export declare const isMermaidReady: () => boolean;
+export declare const renderMermaid: (code: string, key?: string) => Promise<string>;
+export {};

package/dist/types/utils/message.d.ts

@@ -0,0 +1,27 @@
+export interface MessageOptions {
+    type?: 'info' | 'success' | 'warning' | 'error' | 'loading';
+    title?: string;
+    message?: string;
+    duration?: number;
+    closable?: boolean;
+    ctx?: unknown;
+    onClose?: () => void;
+}
+export type MessageTypeOptions = Omit<MessageOptions, 'type' | 'message'>;
+export interface MessageIntance {
+    id: string;
+    close: () => void;
+}
+export type MessageFn = (message: string, options?: MessageTypeOptions) => MessageIntance;
+export interface Message {
+    (options: MessageOptions): MessageIntance;
+    info: MessageFn;
+    success: MessageFn;
+    error: MessageFn;
+    warning: MessageFn;
+    loading: MessageFn;
+    closeAll: () => void;
+    _context?: unknown;
+}
+declare const message: Message;
+export default message;

package/dist/types/utils/object.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Copy `obj` without `keys`. Spread-then-delete so Immer drafts are not mutated in place.
+ */
+export declare function omit<T extends object>(obj: T, keys: string | string[]): T;
+/**
+ * Deep equality for JSON-like values (slides, plain objects, arrays).
+ * Key order does not matter; array order does. Cycles are compared by pairing.
+ */
+export declare function isEqual(a: unknown, b: unknown): boolean;
+export declare function arraysEqual<T>(a: readonly T[] | null | undefined, b: readonly T[] | null | undefined): boolean;

package/dist/types/utils/openContextmenu.d.ts

@@ -0,0 +1,29 @@
+import type { ContextmenuItem } from '../components/Contextmenu/types';
+export interface ContextmenuRenderProps {
+    axis: {
+        x: number;
+        y: number;
+    };
+    bounds?: {
+        width: number;
+        height: number;
+    };
+    el: HTMLElement;
+    menus: ContextmenuItem[];
+    removeContextmenu: () => void;
+}
+type Menus = ContextmenuItem[] | ((el: HTMLElement) => ContextmenuItem[] | null | undefined);
+interface ContextmenuPointerEvent {
+    stopPropagation(): void;
+    preventDefault(): void;
+    currentTarget: EventTarget | null;
+    target?: EventTarget | null;
+    clientX: number;
+    clientY: number;
+    x?: number;
+    y?: number;
+}
+type ContextmenuRenderer = (container: HTMLElement, props: ContextmenuRenderProps) => void | (() => void);
+export declare function setContextmenuRenderer(fn: ContextmenuRenderer | null): void;
+export declare function openContextmenu(event: ContextmenuPointerEvent, menusOrFn: Menus): void;
+export {};

package/dist/types/utils/placeholderLayout.d.ts

@@ -0,0 +1,64 @@
+import type { PPTTextElement, Slide, TextAlignVertical, TextInset } from '../types/slides';
+export { elementLocksTextBox, shapeTextLocksSize, textElementLocksSize } from './textBoxLock';
+export interface PlaceholderBoxMetrics {
+    placeholderFontSize?: number;
+    lineHeight?: number;
+    inset?: TextInset;
+    /** Lines of placeholder-sized text the box should fit (default 1). */
+    lines?: number;
+    paragraphSpace?: number;
+}
+/**
+ * Minimum box height from placeholder typography: vertical inset + text lines at
+ * placeholderFontSize × lineHeight (+ paragraph gaps between lines).
+ */
+export declare const computePlaceholderMinBoxHeight: (metrics?: PlaceholderBoxMetrics) => number;
+/**
+ * Empty-slot height: the larger of the quiet prompt and the typed default.
+ * Used only while the placeholder is empty. Filled auto-height hugs the text.
+ */
+export declare const computePlaceholderSlotHeight: (el: Pick<PPTTextElement, 'placeholderFontSize' | 'lineHeight' | 'inset' | 'paragraphSpace' | 'textType'> & {
+    lines?: number;
+}) => number;
+/** Fixed slot height: the larger of the two paints, never smaller than a stored layout height. */
+export declare const getPlaceholderBaselineHeight: (el: PPTTextElement) => number;
+export declare const isPlaceholderElement: (el: PPTTextElement) => boolean;
+/** Title placeholder on content slides (slide 2+): left-aligned, vertically centered in the layout box. */
+export declare const isContentSlideTitlePlaceholder: (el: PPTTextElement, slideType?: Slide['type']) => boolean;
+export interface TextBoxLayout {
+    fixedHeight: boolean;
+    vAlign: TextAlignVertical;
+    /** Flex-column vertical centering without locking box height (content slides title). */
+    flexCenterInLayoutBox: boolean;
+    /**
+     * Definite `height` (not `auto`). True for explicit fixed-height and for an
+     * *empty* placeholder slot (dashed box + centered prompt). A filled
+     * auto-height title/subtitle unlocks so the box can grow with the text.
+     */
+    lockPaintHeight: boolean;
+}
+export declare const V_ALIGN_JUSTIFY: {
+    readonly top: 'flex-start';
+    readonly middle: 'center';
+    readonly bottom: 'flex-end';
+};
+export declare const resolveTextBoxLayout: (el: PPTTextElement, slideType?: Slide['type'], contentEmpty?: boolean) => TextBoxLayout;
+/**
+ * Live paint mode. `fit` shrinks type; `grow` grows the box; `slot` is the
+ * empty dashed placeholder (definite height, no shrink-to-fit).
+ */
+export type TextBoxLiveMode = 'grow' | 'fit' | 'slot';
+export declare const textBoxLiveMode: (el: Pick<PPTTextElement, 'fixedHeight' | 'vertical'>, layout: TextBoxLayout) => TextBoxLiveMode;
+/** Painted size for unmarked runs. Placeholder/title slots use the typed size, not 16. */
+export declare const authoredTextFitSize: (el: Pick<PPTTextElement, 'placeholder' | 'placeholderFontSize' | 'textType'>) => number;
+export declare const textBoxPaintSize: (el: PPTTextElement, layout: TextBoxLayout) => {
+    width: string;
+    height: string;
+};
+export declare const textBoxFlexColumn: (layout: TextBoxLayout) => boolean;
+export declare const textBoxJustify: (layout: TextBoxLayout) => "center" | "flex-end" | "flex-start";
+/**
+ * Empty slots keep the dashed frame. Filled auto-height follows the text —
+ * including shrinking off the empty-slot floor so Enter can grow the box.
+ */
+export declare const shouldBlockPlaceholderHeightShrink: (el: PPTTextElement, measuredHeight: number, contentEmpty: boolean) => boolean;

package/dist/types/utils/placeholderPaint.d.ts

@@ -0,0 +1,57 @@
+import type { CSSPropertiesWithVars } from '../types/css';
+import type { PPTTextElement, TextAlign } from '../types/slides';
+import { isListPlaceholderType, placeholderAlignOf } from '../configs/textPresets';
+import type { PlaceholderStyleOptions } from './prosemirror/commands/applyPlaceholderStyles';
+export { isListPlaceholderType, placeholderAlignOf };
+export declare const EMPTY_LIST_HTML = "<ul><li><p></p></li></ul>";
+export declare const EMPTY_PARA_HTML = "<p></p>";
+export declare const isEmptyRichText: (html?: string) => boolean;
+export declare const isUnfilledPlaceholder: (el: {
+    placeholder?: string;
+    content?: string;
+}) => boolean;
+/** Slide previews paint authored text only. Empty placeholder prompts stay on the canvas. */
+export declare const shouldRasterPreviewText: (el: {
+    placeholder?: string;
+    content?: string;
+}) => boolean;
+/** Rewrite leaked prompt-size marks (36 on a cover title) back to the typed size. */
+export declare const repairFilledPlaceholderHtml: (el: {
+    placeholder?: string;
+    textType?: string;
+    placeholderFontSize?: number;
+}, html: string) => string;
+export declare const isListPlaceholder: (el: {
+    placeholder?: string;
+    textType?: string;
+}) => boolean;
+export declare const emptyPlaceholderHtml: (el: {
+    placeholder?: string;
+    textType?: string;
+}) => "<p></p>" | "<ul><li><p></p></li></ul>";
+export type PlaceholderPhase = 'empty' | 'filled';
+export declare const placeholderPhase: (empty: boolean) => PlaceholderPhase;
+/** Empty-prompt styles must never rewrite typed text (that is how 66 collapses to 36). */
+export declare const shouldSkipPlaceholderStyleApply: (input: {
+    docEmpty: boolean;
+    phaseHint?: PlaceholderPhase;
+    fontSize?: string;
+}) => boolean;
+export declare const placeholderSeed: (el: {
+    placeholderFontSize?: number;
+    placeholderAlign?: TextAlign;
+    placeholderBold?: boolean;
+    placeholderItalic?: boolean;
+    defaultFontName?: string;
+    textType?: string;
+}, phase: PlaceholderPhase, color: string) => PlaceholderStyleOptions;
+export declare const placeholderBoxVars: (el: PPTTextElement, empty: boolean, promptColor: string) => CSSPropertiesWithVars;
+export declare const placeholderChrome: (input: {
+    placeholder?: string;
+    empty: boolean;
+    editing: boolean;
+}) => {
+    editorMounted: boolean;
+    showPrompt: boolean;
+    hidePrompt: boolean;
+};

package/dist/types/utils/portal.d.ts

@@ -0,0 +1,37 @@
+export declare const APP_SHELL_ID = "fika-shell";
+export declare const APP_PORTALS_ID = "fika-portals";
+export declare const EMBED_ROOT_CLASS = "fika-embed-root";
+export declare function setFikaPortalTarget(target: HTMLElement | null): void;
+export declare function clearFikaPortalTarget(target: HTMLElement): void;
+/** Overlay mount for the standalone app. Never document.body — that is the page, not Fika. */
+export declare function ensureAppPortalRoot(): HTMLElement;
+export declare function getFikaPortalTarget(): HTMLElement;
+/**
+ * Resolve the portal target for a *specific* embed instance.
+ *
+ * The module-level `portalTarget` only tracks the last-mounted embed, so when
+ * several embeds coexist (e.g. multiple decks force-mounted side by side in a
+ * host app) it points at the wrong one — overlays then render into a sibling
+ * embed's portal, which the host may have hidden (`display:none`), so they
+ * never appear. Resolving from the interacted element keeps each overlay in
+ * its own embed. Falls back to the standalone portal root.
+ */
+export declare function resolveFikaPortalTarget(el?: Element | null): HTMLElement;
+/** Ancestor that becomes the containing block for `position: fixed` descendants. */
+export declare function findFixedContainingBlock(from: HTMLElement): HTMLElement | null;
+export declare function menuAxisFromEvent(event: MouseEvent, portal: HTMLElement): {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+};
+export declare function queryFika<T extends Element = Element>(selector: string): T | null;
+export declare function queryFikaAll<T extends Element = Element>(selector: string): NodeListOf<T>;
+/**
+ * True when the event belongs to Fika (shell / embed), not a host overlay.
+ *
+ * Canvas clicks set editorAreaFocus but do not move DOM focus, so keydown/paste
+ * land on document.body. Those document-level events are app-owned while Fika
+ * is mounted. Foreign overlays (react-scan) focus their own nodes and stay out.
+ */
+export declare function isAppOwnedEvent(event: Event): boolean;

package/dist/types/utils/pptxImportDiagnostics.d.ts

@@ -0,0 +1,36 @@
+import type { Slide } from '../types/slides';
+export type ImportDisposition = 'modeled' | 'approximated' | 'opaque' | 'dropped';
+export interface ImportDiagnosticItem {
+    disposition: ImportDisposition;
+    capability: string;
+    detail?: string;
+    slideIndex?: number;
+    elementId?: string;
+}
+export interface ImportDiagnosticsReport {
+    status: 'complete' | 'complete-with-approximations' | 'partial';
+    packageId?: string;
+    slideCount: number;
+    elementCount: number;
+    provenanceMatched: number;
+    items: ImportDiagnosticItem[];
+    summary: Record<ImportDisposition, number>;
+}
+export declare function setLastImportDiagnostics(report: ImportDiagnosticsReport | null): void;
+export declare function getLastImportDiagnostics(): ImportDiagnosticsReport | null;
+export interface BuildImportDiagnosticsInput {
+    slides: Slide[];
+    packageId?: string;
+    /** pptxtojson element type counts that never became Fika elements */
+    droppedByType?: Record<string, number>;
+    /** Transitions present in OOXML but unmapped */
+    unmappedTransitions?: number;
+    /** Math nodes imported as images because latex was empty */
+    mathFallbackImages?: number;
+    /** Layout elements flattened into slide (not preserved as masters) */
+    flattenedLayoutElements?: number;
+}
+/**
+ * Build a Mona-style import diagnostics matrix for a converted deck.
+ */
+export declare function buildImportDiagnosticsReport(input: BuildImportDiagnosticsInput): ImportDiagnosticsReport;

package/dist/types/utils/pptxImportFidelity.d.ts

@@ -0,0 +1,138 @@
+import type { ElementSource, Note, PPTAnimation, PPTElementEffects, PPTLatexElement, TurningMode } from '../types/slides';
+export type { ElementSource };
+export interface SlideObjectIdentity {
+    order: number;
+    objectId: string;
+    name?: string;
+    partPath: string;
+    /** Position/size in points (pptxtojson units, pre-viewport scale) */
+    left: number;
+    top: number;
+    width: number;
+    height: number;
+    effects?: PPTElementEffects;
+}
+export interface PptxSlideTransition {
+    type: string;
+    duration?: number;
+    direction?: string | null;
+}
+export interface PptxMathElement {
+    type: 'math';
+    left: number;
+    top: number;
+    width: number;
+    height: number;
+    latex?: string;
+    picBase64?: string;
+    order?: number;
+}
+type XmlNode = {
+    tagName?: string;
+    attributes?: Record<string, string>;
+    children?: Array<XmlNode | string>;
+};
+/**
+ * Map pptxtojson / OOXML transition type (+ optional direction) → Fika turningMode.
+ */
+export declare function mapPptxTransitionToTurningMode(transition?: PptxSlideTransition | null): TurningMode | undefined;
+/**
+ * Normalize OMML→LaTeX quirks from real PowerPoint / pptxtojson output:
+ * - NBSP → space
+ * - Mathematical Alphanumeric Symbols (italic/bold/…) → ASCII
+ */
+export declare function normalizeImportedLatex(latex: string): string;
+/**
+ * Build an editable LaTeX element from a pptxtojson math node.
+ * Falls back to null when latex is missing (caller may keep the PNG).
+ */
+export declare function buildLatexElementFromMath(el: PptxMathElement, options?: {
+    color?: string;
+    id?: string;
+}): PPTLatexElement | null;
+/**
+ * Parse author lists from either:
+ * - legacy `ppt/commentAuthors.xml` (`p:cmAuthor`)
+ * - modern `ppt/authors.xml` (`p188:author`)
+ */
+export declare function parseCommentAuthorsXml(xml: string): Map<string, string>;
+/**
+ * Parse a slide comments part into Fika Note[].
+ * Supports legacy `p:cmLst/p:cm/p:text` and modern threaded
+ * `p188:cmLst/p188:cm` (+ `replyLst`) used by PowerPoint / pptxgenjs 4.x.
+ */
+export declare function parseCommentsXml(xml: string, authors?: Map<string, string>): Note[];
+/** @deprecated Use parseCommentsXml — kept for call-site compatibility. */
+export declare function parseLegacyCommentsXml(xml: string, authors?: Map<string, string>): Note[];
+/** Parse a:effectLst into Mona-compatible PPTElementEffects (points). */
+export declare function parseEffectLst(effectLst: XmlNode | undefined): PPTElementEffects | undefined;
+/**
+ * Collect cNvPr identities from a slide XML part (document order).
+ * Geometry is in points so it can match pptxtojson element boxes.
+ */
+export declare function extractCNvPrIdentitiesFromSlideXml(xml: string, partPath: string): SlideObjectIdentity[];
+export declare function hashPackageId(bytes: ArrayBuffer): Promise<string>;
+export interface PptxImportExtras {
+    packageId: string;
+    /** Comments keyed by 0-based slide index */
+    commentsBySlide: Map<number, Note[]>;
+    /** cNvPr identities keyed by 0-based slide index (slide-local parts only) */
+    identitiesBySlide: Map<number, SlideObjectIdentity[]>;
+    /** Click/build animations keyed by 0-based slide index (from `p:timing`) */
+    animationsBySlide: Map<number, ImportedSlideAnimation[]>;
+}
+export interface ImportedSlideAnimation {
+    objectId: string;
+    trigger: PPTAnimation['trigger'];
+    type: PPTAnimation['type'];
+    effect: string;
+    duration: number;
+}
+/** pptxtojson `slide.animations` item (OOXML timing, presenter order). */
+export interface PptxtojsonSlideAnimation {
+    spid: string;
+    trigger: string;
+    class: string;
+    presetId: number;
+    presetSubtype?: number;
+    duration: number;
+    delay?: number;
+    filter?: string;
+}
+export declare function mapPresetToEffect(presetClass: string, presetId: number, filter?: string, presetSubtype?: number): string;
+/**
+ * Parse `p:timing` click/build animations from a slide XML part.
+ * Effect nodes are `p:cTn` with `presetClass`; `nodeType` may live on an ancestor
+ * grouping wrapper. Document order is the presenter sequence.
+ */
+export declare function extractSlideAnimationsFromXml(xml: string): ImportedSlideAnimation[];
+export declare function mapPptxtojsonAnimation(anim: PptxtojsonSlideAnimation): ImportedSlideAnimation | null;
+/** Map OOXML shape ids onto imported editor elements via `source.objectId` or a spid map. */
+export declare function bindImportedAnimations(imported: ImportedSlideAnimation[], elements: Array<{
+    id: string;
+    source?: {
+        objectId?: string;
+    };
+}>, spidToElId?: Map<string, string>): PPTAnimation[];
+/**
+ * Extract comments + cNvPr provenance from the retained OOXML package.
+ */
+export declare function extractPptxImportExtras(bytes: ArrayBuffer): Promise<PptxImportExtras>;
+export declare function attachElementSource(element: {
+    source?: ElementSource;
+    effects?: PPTElementEffects;
+}, packageId: string, identity?: SlideObjectIdentity): void;
+/**
+ * Match a pptxtojson element box (points, pre-scale) to a slide-local cNvPr identity.
+ * Consumes the identity so one OOXML object maps to one editor element.
+ */
+export declare function takeIdentityForGeometry(pool: SlideObjectIdentity[] | undefined, box: {
+    left: number;
+    top: number;
+    width: number;
+    height: number;
+}, epsilon?: number): SlideObjectIdentity | undefined;
+/** Match a pptxtojson `el.id` (cNvPr id) when geometry matching misses. */
+export declare function takeIdentityForObjectId(pool: SlideObjectIdentity[] | undefined, objectId: string | undefined): SlideObjectIdentity | undefined;
+/** @deprecated Prefer takeIdentityForGeometry — pptxtojson order is parser-private. */
+export declare function takeIdentityForOrder(pool: SlideObjectIdentity[] | undefined, order: number | undefined): SlideObjectIdentity | undefined;

package/dist/types/utils/pptxImportFonts.d.ts

@@ -0,0 +1,34 @@
+/**
+ * pptxtojson 2.2+ emits embedded fonts as `{ name, fontFamily, blob }`,
+ * not `string[]`. String APIs (`replace`, Google Fonts) must go through
+ * {@link normalizePptxUsedFonts}; blob URLs must be registered as FontFace
+ * so import does not crash and the packaged face actually paints.
+ */
+export type PptxUsedFontObject = {
+    name?: string;
+    fontFamily?: string;
+    blob?: string;
+};
+export type PptxUsedFont = string | PptxUsedFontObject;
+export type NormalizedPptxFont = {
+    name: string;
+    blob?: string;
+};
+/** Pull a CSS family name out of a pptxtojson usedFonts entry (string or object). */
+export declare function pptxUsedFontName(font: unknown): string;
+export declare function normalizePptxUsedFonts(usedFonts: readonly unknown[] | null | undefined): NormalizedPptxFont[];
+/**
+ * Split "Brygada 1918 Bold Italic" → family + FontFace descriptors so both
+ * `font-family: "Brygada 1918 Bold"` and `font-family: "Brygada 1918"; font-weight: 700`
+ * resolve to the embedded face.
+ */
+export declare function splitImportedFontFace(name: string): {
+    family: string;
+    weight?: string;
+    style?: string;
+};
+/**
+ * Register pptxtojson embedded-font blob URLs as FontFace. Safe in Node
+ * (no `document` / `FontFace`) and idempotent.
+ */
+export declare function registerEmbeddedFonts(usedFonts: readonly unknown[] | null | undefined): string[];

package/dist/types/utils/pptxImportMetrics.d.ts

@@ -0,0 +1,29 @@
+/** PowerPoint body lvl1 hanging indent: marL 18pt / 28pt type. */
+export declare const PPTX_BODY_BULLET_INDENT_EM: number;
+export type PptxTextInset = {
+    t: number;
+    r: number;
+    b: number;
+    l: number;
+};
+export type ImportedParagraphMetrics = {
+    lineHeight: number;
+    margin: number | null;
+};
+/** CSS cascade: the last `prop:` in a style string wins. */
+export declare function lastCssDeclaration(style: string, prop: string): string | null;
+/**
+ * Read line-height / paragraph spacing from pptxtojson paragraph HTML.
+ * Duplicate `line-height` declarations (default 1.2 then the real value) must
+ * use the last one — otherwise imported boxes clip like the Odkazy slide.
+ */
+export declare function importedParagraphMetrics(html: string, ratio: number): ImportedParagraphMetrics;
+/** pptxtojson insets are pt; the editor paints px. */
+export declare function scalePptxTextInset(inset: PptxTextInset | undefined, ratio: number): [number, number, number, number] | undefined;
+/**
+ * Overflow-wrap:anywhere line count using a mean glyph width. URLs have no
+ * spaces, so PowerPoint / CSS wrap them by character.
+ */
+export declare function estimateAnywhereWrapLines(text: string, innerWidth: number, fontSize: number, avgGlyphEm?: number): number;
+export declare function estimateColumnHeight(linesPerBlock: number[], fontSize: number, lineHeight: number, blockSpace: number): number;
+export declare function textFitsFixedBox(contentHeight: number, boxInnerHeight: number, epsilon?: number): boolean;

package/dist/types/utils/pptxImportPicture.d.ts

@@ -0,0 +1,30 @@
+import type { ImageElementClip } from '../types/slides';
+/**
+ * pptxtojson emits a `p:pic` as `type: 'image'` only when it has no preset/custom
+ * geometry. PowerPoint always writes `<a:prstGeom prst="rect"/>` on pictures, so
+ * almost every photo arrives as `type: 'shape'` with `fill.type === 'image'`.
+ * Importing that as an SVG pattern (200×200 viewBox, then non-uniform scale)
+ * stretches the bitmap. Map picture-like shapes back to image elements instead.
+ */
+export declare const PPTX_IMAGE_CLIP_SHAPES: readonly ['rect', 'snip1Rect', 'snip2DiagRect', 'roundRect', 'ellipse', 'triangle', 'rtTriangle', 'diamond', 'pentagon', 'hexagon', 'heptagon', 'octagon', 'chevron', 'homePlate', 'rightArrow', 'parallelogram', 'trapezoid'];
+export type PptxSrcRect = {
+    t?: number;
+    b?: number;
+    l?: number;
+    r?: number;
+};
+export type PptxPictureSource = {
+    src: string;
+    geom: string;
+    rect?: PptxSrcRect;
+    isFlipH?: boolean;
+    isFlipV?: boolean;
+    rotate?: number;
+    link?: string;
+    borderWidth?: number;
+};
+export declare function isPptxConnectorShape(shapType?: string): boolean;
+export declare function pptxPictureSource(el: unknown): PptxPictureSource | null;
+/** Preset picture frames (rect / ellipse / roundRect / …) become image clips. Custom paths stay shapes. */
+export declare function pptxPictureShapeCanBeImage(shapType?: string): boolean;
+export declare function pptxImageClip(geom: string, rect?: PptxSrcRect): ImageElementClip | undefined;