fika-editor 3.0.0 → 3.0.2

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

@@ -0,0 +1,55 @@
+export interface ElementAttribute {
+    key: string;
+    value: string | null;
+}
+export interface CommentElement {
+    type: 'comment';
+    content: string;
+}
+export interface TextElement {
+    type: 'text';
+    content: string;
+}
+export interface NormalElement {
+    type: 'element';
+    tagName: string;
+    children: HTMLNode[];
+    attributes: string[];
+}
+export type HTMLNode = CommentElement | TextElement | NormalElement;
+export interface ElementAST {
+    type: 'element';
+    tagName: string;
+    children: AST[];
+    attributes: ElementAttribute[];
+}
+export interface CommentOrTextAST {
+    type: 'comment' | 'text';
+    content: string;
+}
+export type AST = CommentOrTextAST | ElementAST;
+export interface TagStartToken {
+    type: 'tag-start';
+    close: boolean;
+}
+export interface TagEndToken {
+    type: 'tag-end';
+    close: boolean;
+}
+export interface TagToken {
+    type: 'tag';
+    content: string;
+}
+export interface TextToken {
+    type: 'text';
+    content: string;
+}
+export interface CommentToken {
+    type: 'comment';
+    content: string;
+}
+export interface AttributeToken {
+    type: 'attribute';
+    content: string;
+}
+export type Token = TagStartToken | TagEndToken | TagToken | TextToken | CommentToken | AttributeToken;

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

@@ -0,0 +1,12 @@
+export type FollowHyperlinkModifier = 'Ctrl+Click' | '⌘+Click';
+export declare function hyperlinkAnchorFromEvent(event: Event): HTMLAnchorElement | null;
+export declare function isSafeHyperlinkHref(href: string): boolean;
+export declare function isFollowHyperlinkClick(event: Pick<MouseEvent, 'button' | 'ctrlKey' | 'metaKey'>): boolean;
+export declare function followHyperlinkModifier(platform?: string): FollowHyperlinkModifier;
+export declare function openHyperlink(href: string): boolean;
+export type HyperlinkHoverTooltip = {
+    href: string;
+    left: number;
+    top: number;
+};
+export declare function hyperlinkTooltipFromAnchor(anchor: HTMLAnchorElement, offset?: number): HyperlinkHoverTooltip | null;

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

@@ -0,0 +1,25 @@
+interface ImageSize {
+    width: number;
+    height: number;
+}
+/**
+ * Get the intrinsic width and height of an image.
+ * @param src Image URL
+ */
+export declare const getImageSize: (src: string) => Promise<ImageSize>;
+/**
+ * Read an image file as a data URL.
+ * @param file Image file
+ */
+export declare const getImageDataURL: (file: File) => Promise<string>;
+/**
+ * Check whether a string is SVG markup.
+ * @param text Text to validate
+ */
+export declare const isSVGString: (text: string) => boolean;
+/**
+ * Convert SVG markup to a File.
+ * @param svg SVG markup
+ */
+export declare const svg2File: (svg: string) => File;
+export {};

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

@@ -0,0 +1,18 @@
+import type { Slide } from '../types/slides';
+export declare const PREVIEW_BITMAP_MAX_EDGE = 512;
+export declare const PREVIEW_BITMAP_CACHE_MAX = 640;
+export declare const FULL_BITMAP_CACHE_MAX = 64;
+export type LoadImageBitmapOptions = {
+    maxEdge?: number;
+};
+export declare const subscribePreviewBitmaps: (fn: (src: string) => void) => () => void;
+export declare const getCachedImageBitmap: (src: string, options?: LoadImageBitmapOptions) => ImageBitmap | undefined;
+export declare const previewPaintHasMedia: (painted: Set<string> | undefined, srcs: readonly string[]) => boolean;
+export declare const loadImageBitmap: (src: string, options?: LoadImageBitmapOptions) => Promise<ImageBitmap | null>;
+export declare const loadPreviewImageBitmap: (src: string) => Promise<ImageBitmap>;
+export declare const getCachedPreviewImageBitmap: (src: string) => ImageBitmap;
+export declare const collectSlidePreviewSrcs: (slide: Slide) => string[];
+export declare const collectSlideImageSrcs: (slides: readonly Slide[]) => string[];
+export declare const prefetchPreviewImageBitmaps: (srcs: readonly string[]) => void;
+export declare const revokeImageBitmapsNotIn: (keep: Iterable<string>) => void;
+export declare const syncImageBitmapsToSlides: (slides: readonly Slide[]) => void;

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

@@ -0,0 +1,34 @@
+import type { PPTImageElement, Slide } from '../types/slides';
+import type { ImagePaintCache } from './textContrast';
+interface CanvasRange {
+    minX: number;
+    maxX: number;
+    minY: number;
+    maxY: number;
+}
+interface Viewport {
+    width: number;
+    height: number;
+}
+/** Map a canvas overlap onto the image's natural pixels, honoring clip + flip. */
+export declare const canvasRegionToImagePixels: (el: PPTImageElement, region: CanvasRange, naturalWidth: number, naturalHeight: number) => {
+    left: number;
+    top: number;
+    width: number;
+    height: number;
+} | null;
+/** Map a canvas overlap onto a cover-fitted slide background image. */
+export declare const canvasRegionToCoverPixels: (region: CanvasRange, viewport: Viewport, naturalWidth: number, naturalHeight: number) => {
+    left: number;
+    top: number;
+    width: number;
+    height: number;
+} | null;
+/**
+ * Sample average colors for image layers that actually sit under text.
+ * Browser-only (`Image` + canvas). Returns `undefined` when there is nothing
+ * to sample or the environment can't decode images — the contrast query then
+ * keeps treating those layers as `unknown`.
+ */
+export declare const sampleImagePaintsForSlide: (slide: Slide, viewport: Viewport) => Promise<ImagePaintCache | undefined>;
+export {};

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

@@ -0,0 +1,9 @@
+export type ImageSize = {
+    width: number;
+    height: number;
+};
+export declare const readImageSize: (buffer: ArrayBuffer | Uint8Array) => ImageSize | null;
+export declare const resizeToMaxEdge: (width: number, height: number, maxEdge: number) => {
+    width: number;
+    height: number;
+};

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

@@ -0,0 +1,31 @@
+export type ImportApplyMode = 'replace' | 'append';
+export interface ImportApplyOptions {
+    /**
+     * How to apply imported slides. Takes precedence over `cover`.
+     * Default is `replace`.
+     */
+    mode?: ImportApplyMode;
+    /**
+     * Legacy alias: `true` replace, `false` append.
+     * An empty deck (0 slides) is always replaced.
+     */
+    cover?: boolean;
+    /**
+     * When replacing a deck that already has more than one slide, ask first.
+     * Default `true` for the editor UI; the controller should pass `false`.
+     */
+    confirm?: boolean;
+}
+export interface ImportApplyDecision {
+    apply: ImportApplyMode;
+    needsConfirm: boolean;
+}
+/**
+ * UI / controller policy for PPTX and JSON import.
+ *
+ * - 0 slides (starter deleted) or 1 slide: replace immediately.
+ * - 2+ slides: replace after confirm, unless `confirm: false`.
+ * - `mode: 'append'` / `cover: false`: append, no confirm (still replace if empty).
+ */
+export declare function resolveImportApply(slideCount: number, options?: ImportApplyOptions): ImportApplyDecision;
+export declare function normalizeImportApplyOptions(options?: boolean | ImportApplyOptions): ImportApplyOptions;

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

@@ -0,0 +1,68 @@
+import type { MagicalInkId } from '../configs/inkPaint';
+import type { Gradient } from '../types/slides';
+import type { Command } from './commandHistory';
+export type ShapeType = 'rect' | 'circle' | 'arrow' | 'line' | 'triangle';
+export type InkStrokePaint = {
+    color: string;
+    gradient?: Gradient;
+    gradientId?: MagicalInkId;
+};
+export type PenStroke = InkStrokePaint & {
+    kind: 'pen';
+    size: number;
+    points: Array<{
+        x: number;
+        y: number;
+        pressure?: number;
+    }>;
+    simulatePressure?: boolean;
+};
+export type MarkStroke = InkStrokePaint & {
+    kind: 'mark';
+    size: number;
+    points: Array<{
+        x: number;
+        y: number;
+        pressure?: number;
+    }>;
+    simulatePressure?: boolean;
+};
+export type EraserStroke = {
+    kind: 'eraser';
+    size: number;
+    points: Array<{
+        x: number;
+        y: number;
+    }>;
+};
+export type ShapeStroke = InkStrokePaint & {
+    kind: 'shape';
+    shapeType: ShapeType;
+    size: number;
+    startX: number;
+    startY: number;
+    endX: number;
+    endY: number;
+};
+export type Stroke = PenStroke | MarkStroke | EraserStroke | ShapeStroke;
+export interface DrawingSurface {
+    strokes: Stroke[];
+    baseline: HTMLImageElement | null;
+    redraw: () => void;
+}
+export declare const strokeHasInk: (stroke: Stroke) => boolean;
+export declare class AddStrokeCommand implements Command {
+    private readonly surface;
+    private readonly stroke;
+    constructor(surface: DrawingSurface, stroke: Stroke);
+    do(): void;
+    undo(): void;
+}
+export declare class ClearInkCommand implements Command {
+    private readonly surface;
+    private removedStrokes;
+    private removedBaseline;
+    constructor(surface: DrawingSurface);
+    do(): void;
+    undo(): void;
+}

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

@@ -0,0 +1,36 @@
+export type JobProgressPhase = 'preparing' | 'working' | 'finishing';
+export interface JobProgressBox<T> {
+    value: T;
+}
+export interface JobProgress {
+    running: JobProgressBox<boolean>;
+    progress: JobProgressBox<number>;
+    current: JobProgressBox<number>;
+    total: JobProgressBox<number>;
+    generation: () => number;
+    start: (total?: number) => number;
+    setTotal: (total: number, gen?: number) => boolean;
+    tick: (value: number, slide?: number, gen?: number, options?: {
+        yieldPaint?: boolean;
+    }) => Promise<boolean>;
+    finish: (gen?: number) => boolean;
+    isCurrent: (gen: number) => boolean;
+    subscribe: (listener: () => void) => () => void;
+}
+export interface JobProgressLabels {
+    running: string;
+    preparing: string;
+    finishing: string;
+    slideProgress: (params: {
+        current: number;
+        total: number;
+    }) => string;
+}
+export declare function jobProgressPhase(current: number, total: number): JobProgressPhase;
+export declare function jobBoxValue<T>(box: T | {
+    value: T;
+} | undefined, fallback: T): T;
+export declare function formatJobProgressTip(running: boolean, current: number, total: number, labels: JobProgressLabels): string;
+export declare function slideJobProgress(index: number, count: number, start?: number, end?: number): number;
+export declare const isAbortError: (error: unknown) => boolean;
+export declare function createJobProgress(): JobProgress;

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

@@ -0,0 +1,27 @@
+import type { PPTLatexElement } from '../types/slides';
+/**
+ * Apply an editor save onto an existing formula.
+ *
+ * The canvas box (`width` / `height`) is the authored scale. Never replace it
+ * with the newly measured natural size — `useLiveBoxFit` scales the new
+ * formula into that box. `viewBox` stores the natural measure for export.
+ */
+export declare function latexPropsAfterEdit(_current: Pick<PPTLatexElement, 'width' | 'height'>, next: {
+    latex: string;
+    path?: string;
+    w: number;
+    h: number;
+}): Pick<PPTLatexElement, 'latex' | 'path' | 'viewBox'>;
+/** Same uniform scale `useLiveBoxFit` writes: authored box / natural viewBox. */
+export declare function latexPaintScale(el: Pick<PPTLatexElement, 'width' | 'height' | 'viewBox'>): number;
+/**
+ * Extract the contents of every equation (or equation*) environment.
+ */
+export declare const extractEquationLatex: (source: string) => string[];
+/**
+ * MathLive emits compact TeX (`4^5\cdot3x`). hfmath's tokenizer treats digits
+ * as part of a command name, so `\cdot3x` becomes one unknown token and is
+ * drawn as literal text. TeX ends a control word before a digit; insert that
+ * space here before handing the string to hfmath.
+ */
+export declare const toHfmathLatex: (latex: string) => string;

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

@@ -0,0 +1,28 @@
+/**
+ * LaTeX → MathML (MathLive) → OMML (mathml2omml) for native PowerPoint equations.
+ * No hand-rolled math grammar — conversion is entirely library-based.
+ */
+export interface OmmlRunStyle {
+    /** CSS/hex color applied to every math glyph run and control (vinculum, …). */
+    color?: string;
+    /** Font size in points (`a:rPr sz` is hundredths of a point). */
+    fontSizePt?: number;
+}
+/**
+ * Stamp `a:rPr` (color / size) onto every `m:r` and `m:ctrlPr` in an OMML
+ * fragment. pptxgenjs embeds OMML as opaque XML and does not propagate the
+ * surrounding text-run `options.color`, so contrast-fixed (and user-styled)
+ * equation colors must be written into the math markup itself.
+ */
+export declare function applyOmmlRunStyle(omml: string, style: OmmlRunStyle): string;
+/** Ensure MathLive is loaded so sync conversion can run during PPTX export. */
+export declare function prepareLatexToOmml(): Promise<void>;
+/**
+ * Convert a LaTeX expression to an OMML `<m:oMath>…</m:oMath>` string.
+ */
+export declare function latexToOmml(latex: string): Promise<string>;
+/**
+ * Sync conversion — MathLive must already be loaded via {@link prepareLatexToOmml}.
+ * Returns null when conversion fails (caller falls back to plain LaTeX text).
+ */
+export declare function tryLatexToOmmlSync(latex: string): string | null;

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

@@ -0,0 +1,56 @@
+/**
+ * Live drag preview for canvas elements.
+ *
+ * Two coordinate spaces, because the painted box and the operate chrome
+ * do not live in the same CSS transform:
+ *
+ * - Slide space: `#editable-element-* > *` sits inside `.viewport`, which
+ *   already has `transform: scale(canvasScale)`. `left` / `top` here are
+ *   the same unit the store commits on drop.
+ * - Visual space: `#operate-element-*` and `.multi-select-operate` sit in
+ *   `.viewport-wrapper` (already sized to the *visual* slide). Position
+ *   here is slide × canvasScale.
+ *
+ * Never use CSS `translate` on the painted box. Auto-size text measures
+ * and rasterizes differently under a transform than under `left`/`top`,
+ * so the glyphs shift on pointerup when the transform is removed. Write
+ * the same `left`/`top` the store will commit — drag and drop are one
+ * paint path. Scale already does this (`applyLiveSize`).
+ */
+export type LiveOffsetPosition = {
+    id: string;
+    left: number;
+    top: number;
+};
+export type LiveOffsetNodes = {
+    box?: {
+        style: CSSStyleDeclaration;
+    } | null;
+    operate?: {
+        style: CSSStyleDeclaration;
+    } | null;
+    multi?: {
+        style: CSSStyleDeclaration;
+    } | null;
+};
+export type LivePositionCss = {
+    slideLeft: string;
+    slideTop: string;
+    visualLeft: string;
+    visualTop: string;
+};
+export declare const livePositionCss: (left: number, top: number, canvasScale: number) => LivePositionCss;
+export declare const applyLivePositionStyles: (nodes: LiveOffsetNodes, left: number, top: number, canvasScale: number) => void;
+export declare const readLiveMultiOrigin: (canvasScale: number) => {
+    left: number;
+    top: number;
+} | null;
+export declare const setLiveElementOffset: (origins: readonly LiveOffsetPosition[], dxSlide: number, dySlide: number, canvasScale: number, multiOrigin?: {
+    left: number;
+    top: number;
+} | null) => void;
+export declare const clearLiveElementOffset: (origins: readonly LiveOffsetPosition[], canvasScale: number, multiOrigin?: {
+    left: number;
+    top: number;
+} | null) => void;
+export declare const settleLiveElementOffset: (positions: readonly LiveOffsetPosition[], canvasScale: number) => void;

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

@@ -0,0 +1,13 @@
+/**
+ * Live paint for fill / gradient / opacity. Same contract as applyLiveSize:
+ * write the canvas DOM during the gesture. Do not go through the store until
+ * pointerup — a store write rebuilds the preview raster and the canvas list.
+ */
+import type { Gradient } from '../types/slides';
+export declare const liveGradientId: (elementId: string, source?: string) => string;
+export declare const liveGradientTransform: (rotate: number) => string;
+/** Single writer for SVG gradient stops. React must not also own these children. */
+export declare const syncGradientDef: (def: Element, gradient: Pick<Gradient, 'colors' | 'rotate'>) => void;
+export declare const applyLiveGradient: (elementId: string, gradient: Gradient, source?: string) => boolean;
+export declare const applyLiveBackgroundGradient: (gradient: Gradient) => boolean;
+export declare const readPaintedGradientRotate: (elementId: string, source?: string) => number | null;

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

@@ -0,0 +1,52 @@
+/**
+ * Live resize for canvas elements.
+ *
+ * One writer (`applyLiveSize`) updates the painted box, `[data-live-box]`,
+ * and operate chrome. Contents that depend on box size must read that live
+ * geometry — never wait for the store commit on pointerup.
+ *
+ * Auto-height boxes opt out with `data-live-auto-height` (or `height: auto`).
+ * Missing inline height is not an opt-out — tables and other content-sized
+ * wrappers still preview both axes. Direct-child SVGs get a viewBox so
+ * preserveAspectRatio=none can stretch Y, and tables update row heights.
+ */
+export type LiveBoxSize = {
+    width: number;
+    height: number;
+};
+export declare const isAutoCss: (value: string | undefined) => boolean;
+export declare const isLiveAutoHeight: (el: HTMLElement | null | undefined) => boolean;
+export declare const readLiveBoxSize: (box: HTMLElement | null | undefined, fallback: LiveBoxSize) => LiveBoxSize;
+export declare const liveBoxOf: (node: HTMLElement | null | undefined) => HTMLElement | null;
+/** Uniform scale that fits `natural` inside `box` without growing past 1 when either side is empty. */
+export declare const fitUniformScale: (natural: LiveBoxSize, box: LiveBoxSize) => number;
+type LiveBoxListener = (id: string, size: LiveBoxSize) => void;
+export declare const subscribeLiveBox: (listener: LiveBoxListener) => () => void;
+export declare const shapeGroupTransform: (width: number, height: number, viewBox: readonly [number, number] | readonly number[]) => string;
+export declare const syncShapePaint: (svg: SVGSVGElement, width: number, height: number, viewBox: readonly [number, number] | readonly number[]) => void;
+export declare const tableCellMinHeight: (boxHeight: number, rowCount: number) => number;
+export type LivePaintExtras = {
+    path?: string;
+    viewBox?: readonly number[];
+};
+/** True when the element's height is text-driven (auto-height box). */
+export declare const autoHeightInsetSum: (el: {
+    type?: string;
+    fixedHeight?: boolean;
+    vertical?: boolean;
+    inset?: readonly number[];
+    text?: {
+        fixedHeight?: boolean;
+        inset?: readonly number[];
+    } | null;
+}) => number | null;
+/**
+ * Height the auto-height element's text actually needs at its CURRENT live
+ * width (call after the width has been painted). scrollHeight reports the
+ * true content height even when the container still carries a stale height.
+ */
+export declare const measureAutoTextHeight: (id: string, insetSum: number) => number | null;
+export declare const applyLiveSize: (id: string, left: number, top: number, width: number, height: number, canvasScale: number, extras?: LivePaintExtras, options?: {
+    forceHeight?: boolean;
+}) => void;
+export {};

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

@@ -0,0 +1,2 @@
+import type { PPTElement } from '../types/slides';
+export declare const applyLiveLayoutOntoStore: (liveList: PPTElement[], storeList: PPTElement[]) => PPTElement[];

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

@@ -0,0 +1,48 @@
+/** True when a string carries math delimiters the math parser should handle. */
+export declare function containsMath(source: string): boolean;
+/**
+ * A run of either plain text or a single math span, in source order. `raw` is
+ * the exact source slice (delimiters included for math); `value` is the inner
+ * formula for math (delimiters stripped) and equals `raw` for text.
+ */
+export interface ContentSegment {
+    type: 'text' | 'math';
+    raw: string;
+    value: string;
+    /** Math only: display (block) vs inline. */
+    display: boolean;
+}
+/**
+ * Split `source` into ordered text and math segments. This is the robust core
+ * behind both line-splitting and inline rendering: it scans once, picking the
+ * earliest opener at each position (longest on ties, so `$$` beats `$`), honors
+ * backslash escapes (`\$`, `\\`), skips inline code spans (so `` `$x` `` is not
+ * read as math) and keeps unterminated openers as literal text (graceful for
+ * partial/streamed content). Inline math may not span newlines; display math
+ * (`$$`, `\[`, `\begin{}`) may.
+ */
+export declare function tokenizeMath(source: string): ContentSegment[];
+export declare function normalizeAgentText(text: string): string;
+export declare function splitLinesPreservingMath(value: string): string[];
+export declare function markdownToHtml(markdown: string): Promise<string>;
+/**
+ * Preload the math-capable markdown parser (lazy MathLive + texmath) so
+ * `renderInlineMarkdown` can render `$…$` math synchronously afterwards. No-op
+ * once loaded; call before rendering content that may contain math.
+ */
+export declare function ensureInlineMathReady(): Promise<void>;
+/**
+ * Render one line of markdown to inline HTML (no `<p>` wrapper) using the same
+ * CommonMark + texmath pipeline as {@link markdownToHtml}.
+ *
+ * Plain (math-free) lines use markdown-it's inline renderer directly. Lines that
+ * carry math are rendered through the full *block* pipeline and then unwrapped
+ * from their single `<p>`: this is what makes display math correct. texmath
+ * exposes `\[…\]` and `\begin{env}…\end{env}` only as block rules, so the inline
+ * renderer would emit them verbatim; routing through the block parser renders
+ * every delimiter (`$…$`, `$$…$$`, `\(…\)`, `\[…\]`, environments), and matches
+ * the `text.setMarkdown` output byte-for-byte. Math renders only when the parser
+ * has been preloaded via {@link ensureInlineMathReady}; otherwise delimiters
+ * read as literal text.
+ */
+export declare function renderInlineMarkdown(markdown: string): string;

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/mediaIntern.d.ts

@@ -0,0 +1,12 @@
+import type { Slide } from '../types/slides';
+export declare const isDataUrl: (src: string) => boolean;
+export declare const onMediaInterned: (fn: (from: string, to: string) => void) => () => void;
+/** Data URL and its blob: alias are the same bytes. */
+export declare const bitmapSrcKeys: (src: string) => string[];
+export declare const getInternedBlob: (src: string) => Blob | undefined;
+export declare const startInternSlideMedia: (slide: Slide) => void;
+export declare const internMediaSrc: (src: string) => Promise<string>;
+export declare const visitSlideMediaSrcs: (slide: Slide, visit: (src: string) => void) => void;
+export declare const collectSlideMediaSrcs: (slides: readonly Slide[]) => string[];
+export declare const internSlidesMedia: (slides: Slide[]) => Promise<void>;
+export declare const resetMediaInternForTests: () => void;