fika-editor 3.0.0 → 3.0.2

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

@@ -0,0 +1,387 @@
+import type { PPTElement, PPTLineElement, Slide } from '../types/slides';
+interface RotatedElementData {
+    left: number;
+    top: number;
+    width: number;
+    height: number;
+    rotate: number;
+}
+interface Point {
+    x: number;
+    y: number;
+}
+interface IdMap {
+    [id: string]: string;
+}
+/**
+ * Bounding box of an element's rect after rotation on the canvas.
+ * @param element Position, size, and rotation of the element
+ */
+export declare const getRectRotatedRange: (element: RotatedElementData) => {
+    xRange: number[];
+    yRange: number[];
+};
+/**
+ * Offset between an element's axis-aligned bounds before and after rotation.
+ * @param element Position, size, and rotation of the element
+ */
+export declare const getRectRotatedOffset: (element: RotatedElementData) => {
+    offsetX: number;
+    offsetY: number;
+};
+/**
+ * Local control points that define a line's painted path.
+ * Includes elbows so a bent/curved stroke is never clipped to the start–end chord.
+ */
+export declare const getLineLocalPoints: (element: PPTLineElement) => [number, number][];
+/**
+ * Axis-aligned bounds of a single element on the canvas.
+ * @param element Element data
+ */
+export declare const getElementRange: (element: PPTElement) => {
+    minX: any;
+    maxX: any;
+    minY: any;
+    maxY: any;
+};
+export type ElementRangeAlign = {
+    minX?: number;
+    maxX?: number;
+    centerX?: number;
+    minY?: number;
+    maxY?: number;
+    centerY?: number;
+};
+/**
+ * Shift left/top so the element's painted AABB matches the given edges or centers.
+ * Lines use control-point bounds, not the start–end chord.
+ */
+export declare const alignElementToRange: (element: PPTElement, target: ElementRangeAlign) => void;
+/**
+ * Combined axis-aligned bounds of multiple elements on the canvas.
+ * @param elementList Elements to measure
+ */
+export declare const getElementListRange: (elementList: PPTElement[]) => {
+    minX: number;
+    maxX: number;
+    minY: number;
+    maxY: number;
+};
+/**
+ * Whether the selection is the full membership of a single group.
+ * @param elements Selected elements
+ */
+export declare const isSingleGroupSelection: (elements: PPTElement[]) => boolean;
+/**
+ * Whether the group can be rotated as a unit.
+ * @param elements Group members
+ */
+export declare const canRotateGroupElements: (elements: PPTElement[]) => boolean;
+/**
+ * Center of the combined bounds of a set of elements.
+ * @param elements Elements in the group
+ * @param rotate Reference rotation: bounds are aligned to this angle before computing the center
+ */
+export declare const getGroupElementCenter: (elements: PPTElement[], rotate?: number) => Point;
+/**
+ * Normalize an angle to the [-180, 180] range.
+ * @param angle Angle in degrees
+ */
+export declare const normalizeAngle: (angle: number) => number;
+/**
+ * Rotate a point around a center by the given angle.
+ * @param point Point to rotate
+ * @param center Rotation center
+ * @param angle Rotation in degrees
+ */
+export declare const rotatePoint: (point: Point, center: Point, angle: number) => Point;
+/**
+ * Rotate a rect-like element by rotating its center and adding to `rotate`.
+ * @param element Element to rotate
+ * @param center Group rotation center
+ * @param angle Rotation in degrees
+ */
+export declare const rotateRectLikeElement: (element: Exclude<PPTElement, PPTLineElement>, center: Point, angle: number) => {
+    id: string;
+    lock?: boolean;
+    groupId?: string;
+    width: number;
+    height: number;
+    link?: import("../types/slides").PPTElementLink;
+    name?: string;
+    source?: import("../types/slides").ElementSource;
+    effects?: import("../types/slides").PPTElementEffects;
+    type: 'audio';
+    fixedRatio: boolean;
+    color: string;
+    loop: boolean;
+    autoplay: boolean;
+    src: string;
+    poster?: string;
+    ext?: string;
+    left: number;
+    top: number;
+    rotate: number;
+} | {
+    id: string;
+    lock?: boolean;
+    groupId?: string;
+    width: number;
+    height: number;
+    link?: import("../types/slides").PPTElementLink;
+    name?: string;
+    source?: import("../types/slides").ElementSource;
+    effects?: import("../types/slides").PPTElementEffects;
+    type: 'chart';
+    fill?: string;
+    chartType: import("../types/slides").ChartType;
+    data: import("../types/slides").ChartData;
+    options?: import("../types/slides").ChartOptions;
+    outline?: import("../types/slides").PPTElementOutline;
+    themeColors: string[];
+    textColor?: string;
+    lineColor?: string;
+    left: number;
+    top: number;
+    rotate: number;
+} | {
+    id: string;
+    lock?: boolean;
+    groupId?: string;
+    width: number;
+    height: number;
+    link?: import("../types/slides").PPTElementLink;
+    name?: string;
+    source?: import("../types/slides").ElementSource;
+    effects?: import("../types/slides").PPTElementEffects;
+    type: 'code';
+    code: string;
+    language: string;
+    theme: string;
+    fontSize: number;
+    showLineNumbers: boolean;
+    left: number;
+    top: number;
+    rotate: number;
+} | {
+    id: string;
+    lock?: boolean;
+    groupId?: string;
+    width: number;
+    height: number;
+    link?: import("../types/slides").PPTElementLink;
+    name?: string;
+    source?: import("../types/slides").ElementSource;
+    effects?: import("../types/slides").PPTElementEffects;
+    type: 'image';
+    fixedRatio: boolean;
+    src: string;
+    outline?: import("../types/slides").PPTElementOutline;
+    filters?: import("../types/slides").ImageElementFilters;
+    clip?: import("../types/slides").ImageElementClip;
+    flipH?: boolean;
+    flipV?: boolean;
+    shadow?: import("../types/slides").PPTElementShadow;
+    radius?: number;
+    colorMask?: string;
+    imageType?: import("../types/slides").ImageType;
+    left: number;
+    top: number;
+    rotate: number;
+} | {
+    id: string;
+    lock?: boolean;
+    groupId?: string;
+    width: number;
+    height: number;
+    link?: import("../types/slides").PPTElementLink;
+    name?: string;
+    source?: import("../types/slides").ElementSource;
+    effects?: import("../types/slides").PPTElementEffects;
+    type: 'latex';
+    latex: string;
+    path: string;
+    color: string;
+    strokeWidth: number;
+    viewBox: [number, number];
+    fixedRatio: boolean;
+    left: number;
+    top: number;
+    rotate: number;
+} | {
+    id: string;
+    lock?: boolean;
+    groupId?: string;
+    width: number;
+    height: number;
+    link?: import("../types/slides").PPTElementLink;
+    name?: string;
+    source?: import("../types/slides").ElementSource;
+    effects?: import("../types/slides").PPTElementEffects;
+    type: 'mermaid';
+    code: string;
+    left: number;
+    top: number;
+    rotate: number;
+} | {
+    id: string;
+    lock?: boolean;
+    groupId?: string;
+    width: number;
+    height: number;
+    link?: import("../types/slides").PPTElementLink;
+    name?: string;
+    source?: import("../types/slides").ElementSource;
+    effects?: import("../types/slides").PPTElementEffects;
+    type: 'shape';
+    viewBox: [number, number];
+    path: string;
+    fixedRatio: boolean;
+    fill: string;
+    gradient?: import("../types/slides").Gradient;
+    pattern?: string;
+    outline?: import("../types/slides").PPTElementOutline;
+    opacity?: number;
+    flipH?: boolean;
+    flipV?: boolean;
+    shadow?: import("../types/slides").PPTElementShadow;
+    special?: boolean;
+    text?: import("../types/slides").ShapeText;
+    pathFormula?: import("../types/slides").ShapePathFormulasKeys;
+    keypoints?: number[];
+    left: number;
+    top: number;
+    rotate: number;
+} | {
+    id: string;
+    lock?: boolean;
+    groupId?: string;
+    width: number;
+    height: number;
+    link?: import("../types/slides").PPTElementLink;
+    name?: string;
+    source?: import("../types/slides").ElementSource;
+    effects?: import("../types/slides").PPTElementEffects;
+    type: 'table';
+    outline: import("../types/slides").PPTElementOutline;
+    theme?: import("../types/slides").TableTheme;
+    colWidths: number[];
+    cellMinHeight: number;
+    data: import("../types/slides").TableCell[][];
+    left: number;
+    top: number;
+    rotate: number;
+} | {
+    id: string;
+    lock?: boolean;
+    groupId?: string;
+    width: number;
+    height: number;
+    link?: import("../types/slides").PPTElementLink;
+    name?: string;
+    source?: import("../types/slides").ElementSource;
+    effects?: import("../types/slides").PPTElementEffects;
+    type: 'text';
+    content: string;
+    defaultFontName: string;
+    defaultColor: string;
+    placeholder?: string;
+    placeholderFontSize?: number;
+    placeholderColor?: string;
+    placeholderAlign?: import("../types/slides").TextAlign;
+    placeholderBold?: boolean;
+    placeholderItalic?: boolean;
+    placeholderLayoutHeight?: number;
+    outline?: import("../types/slides").PPTElementOutline;
+    fill?: string;
+    lineHeight?: number;
+    wordSpace?: number;
+    opacity?: number;
+    shadow?: import("../types/slides").PPTElementShadow;
+    paragraphSpace?: number;
+    vertical?: boolean;
+    textType?: import("../types/slides").TextType;
+    inset?: import("../types/slides").TextInset;
+    fixedHeight?: boolean;
+    vAlign?: import("../types/slides").TextAlignVertical;
+    structuredText?: import("../types/slides").StructuredTextBody;
+    left: number;
+    top: number;
+    rotate: number;
+} | {
+    id: string;
+    lock?: boolean;
+    groupId?: string;
+    width: number;
+    height: number;
+    link?: import("../types/slides").PPTElementLink;
+    name?: string;
+    source?: import("../types/slides").ElementSource;
+    effects?: import("../types/slides").PPTElementEffects;
+    type: 'video';
+    src: string;
+    autoplay: boolean;
+    poster?: string;
+    ext?: string;
+    left: number;
+    top: number;
+    rotate: number;
+};
+/**
+ * Rotate a line element by rotating all control points and rebuilding line data.
+ * @param element Line element
+ * @param center Group rotation center
+ * @param angle Rotation in degrees
+ */
+export declare const rotateLineElement: (element: PPTLineElement, center: Point, angle: number) => PPTLineElement;
+export declare const getLineElementLength: (element: PPTLineElement) => number;
+export declare const getBroken2LineDirection: (element: PPTLineElement) => import("../types/slides").Broken2LineDirection;
+export interface AlignLine {
+    value: number;
+    range: [number, number];
+}
+/**
+ * Deduplicate alignment snap lines at the same position; merge their ranges to min/max.
+ * @param lines Alignment snap lines
+ */
+export declare const uniqAlignLines: (lines: AlignLine[]) => AlignLine[];
+/**
+ * Map each slide id to a new id (used when duplicating slides to preserve references).
+ * @param slides Slide list
+ */
+export declare const createSlideIdMap: (slides: Slide[]) => IdMap;
+/**
+   * Map each element (and group) id to a new id when copying elements.
+   * e.g. two grouped elements keep the same new groupId after copy.
+   * @param elements Element list
+   */
+export declare const createElementIdMap: (elements: PPTElement[]) => {
+    groupIdMap: IdMap;
+    elIdMap: IdMap;
+};
+/**
+ * Header is the opaque theme color (ink by default). Body stripes are a fixed
+ * zinc paper pair so a blue accent can never wash the grid.
+ */
+export declare const getTableThemeColors: (themeColor: string) => {
+    header: string;
+    stripe: string;
+    stripeAlt: string;
+};
+/**
+ * SVG path `d` attribute for a line element (logical geometry).
+ * @param element Line element
+ */
+export declare const getLineElementPath: (element: PPTLineElement) => string;
+/**
+ * SVG path for rendering a line: markers stay at original start/end; stroke is inset at caps.
+ * @param element Line element
+ */
+export declare const getLineElementRenderPath: (element: PPTLineElement) => string;
+/**
+ * Whether an element is fully visible within a scroll parent's viewport (vertical).
+ * @param element DOM element
+ * @param parent Scroll container
+ */
+export declare const isElementInViewport: (element: HTMLElement, parent: HTMLElement) => boolean;
+export {};

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

@@ -0,0 +1,8 @@
+import type { PPTElement } from '../types/slides';
+export type ElementOrderCommand = 'up' | 'down' | 'top' | 'bottom';
+/**
+ * Excel-style z-order: a group (or multi-selection) moves as one block,
+ * keeping members' relative order. Neighboring groups are skipped as a unit.
+ */
+export declare function collectOrderUnitIds(elementList: PPTElement[], seedIds: string[]): string[];
+export declare function orderElementList(elementList: PPTElement[], seedIds: string[], command: ElementOrderCommand): PPTElement[] | null;

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

@@ -0,0 +1,41 @@
+import type { LineStyleType, PPTElementOutline } from '../types/slides';
+/** Clamp corner radius to half the shorter box side. */
+export declare const clampOutlineRadius: (radius: number, width: number, height: number) => number;
+export declare const outlineRadiusCss: (radius: number | undefined, width: number, height: number) => string | undefined;
+/** SVG path for a rectangular outline (optionally rounded). */
+export declare const roundedRectOutlinePath: (width: number, height: number, radius?: number) => string;
+/** pptxgenjs `rectRadius` is 0–1 relative to the shorter side. */
+export declare const outlineRadiusToPptxRectRadius: (radius: number, width: number, height: number) => number;
+/** pptxtojson emits border colors as a structured solid/gradient object. */
+export type PptxBorderColor = string | {
+    type: 'color';
+    value: string;
+} | {
+    type: 'gradient';
+    value: {
+        colors: {
+            color: string;
+            pos: string;
+        }[];
+        path: string;
+        rot: number;
+    };
+};
+/**
+ * Flatten a pptxtojson border color to the single CSS color Fika outlines
+ * and lines support. Gradient strokes fall back to their first stop.
+ */
+export declare const pptxBorderColorToString: (borderColor?: PptxBorderColor) => string | undefined;
+interface PptxOutlineSource {
+    borderColor?: PptxBorderColor;
+    borderWidth?: number;
+    borderType?: LineStyleType;
+    shapType?: string;
+    keypoints?: Record<string, number>;
+    width: number;
+    height: number;
+}
+export declare const importOutlineFromPptx: (el: PptxOutlineSource, ratio: number, options?: {
+    includeCornerRadius?: boolean;
+}) => PPTElementOutline;
+export {};

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

@@ -0,0 +1,54 @@
+import { type Emitter } from 'mitt';
+export declare const enum EmitterEvents {
+    RICH_TEXT_COMMAND = "RICH_TEXT_COMMAND",
+    TABLE_COMMAND = "TABLE_COMMAND",
+    SYNC_RICH_TEXT_ATTRS_TO_STORE = "SYNC_RICH_TEXT_ATTRS_TO_STORE",
+    OPEN_CHART_DATA_EDITOR = "OPEN_CHART_DATA_EDITOR",
+    OPEN_LATEX_EDITOR = "OPEN_LATEX_EDITOR",
+    OPEN_MERMAID_EDITOR = "OPEN_MERMAID_EDITOR",
+    OPEN_CODE_EDITOR = "OPEN_CODE_EDITOR",
+    OPEN_INLINE_MATH_EDITOR = "OPEN_INLINE_MATH_EDITOR",
+    APPLY_INLINE_MATH = "APPLY_INLINE_MATH"
+}
+export interface RichTextAction {
+    command: string;
+    value?: string;
+}
+export interface RichTextCommand {
+    target?: string;
+    action: RichTextAction | RichTextAction[];
+}
+export interface TableCommand {
+    targetId: string;
+    command: 'insert-row' | 'insert-col' | 'delete-row' | 'delete-col';
+    position?: 'before' | 'after';
+}
+/** Request to open the inline-math (MathLive) editor for a math node in a text element. */
+export interface OpenInlineMathPayload {
+    elementId: string;
+    /** Document position immediately before the math node (for `setNodeMarkup`). */
+    pos: number;
+    latex: string;
+    display: boolean;
+}
+/** Result of editing an inline-math node, applied back to its text element. */
+export interface ApplyInlineMathPayload {
+    elementId: string;
+    pos: number;
+    latex: string;
+    html: string;
+    display: boolean;
+}
+type Events = {
+    [EmitterEvents.RICH_TEXT_COMMAND]: RichTextCommand;
+    [EmitterEvents.TABLE_COMMAND]: TableCommand;
+    [EmitterEvents.SYNC_RICH_TEXT_ATTRS_TO_STORE]: void;
+    [EmitterEvents.OPEN_CHART_DATA_EDITOR]: void;
+    [EmitterEvents.OPEN_LATEX_EDITOR]: void;
+    [EmitterEvents.OPEN_MERMAID_EDITOR]: string;
+    [EmitterEvents.OPEN_CODE_EDITOR]: string;
+    [EmitterEvents.OPEN_INLINE_MATH_EDITOR]: OpenInlineMathPayload;
+    [EmitterEvents.APPLY_INLINE_MATH]: ApplyInlineMathPayload;
+};
+declare const emitter: Emitter<Events>;
+export default emitter;

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

@@ -0,0 +1,22 @@
+/**
+ * Font embedding for PPTX export.
+ *
+ * Collects the non-system font families actually used in the deck, fetches their
+ * woff2 bytes (bundled via `new URL(...)` so Vite emits them), decompresses
+ * woff2 → TTF (via wawoff2), and returns `AddFontOptions[]` for `pptx.addFont()`.
+ * PPTX embeds fonts as EOT-wrapped data and pptxgenjs handles TTF/OTF directly,
+ * so the only required step is woff2 → TTF decompression.
+ */
+import type pptxgen from 'pptxgenjs-plus';
+type AddFontOptions = Parameters<pptxgen['addFont']>[0];
+/** Collect candidate font families from a CSS font-family string. */
+export declare const parseFontFamilyList: (value?: string) => string[];
+/** Decide whether a family should be embedded (custom, not a system font). */
+export declare const isEmbeddableFont: (family: string) => boolean;
+/**
+ * Embed fonts used in the deck into the PPTX.
+ * `usedFamilies` should be the raw font-family strings gathered from elements/theme.
+ * Silently skips families that are system fonts, have no bundled file, or fail to load.
+ */
+export declare const collectEmbeddedFonts: (usedFamilies: string[]) => Promise<AddFontOptions[]>;
+export {};

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

@@ -0,0 +1,17 @@
+export type FitLabelParams = {
+    text: string;
+    width: number;
+    height: number;
+    maxFontSize: number;
+    minFontSize: number;
+    fontWeight: number | string;
+    fontStyle: string;
+    fontFamily: string;
+    letterSpacing: number;
+    lineHeight: number;
+    maxLines: number;
+    locale: string;
+};
+export declare const lastFitLabelSize: (params: Omit<FitLabelParams, 'width' | 'height'>) => number;
+/** Largest size in [min, max] that fits `width` × `height` in `maxLines`. One prepare, one width read. */
+export declare function fitLabelFontSize(params: FitLabelParams): number;

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

@@ -0,0 +1,14 @@
+import { type PptxUsedFont } from './pptxImportFonts';
+export { normalizePptxUsedFonts, pptxUsedFontName, registerEmbeddedFonts, splitImportedFontFace } from './pptxImportFonts';
+export type { NormalizedPptxFont, PptxUsedFont, PptxUsedFontObject } from './pptxImportFonts';
+export declare const isSystemFont: (font: string) => boolean;
+/**
+ * Collect every font family a deck references: inline `font-family` styles in
+ * text/table HTML content plus explicit font props (`defaultFontName`, table
+ * `fontname`, theme `fontName`). Feed the result to {@link loadGoogleFonts}
+ * whenever a whole document is applied — importing a .pptx is not the only
+ * entry point (hosts set persisted documents directly), and a persisted deck
+ * re-opened later must load its webfonts again.
+ */
+export declare const collectSlidesFonts: (slides: unknown) => string[];
+export declare const loadGoogleFonts: (usedFonts?: readonly unknown[] | PptxUsedFont[]) => void;

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