fetta 1.4.4 → 1.5.1

package/dist/helpers.d.ts

@@ -0,0 +1,46 @@
+import { S as SplitTextResult } from './index-c1UKfWWK.js';
+
+type SplitUnit = "chars" | "words" | "lines";
+type StyleInput = Partial<CSSStyleDeclaration> | ((ctx: {
+    index: number;
+    unit: SplitUnit;
+    original: HTMLSpanElement;
+}) => Partial<CSSStyleDeclaration>);
+type ClassInput = string | ((ctx: {
+    index: number;
+    unit: SplitUnit;
+    original: HTMLSpanElement;
+}) => string | undefined);
+interface CreateSplitClonesOptions {
+    unit: SplitUnit;
+    wrap?: boolean;
+    display?: "auto" | "inline-block" | "block";
+    cloneOffset?: {
+        axis?: "x" | "y";
+        direction?: "start" | "end";
+        distance?: string;
+    };
+    trackClassName?: ClassInput;
+    cloneClassName?: ClassInput;
+    trackStyle?: StyleInput;
+    cloneStyle?: StyleInput;
+}
+interface SplitCloneItem {
+    index: number;
+    original: HTMLSpanElement;
+    clone: HTMLSpanElement;
+    track: HTMLSpanElement | null;
+}
+interface CreateSplitClonesResult {
+    unit: SplitUnit;
+    originals: HTMLSpanElement[];
+    clones: HTMLSpanElement[];
+    tracks: HTMLSpanElement[];
+    items: SplitCloneItem[];
+    cleanup: (options?: {
+        revertSplit?: boolean;
+    }) => void;
+}
+declare function createSplitClones(split: SplitTextResult, options: CreateSplitClonesOptions): CreateSplitClonesResult;
+
+export { type ClassInput, type CreateSplitClonesOptions, type CreateSplitClonesResult, type SplitCloneItem, type SplitUnit, type StyleInput, createSplitClones };

package/dist/helpers.js

@@ -0,0 +1,121 @@
+import './chunk-ORMEWXMH.js';
+
+// src/helpers/createSplitClones.ts
+function resolveDisplay(display, unit) {
+  if (display && display !== "auto") return display;
+  return unit === "lines" ? "block" : "inline-block";
+}
+function applyClass(element, classInput, ctx) {
+  if (!classInput) return;
+  const className = typeof classInput === "function" ? classInput(ctx) : classInput;
+  if (!className) return;
+  const classes = className.split(/\s+/).filter(Boolean);
+  if (classes.length > 0) {
+    element.classList.add(...classes);
+  }
+}
+function applyStyle(element, styleInput, ctx) {
+  if (!styleInput) return;
+  const styles = typeof styleInput === "function" ? styleInput(ctx) : styleInput;
+  for (const [key, value] of Object.entries(styles)) {
+    if (value !== void 0 && value !== null) {
+      element.style[key] = value;
+    }
+  }
+}
+function normalizeOffset(direction, distance) {
+  const trimmed = distance.trim();
+  if (direction === "start") {
+    return trimmed.startsWith("-") ? trimmed : `-${trimmed}`;
+  }
+  return trimmed.startsWith("-") ? trimmed.slice(1) : trimmed;
+}
+function applyCloneOffset(clone, cloneOffset) {
+  var _a, _b, _c;
+  const axis = (_a = cloneOffset == null ? void 0 : cloneOffset.axis) != null ? _a : "y";
+  const direction = (_b = cloneOffset == null ? void 0 : cloneOffset.direction) != null ? _b : "start";
+  const distance = (_c = cloneOffset == null ? void 0 : cloneOffset.distance) != null ? _c : "100%";
+  const offset = normalizeOffset(direction, distance);
+  clone.style.position = "absolute";
+  if (axis === "y") {
+    clone.style.left = "0";
+    clone.style.top = offset;
+  } else {
+    clone.style.top = "0";
+    clone.style.left = offset;
+  }
+}
+function resolveOriginals(split, unit) {
+  if (unit === "chars") return split.chars;
+  if (unit === "words") return split.words;
+  if (unit === "lines") return split.lines;
+  throw new Error(`createSplitClones: unsupported unit "${unit}"`);
+}
+function createSplitClones(split, options) {
+  var _a;
+  const unit = options.unit;
+  const wrap = (_a = options.wrap) != null ? _a : false;
+  const originals = resolveOriginals(split, unit);
+  const clones = [];
+  const tracks = [];
+  const items = [];
+  let didCleanup = false;
+  originals.forEach((original, index) => {
+    const parent = original.parentElement;
+    if (!parent) return;
+    const ctx = { index, unit, original };
+    let track = null;
+    if (wrap) {
+      track = document.createElement("span");
+      track.style.position = "relative";
+      track.style.display = resolveDisplay(options.display, unit);
+      applyClass(track, options.trackClassName, ctx);
+      applyStyle(track, options.trackStyle, ctx);
+      parent.insertBefore(track, original);
+      track.appendChild(original);
+      tracks.push(track);
+    }
+    const clone = original.cloneNode(true);
+    applyCloneOffset(clone, options.cloneOffset);
+    applyClass(clone, options.cloneClassName, ctx);
+    applyStyle(clone, options.cloneStyle, ctx);
+    const host = original.parentElement;
+    if (!host) return;
+    host.appendChild(clone);
+    clones.push(clone);
+    items.push({
+      index,
+      original,
+      clone,
+      track
+    });
+  });
+  const cleanup = (cleanupOptions) => {
+    if (didCleanup) return;
+    didCleanup = true;
+    for (const item of items) {
+      item.clone.remove();
+    }
+    for (const item of items) {
+      if (!item.track) continue;
+      const trackParent = item.track.parentNode;
+      if (trackParent) {
+        trackParent.insertBefore(item.original, item.track);
+      }
+      item.track.remove();
+    }
+    if (cleanupOptions == null ? void 0 : cleanupOptions.revertSplit) {
+      split.revert();
+    }
+  };
+  return {
+    unit,
+    originals,
+    clones,
+    tracks,
+    items,
+    cleanup
+  };
+}
+
+export { createSplitClones };

package/dist/index-c1UKfWWK.d.ts

@@ -0,0 +1,144 @@
+/** Animation object shape used by Motion's `animate` return value. */
+type FinishedAnimation = {
+    finished: Promise<unknown>;
+};
+/** Generic thenable animation object (e.g. GSAP Tween/Timeline). */
+type ThenableAnimation = {
+    then: (onFulfilled?: ((result: unknown) => unknown) | undefined) => unknown;
+};
+type AnimationCallbackValue = FinishedAnimation | ThenableAnimation | Promise<unknown>;
+/** Callback return type accepted by revertOnComplete normalization. */
+type AnimationCallbackReturn = void | AnimationCallbackValue | AnimationCallbackReturn[];
+/**
+ * Configuration options for the splitText function.
+ *
+ * @example
+ * ```typescript
+ * const options: SplitTextOptions = {
+ *   type: "chars,words,lines",
+ *   charClass: "char",
+ *   mask: "lines",
+ *   autoSplit: true,
+ * };
+ * ```
+ */
+interface SplitTextOptions {
+    /** Split type: chars, words, lines, or combinations like "chars,words" */
+    type?: "chars" | "words" | "lines" | "chars,words" | "words,lines" | "chars,lines" | "chars,words,lines";
+    charClass?: string;
+    wordClass?: string;
+    lineClass?: string;
+    /** Apply overflow mask wrapper to elements for reveal animations */
+    mask?: "lines" | "words" | "chars";
+    /** Auto-split on resize (observes parent element) */
+    autoSplit?: boolean;
+    /** Callback when autoSplit/full-resplit replaces split output elements */
+    onResplit?: (result: Omit<SplitTextResult, "revert" | "dispose">) => void;
+    /** Callback fired after text is split, receives split elements. Return animation for revertOnComplete. */
+    onSplit?: (result: {
+        chars: HTMLSpanElement[];
+        words: HTMLSpanElement[];
+        lines: HTMLSpanElement[];
+    }) => AnimationCallbackReturn;
+    /** Auto-revert when onSplit animation completes */
+    revertOnComplete?: boolean;
+    /** Add CSS custom properties (--char-index, --word-index, --line-index) */
+    propIndex?: boolean;
+    /** Skip kerning compensation (no margin adjustments applied).
+     * Kerning is naturally lost when splitting into inline-block spans.
+     * Use this if you prefer no compensation over imperfect Safari compensation. */
+    disableKerning?: boolean;
+    /** Apply initial inline styles to elements after split (and after kerning compensation).
+     * Can be a static style object or a function that receives (element, index). */
+    initialStyles?: {
+        chars?: InitialStyle;
+        words?: InitialStyle;
+        lines?: InitialStyle;
+    };
+    /** Apply initial classes to elements after split (and after kerning compensation).
+     * Classes are added via classList.add() and support space-separated class names. */
+    initialClasses?: {
+        chars?: string;
+        words?: string;
+        lines?: string;
+    };
+}
+type CSSVariableStyles = {
+    [K in `--${string}`]?: string | number;
+};
+/** Style value for initialStyles - CSS-like properties with numeric value support */
+type InitialStyleValue = {
+    [property: string]: string | number | undefined;
+} & CSSVariableStyles;
+/** Function that returns styles based on element and index */
+type InitialStyleFn = (element: HTMLElement, index: number) => InitialStyleValue;
+/** Initial style can be a static object or a function */
+type InitialStyle = InitialStyleValue | InitialStyleFn;
+/**
+ * Result returned by splitText containing arrays of split elements and a revert function.
+ *
+ * Each array contains the created span elements. Empty arrays are returned for
+ * split types not requested (e.g., if `type: "words"`, chars and lines will be empty).
+ */
+interface SplitTextResult {
+    /** Array of character span elements (empty if chars not in type) */
+    chars: HTMLSpanElement[];
+    /** Array of word span elements (empty if words not in type) */
+    words: HTMLSpanElement[];
+    /** Array of line span elements (empty if lines not in type) */
+    lines: HTMLSpanElement[];
+    /** Revert the element to its original HTML and cleanup all observers/timers */
+    revert: () => void;
+}
+/**
+ * Split text into characters, words, and lines with kerning compensation.
+ *
+ * Fetta measures character positions before splitting, then applies margin adjustments
+ * after splitting to preserve the original kerning (letter spacing). This prevents
+ * the visual "jumping" that occurs with naive text splitting.
+ *
+ * @param element - The HTML element containing text to split. Must have text content.
+ * @param options - Configuration options for splitting behavior
+ * @returns Object containing arrays of split elements and a revert function
+ *
+ * @throws {Error} If element is not an HTMLElement
+ *
+ * @example
+ * ```typescript
+ * import { splitText } from "fetta";
+ * import { animate, stagger } from "motion";
+ *
+ * // Basic usage
+ * const { chars, words, lines, revert } = splitText(element);
+ *
+ * // Animate words
+ * animate(words, { opacity: [0, 1], y: [20, 0] }, { delay: stagger(0.05) });
+ *
+ * // Revert to original HTML when done
+ * revert();
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Auto-revert after animation completes
+ * splitText(element, {
+ *   onSplit: ({ words }) => animate(words, { opacity: [0, 1] }),
+ *   revertOnComplete: true,
+ * });
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Responsive re-splitting
+ * splitText(element, {
+ *   autoSplit: true,
+ *   onResplit: ({ lines }) => {
+ *     // Re-animate after resize
+ *     animate(lines, { opacity: [0, 1] });
+ *   },
+ * });
+ * ```
+ */
+declare function splitText(element: HTMLElement, rawOptions?: SplitTextOptions): SplitTextResult;
+
+export { type AnimationCallbackReturn as A, type SplitTextResult as S, type SplitTextOptions as a, splitText as s };

package/dist/index.d.ts

@@ -1,137 +1 @@
-/**
- * Custom splitText implementation with built-in kerning compensation.
- * Measures kerning between character pairs, splits text into spans,
- * applies margin compensation, and detects lines based on rendered positions.
- */
-/**
- * Configuration options for the splitText function.
- *
- * @example
- * ```typescript
- * const options: SplitTextOptions = {
- *   type: "chars,words,lines",
- *   charClass: "char",
- *   mask: "lines",
- *   autoSplit: true,
- * };
- * ```
- */
-interface SplitTextOptions {
-    /** Split type: chars, words, lines, or combinations like "chars,words" */
-    type?: "chars" | "words" | "lines" | "chars,words" | "words,lines" | "chars,lines" | "chars,words,lines";
-    charClass?: string;
-    wordClass?: string;
-    lineClass?: string;
-    /** Apply overflow mask wrapper to elements for reveal animations */
-    mask?: "lines" | "words" | "chars";
-    /** Auto-split on resize (observes parent element) */
-    autoSplit?: boolean;
-    /** Callback when resize triggers re-split (does not re-trigger initial animations) */
-    onResize?: (result: Omit<SplitTextResult, "revert" | "dispose">) => void;
-    /** Callback fired after text is split, receives split elements. Return animation for revertOnComplete. */
-    onSplit?: (result: {
-        chars: HTMLSpanElement[];
-        words: HTMLSpanElement[];
-        lines: HTMLSpanElement[];
-    }) => void | {
-        finished: Promise<unknown>;
-    } | Array<{
-        finished: Promise<unknown>;
-    }> | Promise<unknown>;
-    /** Auto-revert when onSplit animation completes */
-    revertOnComplete?: boolean;
-    /** Add CSS custom properties (--char-index, --word-index, --line-index) */
-    propIndex?: boolean;
-    /** Skip kerning compensation (no margin adjustments applied).
-     * Kerning is naturally lost when splitting into inline-block spans.
-     * Use this if you prefer no compensation over imperfect Safari compensation. */
-    disableKerning?: boolean;
-    /** Apply initial inline styles to elements after split (and after kerning compensation).
-     * Can be a static style object or a function that receives (element, index). */
-    initialStyles?: {
-        chars?: InitialStyle;
-        words?: InitialStyle;
-        lines?: InitialStyle;
-    };
-    /** Apply initial classes to elements after split (and after kerning compensation).
-     * Classes are added via classList.add() and support space-separated class names. */
-    initialClasses?: {
-        chars?: string;
-        words?: string;
-        lines?: string;
-    };
-}
-/** Style value for initialStyles - a partial CSSStyleDeclaration object */
-type InitialStyleValue = Partial<CSSStyleDeclaration>;
-/** Function that returns styles based on element and index */
-type InitialStyleFn = (element: HTMLElement, index: number) => InitialStyleValue;
-/** Initial style can be a static object or a function */
-type InitialStyle = InitialStyleValue | InitialStyleFn;
-/**
- * Result returned by splitText containing arrays of split elements and a revert function.
- *
- * Each array contains the created span elements. Empty arrays are returned for
- * split types not requested (e.g., if `type: "words"`, chars and lines will be empty).
- */
-interface SplitTextResult {
-    /** Array of character span elements (empty if chars not in type) */
-    chars: HTMLSpanElement[];
-    /** Array of word span elements (empty if words not in type) */
-    words: HTMLSpanElement[];
-    /** Array of line span elements (empty if lines not in type) */
-    lines: HTMLSpanElement[];
-    /** Revert the element to its original HTML and cleanup all observers/timers */
-    revert: () => void;
-}
-/**
- * Split text into characters, words, and lines with kerning compensation.
- *
- * Fetta measures character positions before splitting, then applies margin adjustments
- * after splitting to preserve the original kerning (letter spacing). This prevents
- * the visual "jumping" that occurs with naive text splitting.
- *
- * @param element - The HTML element containing text to split. Must have text content.
- * @param options - Configuration options for splitting behavior
- * @returns Object containing arrays of split elements and a revert function
- *
- * @throws {Error} If element is not an HTMLElement
- *
- * @example
- * ```typescript
- * import { splitText } from "fetta";
- * import { animate, stagger } from "motion";
- *
- * // Basic usage
- * const { chars, words, lines, revert } = splitText(element);
- *
- * // Animate words
- * animate(words, { opacity: [0, 1], y: [20, 0] }, { delay: stagger(0.05) });
- *
- * // Revert to original HTML when done
- * revert();
- * ```
- *
- * @example
- * ```typescript
- * // Auto-revert after animation completes
- * splitText(element, {
- *   onSplit: ({ words }) => animate(words, { opacity: [0, 1] }),
- *   revertOnComplete: true,
- * });
- * ```
- *
- * @example
- * ```typescript
- * // Responsive re-splitting
- * splitText(element, {
- *   autoSplit: true,
- *   onResize: ({ lines }) => {
- *     // Re-animate after resize
- *     animate(lines, { opacity: [0, 1] });
- *   },
- * });
- * ```
- */
-declare function splitText(element: HTMLElement, { type, charClass, wordClass, lineClass, mask, autoSplit, onResize, onSplit, revertOnComplete, propIndex, disableKerning, initialStyles, initialClasses, }?: SplitTextOptions): SplitTextResult;
-
-export { type SplitTextOptions, type SplitTextResult, splitText };
+export { a as SplitTextOptions, S as SplitTextResult, s as splitText } from './index-c1UKfWWK.js';

package/dist/index.js

@@ -1 +1,2 @@
-export { splitText } from './chunk-Y4GCLM4K.js';
+export { splitText } from './chunk-UPF3IYHC.js';
+import './chunk-ORMEWXMH.js';

package/dist/initialStyles-BGuPp5CS.d.ts

@@ -0,0 +1,23 @@
+type CSSVariableStyles = {
+    [K in `--${string}`]?: string | number;
+};
+/** Style value for initialStyles - CSS properties with numeric + CSS variable support */
+type InitialStyleValue = Partial<Record<keyof CSSStyleDeclaration, string | number>> & CSSVariableStyles;
+/** Function that returns styles based on element and index */
+type InitialStyleFn = (element: HTMLElement, index: number) => InitialStyleValue;
+/** Initial style can be a static object or a function */
+type InitialStyle = InitialStyleValue | InitialStyleFn;
+/** Initial styles configuration for chars, words, and/or lines */
+interface InitialStyles {
+    chars?: InitialStyle;
+    words?: InitialStyle;
+    lines?: InitialStyle;
+}
+/** Initial classes configuration for chars, words, and/or lines */
+interface InitialClasses {
+    chars?: string;
+    words?: string;
+    lines?: string;
+}
+
+export type { InitialStyles as I, InitialClasses as a };

package/dist/motion.d.ts

@@ -0,0 +1,185 @@
+import { I as InitialStyles, a as InitialClasses } from './initialStyles-BGuPp5CS.js';
+import { DOMKeyframesDefinition, AnimationOptions, scroll } from 'motion';
+import { HTMLMotionProps } from 'motion/react';
+import { ReactElement, RefAttributes } from 'react';
+import { A as AnimationCallbackReturn } from './index-c1UKfWWK.js';
+export { a as CoreSplitTextOptions, S as SplitTextResult } from './index-c1UKfWWK.js';
+
+interface SplitTextOptions {
+    type?: "chars" | "words" | "lines" | "chars,words" | "words,lines" | "chars,lines" | "chars,words,lines";
+    charClass?: string;
+    wordClass?: string;
+    lineClass?: string;
+    /** Apply overflow mask wrapper to elements for reveal animations */
+    mask?: "lines" | "words" | "chars";
+    propIndex?: boolean;
+    /** Skip kerning compensation (no margin adjustments applied).
+     * Kerning is naturally lost when splitting into inline-block spans.
+     * Use this if you prefer no compensation over imperfect Safari compensation. */
+    disableKerning?: boolean;
+}
+interface ScrollPropOptions {
+    /** Scroll offsets. Default: Motion's default ["start end", "end start"] */
+    offset?: MotionScrollOffset;
+    /** Scroll axis. Default: "y" */
+    axis?: "x" | "y";
+    /** Custom scroll container ref. Default: nearest scrollable ancestor / window */
+    container?: React.RefObject<Element | null>;
+}
+/** Matches Motion's viewport prop */
+interface ViewportOptions {
+    /** Only trigger once. Default: false */
+    once?: boolean;
+    /** How much of the element must be visible. Motion supports "some" | "all" | number. Default: 0 */
+    amount?: number | "some" | "all";
+    /** How much visibility is required to consider the element out of view. Default: 0 (fully out) */
+    leave?: number | "some" | "all";
+    /** Root margin for IntersectionObserver. Default: "0px" */
+    margin?: string;
+    /** Root element for IntersectionObserver */
+    root?: React.RefObject<Element>;
+}
+/**
+ * Result passed to SplitText callbacks (onSplit, onViewportEnter, onViewportLeave, onResplit).
+ *
+ * Contains arrays of split elements and a revert function for manual control.
+ * Empty arrays are returned for split types not requested in options.
+ */
+interface SplitTextElements {
+    /** Array of character span elements */
+    chars: HTMLSpanElement[];
+    /** Array of word span elements */
+    words: HTMLSpanElement[];
+    /** Array of line span elements */
+    lines: HTMLSpanElement[];
+    /** Revert to original HTML and cleanup observers */
+    revert: () => void;
+}
+/** Motion-compatible animation target (passed directly to motion variants) */
+type VariantTarget = DOMKeyframesDefinition & {
+    transition?: AnimationOptions;
+};
+/** Info passed to function variant callbacks */
+interface VariantInfo<TCustom = unknown> {
+    /** Relative index within nearest split parent (line > word > global) */
+    index: number;
+    /** Total elements in that parent group */
+    count: number;
+    /** Absolute index across all elements of this type */
+    globalIndex: number;
+    /** Total elements of this type across the entire split */
+    globalCount: number;
+    /** Parent line index (0 if lines not split) */
+    lineIndex: number;
+    /** Parent word index (0 if words not split) */
+    wordIndex: number;
+    /** User custom data passed to SplitText */
+    custom: TCustom | undefined;
+    /** AnimatePresence presence state */
+    isPresent: boolean;
+}
+type VariantResolver<TCustom = unknown> = (info: VariantInfo<TCustom>) => VariantTarget;
+type WrapperVariantResolver<TCustom = unknown> = (args: {
+    custom?: TCustom;
+}) => VariantTarget;
+type PerTypeVariant<TCustom = unknown> = VariantTarget | VariantResolver<TCustom>;
+type WrapperVariant<TCustom = unknown> = VariantTarget | WrapperVariantResolver<TCustom>;
+/** A variant: flat target, flat function, per-type targets (static or function), with optional transition */
+type VariantDefinition<TCustom = unknown> = VariantTarget | VariantResolver<TCustom> | {
+    chars?: PerTypeVariant<TCustom>;
+    words?: PerTypeVariant<TCustom>;
+    lines?: PerTypeVariant<TCustom>;
+    wrapper?: WrapperVariant<TCustom>;
+    transition?: AnimationOptions;
+};
+type DelayScope = "global" | "local";
+type MotionScrollOptions = NonNullable<Parameters<typeof scroll>[1]>;
+type MotionScrollOffset = MotionScrollOptions["offset"];
+type ControlledWrapperMotionKeys = "children" | "className" | "style" | "ref" | "variants" | "initial" | "animate" | "exit" | "whileInView" | "whileHover" | "whileTap" | "whileFocus" | "transition" | "custom" | "onViewportEnter" | "onViewportLeave" | "onRevert" | "onHoverStart" | "onHoverEnd";
+type WrapperMotionProps = Omit<HTMLMotionProps<"div">, ControlledWrapperMotionKeys>;
+interface SplitTextProps<TCustom = unknown> extends WrapperMotionProps {
+    children: ReactElement;
+    /** The wrapper element type. Default: "div" */
+    as?: keyof HTMLElementTagNameMap;
+    /** Class name for the wrapper element */
+    className?: string;
+    /** Additional styles for the wrapper element (merged with internal styles) */
+    style?: React.CSSProperties;
+    /**
+     * Called after text is split.
+     * Return an animation or promise to enable revert (requires revertOnComplete).
+     * Still fires in variant mode for side effects.
+     */
+    onSplit?: (result: SplitTextElements) => AnimationCallbackReturn;
+    /** Called when autoSplit/full-resplit replaces split output elements */
+    onResplit?: (result: SplitTextElements) => void;
+    options?: SplitTextOptions;
+    autoSplit?: boolean;
+    /** When true, autoSplit/full-resplit updates replay initial->animate. */
+    animateOnResplit?: boolean;
+    /** When true, reverts to original HTML after animation promise resolves */
+    revertOnComplete?: boolean;
+    /** Viewport observer options (replaces `inView`). Configures IntersectionObserver. */
+    viewport?: ViewportOptions;
+    /** Called when element enters viewport (replaces `onInView`). Return animation for revertOnComplete support */
+    onViewportEnter?: (result: SplitTextElements) => AnimationCallbackReturn;
+    /** Called when element leaves viewport (replaces `onLeaveView`) */
+    onViewportLeave?: (result: SplitTextElements) => AnimationCallbackReturn;
+    /** Called when split text is reverted (manual or automatic) */
+    onRevert?: () => void;
+    /** Apply initial inline styles to elements after split (and after kerning compensation).
+     * Can be a static style object or a function that receives (element, index). */
+    initialStyles?: InitialStyles;
+    /** Apply initial classes to elements after split (and after kerning compensation).
+     * Classes are added via classList.add() and support space-separated class names. */
+    initialClasses?: InitialClasses;
+    /** Re-apply initialStyles/initialClasses (callback mode) or initial variant (variant mode) when element leaves viewport.
+     * Useful for scroll-triggered animations that should reset when scrolling away. */
+    resetOnViewportLeave?: boolean;
+    /** Wait for `document.fonts.ready` before splitting. Disable for immediate split. */
+    waitForFonts?: boolean;
+    /** Named variant definitions. Keys are variant names, values are animation targets. */
+    variants?: Record<string, VariantDefinition<TCustom>>;
+    /** Initial variant applied instantly after split (ignores transitions on mount). Set to false to skip. */
+    initial?: string | VariantDefinition<TCustom> | false;
+    /** Variant to animate to immediately after split */
+    animate?: string | VariantDefinition<TCustom>;
+    /** Variant to animate to when entering viewport */
+    whileInView?: string | VariantDefinition<TCustom>;
+    /** Variant to animate to when leaving viewport */
+    whileOutOfView?: string | VariantDefinition<TCustom>;
+    /** Variant to animate to on exit when used inside AnimatePresence.
+     *  Accepts a variant name or a full variant definition. */
+    exit?: string | VariantDefinition<TCustom> | false;
+    /** Variant to scroll-animate to. Animation progress is driven by scroll position.
+     *  Takes priority over `animate` and `whileInView`. */
+    whileScroll?: string | VariantDefinition<TCustom>;
+    /** Scroll options for whileScroll. Configures target tracking and scroll range. */
+    scroll?: ScrollPropOptions;
+    /** Variant to animate to on hover */
+    whileHover?: string | VariantDefinition<TCustom>;
+    /** Variant to animate to on tap */
+    whileTap?: string | VariantDefinition<TCustom>;
+    /** Variant to animate to on focus */
+    whileFocus?: string | VariantDefinition<TCustom>;
+    /** Reduced motion handling (matches MotionConfig reducedMotion) */
+    reducedMotion?: "user" | "always" | "never";
+    /** Custom data forwarded to function variants and AnimatePresence */
+    custom?: TCustom;
+    /** Called when hover starts */
+    onHoverStart?: () => void;
+    /** Called when hover ends */
+    onHoverEnd?: () => void;
+    /** Global transition options for variant animations.
+     *  Precedence: per-element fn return > per-variant transition > this global transition. */
+    transition?: AnimationOptions;
+    /** Controls how delay functions are resolved. "global" uses globalIndex/globalCount, "local" uses index/count. */
+    delayScope?: DelayScope;
+}
+/**
+ * Motion-enabled SplitText component.
+ */
+type SplitTextComponent = <TCustom = unknown>(props: SplitTextProps<TCustom> & RefAttributes<HTMLElement>) => ReactElement | null;
+declare const SplitText: SplitTextComponent;
+
+export { SplitText, type SplitTextElements, type SplitTextOptions, type VariantInfo };