rtl-text-transform 0.0.0-stage → 0.1.0

package/dist/index.cjs

@@ -0,0 +1,1867 @@
+'use strict';
+
+// src/core/easing.ts
+function linear(t) {
+  return t;
+}
+function clamp01(value) {
+  if (value <= 0) return 0;
+  if (value >= 1) return 1;
+  return value;
+}
+function cubicBezier(x1, y1, x2, y2) {
+  const cx = 3 * clamp01(x1);
+  const bx = 3 * (clamp01(x2) - clamp01(x1)) - cx;
+  const ax = 1 - cx - bx;
+  const cy = 3 * y1;
+  const by = 3 * (y2 - y1) - cy;
+  const ay = 1 - cy - by;
+  const sampleX = (t) => ((ax * t + bx) * t + cx) * t;
+  const sampleY = (t) => ((ay * t + by) * t + cy) * t;
+  const sampleDerivativeX = (t) => (3 * ax * t + 2 * bx) * t + cx;
+  return (input) => {
+    if (input <= 0) return 0;
+    if (input >= 1) return 1;
+    let t = input;
+    for (let step = 0; step < 8; step += 1) {
+      const error = sampleX(t) - input;
+      if (Math.abs(error) < 1e-6) return sampleY(t);
+      const derivative = sampleDerivativeX(t);
+      if (Math.abs(derivative) < 1e-6) break;
+      t -= error / derivative;
+    }
+    let lower = 0;
+    let upper = 1;
+    t = clamp01(t);
+    for (let step = 0; step < 20; step += 1) {
+      const value = sampleX(t);
+      if (Math.abs(value - input) < 1e-6) break;
+      if (value < input) lower = t;
+      else upper = t;
+      t = (lower + upper) / 2;
+    }
+    return sampleY(t);
+  };
+}
+var easeInOutCubic = cubicBezier(0.65, 0, 0.35, 1);
+var easeOutCubic = cubicBezier(0.33, 1, 0.68, 1);
+var DEFAULT_MORPH_EASING = easeInOutCubic;
+var DEFAULT_RISE_EASING = easeOutCubic;
+
+// src/core/math.ts
+var MAX_BLUR_PX = 100;
+var OPACITY_EXPONENT = 0.4;
+function clamp012(value) {
+  if (Number.isNaN(value)) return 0;
+  if (value <= 0) return 0;
+  if (value >= 1) return 1;
+  return value;
+}
+function blurForFraction(fraction, fontSizePx, blurEm) {
+  const f = clamp012(fraction);
+  if (f >= 1) return 0;
+  if (f <= 0) return MAX_BLUR_PX;
+  const fontSize = Number.isFinite(fontSizePx) && fontSizePx > 0 ? fontSizePx : 16;
+  const blurEmSafe = Number.isFinite(blurEm) && blurEm > 0 ? blurEm : 0;
+  const blur = blurEmSafe * fontSize * (1 / f - 1);
+  return Math.min(MAX_BLUR_PX, Math.max(0, blur));
+}
+function opacityForFraction(fraction) {
+  return Math.pow(clamp012(fraction), OPACITY_EXPONENT);
+}
+function visualForFraction(fraction, fontSizePx, blurEm) {
+  return {
+    blurPx: blurForFraction(fraction, fontSizePx, blurEm),
+    opacity: opacityForFraction(fraction)
+  };
+}
+function thresholdMatrix(threshold) {
+  const t = Math.max(0, Math.min(255, threshold));
+  return `1 0 0 0 0  0 1 0 0 0  0 0 1 0 0  0 0 0 255 -${t}`;
+}
+function wrapIndex(index, length, loop) {
+  if (length <= 0) return 0;
+  if (loop) return (index % length + length) % length;
+  return Math.max(0, Math.min(length - 1, index));
+}
+function canAdvance(index, length, loop) {
+  if (length <= 1) return false;
+  if (loop) return true;
+  return index < length - 1;
+}
+
+// src/core/effects/rise.ts
+function withoutNegativeZero(value) {
+  return value === 0 ? 0 : value;
+}
+var MAX_STAGGER_SHARE = 0.35;
+var EXIT_DURATION = 0.7;
+function riseTiming(durationSeconds, hunkCount, staggerMs, overlap) {
+  const duration = Math.max(0, durationSeconds);
+  const count = Math.max(1, Math.floor(hunkCount));
+  const configuredStagger = Math.max(0, staggerMs) / 1e3;
+  const stagger = count > 1 ? Math.min(configuredStagger, duration * MAX_STAGGER_SHARE / (count - 1)) : 0;
+  const maxDelay = (count - 1) * stagger;
+  const window = Math.max(0, duration - maxDelay) / (1 + overlap);
+  return { window, stagger, overlap };
+}
+function enterProgress(elapsedSeconds, order, timing) {
+  if (timing.window <= 0) return 1;
+  const start = order * timing.stagger + timing.window * timing.overlap;
+  return clamp012((elapsedSeconds - start) / timing.window);
+}
+function exitProgress(elapsedSeconds, order, timing) {
+  const duration = timing.window * EXIT_DURATION;
+  if (duration <= 0) return 1;
+  const start = order * timing.stagger;
+  return clamp012((elapsedSeconds - start) / duration);
+}
+function enterTransform(progress, travelEm, scale, blurEm, flow) {
+  const eased = clamp012(progress);
+  const distance = travelEm * (1 - eased);
+  let xEm = 0;
+  let yEm = 0;
+  if (flow === "up") yEm = distance;
+  else if (flow === "down") yEm = -distance;
+  else if (flow === "left") xEm = distance;
+  else xEm = -distance;
+  return {
+    xEm: withoutNegativeZero(xEm),
+    yEm: withoutNegativeZero(yEm),
+    scale: 1 - (1 - scale) * (1 - eased),
+    blurEm: blurEm * (1 - eased)
+  };
+}
+function exitTransform(progress, travelEm, scale, blurEm, flow) {
+  const eased = clamp012(progress);
+  const distance = travelEm * 0.6 * eased;
+  let xEm = 0;
+  let yEm = 0;
+  if (flow === "up") yEm = -distance;
+  else if (flow === "down") yEm = distance;
+  else if (flow === "left") xEm = -distance;
+  else xEm = distance;
+  return {
+    xEm: withoutNegativeZero(xEm),
+    yEm: withoutNegativeZero(yEm),
+    scale: 1 - (1 - scale) * eased,
+    blurEm: blurEm * eased
+  };
+}
+
+// src/core/filter.ts
+var SVG_NS = "http://www.w3.org/2000/svg";
+var registries = /* @__PURE__ */ new WeakMap();
+var idCounter = 0;
+function normalizeThreshold(threshold) {
+  if (!Number.isFinite(threshold)) return 140;
+  return Math.max(0, Math.min(255, Math.round(threshold)));
+}
+function registryFor(doc) {
+  let registry = registries.get(doc);
+  if (!registry) {
+    registry = /* @__PURE__ */ new Map();
+    registries.set(doc, registry);
+  }
+  return registry;
+}
+function setStyles(el, styles) {
+  for (const [name, value] of Object.entries(styles)) {
+    el.style.setProperty(name, value);
+  }
+}
+function createFilterSvg(doc, threshold) {
+  const id = `goo-morph-${++idCounter}`;
+  const svg = doc.createElementNS(SVG_NS, "svg");
+  svg.setAttribute("aria-hidden", "true");
+  svg.setAttribute("focusable", "false");
+  svg.setAttribute("width", "0");
+  svg.setAttribute("height", "0");
+  setStyles(svg, {
+    position: "absolute",
+    width: "0",
+    height: "0",
+    overflow: "hidden",
+    "pointer-events": "none"
+  });
+  const defs = doc.createElementNS(SVG_NS, "defs");
+  const filter = doc.createElementNS(SVG_NS, "filter");
+  filter.setAttribute("id", id);
+  filter.setAttribute("x", "-25%");
+  filter.setAttribute("y", "-35%");
+  filter.setAttribute("width", "150%");
+  filter.setAttribute("height", "170%");
+  filter.setAttribute("color-interpolation-filters", "sRGB");
+  const matrix = doc.createElementNS(SVG_NS, "feColorMatrix");
+  matrix.setAttribute("in", "SourceGraphic");
+  matrix.setAttribute("type", "matrix");
+  matrix.setAttribute("values", thresholdMatrix(threshold));
+  filter.appendChild(matrix);
+  defs.appendChild(filter);
+  svg.appendChild(defs);
+  (doc.body ?? doc.documentElement).appendChild(svg);
+  return { id, threshold, svg, refs: 0 };
+}
+function acquireGooFilter(threshold, doc = typeof document === "undefined" ? void 0 : document) {
+  if (!doc) return null;
+  const normalized = normalizeThreshold(threshold);
+  const registry = registryFor(doc);
+  let entry = registry.get(normalized);
+  if (!entry || !entry.svg.isConnected) {
+    if (entry) registry.delete(normalized);
+    entry = createFilterSvg(doc, normalized);
+    registry.set(normalized, entry);
+  }
+  entry.refs += 1;
+  let released = false;
+  return {
+    id: entry.id,
+    threshold: normalized,
+    release() {
+      if (released) return;
+      released = true;
+      const current = registry.get(normalized);
+      if (!current || current !== entry) return;
+      current.refs = Math.max(0, current.refs - 1);
+      if (current.refs === 0) {
+        current.svg.remove();
+        registry.delete(normalized);
+      }
+    }
+  };
+}
+
+// src/core/layers.ts
+var HIDDEN_STYLE = {
+  position: "absolute",
+  width: "1px",
+  height: "1px",
+  padding: "0",
+  margin: "-1px",
+  overflow: "hidden",
+  clip: "rect(0 0 0 0)",
+  "clip-path": "inset(50%)",
+  "white-space": "nowrap",
+  border: "0"
+};
+function styleShell(el) {
+  const style = el.style;
+  style.position = "absolute";
+  style.inset = "0";
+  style.display = "flex";
+  style.alignItems = "center";
+  style.justifyContent = "center";
+  style.width = "100%";
+  style.height = "100%";
+  style.margin = "0";
+  style.padding = "0";
+  style.pointerEvents = "none";
+  style.fontFamily = "inherit";
+  style.fontSize = "inherit";
+  style.fontWeight = "inherit";
+  style.fontStyle = "inherit";
+  style.fontStretch = "inherit";
+  style.fontVariant = "inherit";
+  style.lineHeight = "inherit";
+  style.color = "inherit";
+  style.textAlign = "center";
+  style.overflow = "visible";
+}
+function styleLine(line) {
+  const style = line.style;
+  style.display = "block";
+  style.margin = "0";
+  style.padding = "0";
+  style.whiteSpace = "nowrap";
+  style.direction = "inherit";
+  style.textAlign = "center";
+  style.userSelect = "none";
+  style.webkitUserSelect = "none";
+  style.pointerEvents = "none";
+  style.transformOrigin = "center center";
+  style.opacity = "1";
+  style.filter = "none";
+  style.setProperty("letter-spacing", "0", "important");
+}
+function createLayer(doc, role) {
+  const el = doc.createElement("div");
+  const line = doc.createElement("span");
+  el.setAttribute("aria-hidden", "true");
+  el.dataset.morphLayer = role;
+  styleShell(el);
+  line.dataset.morphLine = role;
+  styleLine(line);
+  el.append(line);
+  return { el, line };
+}
+function createStage(host) {
+  const doc = host.ownerDocument;
+  const outgoing = createLayer(doc, "outgoing");
+  const incoming = createLayer(doc, "incoming");
+  const live = doc.createElement("span");
+  live.setAttribute("aria-live", "polite");
+  live.setAttribute("aria-atomic", "true");
+  live.dataset.morphLive = "";
+  for (const [name, value] of Object.entries(HIDDEN_STYLE)) {
+    live.style.setProperty(name, value);
+  }
+  host.replaceChildren(outgoing.el, incoming.el, live);
+  return { outgoing, incoming, live };
+}
+function defaultView(host) {
+  return host.ownerDocument.defaultView;
+}
+function sizeHost(host) {
+  const view = defaultView(host);
+  const computed = view?.getComputedStyle(host);
+  const computedPosition = computed?.position ?? "";
+  if (!host.style.position && (computedPosition === "" || computedPosition === "static")) {
+    host.style.position = "relative";
+  }
+  if (computed?.display === "inline") {
+    host.style.display = "block";
+    if (!host.style.width) host.style.width = "100%";
+  }
+  const computedMinHeight = computed?.minHeight ?? "";
+  if (!host.style.minHeight && (!computedMinHeight || computedMinHeight === "0px" || computedMinHeight === "auto")) {
+    host.style.minHeight = "1.6em";
+  }
+}
+function resetLayer(layer) {
+  layer.line.style.opacity = "1";
+  layer.line.style.filter = "none";
+  layer.line.style.transform = "none";
+}
+function clearLayer(layer) {
+  layer.line.replaceChildren();
+  resetLayer(layer);
+}
+function setLayerText(layer, text) {
+  if (layer.line.childNodes.length === 1 && layer.line.firstChild?.nodeType === 3 && layer.line.textContent === text) {
+    return;
+  }
+  layer.line.replaceChildren(text);
+}
+function applyGooState(layer, lightFraction, fontSizePx, blurEm) {
+  const visual = visualForFraction(lightFraction, fontSizePx, blurEm);
+  layer.line.style.opacity = String(visual.opacity);
+  layer.line.style.filter = visual.blurPx > 0 ? `blur(${visual.blurPx}px)` : "none";
+}
+function applyFadeState(layer, opacity) {
+  layer.line.style.opacity = String(Math.max(0, Math.min(1, opacity)));
+  layer.line.style.filter = "none";
+}
+function setLiveText(el, text) {
+  if (el.textContent !== text) el.textContent = text;
+}
+function removeStage(stage) {
+  stage.outgoing.el.remove();
+  stage.incoming.el.remove();
+  stage.live.remove();
+}
+
+// src/core/options.ts
+var DEFAULT_GOO = {
+  enabled: true,
+  blur: 0.075,
+  threshold: 140,
+  atRest: true
+};
+var DEFAULT_RISE = {
+  enabled: false,
+  blur: 0.1,
+  travel: 0.3,
+  scale: 0.94,
+  stagger: 35,
+  overlap: 0.15,
+  easing: DEFAULT_RISE_EASING,
+  flow: "up",
+  minChunk: 2,
+  normalizeVariants: true,
+  ignoreDiacritics: true
+};
+function nonNegative(value, fallback) {
+  return typeof value === "number" && Number.isFinite(value) ? Math.max(0, value) : fallback;
+}
+function clamp(value, min, max, fallback) {
+  if (typeof value !== "number" || !Number.isFinite(value)) return fallback;
+  return Math.max(min, Math.min(max, value));
+}
+function normalizeThreshold2(value) {
+  if (typeof value !== "number" || !Number.isFinite(value)) return 140;
+  return Math.max(0, Math.min(255, Math.round(value)));
+}
+function gooFromOptions(options, base) {
+  return {
+    enabled: true,
+    blur: nonNegative(options.blur, base.blur),
+    threshold: options.threshold === void 0 ? base.threshold : normalizeThreshold2(options.threshold),
+    atRest: typeof options.atRest === "boolean" ? options.atRest : base.atRest
+  };
+}
+function riseFromOptions(options, base) {
+  return {
+    enabled: true,
+    blur: nonNegative(options.blur, base.blur),
+    travel: nonNegative(options.travel, base.travel),
+    scale: clamp(options.scale, 0, 1, base.scale),
+    stagger: nonNegative(options.stagger, base.stagger),
+    overlap: clamp(options.overlap, 0, 1, base.overlap),
+    easing: typeof options.easing === "function" ? options.easing : base.easing,
+    flow: options.flow === "up" || options.flow === "down" || options.flow === "left" || options.flow === "right" || typeof options.flow === "function" ? options.flow : base.flow,
+    minChunk: typeof options.minChunk === "number" && Number.isFinite(options.minChunk) ? Math.max(0, Math.floor(options.minChunk)) : base.minChunk,
+    normalizeVariants: typeof options.normalizeVariants === "boolean" ? options.normalizeVariants : base.normalizeVariants,
+    ignoreDiacritics: typeof options.ignoreDiacritics === "boolean" ? options.ignoreDiacritics : base.ignoreDiacritics
+  };
+}
+function resolveInitialEffects(effects) {
+  const gooValue = effects?.goo;
+  const riseValue = effects?.rise;
+  const goo = gooValue === false ? { ...DEFAULT_GOO, enabled: false } : gooValue === void 0 || gooValue === true ? { ...DEFAULT_GOO } : gooFromOptions(gooValue, DEFAULT_GOO);
+  const rise = riseValue === void 0 || riseValue === false ? { ...DEFAULT_RISE, enabled: false } : riseValue === true ? { ...DEFAULT_RISE, enabled: true } : riseFromOptions(riseValue, DEFAULT_RISE);
+  return { goo, rise };
+}
+function applyGooPatch(current, patch) {
+  if (patch === void 0) return current;
+  if (patch === false) return { ...current, enabled: false };
+  if (patch === true) return { ...current, enabled: true };
+  return gooFromOptions(patch, current);
+}
+function applyRisePatch(current, patch) {
+  if (patch === void 0) return current;
+  if (patch === false) return { ...current, enabled: false };
+  if (patch === true) return { ...current, enabled: true };
+  return riseFromOptions(patch, current);
+}
+
+// src/core/presets.ts
+function firstNumber(value) {
+  const normalised = value.replace(/[۰-۹]/g, (digit) => String((digit.codePointAt(0) ?? 1776) - 1776)).replace(/[٠-٩]/g, (digit) => String((digit.codePointAt(0) ?? 1632) - 1632)).replace(/٬/g, "").replace(/(\d),(?=\d)/g, "$1").replace(/٫/g, ".");
+  const match = normalised.match(/-?\d+(?:\.\d+)?/);
+  if (!match) return void 0;
+  const number = Number(match[0]);
+  return Number.isFinite(number) ? number : void 0;
+}
+function flowByNumberChange(context) {
+  const from = firstNumber(context.from);
+  const to = firstNumber(context.to);
+  if (from === void 0 || to === void 0 || to === from) return "up";
+  return to > from ? "up" : "down";
+}
+function flowByHunkPosition(context) {
+  const atStart = context.hunk.position < 0.5;
+  if (context.rtl) return atStart ? "right" : "left";
+  return atStart ? "left" : "right";
+}
+var wordGoo = { blur: 0.1, threshold: 70, atRest: false };
+var wordRise = { blur: 0.04, travel: 0.24, scale: 0.96 };
+var presets = {
+  numbers: {
+    effects: {
+      goo: { ...wordGoo },
+      rise: {
+        ...wordRise,
+        blur: 0.1,
+        travel: 0.6,
+        scale: 0.9,
+        flow: flowByNumberChange
+      }
+    }
+  },
+  wordsHorizontal: {
+    effects: {
+      goo: { ...wordGoo },
+      rise: { ...wordRise, flow: flowByHunkPosition }
+    }
+  },
+  wordsUp: {
+    effects: {
+      goo: { ...wordGoo },
+      rise: { ...wordRise, flow: "up" }
+    }
+  },
+  wordsDown: {
+    effects: {
+      goo: { ...wordGoo },
+      rise: { ...wordRise, flow: "down" }
+    }
+  }
+};
+var motions = {
+  default: {
+    morphTime: 0.3,
+    easing: easeInOutCubic,
+    effects: {
+      rise: { easing: easeOutCubic, stagger: 70, overlap: 0 }
+    }
+  },
+  smooth: {
+    morphTime: 0.8,
+    easing: easeInOutCubic,
+    effects: {
+      rise: {
+        easing: cubicBezier(0.25, 0.8, 0.35, 1),
+        stagger: 30,
+        overlap: 0.18
+      }
+    }
+  },
+  snappy: {
+    morphTime: 0.2,
+    easing: cubicBezier(0.2, 0.8, 0.2, 1),
+    effects: {
+      rise: {
+        easing: cubicBezier(0.16, 1, 0.3, 1),
+        stagger: 50,
+        overlap: 0
+      }
+    }
+  },
+  gentle: {
+    morphTime: 1.1,
+    easing: easeInOutCubic,
+    effects: {
+      rise: {
+        easing: cubicBezier(0.42, 0, 0.58, 1),
+        stagger: 45,
+        overlap: 0.2
+      }
+    }
+  }
+};
+var presetNames = Object.keys(presets);
+var motionNames = Object.keys(motions);
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function mergeValue(base, override) {
+  if (override === void 0) return base;
+  if (Array.isArray(override)) return [...override];
+  if (isRecord(base) && isRecord(override)) return mergeOptions(base, override);
+  return override;
+}
+function mergeOptions(...sources) {
+  const merged = {};
+  for (const source of sources) {
+    if (!source) continue;
+    for (const [key, value] of Object.entries(source)) {
+      if (key === "preset" || key === "motion" || value === void 0) continue;
+      merged[key] = mergeValue(merged[key], value);
+    }
+  }
+  return merged;
+}
+function resolveMorphOptions(options) {
+  const { preset, motion, ...overrides } = options;
+  if (!preset && !motion) return options;
+  const motionName = motion ?? (preset ? "default" : void 0);
+  return mergeOptions(
+    preset ? presets[preset] : void 0,
+    motionName ? motions[motionName] : void 0,
+    overrides
+  );
+}
+function resolvePreset(name, overrides = {}) {
+  return resolveMorphOptions({ ...overrides, preset: name });
+}
+function isRiseFlow(value) {
+  return value === "up" || value === "down" || value === "left" || value === "right";
+}
+
+// src/core/atoms.ts
+var ZWNJ = "\u200C";
+var ZWJ = "\u200D";
+var DIACRITICS_RE = /[\u0610-\u061A\u064B-\u065F\u0670\u06D6-\u06ED\u08D3-\u08E1\u08E3-\u08FF]/g;
+var ALEF_VARIANTS = /* @__PURE__ */ new Set([
+  "\u0622",
+  // آ
+  "\u0623",
+  // أ
+  "\u0625",
+  // إ
+  "\u0627",
+  // ا
+  "\u0671"
+  // ٱ
+]);
+var RIGHT_JOINING = new Set(
+  [
+    "\u0622",
+    // آ
+    "\u0623",
+    // أ
+    "\u0624",
+    // ؤ
+    "\u0625",
+    // إ
+    "\u0627",
+    // ا
+    "\u0629",
+    // ة
+    "\u062F",
+    // د
+    "\u0630",
+    // ذ
+    "\u0631",
+    // ر
+    "\u0632",
+    // ز
+    "\u0648",
+    // و
+    "\u0698"
+    // ژ
+  ].map((char) => char.normalize("NFC"))
+);
+var NON_JOINING = /* @__PURE__ */ new Set([
+  "\u0621"
+  // ء
+]);
+function isMark(char) {
+  return /^\p{M}$/u.test(char);
+}
+function isArabicLetter(char) {
+  return /\p{L}/u.test(char) && /\p{Script=Arabic}/u.test(char);
+}
+function canJoinPrevious(char) {
+  return isArabicLetter(char) && !NON_JOINING.has(char);
+}
+function canJoinNext(char) {
+  return isArabicLetter(char) && !RIGHT_JOINING.has(char) && !NON_JOINING.has(char);
+}
+function neighbor(text, index, direction) {
+  let cursor = index + direction;
+  while (cursor >= 0 && cursor < text.length) {
+    const char = text[cursor];
+    if (isMark(char) || char === ZWJ) {
+      cursor += direction;
+      continue;
+    }
+    if (char === ZWNJ || /\s/u.test(char) || !isArabicLetter(char)) return null;
+    return { char, index: cursor };
+  }
+  return null;
+}
+function formOf(text, index) {
+  const char = text[index];
+  if (!isArabicLetter(char)) return "x";
+  const previous = neighbor(text, index, -1);
+  const next = neighbor(text, index, 1);
+  const joinsPrevious = previous !== null && canJoinNext(previous.char) && canJoinPrevious(char);
+  const joinsNext = next !== null && canJoinNext(char) && canJoinPrevious(next.char);
+  if (joinsPrevious && joinsNext) return "medial";
+  if (joinsPrevious) return "final";
+  if (joinsNext) return "initial";
+  return "isolated";
+}
+function formSignature(text, start, end) {
+  const forms = [];
+  for (let index = start; index < end; index += 1) {
+    if (isArabicLetter(text[index])) forms.push(formOf(text, index));
+  }
+  return forms.length > 0 ? forms.join(",") : "x";
+}
+var cachedSegmenter;
+function getSegmenter() {
+  if (cachedSegmenter !== void 0) return cachedSegmenter;
+  const intl = Intl;
+  if (typeof intl.Segmenter !== "function") {
+    cachedSegmenter = null;
+    return cachedSegmenter;
+  }
+  try {
+    cachedSegmenter = new intl.Segmenter(void 0, { granularity: "grapheme" });
+  } catch {
+    cachedSegmenter = null;
+  }
+  return cachedSegmenter;
+}
+function fallbackSegments(text) {
+  const segments = [];
+  let start = 0;
+  let current = "";
+  let previousWasZWJ = false;
+  for (let index = 0; index < text.length; ) {
+    const codePoint = text.codePointAt(index);
+    if (codePoint === void 0) break;
+    const char = String.fromCodePoint(codePoint);
+    const mark = /^\p{M}$/u.test(char);
+    const variation = /^[\uFE00-\uFE0F]$/u.test(char);
+    const modifier = /^[\u{1F3FB}-\u{1F3FF}]$/u.test(char);
+    const joinControl = char === ZWJ;
+    const joinAfter = previousWasZWJ;
+    const join = mark || variation || modifier || joinControl || joinAfter;
+    if (!join && current.length > 0) {
+      segments.push({ segment: current, index: start });
+      start = index;
+      current = "";
+    }
+    if (current.length === 0) start = index;
+    current += char;
+    previousWasZWJ = char === ZWJ;
+    index += char.length;
+  }
+  if (current.length > 0) segments.push({ segment: current, index: start });
+  return segments;
+}
+function segmentGraphemes(text) {
+  if (text.length === 0) return [];
+  const segmenter = getSegmenter();
+  if (!segmenter) return fallbackSegments(text);
+  return Array.from(segmenter.segment(text), (part) => ({
+    segment: part.segment,
+    index: part.index
+  }));
+}
+function firstArabicLetter(text) {
+  for (const char of text) {
+    if (isArabicLetter(char)) return char;
+  }
+  return "";
+}
+function isLamSegment(text) {
+  return firstArabicLetter(text) === "\u0644";
+}
+function isAlefSegment(text) {
+  return ALEF_VARIANTS.has(firstArabicLetter(text));
+}
+function atomRanges(text) {
+  const segments = segmentGraphemes(text);
+  const ranges = [];
+  for (let index = 0; index < segments.length; index += 1) {
+    const current = segments[index];
+    if (!current) continue;
+    const next = segments[index + 1];
+    if (next && isLamSegment(current.segment) && !current.segment.includes(ZWNJ) && isAlefSegment(next.segment)) {
+      ranges.push({ start: current.index, end: next.index + next.segment.length });
+      index += 1;
+    } else {
+      ranges.push({ start: current.index, end: current.index + current.segment.length });
+    }
+  }
+  return ranges;
+}
+function createAtoms(text) {
+  return atomRanges(text).map(({ start, end }) => {
+    const atomText = text.slice(start, end);
+    const formKey = formSignature(text, start, end);
+    return {
+      text: atomText,
+      key: `${atomText}\0${formKey}`,
+      start,
+      end,
+      formKey
+    };
+  });
+}
+function isWordBreakAtom(atom) {
+  if (atom.text.includes(ZWNJ) || atom.text.includes(ZWJ)) return false;
+  return !/[\p{L}\p{N}]/u.test(atom.text);
+}
+
+// src/core/chunks.ts
+function atWordEdge(atoms, start, end) {
+  const before = start === 0 || isWordBreakAtom(atoms[start - 1]);
+  const after = end === atoms.length - 1 || isWordBreakAtom(atoms[end + 1]);
+  return before && after;
+}
+function isWholeWord(run, a, b) {
+  const aStart = run[0].aIndex;
+  const aEnd = run[run.length - 1].aIndex;
+  const bStart = run[0].bIndex;
+  const bEnd = run[run.length - 1].bIndex;
+  return atWordEdge(a, aStart, aEnd) && atWordEdge(b, bStart, bEnd);
+}
+function diffToChunks(a, b, operations, options = {}) {
+  const minChunk = Math.max(0, Math.floor(options.minChunk ?? 2));
+  const chunks = [];
+  let id = 0;
+  const push = (kind, aIndices, bIndices) => {
+    chunks.push({ id: `chunk-${id++}`, kind, aIndices, bIndices });
+  };
+  let index = 0;
+  while (index < operations.length) {
+    const operation = operations[index];
+    if (operation.type === "match") {
+      const run = [operation];
+      let nextIndex2 = index + 1;
+      while (nextIndex2 < operations.length) {
+        const next = operations[nextIndex2];
+        if (next.type !== "match") break;
+        const last = run[run.length - 1];
+        if (next.aIndex !== last.aIndex + 1 || next.bIndex !== last.bIndex + 1) {
+          break;
+        }
+        run.push(next);
+        nextIndex2 += 1;
+      }
+      if (run.length >= minChunk || isWholeWord(run, a, b)) {
+        push(
+          "match",
+          run.map((match) => match.aIndex),
+          run.map((match) => match.bIndex)
+        );
+      } else {
+        for (const match of run) {
+          push("remove", [match.aIndex], []);
+          push("add", [], [match.bIndex]);
+        }
+      }
+      index = nextIndex2;
+      continue;
+    }
+    if (operation.type === "delete") {
+      const indices2 = [];
+      let nextIndex2 = index;
+      while (nextIndex2 < operations.length) {
+        const current = operations[nextIndex2];
+        if (current.type !== "delete") break;
+        indices2.push(current.aIndex);
+        nextIndex2 += 1;
+      }
+      push("remove", indices2, []);
+      index = nextIndex2;
+      continue;
+    }
+    const indices = [];
+    let nextIndex = index;
+    while (nextIndex < operations.length) {
+      const current = operations[nextIndex];
+      if (current.type !== "insert") break;
+      indices.push(current.bIndex);
+      nextIndex += 1;
+    }
+    push("add", [], indices);
+    index = nextIndex;
+  }
+  const mergeSide = (kind) => {
+    const sideChunks = chunks.filter((chunk) => chunk.kind === kind).sort((left, right) => {
+      const aIndex = kind === "remove" ? left.aIndices[0] : left.bIndices[0];
+      const bIndex = kind === "remove" ? right.aIndices[0] : right.bIndices[0];
+      return (aIndex ?? 0) - (bIndex ?? 0);
+    });
+    const merged2 = [];
+    for (const chunk of sideChunks) {
+      const last = merged2[merged2.length - 1];
+      const lastIndices = last ? kind === "remove" ? last.aIndices : last.bIndices : [];
+      const indices = kind === "remove" ? chunk.aIndices : chunk.bIndices;
+      if (last && lastIndices.length > 0 && indices.length > 0 && indices[0] === lastIndices[lastIndices.length - 1] + 1) {
+        if (kind === "remove") last.aIndices.push(...chunk.aIndices);
+        else last.bIndices.push(...chunk.bIndices);
+      } else {
+        merged2.push({
+          id: "",
+          kind,
+          aIndices: [...chunk.aIndices],
+          bIndices: [...chunk.bIndices]
+        });
+      }
+    }
+    return merged2;
+  };
+  const merged = [
+    ...mergeSide("remove"),
+    ...mergeSide("add"),
+    ...chunks.filter((chunk) => chunk.kind === "match")
+  ];
+  const splitChanged = (chunk) => {
+    if (chunk.kind === "match") return [chunk];
+    const indices = chunk.kind === "remove" ? chunk.aIndices : chunk.bIndices;
+    const atoms = chunk.kind === "remove" ? a : b;
+    const pieces = [];
+    let current = [];
+    const flush = () => {
+      if (current.length === 0) return;
+      pieces.push({
+        id: "",
+        kind: chunk.kind,
+        aIndices: chunk.kind === "remove" ? current : [],
+        bIndices: chunk.kind === "add" ? current : []
+      });
+      current = [];
+    };
+    for (const atomIndex of indices) {
+      current.push(atomIndex);
+      if (/\s/u.test(atoms[atomIndex]?.text ?? "")) flush();
+    }
+    flush();
+    return pieces.length > 0 ? pieces : [chunk];
+  };
+  const split = merged.flatMap(splitChanged);
+  split.forEach((chunk, chunkIndex) => {
+    chunk.id = `chunk-${chunkIndex}`;
+  });
+  return split;
+}
+
+// src/core/diff.ts
+var VARIANT_MAP = {
+  "\u064A": "\u06CC",
+  // ي -> ی
+  "\u0643": "\u06A9"
+  // ك -> ک
+};
+function normalizeVariantText(text) {
+  return text.replace(/[\u064A\u0643]/g, (char) => VARIANT_MAP[char] ?? char);
+}
+function normalizedText(atom, options) {
+  let text = atom.text.normalize("NFC").split(ZWNJ).join("");
+  if (options.normalizeVariants) text = normalizeVariantText(text);
+  if (options.ignoreDiacritics) text = text.replace(DIACRITICS_RE, "");
+  return text;
+}
+function atomsEqual(a, b, options = {}) {
+  if (a.formKey !== b.formKey) return false;
+  return normalizedText(a, options) === normalizedText(b, options);
+}
+function diffAtoms(a, b, options = {}) {
+  const rows = a.length;
+  const columns = b.length;
+  const table = Array.from({ length: rows + 1 }, () => new Uint32Array(columns + 1));
+  for (let row2 = rows - 1; row2 >= 0; row2 -= 1) {
+    for (let column2 = columns - 1; column2 >= 0; column2 -= 1) {
+      table[row2][column2] = atomsEqual(a[row2], b[column2], options) ? table[row2 + 1][column2 + 1] + 1 : Math.max(table[row2 + 1][column2], table[row2][column2 + 1]);
+    }
+  }
+  const operations = [];
+  let row = 0;
+  let column = 0;
+  while (row < rows && column < columns) {
+    if (atomsEqual(a[row], b[column], options)) {
+      operations.push({ type: "match", aIndex: row, bIndex: column });
+      row += 1;
+      column += 1;
+    } else if (table[row + 1][column] >= table[row][column + 1]) {
+      operations.push({ type: "delete", aIndex: row });
+      row += 1;
+    } else {
+      operations.push({ type: "insert", bIndex: column });
+      column += 1;
+    }
+  }
+  while (row < rows) {
+    operations.push({ type: "delete", aIndex: row });
+    row += 1;
+  }
+  while (column < columns) {
+    operations.push({ type: "insert", bIndex: column });
+    column += 1;
+  }
+  return operations;
+}
+
+// src/core/scene.ts
+function previousBase(text, index) {
+  let cursor = index - 1;
+  while (cursor >= 0 && isMark(text[cursor])) cursor -= 1;
+  return cursor >= 0 ? text[cursor] : "";
+}
+function nextBase(text, index) {
+  let cursor = index;
+  while (cursor < text.length && isMark(text[cursor])) cursor += 1;
+  return cursor < text.length ? text[cursor] : "";
+}
+function firstBaseBetween(text, start, end) {
+  let cursor = start;
+  while (cursor < end && isMark(text[cursor])) cursor += 1;
+  return cursor < end ? text[cursor] : "";
+}
+function lastBaseBefore(text, end) {
+  let cursor = end - 1;
+  while (cursor >= 0 && isMark(text[cursor])) cursor -= 1;
+  return cursor >= 0 ? text[cursor] : "";
+}
+function shouldPadStart(text, start, end) {
+  if (start <= 0) return false;
+  const first = firstBaseBetween(text, start, end);
+  const before = previousBase(text, start);
+  if (!isArabicLetter(first) || !isArabicLetter(before)) return false;
+  return canJoinPrevious(first) && canJoinNext(before);
+}
+function shouldPadEnd(text, start, end) {
+  if (end >= text.length) return false;
+  const last = lastBaseBefore(text, end);
+  const after = nextBase(text, end);
+  if (!isArabicLetter(last) || !isArabicLetter(after)) return false;
+  return canJoinNext(last) && canJoinPrevious(after);
+}
+function atomSourceRange(atoms, indices) {
+  let start = Number.POSITIVE_INFINITY;
+  let end = Number.NEGATIVE_INFINITY;
+  for (const index of indices) {
+    const atom = atoms[index];
+    if (!atom) continue;
+    start = Math.min(start, atom.start);
+    end = Math.max(end, atom.end);
+  }
+  if (!Number.isFinite(start) || !Number.isFinite(end)) {
+    return { start: 0, end: 0 };
+  }
+  return { start, end };
+}
+function styleChunk(span, dir) {
+  span.dir = dir;
+  span.style.display = "inline-block";
+  span.style.whiteSpace = "pre";
+  span.style.unicodeBidi = "isolate";
+  span.style.direction = dir === "auto" ? "inherit" : dir;
+  span.style.verticalAlign = "baseline";
+  span.style.transformOrigin = "center center";
+  span.style.willChange = "transform, opacity, filter";
+  span.style.pointerEvents = "none";
+  span.style.setProperty("letter-spacing", "0", "important");
+}
+function renderLayer(layer, source, atoms, chunks, side, options) {
+  resetLayer(layer);
+  layer.line.replaceChildren();
+  const records = [];
+  for (const chunk of chunks) {
+    const indices = side === "a" ? chunk.aIndices : chunk.bIndices;
+    if (indices.length === 0) continue;
+    const range = atomSourceRange(atoms, indices);
+    if (range.end <= range.start) continue;
+    const text = source.slice(range.start, range.end);
+    const leadingPad = shouldPadStart(source, range.start, range.end) ? ZWJ : "";
+    const trailingPad = shouldPadEnd(source, range.start, range.end) ? ZWJ : "";
+    const span = layer.el.ownerDocument.createElement("span");
+    span.className = `rtm-chunk rtm-chunk--${chunk.kind}`;
+    span.dataset.chunkId = chunk.id;
+    span.dataset.chunkKind = chunk.kind;
+    span.dataset.chunkSide = side;
+    styleChunk(span, options.dir);
+    span.textContent = leadingPad + text + trailingPad;
+    records.push({
+      chunk,
+      span,
+      text,
+      sourceStart: range.start,
+      sourceEnd: range.end,
+      side
+    });
+  }
+  records.sort((left, right) => left.sourceStart - right.sourceStart);
+  for (const record of records) layer.line.appendChild(record.span);
+  return records;
+}
+function measureSpan(span) {
+  const range = span.ownerDocument.createRange();
+  range.selectNodeContents(span);
+  const rangeRect = typeof range.getBoundingClientRect === "function" ? range.getBoundingClientRect() : null;
+  const spanRect = span.getBoundingClientRect();
+  if (!rangeRect) return spanRect;
+  if (rangeRect.width === 0 && rangeRect.height === 0 && (spanRect.width > 0 || spanRect.height > 0)) {
+    return spanRect;
+  }
+  return rangeRect;
+}
+function readingOrder(records, rtl) {
+  return records.map((record) => {
+    const rect = record.span.getBoundingClientRect();
+    return { record, x: rtl ? rect.right : rect.left };
+  }).sort((left, right) => rtl ? right.x - left.x : left.x - right.x).map((entry) => entry.record);
+}
+function buildDiffScene(stage, from, to, options) {
+  const atomsA = createAtoms(from);
+  const atomsB = createAtoms(to);
+  const operations = diffAtoms(atomsA, atomsB, {
+    normalizeVariants: options.normalizeVariants,
+    ignoreDiacritics: options.ignoreDiacritics
+  });
+  const chunks = diffToChunks(atomsA, atomsB, operations, {
+    minChunk: options.minChunk
+  });
+  const oldRecords = renderLayer(stage.outgoing, from, atomsA, chunks, "a", options);
+  const newRecords = renderLayer(stage.incoming, to, atomsB, chunks, "b", options);
+  const oldMatched = /* @__PURE__ */ new Map();
+  for (const record of oldRecords) {
+    if (record.chunk.kind === "match") oldMatched.set(record.chunk.id, record);
+  }
+  const matched = [];
+  for (const record of newRecords) {
+    if (record.chunk.kind !== "match") continue;
+    const old = oldMatched.get(record.chunk.id);
+    if (!old) continue;
+    old.span.style.opacity = "0";
+    const oldRect = measureSpan(old.span);
+    const newRect = measureSpan(record.span);
+    matched.push({
+      ...record,
+      dx: oldRect.left - newRect.left,
+      dy: oldRect.top - newRect.top
+    });
+  }
+  const enter = newRecords.filter((record) => record.chunk.kind === "add");
+  for (const record of enter) record.span.style.opacity = "0";
+  const exit = oldRecords.filter((record) => record.chunk.kind === "remove");
+  return {
+    from,
+    to,
+    atomsA,
+    atomsB,
+    chunks,
+    enter,
+    exit,
+    matched
+  };
+}
+function enterOrder(scene, rtl) {
+  return readingOrder(scene.enter, rtl);
+}
+function exitOrder(scene, rtl) {
+  return readingOrder(scene.exit, rtl);
+}
+
+// src/core/transition.ts
+var DEFAULT_FONT_SIZE = 16;
+var MAX_FRAME_DELTA = 0.1;
+var REDUCED_MOTION_FADE = 0.18;
+var NO_EFFECT_FADE = 0.3;
+var FAST_FORWARD = 0.12;
+var GOO_SOFTEN = " blur(0.6px)";
+function nonNegative2(value, fallback) {
+  return typeof value === "number" && Number.isFinite(value) ? Math.max(0, value) : fallback;
+}
+function sameWords(a, b) {
+  return a.length === b.length && a.every((word, index) => word === b[index]);
+}
+function prefersReducedMotion(doc) {
+  const view = doc.defaultView;
+  if (!view || typeof view.matchMedia !== "function") return false;
+  try {
+    return view.matchMedia("(prefers-reduced-motion: reduce)").matches;
+  } catch {
+    return false;
+  }
+}
+function reportCallbackError(error) {
+  if (typeof console !== "undefined" && typeof console.error === "function") {
+    console.error("[rtl-text-transform]", error);
+  }
+}
+function combineBlur(gooPx, risePx) {
+  const goo = Math.max(0, gooPx);
+  const rise = Math.max(0, risePx);
+  if (goo < 0.01 && rise < 0.01) return "none";
+  if (goo < 0.01) return `blur(${rise.toFixed(2)}px)`;
+  if (rise < 0.01) return `blur(${goo.toFixed(2)}px)`;
+  return `blur(${goo.toFixed(2)}px) blur(${rise.toFixed(2)}px)`;
+}
+function resolveFlow(flow, context) {
+  if (typeof flow !== "function") return flow;
+  try {
+    const resolved = flow(context);
+    return isRiseFlow(resolved) ? resolved : "up";
+  } catch (error) {
+    reportCallbackError(error);
+    return "up";
+  }
+}
+function flowForTransition(flow, scene, from, to, dir, rtl) {
+  if (typeof flow !== "function") {
+    return { fallback: flow };
+  }
+  const byChunk = /* @__PURE__ */ new Map();
+  for (const chunk of scene.chunks) {
+    if (chunk.kind === "match") continue;
+    const useTarget = chunk.bIndices.length > 0;
+    const source = useTarget ? to : from;
+    const atoms = useTarget ? scene.atomsB : scene.atomsA;
+    const range = atomSourceRange(atoms, useTarget ? chunk.bIndices : chunk.aIndices);
+    const text = source.slice(range.start, range.end);
+    const length = source.length;
+    const position = length > 0 ? Math.min(1, Math.max(0, (range.start + range.end) / 2 / length)) : 0;
+    const context = {
+      from,
+      to,
+      dir,
+      rtl,
+      hunk: {
+        id: chunk.id,
+        kind: chunk.kind === "add" ? "add" : "remove",
+        text,
+        start: range.start,
+        end: range.end,
+        length,
+        position
+      }
+    };
+    byChunk.set(chunk.id, resolveFlow(flow, context));
+  }
+  return { fallback: "up", byChunk };
+}
+
+// src/core/controller.ts
+function createMorph(el, options = {}) {
+  if (!el || !el.ownerDocument) {
+    throw new TypeError("createMorph(el): el must be an HTMLElement");
+  }
+  const resolvedOptions = resolveMorphOptions(options);
+  const doc = el.ownerDocument;
+  const originalNodes = Array.from(el.childNodes);
+  const originalDir = el.getAttribute("dir");
+  const originalLang = el.getAttribute("lang");
+  const savedStyle = {
+    position: el.style.position,
+    display: el.style.display,
+    minHeight: el.style.minHeight,
+    width: el.style.width,
+    filter: el.style.filter
+  };
+  const initialText = (el.textContent ?? "").trim();
+  let words = Array.isArray(resolvedOptions.words) ? resolvedOptions.words.map((word) => String(word)) : [];
+  const initialEffects = resolveInitialEffects(resolvedOptions.effects);
+  let goo = initialEffects.goo;
+  let rise = initialEffects.rise;
+  let morphTime = nonNegative2(resolvedOptions.morphTime, 1);
+  let restTime = nonNegative2(resolvedOptions.restTime, 0.25);
+  let dir = resolvedOptions.dir;
+  let lang = resolvedOptions.lang;
+  let autoplay = resolvedOptions.autoplay ?? true;
+  let loop = resolvedOptions.loop ?? true;
+  let easing = typeof resolvedOptions.easing === "function" ? resolvedOptions.easing : DEFAULT_MORPH_EASING;
+  let onMorphStart = resolvedOptions.onMorphStart;
+  let onMorphEnd = resolvedOptions.onMorphEnd;
+  let currentPreset = options.preset;
+  let currentMotion = options.motion;
+  if (dir) el.setAttribute("dir", dir);
+  if (lang) el.setAttribute("lang", lang);
+  let currentText = words.length > 0 ? words[0] : initialText;
+  let wordIndex = 0;
+  let auto = autoplay;
+  let autoRest = auto && words.length > 1 && canAdvance(wordIndex, words.length, loop) ? restTime : null;
+  let paused = false;
+  let destroyed = false;
+  let hidden = doc.visibilityState === "hidden";
+  let offscreen = false;
+  let transition = null;
+  let pending = null;
+  let rafId = null;
+  let lastTimestamp = null;
+  let filter = goo.enabled ? acquireGooFilter(goo.threshold, doc) : null;
+  sizeHost(el);
+  const stage = createStage(el);
+  function readFontSize() {
+    const view2 = doc.defaultView;
+    const computed = view2?.getComputedStyle(el).fontSize;
+    const parsed = computed ? Number.parseFloat(computed) : Number.NaN;
+    if (Number.isFinite(parsed) && parsed > 0) return parsed;
+    const inline = Number.parseFloat(el.style.fontSize);
+    return Number.isFinite(inline) && inline > 0 ? inline : DEFAULT_FONT_SIZE;
+  }
+  function readDirection() {
+    const attr = dir ?? el.getAttribute("dir") ?? "rtl";
+    const view2 = doc.defaultView;
+    const computed = view2?.getComputedStyle(el).direction;
+    const rtl = computed === "rtl" ? true : computed === "ltr" ? false : attr !== "ltr";
+    return { dir: attr === "ltr" || attr === "rtl" || attr === "auto" ? attr : "rtl", rtl };
+  }
+  function applyEasing(curve, value) {
+    try {
+      const eased = curve(value);
+      return Number.isFinite(eased) ? clamp012(eased) : value;
+    } catch {
+      return value;
+    }
+  }
+  function ease(value) {
+    return applyEasing(easing, value);
+  }
+  function easeRise(value) {
+    return applyEasing(rise.easing, value);
+  }
+  function renderSettled(text) {
+    clearLayer(stage.outgoing);
+    clearLayer(stage.incoming);
+    setLayerText(stage.outgoing, text);
+    setLayerText(stage.incoming, text);
+    stage.outgoing.line.style.opacity = "0";
+    stage.outgoing.line.style.filter = "none";
+    stage.incoming.line.style.opacity = "1";
+    stage.incoming.line.style.filter = "none";
+    stage.incoming.line.style.transform = "none";
+  }
+  function syncFilter() {
+    if (destroyed) return;
+    const reduced = prefersReducedMotion(doc);
+    const activeGoo = transition !== null && (transition.mode === "goo" || transition.mode === "rise");
+    const canUseGoo = goo.enabled && filter !== null && !reduced && (transition === null ? goo.atRest : activeGoo);
+    if (!canUseGoo) {
+      el.style.filter = "none";
+      return;
+    }
+    const soften = rise.enabled ? "" : GOO_SOFTEN;
+    el.style.filter = `url(#${filter.id})${soften}`;
+  }
+  function refreshFilter() {
+    if (destroyed) return;
+    if (!goo.enabled) {
+      filter?.release();
+      filter = null;
+      syncFilter();
+      return;
+    }
+    if (!filter || filter.threshold !== goo.threshold) {
+      const next2 = acquireGooFilter(goo.threshold, doc);
+      filter?.release();
+      filter = next2;
+    }
+    syncFilter();
+  }
+  function safeCallback(callback, from, to) {
+    if (!callback) return;
+    try {
+      callback(from, to);
+    } catch (error) {
+      reportCallbackError(error);
+    }
+  }
+  function canAutoAdvance() {
+    return canAdvance(wordIndex, words.length, loop);
+  }
+  function needsLoop() {
+    if (destroyed || paused || hidden || offscreen) return false;
+    if (transition) return true;
+    return auto && words.length > 1 && canAutoAdvance();
+  }
+  function requestFrame() {
+    if (typeof requestAnimationFrame === "function") {
+      return requestAnimationFrame(tick);
+    }
+    return setTimeout(() => tick(Date.now()), 16);
+  }
+  function cancelFrame(id) {
+    if (typeof cancelAnimationFrame === "function") {
+      cancelAnimationFrame(id);
+    } else {
+      clearTimeout(id);
+    }
+  }
+  function stopLoop() {
+    if (rafId !== null) {
+      cancelFrame(rafId);
+      rafId = null;
+    }
+    lastTimestamp = null;
+  }
+  function syncLoop() {
+    if (!needsLoop()) {
+      stopLoop();
+      return;
+    }
+    if (rafId !== null) return;
+    lastTimestamp = null;
+    rafId = requestFrame();
+  }
+  function renderGooOrFade(tr, eased) {
+    if (tr.mode === "goo" && goo.enabled) {
+      const fontSize = readFontSize();
+      applyGooState(stage.outgoing, tr.outStart * (1 - eased), fontSize, goo.blur);
+      applyGooState(stage.incoming, eased, fontSize, goo.blur);
+    } else {
+      applyFadeState(stage.outgoing, tr.outStart * (1 - eased));
+      applyFadeState(stage.incoming, eased);
+    }
+  }
+  function renderRise(tr) {
+    const scene = tr.scene;
+    const timing = tr.timing;
+    if (!scene || !timing) return;
+    const duration = tr.duration;
+    const elapsed = Math.max(0, Math.min(duration, tr.elapsed));
+    const global = duration > 0 ? clamp012(elapsed / duration) : 1;
+    const globalEased = ease(global);
+    const fontSize = readFontSize();
+    for (let order = 0; order < tr.enter.length; order += 1) {
+      const record = tr.enter[order];
+      const local = easeRise(enterProgress(elapsed, order, timing));
+      const gooOpacity = goo.enabled ? opacityForFraction(local) : local;
+      const gooBlur = goo.enabled ? blurForFraction(local, fontSize, goo.blur) : 0;
+      const motion = enterTransform(
+        local,
+        rise.travel,
+        rise.scale,
+        rise.blur,
+        tr.flowByChunk?.get(record.chunk.id) ?? tr.flow
+      );
+      record.span.style.opacity = String(gooOpacity);
+      record.span.style.filter = combineBlur(gooBlur, motion.blurEm * fontSize);
+      record.span.style.transform = `translate(${(motion.xEm * fontSize).toFixed(2)}px, ${(motion.yEm * fontSize).toFixed(2)}px) scale(${motion.scale.toFixed(4)})`;
+    }
+    for (let order = 0; order < tr.exit.length; order += 1) {
+      const record = tr.exit[order];
+      const local = easeRise(exitProgress(elapsed, order, timing));
+      const remaining = 1 - local;
+      const gooOpacity = goo.enabled ? opacityForFraction(remaining) : remaining;
+      const gooBlur = goo.enabled ? blurForFraction(remaining, fontSize, goo.blur) : 0;
+      const motion = exitTransform(
+        local,
+        rise.travel,
+        rise.scale,
+        rise.blur,
+        tr.flowByChunk?.get(record.chunk.id) ?? tr.flow
+      );
+      record.span.style.opacity = String(gooOpacity);
+      record.span.style.filter = combineBlur(gooBlur, motion.blurEm * fontSize);
+      record.span.style.transform = `translate(${(motion.xEm * fontSize).toFixed(2)}px, ${(motion.yEm * fontSize).toFixed(2)}px) scale(${motion.scale.toFixed(4)})`;
+    }
+    for (const record of scene.matched) {
+      record.span.style.opacity = "1";
+      record.span.style.filter = "none";
+      record.span.style.transform = `translate(${(record.dx * (1 - globalEased)).toFixed(2)}px, ${(record.dy * (1 - globalEased)).toFixed(2)}px)`;
+    }
+  }
+  function renderTransition(tr, raw) {
+    tr.raw = clamp012(raw);
+    const eased = ease(tr.raw);
+    tr.eased = eased;
+    if (tr.mode === "rise") {
+      renderRise(tr);
+    } else {
+      renderGooOrFade(tr, eased);
+    }
+  }
+  function clearPending() {
+    if (!pending) return;
+    const queued = pending;
+    pending = null;
+    queued.resolve();
+  }
+  function completeTransition(tr) {
+    if (transition !== tr) return;
+    transition = null;
+    tr.elapsed = tr.duration;
+    tr.raw = 1;
+    tr.eased = 1;
+    renderTransition(tr, 1);
+    currentText = tr.to;
+    const completedIndex = words.indexOf(tr.to);
+    if (completedIndex >= 0) wordIndex = completedIndex;
+    renderSettled(currentText);
+    setLiveText(stage.live, currentText);
+    tr.resolve();
+    syncFilter();
+    safeCallback(onMorphEnd, tr.from, tr.to);
+    const queued = pending;
+    pending = null;
+    if (queued && !destroyed) {
+      void startMorph(queued.text).then(queued.resolve, queued.resolve);
+      return;
+    }
+    if (!destroyed) {
+      if (auto && !paused) {
+        if (canAutoAdvance()) {
+          autoRest = restTime;
+        } else {
+          auto = false;
+          autoRest = null;
+        }
+      }
+      syncLoop();
+    }
+  }
+  function snapTo(text) {
+    clearPending();
+    if (transition) {
+      const tr = transition;
+      transition = null;
+      tr.resolve();
+    }
+    currentText = text;
+    const settledIndex = words.indexOf(text);
+    if (settledIndex >= 0) wordIndex = settledIndex;
+    renderSettled(text);
+    setLiveText(stage.live, text);
+    autoRest = null;
+    if (auto && !paused && words.length > 1) {
+      if (canAutoAdvance()) autoRest = restTime;
+      else auto = false;
+    }
+    syncFilter();
+    syncLoop();
+    return Promise.resolve();
+  }
+  function queueMorph(to) {
+    if (pending?.text === to) return pending.promise;
+    if (pending) pending.resolve();
+    let resolve = () => void 0;
+    const promise = new Promise((done) => {
+      resolve = done;
+    });
+    pending = { text: to, promise, resolve };
+    if (transition) transition.fastForward = true;
+    syncLoop();
+    return promise;
+  }
+  function startMorph(to) {
+    if (destroyed) return Promise.resolve();
+    if (paused) return snapTo(to);
+    if (transition && transition.to === to) return transition.promise;
+    if (!transition && to === currentText) return Promise.resolve();
+    let fromText;
+    let outStart = 1;
+    const previous = transition;
+    if (previous) {
+      if (previous.mode === "rise") return queueMorph(to);
+      const progress = previous.eased;
+      const outValue = previous.outStart * (1 - progress);
+      const outOpacity = previous.mode === "goo" ? opacityForFraction(outValue) : outValue;
+      const inOpacity = previous.mode === "goo" ? opacityForFraction(progress) : progress;
+      const dominantOpacity = Math.max(outOpacity, inOpacity);
+      if (inOpacity > outOpacity) fromText = previous.to;
+      else fromText = previous.from;
+      transition = null;
+      previous.resolve();
+      const reduced2 = prefersReducedMotion(doc);
+      const nextMode = reduced2 ? "fade" : rise.enabled ? "rise" : goo.enabled ? "goo" : "fade";
+      outStart = nextMode === "goo" ? Math.pow(clamp012(dominantOpacity), 1 / 0.4) : clamp012(dominantOpacity);
+    } else {
+      fromText = currentText;
+    }
+    const reduced = prefersReducedMotion(doc);
+    const mode = reduced ? "fade" : rise.enabled ? "rise" : goo.enabled ? "goo" : "fade";
+    const duration = mode === "fade" ? morphTime <= 0 ? 0 : Math.min(reduced ? REDUCED_MOTION_FADE : NO_EFFECT_FADE, morphTime) : morphTime;
+    let resolve = () => void 0;
+    const promise = new Promise((done) => {
+      resolve = done;
+    });
+    const tr = {
+      from: fromText,
+      to,
+      mode,
+      duration,
+      elapsed: 0,
+      raw: 0,
+      eased: 0,
+      outStart,
+      enter: [],
+      exit: [],
+      flow: "up",
+      fastForward: false,
+      promise,
+      resolve
+    };
+    transition = tr;
+    autoRest = null;
+    if (mode === "rise") {
+      const direction = readDirection();
+      const scene = buildDiffScene(stage, fromText, to, {
+        dir: direction.dir,
+        minChunk: rise.minChunk,
+        normalizeVariants: rise.normalizeVariants,
+        ignoreDiacritics: rise.ignoreDiacritics
+      });
+      tr.scene = scene;
+      tr.enter = enterOrder(scene, direction.rtl);
+      tr.exit = exitOrder(scene, direction.rtl);
+      const flowState = flowForTransition(
+        rise.flow,
+        scene,
+        fromText,
+        to,
+        direction.dir,
+        direction.rtl
+      );
+      tr.flow = flowState.fallback;
+      tr.flowByChunk = flowState.byChunk;
+      tr.timing = riseTiming(
+        duration,
+        Math.max(tr.enter.length, tr.exit.length),
+        rise.stagger,
+        rise.overlap
+      );
+      renderRise(tr);
+    } else {
+      resetLayer(stage.outgoing);
+      resetLayer(stage.incoming);
+      setLayerText(stage.outgoing, fromText);
+      setLayerText(stage.incoming, to);
+      renderGooOrFade(tr, 0);
+    }
+    setLiveText(stage.live, to);
+    syncFilter();
+    safeCallback(onMorphStart, fromText, to);
+    if (destroyed) {
+      if (transition === tr) transition = null;
+      return promise;
+    }
+    if (duration <= 0) {
+      completeTransition(tr);
+      return promise;
+    }
+    syncLoop();
+    return promise;
+  }
+  function tick(timestamp) {
+    rafId = null;
+    if (!needsLoop()) {
+      lastTimestamp = null;
+      return;
+    }
+    if (lastTimestamp === null) {
+      lastTimestamp = timestamp;
+      rafId = requestFrame();
+      return;
+    }
+    const dt = Math.min(Math.max((timestamp - lastTimestamp) / 1e3, 0), MAX_FRAME_DELTA);
+    lastTimestamp = timestamp;
+    if (transition) {
+      const tr = transition;
+      let step = dt;
+      if (tr.fastForward && tr.duration > 0) {
+        const remaining = Math.max(0, tr.duration - tr.elapsed);
+        step *= Math.max(1, remaining / FAST_FORWARD);
+      }
+      tr.elapsed = Math.min(tr.duration, tr.elapsed + step);
+      const raw = tr.duration > 0 ? clamp012(tr.elapsed / tr.duration) : 1;
+      renderTransition(tr, raw);
+      if (raw >= 1) completeTransition(tr);
+    } else if (auto && !paused) {
+      if (autoRest === null) {
+        if (canAutoAdvance()) autoRest = restTime;
+        else auto = false;
+      }
+      if (autoRest !== null) {
+        autoRest -= dt;
+        if (autoRest <= 0) {
+          if (!canAutoAdvance()) {
+            auto = false;
+            autoRest = null;
+          } else {
+            wordIndex = wrapIndex(wordIndex + 1, words.length, loop);
+            const nextWord = words[wordIndex];
+            if (nextWord !== void 0) {
+              autoRest = null;
+              void startMorph(nextWord);
+            }
+          }
+        }
+      }
+    }
+    if (rafId === null && needsLoop()) {
+      rafId = requestFrame();
+    } else if (!needsLoop()) {
+      lastTimestamp = null;
+    }
+  }
+  function onVisibilityChange() {
+    hidden = doc.visibilityState === "hidden";
+    syncLoop();
+  }
+  doc.addEventListener("visibilitychange", onVisibilityChange);
+  let observer = null;
+  const view = doc.defaultView;
+  if (view && typeof view.IntersectionObserver === "function") {
+    observer = new view.IntersectionObserver(
+      (entries) => {
+        const entry = entries[0];
+        if (!entry) return;
+        offscreen = !entry.isIntersecting;
+        syncLoop();
+      },
+      { rootMargin: "80px" }
+    );
+    observer.observe(el);
+  }
+  function setText(text) {
+    if (destroyed) return Promise.resolve();
+    const value = String(text);
+    if (paused) return snapTo(value);
+    return startMorph(value);
+  }
+  function next() {
+    if (destroyed || words.length === 0) return Promise.resolve();
+    if (!canAdvance(wordIndex, words.length, loop)) {
+      return Promise.resolve();
+    }
+    wordIndex = wrapIndex(wordIndex + 1, words.length, loop);
+    const target = words[wordIndex];
+    if (target === void 0) return Promise.resolve();
+    return startMorph(target);
+  }
+  function setWords(nextWords) {
+    if (destroyed) return;
+    words = Array.isArray(nextWords) ? nextWords.map((word) => String(word)) : [];
+    if (words.length === 0) {
+      wordIndex = 0;
+      autoRest = null;
+      syncLoop();
+      return;
+    }
+    const reference = pending?.text ?? transition?.to ?? currentText;
+    const found = words.indexOf(reference);
+    wordIndex = found >= 0 ? found : 0;
+    autoRest = null;
+    if (autoplay && !paused && words.length > 1 && canAutoAdvance()) {
+      auto = true;
+      autoRest = restTime;
+    }
+    syncLoop();
+  }
+  function play() {
+    if (destroyed) return;
+    paused = false;
+    if (!transition && pending) {
+      const queued = pending;
+      pending = null;
+      void startMorph(queued.text).then(queued.resolve, queued.resolve);
+    }
+    if (words.length > 1 && canAutoAdvance()) {
+      auto = true;
+      if (!transition && autoRest === null) autoRest = restTime;
+    }
+    syncLoop();
+  }
+  function pause() {
+    if (destroyed) return;
+    paused = true;
+    stopLoop();
+  }
+  function applyUpdate(partial) {
+    if (destroyed) return;
+    if (partial.words !== void 0) {
+      const nextWords = Array.isArray(partial.words) ? partial.words.map((word) => String(word)) : [];
+      if (!sameWords(nextWords, words)) setWords(nextWords);
+    }
+    if (partial.morphTime !== void 0) {
+      morphTime = nonNegative2(partial.morphTime, morphTime);
+    }
+    if (partial.restTime !== void 0) {
+      restTime = nonNegative2(partial.restTime, restTime);
+    }
+    let effectsChanged = false;
+    if (partial.effects !== void 0) {
+      if (partial.effects.goo !== void 0) {
+        const nextGoo = applyGooPatch(goo, partial.effects.goo);
+        effectsChanged = effectsChanged || nextGoo.enabled !== goo.enabled || nextGoo.threshold !== goo.threshold || nextGoo.blur !== goo.blur || nextGoo.atRest !== goo.atRest;
+        goo = nextGoo;
+      }
+      if (partial.effects.rise !== void 0) {
+        const nextRise = applyRisePatch(rise, partial.effects.rise);
+        effectsChanged = effectsChanged || nextRise.enabled !== rise.enabled;
+        rise = nextRise;
+      }
+      refreshFilter();
+    }
+    if (partial.dir !== void 0) {
+      dir = partial.dir;
+      el.setAttribute("dir", partial.dir);
+    }
+    if (partial.lang !== void 0) {
+      lang = partial.lang;
+      el.setAttribute("lang", partial.lang);
+    }
+    if (partial.easing !== void 0) {
+      easing = typeof partial.easing === "function" ? partial.easing : DEFAULT_MORPH_EASING;
+    }
+    if (partial.onMorphStart !== void 0) {
+      onMorphStart = partial.onMorphStart;
+    }
+    if (partial.onMorphEnd !== void 0) {
+      onMorphEnd = partial.onMorphEnd;
+    }
+    if (partial.loop !== void 0 && partial.loop !== loop) {
+      loop = partial.loop;
+      if (autoplay && !paused && !transition && words.length > 1 && canAutoAdvance()) {
+        auto = true;
+        autoRest = restTime;
+      } else if (auto && words.length > 1 && canAutoAdvance() && autoRest === null) {
+        autoRest = restTime;
+      }
+    }
+    if (partial.autoplay !== void 0 && partial.autoplay !== autoplay) {
+      autoplay = partial.autoplay;
+      auto = partial.autoplay;
+      autoRest = null;
+      if (auto && !paused && words.length > 1 && canAutoAdvance()) {
+        autoRest = restTime;
+      }
+    }
+    if (effectsChanged && !transition) {
+      renderSettled(currentText);
+    }
+    syncFilter();
+    syncLoop();
+  }
+  function update(partial) {
+    if (destroyed) return;
+    if (partial.preset !== void 0 || partial.motion !== void 0) {
+      const nextPreset = partial.preset ?? currentPreset;
+      const nextMotion = partial.motion ?? (partial.preset !== void 0 ? "default" : currentMotion);
+      const resolved = resolveMorphOptions({
+        ...partial,
+        preset: nextPreset,
+        motion: nextMotion
+      });
+      currentPreset = nextPreset;
+      currentMotion = nextMotion;
+      applyUpdate(resolved);
+      return;
+    }
+    applyUpdate(partial);
+  }
+  function restoreStyle(name, value) {
+    if (value) {
+      el.style[name] = value;
+    } else {
+      el.style.removeProperty(
+        name === "minHeight" ? "min-height" : name === "filter" ? "filter" : name
+      );
+    }
+  }
+  function destroy() {
+    if (destroyed) return;
+    destroyed = true;
+    paused = true;
+    stopLoop();
+    doc.removeEventListener("visibilitychange", onVisibilityChange);
+    observer?.disconnect();
+    observer = null;
+    clearPending();
+    if (transition) {
+      const tr = transition;
+      transition = null;
+      tr.resolve();
+    }
+    filter?.release();
+    filter = null;
+    removeStage(stage);
+    if (originalNodes.length > 0) el.append(...originalNodes);
+    restoreStyle("position", savedStyle.position);
+    restoreStyle("display", savedStyle.display);
+    restoreStyle("minHeight", savedStyle.minHeight);
+    restoreStyle("width", savedStyle.width);
+    restoreStyle("filter", savedStyle.filter);
+    if (originalDir === null) el.removeAttribute("dir");
+    else el.setAttribute("dir", originalDir);
+    if (originalLang === null) el.removeAttribute("lang");
+    else el.setAttribute("lang", originalLang);
+  }
+  renderSettled(currentText);
+  setLiveText(stage.live, currentText);
+  syncFilter();
+  syncLoop();
+  return {
+    setText,
+    next,
+    setWords,
+    play,
+    pause,
+    destroy,
+    update
+  };
+}
+
+exports.createMorph = createMorph;
+exports.cubicBezier = cubicBezier;
+exports.easeInOutCubic = easeInOutCubic;
+exports.easeOutCubic = easeOutCubic;
+exports.firstNumber = firstNumber;
+exports.flowByHunkPosition = flowByHunkPosition;
+exports.flowByNumberChange = flowByNumberChange;
+exports.linear = linear;
+exports.motionNames = motionNames;
+exports.motions = motions;
+exports.presetNames = presetNames;
+exports.presets = presets;
+exports.resolvePreset = resolvePreset;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map