fika-editor 3.0.0 → 3.0.1

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

@@ -0,0 +1,57 @@
+import type { Gradient } from '../types/slides';
+export declare const DEFAULT_FREEHAND_SIZE = 6;
+export type FreehandPoint = {
+    x: number;
+    y: number;
+    pressure?: number;
+};
+export type FreehandCapOptions = {
+    cap?: boolean;
+    taper?: number | boolean;
+};
+export type FreehandStrokeOptions = {
+    last?: boolean;
+    thinning?: number;
+    simulatePressure?: boolean;
+    streamline?: number;
+    smoothing?: number;
+    start?: FreehandCapOptions;
+    end?: FreehandCapOptions;
+};
+export declare const shouldKeepFreehandPoint: (from: FreehandPoint, to: FreehandPoint, simulatePressure?: boolean) => boolean;
+/**
+ * Keep raw pointer spacing. Evenly interpolating jumps flattens velocity, which
+ * is what perfect-freehand uses to simulate pressure.
+ */
+export declare const appendFreehandPoint: (points: FreehandPoint[], next: FreehandPoint, simulatePressure?: boolean) => void;
+export declare const shouldSimulatePressure: (e: PointerEvent) => boolean;
+export declare const readPointerPressure: (e: PointerEvent) => number;
+export declare const pointerStrokeSamples: (e: PointerEvent) => PointerEvent[];
+/**
+ * Excalidraw's outline → SVG path: quadratic midpoints, then close.
+ * See getSvgPathFromStroke in packages/element/src/shape.ts.
+ */
+export declare const getSvgPathFromStroke: (points: number[][]) => string;
+export declare const getFreehandOutline: (points: FreehandPoint[], size: number, options?: FreehandStrokeOptions) => import("perfect-freehand").Vec2[];
+export declare const getFreehandSvgPath: (points: FreehandPoint[], size: number, options?: FreehandStrokeOptions) => string;
+export declare const getFreehandPath: (points: FreehandPoint[], size: number, options?: FreehandStrokeOptions) => Path2D;
+export type FreehandShapeGeometry = {
+    path: string;
+    viewBox: [number, number];
+    minX: number;
+    minY: number;
+    maxX: number;
+    maxY: number;
+};
+export declare const getFreehandShapeGeometry: (points: FreehandPoint[], size: number, options?: FreehandStrokeOptions, minViewBox?: number) => FreehandShapeGeometry | null;
+export declare const joinFreehandStrokes: (strokes: Array<{
+    points: FreehandPoint[];
+    size: number;
+    options?: FreehandStrokeOptions;
+}>, minViewBox?: number) => FreehandShapeGeometry | null;
+export declare const joinFreehandOutlines: (outlines: number[][][], minViewBox?: number) => FreehandShapeGeometry;
+export declare const fillFreehandStroke: (ctx: CanvasRenderingContext2D, points: FreehandPoint[], size: number, color: string, options?: FreehandStrokeOptions & {
+    alpha?: number;
+    composite?: GlobalCompositeOperation;
+    gradient?: Gradient;
+}) => void;

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

@@ -0,0 +1,3 @@
+export declare const enterFullscreen: () => void;
+export declare const exitFullscreen: () => void;
+export declare const isFullscreen: () => boolean;

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

@@ -0,0 +1,18 @@
+export type GestureDragState = {
+    xy: [number, number];
+    delta: [number, number];
+    movement: [number, number];
+    first: boolean;
+    last: boolean;
+    event: PointerEvent | MouseEvent | TouchEvent | KeyboardEvent;
+};
+export type GestureDragHandlers = {
+    onDrag?: (state: GestureDragState) => void;
+    onDragStart?: (state: GestureDragState) => void;
+    onDragEnd?: (state: GestureDragState) => void;
+};
+export type RafCoalesced<T extends (event: MouseEvent | TouchEvent) => void> = T & {
+    cancel: () => void;
+};
+export declare const bindDocumentDrag: (handlers: GestureDragHandlers) => () => void;
+export declare const rafCoalesce: <T extends (event: MouseEvent | TouchEvent) => void>(fn: T) => RafCoalesced<T>;

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

@@ -0,0 +1,2 @@
+/** True when canvas/element hotkeys must yield to a focused text field. */
+export declare const isTypingTarget: (target: EventTarget | null) => boolean;

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

@@ -0,0 +1,3 @@
+import type { HTMLNode, AST } from './types';
+export declare const splitHead: (str: string, sep: string) => string[];
+export declare const format: (nodes: HTMLNode[]) => AST[];

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

@@ -0,0 +1,4 @@
+import { toHTML } from './stringify';
+export type { AST } from './types';
+export declare const toAST: (str: string) => import("./types").AST[];
+export { toHTML };

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

@@ -0,0 +1,2 @@
+import type { Token } from './types';
+export declare const lexer: (str: string) => Token[];

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

@@ -0,0 +1,15 @@
+import type { Token, HTMLNode } from './types';
+interface StackItem {
+    tagName: string | null;
+    children: HTMLNode[];
+}
+interface State {
+    stack: StackItem[];
+    cursor: number;
+    tokens: Token[];
+}
+export declare const parser: (tokens: Token[]) => HTMLNode[];
+export declare const hasTerminalParent: (tagName: string, stack: StackItem[]) => boolean;
+export declare const rewindStack: (stack: StackItem[], newLength: number) => void;
+export declare const parse: (state: State) => void;
+export {};

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

@@ -0,0 +1,3 @@
+import type { AST, ElementAttribute } from './types';
+export declare const formatAttributes: (attributes: ElementAttribute[]) => string;
+export declare const toHTML: (tree: AST[]) => string;

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

@@ -0,0 +1,4 @@
+export declare const childlessTags: string[];
+export declare const closingTags: string[];
+export declare const closingTagAncestorBreakers: Record<string, string[]>;
+export declare const voidTags: string[];

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,6 @@
+import type { Slide } from '../types/slides';
+export declare const getCachedImageBitmap: (src: string) => ImageBitmap | undefined;
+export declare const loadImageBitmap: (src: string) => Promise<ImageBitmap | null>;
+export declare const collectSlideImageSrcs: (slides: readonly Slide[]) => string[];
+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/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,33 @@
+/**
+ * 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[];
+};
+export declare const applyLiveSize: (id: string, left: number, top: number, width: number, height: number, canvasScale: number, extras?: LivePaintExtras) => 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;