fetta 1.4.3 → 1.5.0

package/dist/chunk-UPF3IYHC.js

@@ -0,0 +1,1762 @@
+// src/internal/kerningUpkeep.ts
+var CONTEXTUAL_SCRIPT_REGEX = /[\u0600-\u06FF\u0750-\u077F\u08A0-\u08FF\uFB50-\uFDFF\uFE70-\uFEFF\u0590-\u05FF\uFB1D-\uFB4F\u0E00-\u0E7F\u0900-\u097F\u0980-\u09FF\u0A00-\u0A7F\u0A80-\u0AFF\u0B00-\u0B7F\u0B80-\u0BFF\u0C00-\u0C7F\u0C80-\u0CFF\u0D00-\u0D7F]/;
+function hasContextualScript(chars) {
+  return chars.some((char) => CONTEXTUAL_SCRIPT_REGEX.test(char));
+}
+var KERNING_STYLE_PROPS = [
+  "font",
+  "font-family",
+  "font-size",
+  "font-style",
+  "font-weight",
+  "font-variant",
+  "line-height",
+  "font-kerning",
+  "font-variant-ligatures",
+  "font-feature-settings",
+  "font-variation-settings",
+  "font-optical-sizing",
+  "font-size-adjust",
+  "font-stretch",
+  "font-variant-caps",
+  "font-variant-numeric",
+  "font-variant-east-asian",
+  "font-synthesis",
+  "font-synthesis-weight",
+  "font-synthesis-style",
+  "letter-spacing",
+  "word-spacing",
+  "text-rendering",
+  "text-transform",
+  "direction",
+  "unicode-bidi",
+  "writing-mode",
+  "text-orientation",
+  "text-combine-upright"
+];
+var KERNING_STYLE_PROPS_SET = new Set(KERNING_STYLE_PROPS);
+function copyKerningStyles(target, styles) {
+  for (let i = 0; i < styles.length; i++) {
+    const prop = styles[i];
+    if (!KERNING_STYLE_PROPS_SET.has(prop) && !prop.startsWith("font-")) {
+      continue;
+    }
+    const value = styles.getPropertyValue(prop);
+    if (value) target.style.setProperty(prop, value);
+  }
+}
+function buildKerningStyleKey(styles) {
+  return KERNING_STYLE_PROPS.map((prop) => styles.getPropertyValue(prop)).join(
+    "|"
+  );
+}
+var isSafariBrowser = null;
+function isSafari() {
+  if (isSafariBrowser !== null) return isSafariBrowser;
+  if (typeof navigator === "undefined") return false;
+  isSafariBrowser = /^((?!chrome|android).)*safari/i.test(navigator.userAgent);
+  return isSafariBrowser;
+}
+var kerningMeasureRoots = /* @__PURE__ */ new WeakMap();
+function getKerningMeasureRoot(doc) {
+  var _a;
+  const existing = kerningMeasureRoots.get(doc);
+  if (existing && existing.isConnected) return existing;
+  const host = (_a = doc.body) != null ? _a : doc.documentElement;
+  if (!host) return null;
+  const root = doc.createElement("div");
+  root.setAttribute("data-fetta-kerning-root", "true");
+  root.style.cssText = [
+    "position:fixed",
+    "left:0",
+    "top:0",
+    "visibility:hidden",
+    "pointer-events:none",
+    "z-index:-2147483647",
+    "contain:layout paint"
+  ].join(";");
+  host.appendChild(root);
+  kerningMeasureRoots.set(doc, root);
+  return root;
+}
+function measureKerningDOM(measureRoot, styleSource, chars, styles) {
+  const kerningMap = /* @__PURE__ */ new Map();
+  if (chars.length < 2) return kerningMap;
+  const doc = styleSource.ownerDocument;
+  const measurer = doc.createElement("span");
+  measurer.style.cssText = `
+    position: absolute;
+    visibility: hidden;
+    white-space: pre;
+  `;
+  const computedStyles = styles != null ? styles : getComputedStyle(styleSource);
+  copyKerningStyles(measurer, computedStyles);
+  const webkitSmoothing = computedStyles.webkitFontSmoothing || computedStyles["-webkit-font-smoothing"];
+  const mozSmoothing = computedStyles.MozOsxFontSmoothing || computedStyles["-moz-osx-font-smoothing"];
+  if (webkitSmoothing) {
+    measurer.style.webkitFontSmoothing = webkitSmoothing;
+  }
+  if (mozSmoothing) {
+    measurer.style.MozOsxFontSmoothing = mozSmoothing;
+  }
+  measureRoot.appendChild(measurer);
+  const charWidths = /* @__PURE__ */ new Map();
+  for (const char of new Set(chars)) {
+    measurer.textContent = char;
+    charWidths.set(char, measurer.getBoundingClientRect().width);
+  }
+  for (let i = 0; i < chars.length - 1; i++) {
+    const char1 = chars[i];
+    const char2 = chars[i + 1];
+    measurer.textContent = char1 + char2;
+    const pairWidth = measurer.getBoundingClientRect().width;
+    const kerning = pairWidth - charWidths.get(char1) - charWidths.get(char2);
+    if (Math.abs(kerning) > 1e-3) {
+      kerningMap.set(i + 1, kerning);
+    }
+  }
+  measureRoot.removeChild(measurer);
+  return kerningMap;
+}
+function measureKerningRange(measureRoot, styleSource, chars, styles) {
+  const kerningMap = /* @__PURE__ */ new Map();
+  if (chars.length < 2) return kerningMap;
+  const doc = styleSource.ownerDocument;
+  const measurer = doc.createElement("span");
+  measurer.style.cssText = "position:absolute;visibility:hidden;white-space:pre;";
+  const computedStyles = styles != null ? styles : getComputedStyle(styleSource);
+  copyKerningStyles(measurer, computedStyles);
+  measureRoot.appendChild(measurer);
+  const range = doc.createRange();
+  const measureWidth = () => {
+    const textNode = measurer.firstChild;
+    if (!textNode) return 0;
+    range.selectNodeContents(textNode);
+    return range.getBoundingClientRect().width;
+  };
+  const charWidths = /* @__PURE__ */ new Map();
+  for (const char of new Set(chars)) {
+    measurer.textContent = char;
+    charWidths.set(char, measureWidth());
+  }
+  for (let i = 0; i < chars.length - 1; i++) {
+    const char1 = chars[i];
+    const char2 = chars[i + 1];
+    measurer.textContent = char1 + char2;
+    const kerning = measureWidth() - charWidths.get(char1) - charWidths.get(char2);
+    if (Math.abs(kerning) > 1e-3) {
+      kerningMap.set(i + 1, kerning);
+    }
+  }
+  range.detach();
+  measureRoot.removeChild(measurer);
+  return kerningMap;
+}
+function measureKerning(container, styleSource, chars, styles, isolateKerningMeasurement = true) {
+  if (chars.length < 2) return /* @__PURE__ */ new Map();
+  if (!styleSource.isConnected) {
+    console.warn(
+      "splitText: kerning measurement requires a connected DOM element. Skipping kerning."
+    );
+    return /* @__PURE__ */ new Map();
+  }
+  const computedStyles = styles != null ? styles : getComputedStyle(styleSource);
+  if (!isolateKerningMeasurement) {
+    if (!container.isConnected) {
+      console.warn(
+        "splitText: kerning measurement requires a connected DOM element. Skipping kerning."
+      );
+      return /* @__PURE__ */ new Map();
+    }
+    return isSafari() ? measureKerningDOM(container, styleSource, chars, computedStyles) : measureKerningRange(container, styleSource, chars, computedStyles);
+  }
+  const measureRoot = getKerningMeasureRoot(styleSource.ownerDocument);
+  if (!measureRoot) {
+    if (!container.isConnected) {
+      console.warn(
+        "splitText: kerning measurement requires a connected DOM element. Skipping kerning."
+      );
+      return /* @__PURE__ */ new Map();
+    }
+    return isSafari() ? measureKerningDOM(container, styleSource, chars, computedStyles) : measureKerningRange(container, styleSource, chars, computedStyles);
+  }
+  return isSafari() ? measureKerningDOM(measureRoot, styleSource, chars, computedStyles) : measureKerningRange(measureRoot, styleSource, chars, computedStyles);
+}
+function classSelector(className) {
+  const tokens = className.split(/\s+/).filter(Boolean);
+  if (tokens.length === 0) return "";
+  return `.${tokens.join(".")}`;
+}
+function querySplitWords(element, wordClass) {
+  const selector = classSelector(wordClass);
+  if (!selector) return [];
+  return Array.from(element.querySelectorAll(selector));
+}
+function hasNoSpaceBefore(wordSpan) {
+  return wordSpan.dataset.fettaNoSpaceBefore === "true";
+}
+function hasHardBreakBefore(wordSpan) {
+  return wordSpan.dataset.fettaHardBreakBefore === "true";
+}
+function getCharKerningTarget(charSpan, mask) {
+  if (mask === "chars" && charSpan.parentElement) {
+    return charSpan.parentElement;
+  }
+  return charSpan;
+}
+function getWordKerningTarget(wordSpan, mask) {
+  if (mask === "words" && wordSpan.parentElement) {
+    return wordSpan.parentElement;
+  }
+  return wordSpan;
+}
+function clearKerningCompensation(allWords, charClass, splitChars, splitWords, mask) {
+  if (splitChars) {
+    const charSelector = classSelector(charClass);
+    if (!charSelector) return;
+    for (const wordSpan of allWords) {
+      const wordChars = Array.from(
+        wordSpan.querySelectorAll(charSelector)
+      );
+      for (const charSpan of wordChars) {
+        const targetElement = getCharKerningTarget(charSpan, mask);
+        targetElement.style.marginLeft = "";
+      }
+    }
+    return;
+  }
+  if (splitWords) {
+    for (const wordSpan of allWords) {
+      const targetElement = getWordKerningTarget(wordSpan, mask);
+      targetElement.style.marginLeft = "";
+    }
+  }
+}
+function applyKerningCompensation(element, allWords, charClass, splitChars, splitWords, options) {
+  if (options == null ? void 0 : options.disableKerning) return;
+  if (splitChars && allWords.length > 0) {
+    const charSelector = classSelector(charClass);
+    if (!charSelector) return;
+    for (const wordSpan of allWords) {
+      const wordChars = Array.from(
+        wordSpan.querySelectorAll(charSelector)
+      );
+      if (wordChars.length < 2) continue;
+      const charStringsForCheck = wordChars.map((char) => char.textContent || "");
+      if (hasContextualScript(charStringsForCheck)) continue;
+      const styleGroups = [];
+      const firstCharStyles = getComputedStyle(wordChars[0]);
+      let currentKey = buildKerningStyleKey(firstCharStyles);
+      let currentGroup = {
+        chars: [wordChars[0]],
+        styleSource: wordChars[0],
+        styles: firstCharStyles
+      };
+      for (let i = 1; i < wordChars.length; i++) {
+        const char = wordChars[i];
+        const charStyles = getComputedStyle(char);
+        const key = buildKerningStyleKey(charStyles);
+        if (key === currentKey) {
+          currentGroup.chars.push(char);
+        } else {
+          styleGroups.push(currentGroup);
+          currentKey = key;
+          currentGroup = { chars: [char], styleSource: char, styles: charStyles };
+        }
+      }
+      styleGroups.push(currentGroup);
+      for (const group of styleGroups) {
+        if (group.chars.length < 2) continue;
+        const charStrings = group.chars.map((char) => char.textContent || "");
+        const kerningMap = measureKerning(
+          element,
+          group.styleSource,
+          charStrings,
+          group.styles,
+          (options == null ? void 0 : options.isolateKerningMeasurement) !== false
+        );
+        for (const [charIndex, kerning] of kerningMap) {
+          const charSpan = group.chars[charIndex];
+          if (charSpan && Math.abs(kerning) < 20) {
+            const targetElement = getCharKerningTarget(charSpan, options == null ? void 0 : options.mask);
+            targetElement.style.marginLeft = `${kerning}px`;
+          }
+        }
+      }
+    }
+    for (let wordIdx = 1; wordIdx < allWords.length; wordIdx++) {
+      const currWord = allWords[wordIdx];
+      if (hasNoSpaceBefore(currWord) || hasHardBreakBefore(currWord)) {
+        continue;
+      }
+      const prevWord = allWords[wordIdx - 1];
+      const prevChars = Array.from(
+        prevWord.querySelectorAll(charSelector)
+      );
+      const currChars = Array.from(
+        currWord.querySelectorAll(charSelector)
+      );
+      if (prevChars.length === 0 || currChars.length === 0) continue;
+      const lastCharSpan = prevChars[prevChars.length - 1];
+      const firstCharSpan = currChars[0];
+      const lastChar = lastCharSpan.textContent || "";
+      const firstChar = firstCharSpan.textContent || "";
+      if (!lastChar || !firstChar) continue;
+      if (hasContextualScript([lastChar, firstChar])) continue;
+      const styles = getComputedStyle(firstCharSpan);
+      const kerningMap = measureKerning(
+        element,
+        firstCharSpan,
+        [lastChar, " ", firstChar],
+        styles,
+        (options == null ? void 0 : options.isolateKerningMeasurement) !== false
+      );
+      let totalKerning = 0;
+      if (kerningMap.has(1)) totalKerning += kerningMap.get(1);
+      if (kerningMap.has(2)) totalKerning += kerningMap.get(2);
+      if (Math.abs(totalKerning) > 1e-3 && Math.abs(totalKerning) < 20) {
+        const targetElement = getCharKerningTarget(firstCharSpan, options == null ? void 0 : options.mask);
+        targetElement.style.marginLeft = `${totalKerning}px`;
+      }
+    }
+    return;
+  }
+  if (splitWords && allWords.length > 1) {
+    for (let wordIdx = 1; wordIdx < allWords.length; wordIdx++) {
+      const currWord = allWords[wordIdx];
+      if (hasNoSpaceBefore(currWord) || hasHardBreakBefore(currWord)) {
+        continue;
+      }
+      const prevWord = allWords[wordIdx - 1];
+      const prevText = prevWord.textContent || "";
+      const currText = currWord.textContent || "";
+      if (!prevText || !currText) continue;
+      const lastChar = prevText[prevText.length - 1];
+      const firstChar = currText[0];
+      if (hasContextualScript([lastChar, firstChar])) continue;
+      const styles = getComputedStyle(currWord);
+      const kerningMap = measureKerning(
+        element,
+        currWord,
+        [lastChar, " ", firstChar],
+        styles,
+        (options == null ? void 0 : options.isolateKerningMeasurement) !== false
+      );
+      let totalKerning = 0;
+      if (kerningMap.has(1)) totalKerning += kerningMap.get(1);
+      if (kerningMap.has(2)) totalKerning += kerningMap.get(2);
+      if (Math.abs(totalKerning) > 1e-3 && Math.abs(totalKerning) < 20) {
+        const targetElement = getWordKerningTarget(currWord, options == null ? void 0 : options.mask);
+        targetElement.style.marginLeft = `${totalKerning}px`;
+      }
+    }
+  }
+}
+
+// src/internal/autoSplitResize.ts
+var TARGET_COUPLING_EPSILON_PX = 0.5;
+var WIDTH_CHANGE_EPSILON_PX = 0.05;
+function getRenderableWidth(element) {
+  const width = element.getBoundingClientRect().width;
+  return Number.isFinite(width) ? width : 0;
+}
+function getSplitElementParent(element) {
+  let target = element.parentElement;
+  if (!target) return null;
+  if (target.dataset.fettaAutoSplitWrapper === "true" && target.parentElement instanceof HTMLElement) {
+    target = target.parentElement;
+  }
+  return target;
+}
+function resolveAutoSplitTargets(splitElement) {
+  const baseTarget = getSplitElementParent(splitElement);
+  if (!baseTarget) return [];
+  const targets = [baseTarget];
+  if (baseTarget.parentElement instanceof HTMLElement) {
+    const targetWidth = getRenderableWidth(baseTarget);
+    const elementWidth = getRenderableWidth(splitElement);
+    if (Math.abs(targetWidth - elementWidth) < TARGET_COUPLING_EPSILON_PX) {
+      targets.push(baseTarget.parentElement);
+    }
+  }
+  return Array.from(new Set(targets));
+}
+function getObservedWidth(entry, target) {
+  var _a;
+  const entryWidth = (_a = entry == null ? void 0 : entry.contentRect) == null ? void 0 : _a.width;
+  if (typeof entryWidth === "number" && Number.isFinite(entryWidth)) {
+    return entryWidth;
+  }
+  if (!target) return null;
+  const targetWidth = getRenderableWidth(target);
+  return Number.isFinite(targetWidth) ? targetWidth : null;
+}
+function recordWidthChange(widthByTarget, target, nextWidth, epsilon = WIDTH_CHANGE_EPSILON_PX) {
+  const previousWidth = widthByTarget.get(target);
+  widthByTarget.set(target, nextWidth);
+  if (previousWidth === void 0) return false;
+  return Math.abs(previousWidth - nextWidth) > epsilon;
+}
+function resolveAutoSplitWidth(targets, widthByTarget, changedTarget) {
+  const orderedTargets = [];
+  if (changedTarget && targets.includes(changedTarget)) {
+    orderedTargets.push(changedTarget);
+  }
+  for (const target of targets) {
+    if (!orderedTargets.includes(target)) {
+      orderedTargets.push(target);
+    }
+  }
+  for (const target of orderedTargets) {
+    const measuredWidth = widthByTarget.get(target);
+    if (typeof measuredWidth === "number" && Number.isFinite(measuredWidth)) {
+      return measuredWidth;
+    }
+    const fallbackWidth = target.offsetWidth;
+    if (Number.isFinite(fallbackWidth)) {
+      return fallbackWidth;
+    }
+  }
+  return 0;
+}
+
+// src/core/splitText.ts
+var ARIA_LABEL_ALLOWED_TAGS = /* @__PURE__ */ new Set([
+  "h1",
+  "h2",
+  "h3",
+  "h4",
+  "h5",
+  "h6",
+  "a",
+  "button",
+  "img",
+  "input",
+  "select",
+  "textarea",
+  "table",
+  "figure",
+  "form",
+  "fieldset",
+  "dialog",
+  "details",
+  "section",
+  "article",
+  "nav",
+  "aside",
+  "header",
+  "footer",
+  "main"
+]);
+function splitTextData(element, rawOptions = {}) {
+  var _a, _b;
+  const options = rawOptions;
+  const {
+    type = "chars,words,lines",
+    charClass = "split-char",
+    wordClass = "split-word",
+    lineClass = "split-line",
+    mask,
+    propIndex = false,
+    disableKerning = false,
+    initialStyles,
+    initialClasses
+  } = options;
+  const isolateKerningMeasurement = options.isolateKerningMeasurement !== false;
+  if (!(element instanceof HTMLElement)) {
+    throw new Error("splitTextData: element must be an HTMLElement");
+  }
+  const text = (_b = (_a = element.textContent) == null ? void 0 : _a.trim()) != null ? _b : "";
+  if (!text) {
+    console.warn("splitTextData: element has no text content");
+    return {
+      nodes: [],
+      meta: {
+        text: "",
+        type,
+        mask,
+        charClass,
+        wordClass,
+        lineClass,
+        propIndex,
+        useAriaLabel: false,
+        ariaLabel: null
+      }
+    };
+  }
+  const originalHTML = element.innerHTML;
+  const originalAriaLabel = element.getAttribute("aria-label");
+  const originalStyle = element.getAttribute("style");
+  let splitChars = type.includes("chars");
+  let splitWords = type.includes("words");
+  let splitLines = type.includes("lines");
+  if (!splitChars && !splitWords && !splitLines) {
+    console.warn(
+      'splitTextData: type must include at least one of: chars, words, lines. Defaulting to "chars,words,lines".'
+    );
+    splitChars = splitWords = splitLines = true;
+  }
+  if (splitChars) {
+    element.style.fontVariantLigatures = "none";
+  }
+  const trackAncestors = hasInlineDescendants(element);
+  const measuredWords = collectTextStructure(element, trackAncestors);
+  const useAriaLabel = !trackAncestors && ARIA_LABEL_ALLOWED_TAGS.has(element.tagName.toLowerCase());
+  performSplit(
+    element,
+    measuredWords,
+    charClass,
+    wordClass,
+    lineClass,
+    splitChars,
+    splitWords,
+    splitLines,
+    {
+      propIndex,
+      mask,
+      ariaHidden: useAriaLabel,
+      disableKerning,
+      isolateKerningMeasurement,
+      initialStyles,
+      initialClasses
+    }
+  );
+  if (trackAncestors) {
+    injectSrOnlyStyles();
+    const visualWrapper = document.createElement("span");
+    visualWrapper.setAttribute("aria-hidden", "true");
+    visualWrapper.dataset.fettaVisual = "true";
+    while (element.firstChild) {
+      visualWrapper.appendChild(element.firstChild);
+    }
+    element.appendChild(visualWrapper);
+    element.appendChild(createScreenReaderCopy(originalHTML));
+  } else if (useAriaLabel) {
+    if (originalAriaLabel === null) {
+      element.setAttribute("aria-label", text);
+    }
+  } else {
+    injectSrOnlyStyles();
+    const visualWrapper = document.createElement("span");
+    visualWrapper.setAttribute("aria-hidden", "true");
+    visualWrapper.dataset.fettaVisual = "true";
+    while (element.firstChild) {
+      visualWrapper.appendChild(element.firstChild);
+    }
+    element.appendChild(visualWrapper);
+    element.appendChild(createScreenReaderCopy(originalHTML));
+  }
+  const nodes = serializeChildren(element, { charClass, wordClass, lineClass });
+  const ariaLabel = element.getAttribute("aria-label");
+  element.innerHTML = originalHTML;
+  if (originalAriaLabel !== null) {
+    element.setAttribute("aria-label", originalAriaLabel);
+  } else {
+    element.removeAttribute("aria-label");
+  }
+  if (originalStyle !== null) {
+    element.setAttribute("style", originalStyle);
+  } else {
+    element.removeAttribute("style");
+  }
+  return {
+    nodes,
+    meta: {
+      text,
+      type,
+      mask,
+      charClass,
+      wordClass,
+      lineClass,
+      propIndex,
+      useAriaLabel,
+      ariaLabel
+    }
+  };
+}
+var BREAK_CHARS = /* @__PURE__ */ new Set([
+  "\u2014",
+  // em-dash
+  "\u2013",
+  // en-dash
+  "-",
+  // hyphen
+  "/",
+  // slash
+  "\u2012",
+  // figure dash (U+2012)
+  "\u2015"
+  // horizontal bar (U+2015)
+]);
+var INLINE_ELEMENTS = /* @__PURE__ */ new Set([
+  "a",
+  "abbr",
+  "acronym",
+  "b",
+  "bdi",
+  "bdo",
+  "big",
+  "cite",
+  "code",
+  "data",
+  "del",
+  "dfn",
+  "em",
+  "i",
+  "ins",
+  "kbd",
+  "mark",
+  "q",
+  "s",
+  "samp",
+  "small",
+  "span",
+  "strong",
+  "sub",
+  "sup",
+  "time",
+  "u",
+  "var"
+]);
+var srOnlyStylesInjected = false;
+function injectSrOnlyStyles() {
+  if (srOnlyStylesInjected || typeof document === "undefined") return;
+  const style = document.createElement("style");
+  style.textContent = `
+.fetta-sr-only {
+  position: absolute;
+  width: 1px;
+  height: 1px;
+  padding: 0;
+  margin: -1px;
+  overflow: hidden;
+  clip-path: inset(50%);
+  white-space: nowrap;
+  border-width: 0;
+}`;
+  document.head.appendChild(style);
+  srOnlyStylesInjected = true;
+}
+function createScreenReaderCopy(originalHTML) {
+  const srCopy = document.createElement("span");
+  srCopy.className = "fetta-sr-only";
+  srCopy.innerHTML = originalHTML;
+  srCopy.dataset.fettaSrCopy = "true";
+  return srCopy;
+}
+function hasInlineDescendants(element) {
+  const walker = document.createTreeWalker(element, NodeFilter.SHOW_ELEMENT);
+  let node;
+  while (node = walker.nextNode()) {
+    if (INLINE_ELEMENTS.has(node.tagName.toLowerCase())) {
+      return true;
+    }
+  }
+  return false;
+}
+function ancestorChainsEqual(a, b) {
+  if (a.length !== b.length) return false;
+  for (let i = 0; i < a.length; i++) {
+    if (a[i].instanceId !== b[i].instanceId) return false;
+  }
+  return true;
+}
+function groupCharsByAncestors(chars) {
+  if (chars.length === 0) return [];
+  const groups = [];
+  let currentGroup = [chars[0]];
+  let currentAncestors = chars[0].ancestors;
+  for (let i = 1; i < chars.length; i++) {
+    const char = chars[i];
+    if (ancestorChainsEqual(char.ancestors, currentAncestors)) {
+      currentGroup.push(char);
+    } else {
+      groups.push({ ancestors: currentAncestors, chars: currentGroup });
+      currentGroup = [char];
+      currentAncestors = char.ancestors;
+    }
+  }
+  groups.push({ ancestors: currentAncestors, chars: currentGroup });
+  return groups;
+}
+function cloneAncestorAsWrapper(info) {
+  const el = document.createElement(info.tagName);
+  info.attributes.forEach((value, key) => {
+    el.setAttribute(key, value);
+  });
+  return el;
+}
+function wrapInAncestors(content, ancestors) {
+  if (ancestors.length === 0) return content;
+  let wrapped = content;
+  for (let i = 0; i < ancestors.length; i++) {
+    const wrapper = cloneAncestorAsWrapper(ancestors[i]);
+    wrapper.appendChild(wrapped);
+    wrapped = wrapper;
+  }
+  return wrapped;
+}
+function hasAllClasses(element, className) {
+  if (!className) return false;
+  const tokens = className.split(/\s+/).filter(Boolean);
+  if (tokens.length === 0) return false;
+  return tokens.every((token) => element.classList.contains(token));
+}
+function getSplitRole(element, classInfo) {
+  if (hasAllClasses(element, classInfo.charClass)) return "char";
+  if (hasAllClasses(element, classInfo.wordClass)) return "word";
+  if (hasAllClasses(element, classInfo.lineClass)) return "line";
+  return void 0;
+}
+function serializeNode(node, classInfo) {
+  var _a;
+  if (node.nodeType === Node.TEXT_NODE) {
+    return {
+      type: "text",
+      text: (_a = node.textContent) != null ? _a : ""
+    };
+  }
+  if (node.nodeType !== Node.ELEMENT_NODE) return null;
+  const element = node;
+  const attrs = {};
+  for (const attr of Array.from(element.attributes)) {
+    attrs[attr.name] = attr.value;
+  }
+  const children = [];
+  element.childNodes.forEach((child) => {
+    const serialized = serializeNode(child, classInfo);
+    if (serialized) children.push(serialized);
+  });
+  const split = getSplitRole(element, classInfo);
+  return {
+    type: "element",
+    tag: element.tagName.toLowerCase(),
+    attrs,
+    children,
+    split
+  };
+}
+function serializeChildren(element, classInfo) {
+  const nodes = [];
+  element.childNodes.forEach((child) => {
+    const serialized = serializeNode(child, classInfo);
+    if (serialized) nodes.push(serialized);
+  });
+  return nodes;
+}
+function normalizeToPromise(value) {
+  if (!value) return null;
+  if (value instanceof Promise) return value;
+  if (typeof value === "object") {
+    if ("finished" in value) {
+      return value.finished;
+    }
+    if ("then" in value && typeof value.then === "function") {
+      return Promise.resolve(value);
+    }
+  }
+  if (Array.isArray(value)) {
+    const promises = value.map(normalizeToPromise).filter((p) => p !== null);
+    return promises.length ? Promise.all(promises) : null;
+  }
+  return null;
+}
+var segmenterCache = null;
+function segmentGraphemes(text) {
+  if (!segmenterCache) {
+    segmenterCache = new Intl.Segmenter(void 0, { granularity: "grapheme" });
+  }
+  return [...segmenterCache.segment(text)].map((s) => s.segment);
+}
+function buildAncestorChain(textNode, rootElement, ancestorCache) {
+  const ancestors = [];
+  let current = textNode.parentNode;
+  while (current && current !== rootElement && current instanceof Element) {
+    const tagName = current.tagName.toLowerCase();
+    if (INLINE_ELEMENTS.has(tagName)) {
+      let info = ancestorCache.get(current);
+      if (!info) {
+        const attributes = /* @__PURE__ */ new Map();
+        for (const attr of current.attributes) {
+          attributes.set(attr.name, attr.value);
+        }
+        info = {
+          tagName,
+          attributes,
+          instanceId: /* @__PURE__ */ Symbol()
+        };
+        ancestorCache.set(current, info);
+      }
+      ancestors.push(info);
+    }
+    current = current.parentNode;
+  }
+  return ancestors;
+}
+function isBoundaryDisplayValue(display) {
+  return !(display.startsWith("inline") || display === "contents");
+}
+function isBlockBoundaryElement(element, cache) {
+  const cached = cache.get(element);
+  if (cached !== void 0) return cached;
+  const tagName = element.tagName.toLowerCase();
+  let isBoundary = false;
+  if (tagName === "br") {
+    isBoundary = true;
+  } else if (element instanceof HTMLElement) {
+    const display = getComputedStyle(element).display;
+    isBoundary = isBoundaryDisplayValue(display);
+  }
+  cache.set(element, isBoundary);
+  return isBoundary;
+}
+function getNearestBlockBoundaryAncestor(textNode, rootElement, cache) {
+  let current = textNode.parentElement;
+  while (current && current !== rootElement) {
+    if (isBlockBoundaryElement(current, cache)) {
+      if (current.tagName.toLowerCase() !== "br") {
+        return current;
+      }
+    }
+    current = current.parentElement;
+  }
+  return null;
+}
+function collectTextStructure(element, trackAncestors) {
+  const words = [];
+  const ancestorCache = trackAncestors ? /* @__PURE__ */ new WeakMap() : null;
+  const walker = document.createTreeWalker(
+    element,
+    NodeFilter.SHOW_TEXT | NodeFilter.SHOW_ELEMENT
+  );
+  let node;
+  let currentWord = [];
+  let noSpaceBeforeNext = false;
+  let hardBreakBeforeNextWord = false;
+  let lastBoundaryOwner;
+  const boundaryCache = /* @__PURE__ */ new WeakMap();
+  const pushWord = () => {
+    if (currentWord.length > 0) {
+      words.push({
+        chars: currentWord,
+        noSpaceBefore: noSpaceBeforeNext,
+        hardBreakBefore: hardBreakBeforeNextWord
+      });
+      currentWord = [];
+      noSpaceBeforeNext = false;
+      hardBreakBeforeNextWord = false;
+    }
+  };
+  const markHardBreakBeforeNextWord = () => {
+    pushWord();
+    if (words.length > 0) {
+      hardBreakBeforeNextWord = true;
+    }
+  };
+  const emptyAncestors = [];
+  while (node = walker.nextNode()) {
+    if (node.nodeType === Node.ELEMENT_NODE) {
+      const elementNode = node;
+      if (elementNode.tagName.toLowerCase() === "br") {
+        markHardBreakBeforeNextWord();
+      }
+      continue;
+    }
+    if (node.nodeType !== Node.TEXT_NODE) continue;
+    const textNode = node;
+    const text = textNode.textContent || "";
+    const boundaryOwner = getNearestBlockBoundaryAncestor(
+      textNode,
+      element,
+      boundaryCache
+    );
+    if (lastBoundaryOwner !== void 0 && boundaryOwner !== lastBoundaryOwner) {
+      markHardBreakBeforeNextWord();
+    }
+    const ancestors = trackAncestors ? buildAncestorChain(textNode, element, ancestorCache) : emptyAncestors;
+    const graphemes = segmentGraphemes(text);
+    let hasVisibleChars = false;
+    for (const grapheme of graphemes) {
+      if (grapheme === " " || grapheme === "\n" || grapheme === "	") {
+        pushWord();
+        noSpaceBeforeNext = false;
+        continue;
+      }
+      hasVisibleChars = true;
+      currentWord.push({ char: grapheme, ancestors });
+      if (BREAK_CHARS.has(grapheme)) {
+        pushWord();
+        noSpaceBeforeNext = true;
+      }
+    }
+    if (hasVisibleChars) {
+      lastBoundaryOwner = boundaryOwner;
+    }
+  }
+  pushWord();
+  return words;
+}
+function splitByHardBreak(items, isHardBreakBefore) {
+  if (items.length === 0) return [];
+  const segments = [];
+  let currentSegment = [];
+  items.forEach((item, index) => {
+    if (index > 0 && isHardBreakBefore(item, index)) {
+      if (currentSegment.length > 0) {
+        segments.push(currentSegment);
+      }
+      currentSegment = [item];
+      return;
+    }
+    currentSegment.push(item);
+  });
+  if (currentSegment.length > 0) {
+    segments.push(currentSegment);
+  }
+  return segments;
+}
+function createSpan(className, index, display = "inline-block", options) {
+  const span = document.createElement("span");
+  if (className) {
+    span.className = className;
+  }
+  if (index !== void 0 && (options == null ? void 0 : options.propName)) {
+    span.setAttribute(`data-${options.propName}-index`, index.toString());
+    if (options.propIndex) {
+      span.style.setProperty(`--${options.propName}-index`, index.toString());
+    }
+  }
+  span.style.display = display;
+  span.style.position = "relative";
+  span.style.textDecoration = "inherit";
+  if (options == null ? void 0 : options.ariaHidden) {
+    span.setAttribute("aria-hidden", "true");
+  }
+  return span;
+}
+function createMaskWrapper(display = "inline-block") {
+  const wrapper = document.createElement("span");
+  wrapper.style.display = display;
+  wrapper.style.position = "relative";
+  wrapper.style.overflow = "clip";
+  return wrapper;
+}
+var PROTECTED_STYLES = /* @__PURE__ */ new Set([
+  "display",
+  "position",
+  "textDecoration",
+  "fontVariantLigatures"
+]);
+function applyInitialStyles(elements, style) {
+  if (!style || elements.length === 0) return;
+  const isFn = typeof style === "function";
+  for (let i = 0; i < elements.length; i++) {
+    const el = elements[i];
+    const styles = isFn ? style(el, i) : style;
+    for (const [key, value] of Object.entries(styles)) {
+      if (!PROTECTED_STYLES.has(key) && value !== void 0) {
+        el.style[key] = value;
+      }
+    }
+  }
+}
+function applyInitialClasses(elements, className) {
+  if (!className || elements.length === 0) return;
+  const classes = className.split(/\s+/).filter(Boolean);
+  for (const el of elements) {
+    el.classList.add(...classes);
+  }
+}
+function groupIntoLines(elements, element) {
+  const fontSize = parseFloat(getComputedStyle(element).fontSize);
+  const tolerance = Math.max(5, fontSize * 0.3);
+  const lineGroups = [];
+  let currentLine = [];
+  let currentY = null;
+  elements.forEach((el) => {
+    const rect = el instanceof HTMLElement ? el.getBoundingClientRect() : el.parentElement.getBoundingClientRect();
+    const y = Math.round(rect.top);
+    if (currentY === null) {
+      currentY = y;
+      currentLine.push(el);
+    } else if (Math.abs(y - currentY) < tolerance) {
+      currentLine.push(el);
+    } else {
+      lineGroups.push(currentLine);
+      currentLine = [el];
+      currentY = y;
+    }
+  });
+  if (currentLine.length > 0) {
+    lineGroups.push(currentLine);
+  }
+  return lineGroups;
+}
+function performSplit(element, measuredWords, charClass, wordClass, lineClass, splitChars, splitWords, splitLines, options) {
+  var _a, _b;
+  element.textContent = "";
+  const allChars = [];
+  const allWords = [];
+  const needWordWrappers = splitChars || splitWords;
+  if (needWordWrappers) {
+    const noSpaceBeforeSet = /* @__PURE__ */ new Set();
+    const hardBreakBeforeSet = /* @__PURE__ */ new Set();
+    const wordLevelAncestors = /* @__PURE__ */ new Map();
+    let globalCharIndex = 0;
+    measuredWords.forEach((measuredWord, wordIndex) => {
+      const wordSpan = createSpan(wordClass, wordIndex, "inline-block", {
+        propIndex: options == null ? void 0 : options.propIndex,
+        propName: "word",
+        ariaHidden: options == null ? void 0 : options.ariaHidden
+      });
+      if (measuredWord.noSpaceBefore) {
+        noSpaceBeforeSet.add(wordSpan);
+        wordSpan.dataset.fettaNoSpaceBefore = "true";
+      }
+      if (measuredWord.hardBreakBefore) {
+        hardBreakBeforeSet.add(wordSpan);
+        wordSpan.dataset.fettaHardBreakBefore = "true";
+      }
+      if (splitChars) {
+        const hasAnyAncestors = measuredWord.chars.some((c) => c.ancestors.length > 0);
+        if (!hasAnyAncestors) {
+          measuredWord.chars.forEach((measuredChar, charIndexInWord) => {
+            const charSpan = createSpan(charClass, globalCharIndex, "inline-block", {
+              propIndex: options == null ? void 0 : options.propIndex,
+              propName: "char",
+              ariaHidden: options == null ? void 0 : options.ariaHidden
+            });
+            charSpan.textContent = measuredChar.char;
+            globalCharIndex++;
+            if ((options == null ? void 0 : options.mask) === "chars") {
+              const charWrapper = createMaskWrapper("inline-block");
+              charWrapper.appendChild(charSpan);
+              wordSpan.appendChild(charWrapper);
+            } else {
+              wordSpan.appendChild(charSpan);
+            }
+            allChars.push(charSpan);
+          });
+        } else {
+          const charGroups = groupCharsByAncestors(measuredWord.chars);
+          const hasWordLevelAncestors = charGroups.length === 1 && charGroups[0].ancestors.length > 0;
+          if (hasWordLevelAncestors) {
+            wordLevelAncestors.set(wordSpan, charGroups[0].ancestors);
+          }
+          charGroups.forEach((group) => {
+            group.chars.forEach((measuredChar) => {
+              const charSpan = createSpan(charClass, globalCharIndex, "inline-block", {
+                propIndex: options == null ? void 0 : options.propIndex,
+                propName: "char"
+              });
+              charSpan.textContent = measuredChar.char;
+              globalCharIndex++;
+              if ((options == null ? void 0 : options.mask) === "chars") {
+                const charWrapper = createMaskWrapper("inline-block");
+                charWrapper.appendChild(charSpan);
+                wordSpan.appendChild(charWrapper);
+              } else {
+                wordSpan.appendChild(charSpan);
+              }
+              allChars.push(charSpan);
+            });
+            if (!hasWordLevelAncestors && group.ancestors.length > 0) {
+              const charsToWrap = Array.from(wordSpan.childNodes);
+              const lastNChars = charsToWrap.slice(-group.chars.length);
+              lastNChars.forEach((node) => wordSpan.removeChild(node));
+              const fragment = document.createDocumentFragment();
+              lastNChars.forEach((node) => fragment.appendChild(node));
+              const wrapped = wrapInAncestors(fragment, group.ancestors);
+              wordSpan.appendChild(wrapped);
+            }
+          });
+        }
+      } else {
+        const hasAnyAncestors = measuredWord.chars.some((c) => c.ancestors.length > 0);
+        if (!hasAnyAncestors) {
+          wordSpan.textContent = measuredWord.chars.map((c) => c.char).join("");
+        } else {
+          const charGroups = groupCharsByAncestors(measuredWord.chars);
+          const hasWordLevelAncestors = charGroups.length === 1 && charGroups[0].ancestors.length > 0;
+          if (hasWordLevelAncestors) {
+            wordLevelAncestors.set(wordSpan, charGroups[0].ancestors);
+            wordSpan.textContent = measuredWord.chars.map((c) => c.char).join("");
+          } else {
+            charGroups.forEach((group) => {
+              const text = group.chars.map((c) => c.char).join("");
+              const textNode = document.createTextNode(text);
+              if (group.ancestors.length > 0) {
+                const wrapped = wrapInAncestors(textNode, group.ancestors);
+                wordSpan.appendChild(wrapped);
+              } else {
+                wordSpan.appendChild(textNode);
+              }
+            });
+          }
+        }
+      }
+      allWords.push(wordSpan);
+    });
+    const appendBoundaryBeforeWord = (nextWordSpan) => {
+      if (hardBreakBeforeSet.has(nextWordSpan)) {
+        element.appendChild(document.createElement("br"));
+      } else if (!noSpaceBeforeSet.has(nextWordSpan)) {
+        element.appendChild(document.createTextNode(" "));
+      }
+    };
+    let i = 0;
+    while (i < allWords.length) {
+      const wordSpan = allWords[i];
+      const ancestors = wordLevelAncestors.get(wordSpan);
+      if (ancestors && ancestors.length > 0) {
+        const wordGroup = [wordSpan];
+        let j = i + 1;
+        while (j < allWords.length) {
+          const nextWordSpan = allWords[j];
+          const nextAncestors = wordLevelAncestors.get(nextWordSpan);
+          if (hardBreakBeforeSet.has(nextWordSpan)) {
+            break;
+          }
+          if (nextAncestors && ancestorChainsEqual(ancestors, nextAncestors)) {
+            wordGroup.push(nextWordSpan);
+            j++;
+          } else {
+            break;
+          }
+        }
+        const fragment = document.createDocumentFragment();
+        wordGroup.forEach((ws, idx) => {
+          if ((options == null ? void 0 : options.mask) === "words") {
+            const wordWrapper = createMaskWrapper("inline-block");
+            wordWrapper.appendChild(ws);
+            fragment.appendChild(wordWrapper);
+          } else {
+            fragment.appendChild(ws);
+          }
+          if (idx < wordGroup.length - 1 && !noSpaceBeforeSet.has(wordGroup[idx + 1]) && !hardBreakBeforeSet.has(wordGroup[idx + 1])) {
+            fragment.appendChild(document.createTextNode(" "));
+          }
+        });
+        const wrapped = wrapInAncestors(fragment, ancestors);
+        element.appendChild(wrapped);
+        if (j < allWords.length) {
+          appendBoundaryBeforeWord(allWords[j]);
+        }
+        i = j;
+      } else {
+        if ((options == null ? void 0 : options.mask) === "words") {
+          const wordWrapper = createMaskWrapper("inline-block");
+          wordWrapper.appendChild(wordSpan);
+          element.appendChild(wordWrapper);
+        } else {
+          element.appendChild(wordSpan);
+        }
+        if (i < allWords.length - 1) {
+          appendBoundaryBeforeWord(allWords[i + 1]);
+        }
+        i++;
+      }
+    }
+    applyKerningCompensation(
+      element,
+      allWords,
+      charClass,
+      splitChars,
+      splitWords,
+      {
+        disableKerning: options == null ? void 0 : options.disableKerning,
+        isolateKerningMeasurement: options == null ? void 0 : options.isolateKerningMeasurement,
+        mask: options == null ? void 0 : options.mask
+      }
+    );
+    if (splitLines) {
+      const wordSegments = splitByHardBreak(
+        allWords,
+        (wordSpan, index) => index > 0 && hardBreakBeforeSet.has(wordSpan)
+      );
+      const lineGroups = wordSegments.flatMap(
+        (segment) => groupIntoLines(segment, element)
+      );
+      element.textContent = "";
+      const allLines = [];
+      lineGroups.forEach((words, lineIndex) => {
+        const lineSpan = createSpan(lineClass, lineIndex, "block", {
+          propIndex: options == null ? void 0 : options.propIndex,
+          propName: "line",
+          ariaHidden: options == null ? void 0 : options.ariaHidden
+        });
+        allLines.push(lineSpan);
+        let wi = 0;
+        while (wi < words.length) {
+          const wordSpan = words[wi];
+          const ancestors = wordLevelAncestors.get(wordSpan);
+          if (ancestors && ancestors.length > 0) {
+            const wordGroup = [wordSpan];
+            let wj = wi + 1;
+            while (wj < words.length) {
+              const nextWordSpan = words[wj];
+              const nextAncestors = wordLevelAncestors.get(nextWordSpan);
+              if (nextAncestors && ancestorChainsEqual(ancestors, nextAncestors)) {
+                wordGroup.push(nextWordSpan);
+                wj++;
+              } else {
+                break;
+              }
+            }
+            const fragment = document.createDocumentFragment();
+            wordGroup.forEach((ws, idx) => {
+              if ((options == null ? void 0 : options.mask) === "words") {
+                const wordWrapper = createMaskWrapper("inline-block");
+                wordWrapper.appendChild(ws);
+                fragment.appendChild(wordWrapper);
+              } else {
+                fragment.appendChild(ws);
+              }
+              if (idx < wordGroup.length - 1 && !noSpaceBeforeSet.has(wordGroup[idx + 1])) {
+                fragment.appendChild(document.createTextNode(" "));
+              }
+            });
+            const wrapped = wrapInAncestors(fragment, ancestors);
+            lineSpan.appendChild(wrapped);
+            if (wj < words.length && !noSpaceBeforeSet.has(words[wj])) {
+              lineSpan.appendChild(document.createTextNode(" "));
+            }
+            wi = wj;
+          } else {
+            if ((options == null ? void 0 : options.mask) === "words") {
+              const wordWrapper = createMaskWrapper("inline-block");
+              wordWrapper.appendChild(wordSpan);
+              lineSpan.appendChild(wordWrapper);
+            } else {
+              lineSpan.appendChild(wordSpan);
+            }
+            if (wi < words.length - 1 && !noSpaceBeforeSet.has(words[wi + 1])) {
+              lineSpan.appendChild(document.createTextNode(" "));
+            }
+            wi++;
+          }
+        }
+        if ((options == null ? void 0 : options.mask) === "lines") {
+          const lineWrapper = createMaskWrapper("block");
+          lineWrapper.appendChild(lineSpan);
+          element.appendChild(lineWrapper);
+        } else {
+          element.appendChild(lineSpan);
+        }
+      });
+      if (options == null ? void 0 : options.initialStyles) {
+        const { chars, words, lines } = options.initialStyles;
+        if (chars) applyInitialStyles(allChars, chars);
+        if (words) applyInitialStyles(allWords, words);
+        if (lines) applyInitialStyles(allLines, lines);
+      }
+      if (options == null ? void 0 : options.initialClasses) {
+        const { chars, words, lines } = options.initialClasses;
+        if (chars) applyInitialClasses(allChars, chars);
+        if (words) applyInitialClasses(allWords, words);
+        if (lines) applyInitialClasses(allLines, lines);
+      }
+      return {
+        chars: allChars,
+        words: splitWords ? allWords : [],
+        lines: allLines
+      };
+    }
+    if (options == null ? void 0 : options.initialStyles) {
+      const { chars, words } = options.initialStyles;
+      if (chars) applyInitialStyles(allChars, chars);
+      if (words) applyInitialStyles(allWords, words);
+    }
+    if (options == null ? void 0 : options.initialClasses) {
+      const { chars, words } = options.initialClasses;
+      if (chars) applyInitialClasses(allChars, chars);
+      if (words) applyInitialClasses(allWords, words);
+    }
+    return {
+      chars: allChars,
+      words: splitWords ? allWords : [],
+      lines: []
+    };
+  } else {
+    if (splitLines) {
+      const wordWrappers = [];
+      measuredWords.forEach((measuredWord, idx) => {
+        const textNode = document.createTextNode(
+          measuredWord.chars.map((c) => c.char).join("")
+        );
+        const wrapper = document.createElement("span");
+        wrapper.style.display = "inline";
+        wrapper.appendChild(textNode);
+        element.appendChild(wrapper);
+        wordWrappers.push({ wrapper, wordIndex: idx });
+        if (idx < measuredWords.length - 1 && !measuredWords[idx + 1].noSpaceBefore && !measuredWords[idx + 1].hardBreakBefore) {
+          const spaceNode = document.createTextNode(" ");
+          element.appendChild(spaceNode);
+        }
+      });
+      const wordWrapperSegments = splitByHardBreak(
+        wordWrappers,
+        (wordWrapper, index) => index > 0 && measuredWords[wordWrapper.wordIndex].hardBreakBefore
+      );
+      const lineGroups = wordWrapperSegments.flatMap(
+        (segment) => groupIntoLines(
+          segment.map((wordWrapper) => wordWrapper.wrapper),
+          element
+        )
+      );
+      element.textContent = "";
+      const allLines = [];
+      lineGroups.forEach((wrappers, lineIndex) => {
+        const lineSpan = createSpan(lineClass, lineIndex, "block", {
+          propIndex: options == null ? void 0 : options.propIndex,
+          propName: "line"
+        });
+        allLines.push(lineSpan);
+        wrappers.forEach((wrapper, wrapperIdx) => {
+          while (wrapper.firstChild) {
+            lineSpan.appendChild(wrapper.firstChild);
+          }
+          if (wrapperIdx < wrappers.length - 1) {
+            const nextWrapper = wrappers[wrapperIdx + 1];
+            const nextWordInfo = wordWrappers.find((w) => w.wrapper === nextWrapper);
+            if (nextWordInfo && !measuredWords[nextWordInfo.wordIndex].noSpaceBefore) {
+              lineSpan.appendChild(document.createTextNode(" "));
+            }
+          }
+        });
+        if ((options == null ? void 0 : options.mask) === "lines") {
+          const lineWrapper = createMaskWrapper("block");
+          lineWrapper.appendChild(lineSpan);
+          element.appendChild(lineWrapper);
+        } else {
+          element.appendChild(lineSpan);
+        }
+      });
+      if ((_a = options == null ? void 0 : options.initialStyles) == null ? void 0 : _a.lines) {
+        applyInitialStyles(allLines, options.initialStyles.lines);
+      }
+      if ((_b = options == null ? void 0 : options.initialClasses) == null ? void 0 : _b.lines) {
+        applyInitialClasses(allLines, options.initialClasses.lines);
+      }
+      return { chars: [], words: [], lines: allLines };
+    } else {
+      const fullText = measuredWords.map((w) => w.chars.map((c) => c.char).join("")).join(" ");
+      element.textContent = fullText;
+      return { chars: [], words: [], lines: [] };
+    }
+  }
+}
+function normalizeLineFingerprintText(value) {
+  return value.replace(/\u00A0/g, " ").replace(/\s+/g, " ").trim();
+}
+function buildLineFingerprintFromElements(lines) {
+  if (lines.length === 0) return "";
+  return lines.map((line) => {
+    var _a;
+    return normalizeLineFingerprintText((_a = line.textContent) != null ? _a : "");
+  }).join("\n");
+}
+function collectNodeText(node) {
+  if (node.type === "text") return node.text;
+  return node.children.map((child) => collectNodeText(child)).join("");
+}
+function collectLineTextsFromData(nodes, lineTexts) {
+  for (const node of nodes) {
+    if (node.type !== "element") continue;
+    if (node.split === "line") {
+      lineTexts.push(normalizeLineFingerprintText(collectNodeText(node)));
+      continue;
+    }
+    collectLineTextsFromData(node.children, lineTexts);
+  }
+}
+function buildLineFingerprintFromData(data) {
+  const lineTexts = [];
+  collectLineTextsFromData(data.nodes, lineTexts);
+  return lineTexts.join("\n");
+}
+function splitText(element, rawOptions = {}) {
+  var _a;
+  const options = rawOptions;
+  const {
+    type = "chars,words,lines",
+    charClass = "split-char",
+    wordClass = "split-word",
+    lineClass = "split-line",
+    mask,
+    autoSplit = false,
+    onResplit,
+    onSplit,
+    revertOnComplete = false,
+    propIndex = false,
+    disableKerning = false,
+    initialStyles,
+    initialClasses
+  } = options;
+  const isolateKerningMeasurement = options.isolateKerningMeasurement !== false;
+  if (!(element instanceof HTMLElement)) {
+    throw new Error("splitText: element must be an HTMLElement");
+  }
+  const text = (_a = element.textContent) == null ? void 0 : _a.trim();
+  if (!text) {
+    console.warn("splitText: element has no text content");
+    return {
+      chars: [],
+      words: [],
+      lines: [],
+      revert: () => {
+      }
+    };
+  }
+  if (autoSplit && !element.parentElement) {
+    console.warn(
+      "splitText: autoSplit requires a parent element. AutoSplit will not work."
+    );
+  }
+  const originalHTML = element.innerHTML;
+  const originalAriaLabel = element.getAttribute("aria-label");
+  let splitChars = type.includes("chars");
+  let splitWords = type.includes("words");
+  let splitLines = type.includes("lines");
+  if (!splitChars && !splitWords && !splitLines) {
+    console.warn(
+      'splitText: type must include at least one of: chars, words, lines. Defaulting to "chars,words,lines".'
+    );
+    splitChars = splitWords = splitLines = true;
+  }
+  let isActive = true;
+  let autoSplitObserver = null;
+  let autoSplitDebounceTimer = null;
+  let kerningObserver = null;
+  let kerningAnimationFrame = null;
+  let removeKerningResizeListener = null;
+  let autoSplitWidthByTarget = /* @__PURE__ */ new Map();
+  let lastKerningStyleKey = null;
+  let currentChars = [];
+  let currentWords = [];
+  let currentLines = [];
+  let currentLineFingerprint = "";
+  let useAriaLabel = false;
+  const applyDirectSplit = () => {
+    const trackAncestors = hasInlineDescendants(element);
+    const measuredWords = collectTextStructure(element, trackAncestors);
+    useAriaLabel = !trackAncestors && ARIA_LABEL_ALLOWED_TAGS.has(element.tagName.toLowerCase());
+    const rendered = performSplit(
+      element,
+      measuredWords,
+      charClass,
+      wordClass,
+      lineClass,
+      splitChars,
+      splitWords,
+      splitLines,
+      {
+        propIndex,
+        mask,
+        ariaHidden: useAriaLabel,
+        disableKerning,
+        isolateKerningMeasurement,
+        initialStyles,
+        initialClasses
+      }
+    );
+    currentChars = rendered.chars;
+    currentWords = rendered.words;
+    currentLines = rendered.lines;
+    currentLineFingerprint = splitLines ? buildLineFingerprintFromElements(currentLines) : "";
+    if (trackAncestors) {
+      injectSrOnlyStyles();
+      const visualWrapper = document.createElement("span");
+      visualWrapper.setAttribute("aria-hidden", "true");
+      visualWrapper.dataset.fettaVisual = "true";
+      while (element.firstChild) {
+        visualWrapper.appendChild(element.firstChild);
+      }
+      element.appendChild(visualWrapper);
+      element.appendChild(createScreenReaderCopy(originalHTML));
+    } else if (useAriaLabel) {
+      if (originalAriaLabel === null) {
+        element.setAttribute("aria-label", text);
+      }
+    } else {
+      injectSrOnlyStyles();
+      const visualWrapper = document.createElement("span");
+      visualWrapper.setAttribute("aria-hidden", "true");
+      visualWrapper.dataset.fettaVisual = "true";
+      while (element.firstChild) {
+        visualWrapper.appendChild(element.firstChild);
+      }
+      element.appendChild(visualWrapper);
+      element.appendChild(createScreenReaderCopy(originalHTML));
+    }
+    if (splitChars) {
+      element.style.fontVariantLigatures = "none";
+    }
+  };
+  applyDirectSplit();
+  const supportsKerningUpkeep = !disableKerning && (splitChars || splitWords);
+  const kerningOnlyUpdate = supportsKerningUpkeep && !splitLines;
+  if (supportsKerningUpkeep) {
+    lastKerningStyleKey = buildKerningStyleKey(getComputedStyle(element));
+  }
+  const resolveLineMeasureWidth = (fallbackWidth) => {
+    const safeFallbackWidth = Number.isFinite(fallbackWidth) && fallbackWidth > 0 ? fallbackWidth : 1;
+    const elementWidth = element.getBoundingClientRect().width;
+    if (Number.isFinite(elementWidth) && elementWidth > 0) {
+      return Math.max(elementWidth, safeFallbackWidth);
+    }
+    return safeFallbackWidth;
+  };
+  const measureLineFingerprintForWidth = (width) => {
+    if (!splitLines) return null;
+    if (!element.parentElement) return null;
+    const ownerDocument = element.ownerDocument;
+    const probeHost = ownerDocument.createElement("div");
+    probeHost.setAttribute("data-fetta-auto-split-probe", "true");
+    probeHost.style.position = "fixed";
+    probeHost.style.left = "-99999px";
+    probeHost.style.top = "0";
+    probeHost.style.visibility = "hidden";
+    probeHost.style.pointerEvents = "none";
+    probeHost.style.contain = "layout style paint";
+    probeHost.style.width = `${Math.max(1, width)}px`;
+    const probeElement = element.cloneNode(false);
+    probeElement.innerHTML = originalHTML;
+    probeHost.appendChild(probeElement);
+    element.parentElement.appendChild(probeHost);
+    try {
+      const probeData = splitTextData(probeElement, {
+        type,
+        charClass,
+        wordClass,
+        lineClass,
+        mask,
+        propIndex,
+        disableKerning,
+        isolateKerningMeasurement,
+        initialStyles,
+        initialClasses
+      });
+      return buildLineFingerprintFromData(probeData);
+    } finally {
+      probeHost.remove();
+    }
+  };
+  const runFullResplit = () => {
+    if (!isActive) return;
+    const previousChars = currentChars;
+    const previousWords = currentWords;
+    const previousLines = currentLines;
+    element.innerHTML = originalHTML;
+    applyDirectSplit();
+    if (supportsKerningUpkeep) {
+      lastKerningStyleKey = buildKerningStyleKey(getComputedStyle(element));
+    }
+    const replacedSplitOutput = previousChars !== currentChars || previousWords !== currentWords || previousLines !== currentLines;
+    if (onResplit && replacedSplitOutput) {
+      onResplit({
+        chars: currentChars,
+        words: currentWords,
+        lines: currentLines
+      });
+    }
+  };
+  const dispose = () => {
+    if (!isActive) return;
+    if (autoSplitObserver) {
+      autoSplitObserver.disconnect();
+      autoSplitObserver = null;
+    }
+    autoSplitWidthByTarget = /* @__PURE__ */ new Map();
+    if (kerningObserver) {
+      kerningObserver.disconnect();
+      kerningObserver = null;
+    }
+    if (autoSplitDebounceTimer) {
+      clearTimeout(autoSplitDebounceTimer);
+      autoSplitDebounceTimer = null;
+    }
+    if (kerningAnimationFrame !== null) {
+      const ownerWindow = element.ownerDocument.defaultView;
+      if (ownerWindow) {
+        ownerWindow.cancelAnimationFrame(kerningAnimationFrame);
+      }
+      kerningAnimationFrame = null;
+    }
+    if (removeKerningResizeListener) {
+      removeKerningResizeListener();
+      removeKerningResizeListener = null;
+    }
+    isActive = false;
+  };
+  const revert = () => {
+    if (!isActive) return;
+    element.innerHTML = originalHTML;
+    if (useAriaLabel) {
+      if (originalAriaLabel !== null) {
+        element.setAttribute("aria-label", originalAriaLabel);
+      } else {
+        element.removeAttribute("aria-label");
+      }
+    }
+    if (splitChars) {
+      element.style.fontVariantLigatures = "none";
+    }
+    dispose();
+  };
+  if (supportsKerningUpkeep) {
+    const runKerningUpkeep = () => {
+      if (!isActive) return;
+      if (!element.isConnected) {
+        dispose();
+        return;
+      }
+      const nextKerningStyleKey = buildKerningStyleKey(getComputedStyle(element));
+      if (nextKerningStyleKey === lastKerningStyleKey) return;
+      lastKerningStyleKey = nextKerningStyleKey;
+      if (!kerningOnlyUpdate) {
+        if (!autoSplit) {
+          return;
+        }
+        runFullResplit();
+        return;
+      }
+      const wordsForKerning = querySplitWords(element, wordClass);
+      if (wordsForKerning.length === 0) return;
+      clearKerningCompensation(
+        wordsForKerning,
+        charClass,
+        splitChars,
+        splitWords,
+        mask
+      );
+      applyKerningCompensation(
+        element,
+        wordsForKerning,
+        charClass,
+        splitChars,
+        splitWords,
+        {
+          disableKerning,
+          isolateKerningMeasurement,
+          mask
+        }
+      );
+    };
+    const scheduleKerningUpkeep = () => {
+      if (kerningAnimationFrame !== null) {
+        return;
+      }
+      const ownerWindow2 = element.ownerDocument.defaultView;
+      if (!ownerWindow2) {
+        runKerningUpkeep();
+        return;
+      }
+      kerningAnimationFrame = ownerWindow2.requestAnimationFrame(() => {
+        kerningAnimationFrame = null;
+        runKerningUpkeep();
+      });
+    };
+    kerningObserver = new ResizeObserver(() => {
+      scheduleKerningUpkeep();
+    });
+    kerningObserver.observe(element);
+    const ownerWindow = element.ownerDocument.defaultView;
+    if (ownerWindow) {
+      const handleWindowResize = () => {
+        scheduleKerningUpkeep();
+      };
+      ownerWindow.addEventListener("resize", handleWindowResize);
+      removeKerningResizeListener = () => {
+        ownerWindow.removeEventListener("resize", handleWindowResize);
+      };
+    }
+  }
+  if (autoSplit) {
+    const targets = resolveAutoSplitTargets(element);
+    let lastChangedTarget = null;
+    if (targets.length === 0) {
+      console.warn(
+        "SplitText: autoSplit enabled but no parent element found. AutoSplit will not work."
+      );
+    } else {
+      const handleResize = () => {
+        if (!isActive) return;
+        if (!element.isConnected) {
+          dispose();
+          return;
+        }
+        const currentWidth = resolveAutoSplitWidth(
+          targets,
+          autoSplitWidthByTarget,
+          lastChangedTarget
+        );
+        lastChangedTarget = null;
+        if (splitLines) {
+          const lineMeasureWidth = resolveLineMeasureWidth(currentWidth);
+          const nextLineFingerprint = measureLineFingerprintForWidth(
+            lineMeasureWidth
+          );
+          if (nextLineFingerprint !== null && nextLineFingerprint === currentLineFingerprint) {
+            return;
+          }
+        }
+        runFullResplit();
+      };
+      autoSplitObserver = new ResizeObserver((entries) => {
+        let changed = false;
+        let changedTarget = null;
+        entries.forEach((entry) => {
+          if (!(entry.target instanceof HTMLElement)) return;
+          const nextWidth = getObservedWidth(entry, entry.target);
+          if (nextWidth === null) return;
+          const didChange = recordWidthChange(
+            autoSplitWidthByTarget,
+            entry.target,
+            nextWidth
+          );
+          if (didChange) {
+            changed = true;
+            changedTarget = entry.target;
+          }
+        });
+        if (!changed) return;
+        lastChangedTarget = changedTarget;
+        if (autoSplitDebounceTimer) {
+          clearTimeout(autoSplitDebounceTimer);
+        }
+        autoSplitDebounceTimer = setTimeout(handleResize, 100);
+      });
+      targets.forEach((target) => {
+        autoSplitObserver.observe(target);
+      });
+    }
+  }
+  if (onSplit) {
+    const animationResult = onSplit({
+      chars: currentChars,
+      words: currentWords,
+      lines: currentLines
+    });
+    if (revertOnComplete) {
+      const promise = normalizeToPromise(animationResult);
+      if (promise) {
+        promise.then(() => {
+          if (isActive) {
+            revert();
+          }
+        }).catch(() => {
+          console.warn("[fetta] Animation rejected, text not reverted");
+        });
+      }
+    }
+  }
+  return {
+    chars: currentChars,
+    words: currentWords,
+    lines: currentLines,
+    revert
+  };
+}
+
+export { applyKerningCompensation, buildKerningStyleKey, clearKerningCompensation, getObservedWidth, normalizeToPromise, querySplitWords, recordWidthChange, resolveAutoSplitTargets, resolveAutoSplitWidth, splitText, splitTextData };