fika-editor 3.0.0 → 3.0.1

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

@@ -0,0 +1,369 @@
+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;
+};
+/**
+ * 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;
+};
+/**
+ * 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/elementPaint.d.ts

@@ -0,0 +1,129 @@
+import type { Gradient, ImageElementClip, ImageElementFilters, LineStyleType, PPTElementOutline, PPTElementShadow, PPTImageElement, PPTLineElement, SlideBackgroundImageSize } from '../types/slides';
+/** Line elements store stroke thickness in `width` (not a bounding-box width). */
+export declare const lineStrokeWidth: (element: Pick<PPTLineElement, 'width'>) => number;
+export declare const shadowPaint: (shadow?: PPTElementShadow | null) => {
+    shadowColor?: undefined;
+    shadowBlur?: undefined;
+    shadowOffsetX?: undefined;
+    shadowOffsetY?: undefined;
+    shadowOpacity?: undefined;
+} | {
+    shadowColor: string;
+    shadowBlur: number;
+    shadowOffsetX: number;
+    shadowOffsetY: number;
+    shadowOpacity: number;
+};
+export declare const outlineDashArray: (style: LineStyleType | undefined, width: number) => number[] | undefined;
+export declare const lineDashArray: (style: LineStyleType, strokeWidth: number) => number[] | undefined;
+export declare const outlineStrokePaint: (outline?: PPTElementOutline) => {
+    strokeEnabled: false;
+    stroke?: undefined;
+    strokeWidth?: undefined;
+    strokeScaleEnabled?: undefined;
+    lineCap?: undefined;
+    miterLimit?: undefined;
+    dash?: undefined;
+    dashEnabled?: undefined;
+} | {
+    stroke: string;
+    strokeWidth: number;
+    strokeScaleEnabled: boolean;
+    lineCap: 'butt';
+    miterLimit: number;
+    dash: number[];
+    dashEnabled: boolean;
+    strokeEnabled: true;
+};
+export declare const imageOpacity: (filters?: ImageElementFilters) => number;
+export declare const imageCropRect: (clip: ImageElementClip | undefined, imgW: number, imgH: number) => {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+} | undefined;
+export declare const imageCornerRadius: (element: PPTImageElement) => number;
+export declare const imageClipKind: (element: PPTImageElement) => 'rect' | 'ellipse' | 'polygon';
+type PathCtx = {
+    beginPath: () => void;
+    moveTo: (x: number, y: number) => void;
+    lineTo: (x: number, y: number) => void;
+    closePath: () => void;
+    rect: (x: number, y: number, width: number, height: number) => void;
+    roundRect: (x: number, y: number, width: number, height: number, radii: number) => void;
+    ellipse: (x: number, y: number, radiusX: number, radiusY: number, rotation: number, startAngle: number, endAngle: number) => void;
+};
+export declare const drawSvgPolyline: (ctx: Pick<PathCtx, 'moveTo' | 'lineTo' | 'closePath'>, d: string) => void;
+export declare const drawImageClip: (ctx: PathCtx, element: PPTImageElement) => void;
+export declare const imageClipPathData: (element: PPTImageElement) => string | undefined;
+export declare const linearGradientPaint: (width: number, height: number, gradient: Gradient) => {
+    fillLinearGradientStartPoint: {
+        x: number;
+        y: number;
+    };
+    fillLinearGradientEndPoint: {
+        x: number;
+        y: number;
+    };
+    fillLinearGradientColorStops: (string | number)[];
+};
+export declare const radialGradientPaint: (width: number, height: number, gradient: Gradient, origin?: 'center' | 'css') => {
+    fillRadialGradientStartPoint: {
+        x: number;
+        y: number;
+    };
+    fillRadialGradientStartRadius: number;
+    fillRadialGradientEndPoint: {
+        x: number;
+        y: number;
+    };
+    fillRadialGradientEndRadius: number;
+    fillRadialGradientColorStops: (string | number)[];
+};
+export declare const shapeFillPaint: (width: number, height: number, fill: string, gradient?: Gradient) => {
+    fillLinearGradientStartPoint: {
+        x: number;
+        y: number;
+    };
+    fillLinearGradientEndPoint: {
+        x: number;
+        y: number;
+    };
+    fillLinearGradientColorStops: (string | number)[];
+} | {
+    fillRadialGradientStartPoint: {
+        x: number;
+        y: number;
+    };
+    fillRadialGradientStartRadius: number;
+    fillRadialGradientEndPoint: {
+        x: number;
+        y: number;
+    };
+    fillRadialGradientEndRadius: number;
+    fillRadialGradientColorStops: (string | number)[];
+} | {
+    fillEnabled: false;
+    fill?: undefined;
+} | {
+    fillEnabled?: undefined;
+    fill: string;
+};
+export declare const patternCoverPaint: (imgW: number, imgH: number, boxW: number, boxH: number) => {
+    fillPatternScaleX: number;
+    fillPatternScaleY: number;
+    fillPatternX: number;
+    fillPatternY: number;
+    fillPatternRepeat: string;
+};
+export declare const fitRect: (imgW: number, imgH: number, boxW: number, boxH: number, mode: Exclude<SlideBackgroundImageSize, 'repeat'>) => {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+};
+export declare const linePolylinePoints: (element: PPTLineElement) => number[] | null;
+export declare const canvasFromBitmap: (bitmap: ImageBitmap) => HTMLCanvasElement;
+/** Konva's config types list HTMLImageElement; runtime also accepts canvas. */
+export declare const patternImageSource: (bitmap: ImageBitmap) => HTMLImageElement;
+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;