Class SplitText

Splits text in a container into words, letters, and optionally lines.

Preserves inline HTML, supports resize-driven line reflow, and restores the original DOM on destroy.

Apply font-kerning: none on the container to reduce layout shift.

Documentation

Hierarchy (View Summary)

Constructors

Accessors

  • get isDestroyed(): boolean

    Indicates whether the instance has been destroyed.

    After destruction, destroy is a no-op.

    Returns boolean

  • get letters(): HTMLElement[]

    Letter elements from the last split.

    Returns HTMLElement[]

  • get lines(): HTMLElement[]

    Line elements from the last split (empty when lines is false).

    Returns HTMLElement[]

  • get name(): string

    The name of the module, derived from the class name

    Returns string

  • get prefix(): string

    Class name prefix for split elements ({corePrefix}split-text).

    Returns string

  • get words(): HTMLElement[]

    Word elements from the last split.

    Returns HTMLElement[]

Methods

  • Adds prefixed classes to an element and removes them on destroy.

    Skips classes that are already present on the element.

    Parameters

    • element: Element

      Target DOM element.

    • ...classes: string[]

      Unprefixed class name segments.

    Returns void

  • Builds one or more prefixed class names.

    Parameters

    • ...classes: string[]

      Unprefixed class name segments.

    Returns string

    Space-separated prefixed class string.

  • Stops listeners, unwraps lines when possible, and restores saved DOM.

    Returns void

  • Set default mutable props

    Returns { __mutableProp: true }

  • Get default static props

    Returns {
        __staticProp: true;
        ariaLabel: string | boolean;
        container: HTMLElement;
        ignore: string | HTMLElement[] | (element: HTMLElement) => boolean;
        letterClass: string;
        letters: boolean;
        letterTag: keyof HTMLElementTagNameMap;
        lineClass: string;
        lines: boolean;
        linesWrapper: boolean;
        lineTag: keyof HTMLElementTagNameMap;
        lineWrapperClass: string;
        prepareText: (text: string) => string;
        resizeDebounce: number;
        wordClass: string;
        wordDelimiter: string;
        wordDelimiterOutput: string;
        wordTag: keyof HTMLElementTagNameMap;
    }

    • __staticProp: true
    • ariaLabel: string | boolean

      Accessible label for the container after splitting.

      • true — uses textContent as aria-label
      • false — does not set aria-label
      • string — uses the provided value
      true
      
    • container: HTMLElement

      Container whose text content is split.

    • ignore: string | HTMLElement[] | (element: HTMLElement) => boolean

      Elements excluded from splitting (selector, list, or predicate).

      null
      
    • letterClass: string

      CSS class for letter elements.

      {prefix}__letter

    • letters: boolean

      Split each word into individual letter elements.

      false
      
    • letterTag: keyof HTMLElementTagNameMap

      HTML tag for letter wrappers.

      span

    • lineClass: string

      CSS class for line elements.

      {prefix}__line

    • lines: boolean

      Group words into line elements (reflows on resize).

      false
      
    • linesWrapper: boolean

      Wrap each line in an extra element (useful for mask animations).

      false
      
    • lineTag: keyof HTMLElementTagNameMap

      HTML tag for line wrappers.

      span

    • lineWrapperClass: string

      CSS class for line wrapper elements.

      {prefix}__line-wrapper

    • prepareText: (text: string) => string

      Preprocesses text before word splitting (e.g. CJK segmentation).

      const segmenter = new Intl.Segmenter('zh', { granularity: 'word' });

      const instance = new SplitText({
      container,
      prepareText: (source) => [...segmenter.segment(source)].map((s) => s.segment).join(' '),
      });
    • resizeDebounce: number

      Debounce delay for resize-driven line reflow (ms).

      0
      
    • wordClass: string

      CSS class for word elements.

      {prefix}__word

    • wordDelimiter: string

      Delimiter used to split text into words.

      whitespace
      
    • wordDelimiterOutput: string

      Delimiter inserted between words in the DOM (defaults to wordDelimiter).

      null
      
    • wordTag: keyof HTMLElementTagNameMap

      HTML tag for word wrappers.

      span

  • Destroys the instance and runs all registered cleanup actions.

    Safe to call multiple times; subsequent calls are ignored.

    Execution order:

    1. _destroy
    2. all onDestroy callbacks, in registration order
    3. isDestroyed is set to true

    Returns void

  • Registers a function to run when the instance is destroyed.

    If the instance is already destroyed, action runs immediately.

    Parameters

    • action: () => void

      Cleanup function (for example remove listeners or DOM classes).

    Returns void

  • Splits text into words, letters, and optionally lines.

    Emits beforeSplit, performs DOM work, then emits split.

    Returns void