@graphrefly/graphrefly 0.44.0 → 0.46.0

package/dist/chunk-3PSLNJDU.js

@@ -0,0 +1,884 @@
+import {
+  emitToMeta
+} from "./chunk-KN3H5CNT.js";
+
+// src/utils/reactive-layout/reactive-layout.ts
+import { monotonicNs, node } from "@graphrefly/pure-ts/core";
+import { Graph } from "@graphrefly/pure-ts/graph";
+function isCJK(s) {
+  for (const ch of s) {
+    const c = ch.codePointAt(0);
+    if (c >= 19968 && c <= 40959 || // CJK Unified Ideographs
+    c >= 13312 && c <= 19903 || // CJK Extension A
+    c >= 12288 && c <= 12351 || // CJK Symbols and Punctuation
+    c >= 12352 && c <= 12447 || // Hiragana
+    c >= 12448 && c <= 12543 || // Katakana
+    c >= 44032 && c <= 55215 || // Hangul
+    c >= 65280 && c <= 65519) {
+      return true;
+    }
+  }
+  return false;
+}
+var kinsokuStart = /* @__PURE__ */ new Set([
+  "\uFF0C",
+  "\uFF0E",
+  "\uFF01",
+  "\uFF1A",
+  "\uFF1B",
+  "\uFF1F",
+  "\u3001",
+  "\u3002",
+  "\u30FB",
+  "\uFF09",
+  "\u3015",
+  "\u3009",
+  "\u300B",
+  "\u300D",
+  "\u300F",
+  "\u3011"
+]);
+var leftStickyPunctuation = /* @__PURE__ */ new Set([
+  ".",
+  ",",
+  "!",
+  "?",
+  ":",
+  ";",
+  ")",
+  "]",
+  "}",
+  "%",
+  '"',
+  "\u201D",
+  "\u2019",
+  "\xBB",
+  "\u203A",
+  "\u2026"
+]);
+function normalizeWhitespace(text) {
+  return text.replace(/[\t\n\r\f ]+/g, " ").replace(/^ | $/g, "");
+}
+function segmentText(normalized) {
+  const wordSegmenter = new Intl.Segmenter(void 0, { granularity: "word" });
+  const pieces = [];
+  for (const s of wordSegmenter.segment(normalized)) {
+    const text = s.segment;
+    const isWordLike = s.isWordLike ?? false;
+    const texts = [];
+    const wordLikes = [];
+    const kinds = [];
+    let currentText = "";
+    let currentKind = null;
+    for (const ch of text) {
+      let kind;
+      if (ch === " ") kind = "space";
+      else if (ch === "\u200B") kind = "zero-width-break";
+      else if (ch === "\xAD") kind = "soft-hyphen";
+      else if (ch === "\n") kind = "hard-break";
+      else kind = "text";
+      if (currentKind !== null && kind === currentKind) {
+        currentText += ch;
+      } else {
+        if (currentKind !== null) {
+          texts.push(currentText);
+          wordLikes.push(currentKind === "text" && isWordLike);
+          kinds.push(currentKind);
+        }
+        currentText = ch;
+        currentKind = kind;
+      }
+    }
+    if (currentKind !== null) {
+      texts.push(currentText);
+      wordLikes.push(currentKind === "text" && isWordLike);
+      kinds.push(currentKind);
+    }
+    pieces.push({ texts, isWordLike: wordLikes, kinds });
+  }
+  return pieces;
+}
+function analyzeAndMeasure(text, font, adapter, cache, stats) {
+  const normalized = normalizeWhitespace(text);
+  if (normalized.length === 0) return [];
+  const pieces = segmentText(normalized);
+  const graphemeSegmenter2 = new Intl.Segmenter(void 0, {
+    granularity: "grapheme"
+  });
+  const rawTexts = [];
+  const rawKinds = [];
+  const rawWordLike = [];
+  for (const piece of pieces) {
+    for (let i = 0; i < piece.texts.length; i++) {
+      rawTexts.push(piece.texts[i]);
+      rawKinds.push(piece.kinds[i]);
+      rawWordLike.push(piece.isWordLike[i]);
+    }
+  }
+  const mergedTexts = [];
+  const mergedKinds = [];
+  const mergedWordLike = [];
+  for (let i = 0; i < rawTexts.length; i++) {
+    const t = rawTexts[i];
+    const k = rawKinds[i];
+    const wl = rawWordLike[i];
+    if (k === "text" && !wl && mergedTexts.length > 0 && mergedKinds[mergedKinds.length - 1] === "text") {
+      const isSticky = t.length === 1 && (leftStickyPunctuation.has(t) || kinsokuStart.has(t));
+      if (isSticky) {
+        mergedTexts[mergedTexts.length - 1] += t;
+        continue;
+      }
+    }
+    if (t === "-" && mergedTexts.length > 0 && mergedKinds[mergedKinds.length - 1] === "text" && mergedWordLike[mergedWordLike.length - 1]) {
+      mergedTexts[mergedTexts.length - 1] += t;
+      continue;
+    }
+    mergedTexts.push(t);
+    mergedKinds.push(k);
+    mergedWordLike.push(wl);
+  }
+  let fontCache = cache.get(font);
+  if (!fontCache) {
+    fontCache = /* @__PURE__ */ new Map();
+    cache.set(font, fontCache);
+  }
+  function measureCached(seg) {
+    let w = fontCache.get(seg);
+    if (w === void 0) {
+      if (stats) stats.misses += 1;
+      const raw = adapter.measureSegment(seg, font).width;
+      w = Number.isFinite(raw) && raw >= 0 ? raw : 0;
+      fontCache.set(seg, w);
+    } else if (stats) {
+      stats.hits += 1;
+    }
+    return w;
+  }
+  const segments = [];
+  for (let i = 0; i < mergedTexts.length; i++) {
+    const t = mergedTexts[i];
+    const k = mergedKinds[i];
+    if (k !== "text") {
+      segments.push({
+        text: t,
+        width: k === "space" ? measureCached(" ") * t.length : 0,
+        kind: k,
+        graphemeWidths: null
+      });
+      continue;
+    }
+    if (isCJK(t)) {
+      let unitText = "";
+      for (const gs of graphemeSegmenter2.segment(t)) {
+        const grapheme = gs.segment;
+        if (unitText.length > 0 && kinsokuStart.has(grapheme)) {
+          unitText += grapheme;
+          continue;
+        }
+        if (unitText.length > 0) {
+          const w2 = measureCached(unitText);
+          segments.push({
+            text: unitText,
+            width: w2,
+            kind: "text",
+            graphemeWidths: null
+          });
+        }
+        unitText = grapheme;
+      }
+      if (unitText.length > 0) {
+        const w2 = measureCached(unitText);
+        segments.push({
+          text: unitText,
+          width: w2,
+          kind: "text",
+          graphemeWidths: null
+        });
+      }
+      continue;
+    }
+    const w = measureCached(t);
+    let graphemeWidths = null;
+    if (mergedWordLike[i] && t.length > 1) {
+      const gWidths = [];
+      for (const gs of graphemeSegmenter2.segment(t)) {
+        gWidths.push(measureCached(gs.segment));
+      }
+      if (gWidths.length > 1) {
+        graphemeWidths = gWidths;
+      }
+    }
+    segments.push({ text: t, width: w, kind: "text", graphemeWidths });
+  }
+  return segments;
+}
+function computeLineBreaks(segments, maxWidth, adapter, font, cache) {
+  if (segments.length === 0) {
+    return { lines: [], lineCount: 0 };
+  }
+  const lines = [];
+  let lineW = 0;
+  let hasContent = false;
+  let lineStartSeg = 0;
+  let lineStartGrapheme = 0;
+  let lineEndSeg = 0;
+  let lineEndGrapheme = 0;
+  let pendingBreakSeg = -1;
+  let pendingBreakWidth = 0;
+  let fontCache = cache.get(font);
+  if (!fontCache) {
+    fontCache = /* @__PURE__ */ new Map();
+    cache.set(font, fontCache);
+  }
+  let hyphenWidth = fontCache.get("-");
+  if (hyphenWidth === void 0) {
+    hyphenWidth = adapter.measureSegment("-", font).width;
+    fontCache.set("-", hyphenWidth);
+  }
+  function flushLine(endSeg = lineEndSeg, endGrapheme = lineEndGrapheme, width = lineW) {
+    let text = "";
+    for (let i = lineStartSeg; i < endSeg; i++) {
+      const seg = segments[i];
+      if (seg.kind === "soft-hyphen" || seg.kind === "hard-break") continue;
+      if (i === lineStartSeg && lineStartGrapheme > 0 && seg.graphemeWidths) {
+        const graphemeSegmenter2 = new Intl.Segmenter(void 0, {
+          granularity: "grapheme"
+        });
+        const graphemes = [...graphemeSegmenter2.segment(seg.text)].map((g) => g.segment);
+        text += graphemes.slice(lineStartGrapheme).join("");
+      } else {
+        text += seg.text;
+      }
+    }
+    if (endGrapheme > 0 && endSeg < segments.length) {
+      const seg = segments[endSeg];
+      const graphemeSegmenter2 = new Intl.Segmenter(void 0, {
+        granularity: "grapheme"
+      });
+      const graphemes = [...graphemeSegmenter2.segment(seg.text)].map((g) => g.segment);
+      const startG = lineStartSeg === endSeg ? lineStartGrapheme : 0;
+      text += graphemes.slice(startG, endGrapheme).join("");
+    }
+    if (endSeg > 0 && segments[endSeg - 1]?.kind === "soft-hyphen" && !(lineStartSeg === endSeg && lineStartGrapheme > 0)) {
+      text += "-";
+    }
+    lines.push({
+      text,
+      width,
+      startSegment: lineStartSeg,
+      startGrapheme: lineStartGrapheme,
+      endSegment: endSeg,
+      endGrapheme
+    });
+    lineW = 0;
+    hasContent = false;
+    pendingBreakSeg = -1;
+    pendingBreakWidth = 0;
+  }
+  function canBreakAfter2(kind) {
+    return kind === "space" || kind === "zero-width-break" || kind === "soft-hyphen";
+  }
+  function startLine(segIdx, graphemeIdx, width) {
+    hasContent = true;
+    lineStartSeg = segIdx;
+    lineStartGrapheme = graphemeIdx;
+    lineEndSeg = segIdx + 1;
+    lineEndGrapheme = 0;
+    lineW = width;
+  }
+  function startLineAtGrapheme(segIdx, graphemeIdx, width) {
+    hasContent = true;
+    lineStartSeg = segIdx;
+    lineStartGrapheme = graphemeIdx;
+    lineEndSeg = segIdx;
+    lineEndGrapheme = graphemeIdx + 1;
+    lineW = width;
+  }
+  for (let i = 0; i < segments.length; i++) {
+    const seg = segments[i];
+    if (seg.kind === "hard-break") {
+      if (hasContent) {
+        flushLine();
+      } else {
+        lines.push({
+          text: "",
+          width: 0,
+          startSegment: i,
+          startGrapheme: 0,
+          endSegment: i,
+          endGrapheme: 0
+        });
+      }
+      lineStartSeg = i + 1;
+      lineStartGrapheme = 0;
+      continue;
+    }
+    const w = seg.width;
+    if (!hasContent) {
+      if (w > maxWidth && seg.graphemeWidths) {
+        appendBreakableSegment(i, 0, seg.graphemeWidths);
+      } else {
+        startLine(i, 0, w);
+      }
+      if (canBreakAfter2(seg.kind)) {
+        pendingBreakSeg = i + 1;
+        pendingBreakWidth = seg.kind === "space" ? lineW - w : lineW;
+      }
+      continue;
+    }
+    const newW = lineW + w;
+    if (newW > maxWidth + 5e-3) {
+      if (canBreakAfter2(seg.kind)) {
+        lineW += w;
+        lineEndSeg = i + 1;
+        lineEndGrapheme = 0;
+        flushLine(i + 1, 0, seg.kind === "space" ? lineW - w : lineW);
+        continue;
+      }
+      if (pendingBreakSeg >= 0) {
+        flushLine(pendingBreakSeg, 0, pendingBreakWidth);
+        i--;
+        continue;
+      }
+      if (w > maxWidth && seg.graphemeWidths) {
+        flushLine();
+        appendBreakableSegment(i, 0, seg.graphemeWidths);
+        continue;
+      }
+      flushLine();
+      i--;
+      continue;
+    }
+    lineW = newW;
+    lineEndSeg = i + 1;
+    lineEndGrapheme = 0;
+    if (canBreakAfter2(seg.kind)) {
+      pendingBreakSeg = i + 1;
+      pendingBreakWidth = seg.kind === "space" ? lineW - w : lineW;
+    }
+  }
+  if (hasContent) {
+    flushLine();
+  }
+  return { lines, lineCount: lines.length };
+  function appendBreakableSegment(segIdx, startG, gWidths) {
+    for (let g = startG; g < gWidths.length; g++) {
+      const gw = gWidths[g];
+      if (!hasContent) {
+        startLineAtGrapheme(segIdx, g, gw);
+        continue;
+      }
+      if (lineW + gw > maxWidth + 5e-3) {
+        flushLine();
+        startLineAtGrapheme(segIdx, g, gw);
+      } else {
+        lineW += gw;
+        lineEndSeg = segIdx;
+        lineEndGrapheme = g + 1;
+      }
+    }
+    if (hasContent && lineEndSeg === segIdx && lineEndGrapheme === gWidths.length) {
+      lineEndSeg = segIdx + 1;
+      lineEndGrapheme = 0;
+    }
+  }
+}
+function canBreakAfter(kind) {
+  return kind === "space" || kind === "zero-width-break" || kind === "soft-hyphen";
+}
+var _graphemeSegmenter = null;
+function graphemeSegmenter() {
+  if (_graphemeSegmenter === null) {
+    _graphemeSegmenter = new Intl.Segmenter(void 0, { granularity: "grapheme" });
+  }
+  return _graphemeSegmenter;
+}
+function sliceSegmentText(seg, startG, endG) {
+  if (startG === 0 && endG < 0) return seg.text;
+  const graphemes = [...graphemeSegmenter().segment(seg.text)].map((g) => g.segment);
+  const stop = endG < 0 ? graphemes.length : endG;
+  return graphemes.slice(startG, stop).join("");
+}
+function buildLineText(segments, startSeg, startG, endSeg, endG, appendHyphen) {
+  let text = "";
+  for (let i = startSeg; i < endSeg; i++) {
+    const seg = segments[i];
+    if (seg.kind === "soft-hyphen" || seg.kind === "hard-break") continue;
+    if (i === startSeg && startG > 0) {
+      text += sliceSegmentText(seg, startG, -1);
+    } else {
+      text += seg.text;
+    }
+  }
+  if (endG > 0 && endSeg < segments.length) {
+    const seg = segments[endSeg];
+    const from = startSeg === endSeg ? startG : 0;
+    text += sliceSegmentText(seg, from, endG);
+  }
+  if (appendHyphen) text += "-";
+  return text;
+}
+function resolveHyphenWidth(ctx) {
+  if (!ctx?.adapter || !ctx.font) return 0;
+  const cache = ctx.cache;
+  if (cache) {
+    let fc = cache.get(ctx.font);
+    if (!fc) {
+      fc = /* @__PURE__ */ new Map();
+      cache.set(ctx.font, fc);
+    }
+    let hw = fc.get("-");
+    if (hw === void 0) {
+      hw = ctx.adapter.measureSegment("-", ctx.font).width;
+      fc.set("-", hw);
+    }
+    return hw;
+  }
+  return ctx.adapter.measureSegment("-", ctx.font).width;
+}
+function layoutNextLine(segments, cursor, slotWidth, ctx) {
+  let i = cursor.segmentIndex;
+  const initialG = cursor.graphemeIndex;
+  if (i >= segments.length) return null;
+  if (initialG === 0) {
+    while (i < segments.length) {
+      const seg = segments[i];
+      if (seg.kind === "hard-break") {
+        return {
+          text: "",
+          width: 0,
+          start: { segmentIndex: cursor.segmentIndex, graphemeIndex: 0 },
+          end: { segmentIndex: i + 1, graphemeIndex: 0 }
+        };
+      }
+      if (seg.kind === "space" || seg.kind === "zero-width-break" || seg.kind === "soft-hyphen") {
+        i += 1;
+        continue;
+      }
+      break;
+    }
+    if (i >= segments.length) return null;
+  }
+  const hyphenWidth = resolveHyphenWidth(ctx);
+  const startSeg = i;
+  const startG = i === cursor.segmentIndex ? initialG : 0;
+  let lineW = 0;
+  let lineEndSeg = startSeg;
+  let lineEndG = 0;
+  let hasContent = false;
+  let pendingBreakSeg = -1;
+  let pendingBreakG = 0;
+  let pendingBreakWidth = 0;
+  let pendingBreakSoftHyphen = false;
+  const recordPending = (sIdx, gIdx, widthAtBreak, kind) => {
+    pendingBreakSeg = sIdx;
+    pendingBreakG = gIdx;
+    pendingBreakWidth = widthAtBreak;
+    pendingBreakSoftHyphen = kind === "soft-hyphen";
+  };
+  const consumeBreakable = (segIdx, gStart, gWidths) => {
+    for (let g = gStart; g < gWidths.length; g++) {
+      const gw = gWidths[g];
+      if (!hasContent) {
+        lineW = gw;
+        lineEndSeg = segIdx;
+        lineEndG = g + 1;
+        hasContent = true;
+        continue;
+      }
+      if (lineW + gw > slotWidth + 5e-3) {
+        return true;
+      }
+      lineW += gw;
+      lineEndSeg = segIdx;
+      lineEndG = g + 1;
+    }
+    if (lineEndSeg === segIdx && lineEndG === gWidths.length) {
+      lineEndSeg = segIdx + 1;
+      lineEndG = 0;
+    }
+    return false;
+  };
+  if (startG > 0 && startSeg < segments.length) {
+    const seg = segments[startSeg];
+    if (seg.graphemeWidths) {
+      const overflowed = consumeBreakable(startSeg, startG, seg.graphemeWidths);
+      if (overflowed) {
+        const text2 = buildLineText(segments, startSeg, startG, lineEndSeg, lineEndG, false);
+        return {
+          text: text2,
+          width: lineW,
+          start: { segmentIndex: startSeg, graphemeIndex: startG },
+          end: { segmentIndex: lineEndSeg, graphemeIndex: lineEndG }
+        };
+      }
+      i = lineEndSeg;
+    } else {
+    }
+  }
+  for (; i < segments.length; ) {
+    const seg = segments[i];
+    if (seg.kind === "hard-break") {
+      if (hasContent) {
+        const endsAtSoftHyphen2 = lineEndSeg > 0 && segments[lineEndSeg - 1]?.kind === "soft-hyphen";
+        const text2 = buildLineText(
+          segments,
+          startSeg,
+          startG,
+          lineEndSeg,
+          lineEndG,
+          endsAtSoftHyphen2
+        );
+        return {
+          text: text2,
+          width: lineW + (endsAtSoftHyphen2 ? hyphenWidth : 0),
+          start: { segmentIndex: startSeg, graphemeIndex: startG },
+          end: { segmentIndex: lineEndSeg, graphemeIndex: lineEndG }
+        };
+      }
+      return {
+        text: "",
+        width: 0,
+        start: { segmentIndex: startSeg, graphemeIndex: startG },
+        end: { segmentIndex: i + 1, graphemeIndex: 0 }
+      };
+    }
+    const w = seg.width;
+    if (!hasContent) {
+      if (w > slotWidth && seg.graphemeWidths) {
+        const overflowed = consumeBreakable(i, 0, seg.graphemeWidths);
+        if (overflowed) {
+          const text2 = buildLineText(segments, startSeg, startG, lineEndSeg, lineEndG, false);
+          return {
+            text: text2,
+            width: lineW,
+            start: { segmentIndex: startSeg, graphemeIndex: startG },
+            end: { segmentIndex: lineEndSeg, graphemeIndex: lineEndG }
+          };
+        }
+        i = lineEndSeg;
+        continue;
+      }
+      lineW = w;
+      lineEndSeg = i + 1;
+      lineEndG = 0;
+      hasContent = true;
+      if (canBreakAfter(seg.kind)) {
+        recordPending(i + 1, 0, seg.kind === "space" ? lineW - w : lineW, seg.kind);
+      }
+      i += 1;
+      continue;
+    }
+    const newW = lineW + w;
+    if (newW > slotWidth + 5e-3) {
+      if (canBreakAfter(seg.kind)) {
+        lineEndSeg = i + 1;
+        lineEndG = 0;
+        const endsAtSoftHyphen2 = seg.kind === "soft-hyphen";
+        const finalWidth = seg.kind === "space" ? lineW : lineW + (endsAtSoftHyphen2 ? hyphenWidth : 0);
+        const text3 = buildLineText(
+          segments,
+          startSeg,
+          startG,
+          lineEndSeg,
+          lineEndG,
+          endsAtSoftHyphen2
+        );
+        return {
+          text: text3,
+          width: finalWidth,
+          start: { segmentIndex: startSeg, graphemeIndex: startG },
+          end: { segmentIndex: lineEndSeg, graphemeIndex: lineEndG }
+        };
+      }
+      if (pendingBreakSeg >= 0) {
+        const text3 = buildLineText(
+          segments,
+          startSeg,
+          startG,
+          pendingBreakSeg,
+          pendingBreakG,
+          pendingBreakSoftHyphen
+        );
+        return {
+          text: text3,
+          width: pendingBreakWidth + (pendingBreakSoftHyphen ? hyphenWidth : 0),
+          start: { segmentIndex: startSeg, graphemeIndex: startG },
+          end: { segmentIndex: pendingBreakSeg, graphemeIndex: pendingBreakG }
+        };
+      }
+      if (w > slotWidth && seg.graphemeWidths) {
+        const text3 = buildLineText(segments, startSeg, startG, lineEndSeg, lineEndG, false);
+        return {
+          text: text3,
+          width: lineW,
+          start: { segmentIndex: startSeg, graphemeIndex: startG },
+          end: { segmentIndex: lineEndSeg, graphemeIndex: lineEndG }
+        };
+      }
+      const text2 = buildLineText(segments, startSeg, startG, lineEndSeg, lineEndG, false);
+      return {
+        text: text2,
+        width: lineW,
+        start: { segmentIndex: startSeg, graphemeIndex: startG },
+        end: { segmentIndex: lineEndSeg, graphemeIndex: lineEndG }
+      };
+    }
+    lineW = newW;
+    lineEndSeg = i + 1;
+    lineEndG = 0;
+    if (canBreakAfter(seg.kind)) {
+      recordPending(i + 1, 0, seg.kind === "space" ? lineW - w : lineW, seg.kind);
+    }
+    i += 1;
+  }
+  if (!hasContent) return null;
+  const endsAtSoftHyphen = lineEndSeg > 0 && segments[lineEndSeg - 1]?.kind === "soft-hyphen";
+  const text = buildLineText(segments, startSeg, startG, lineEndSeg, lineEndG, endsAtSoftHyphen);
+  return {
+    text,
+    width: lineW + (endsAtSoftHyphen ? hyphenWidth : 0),
+    start: { segmentIndex: startSeg, graphemeIndex: startG },
+    end: { segmentIndex: lineEndSeg, graphemeIndex: lineEndG }
+  };
+}
+function carveTextLineSlots(base, blocked, minSlotWidth = 0) {
+  let slots = [base];
+  for (let bi = 0; bi < blocked.length; bi++) {
+    const block = blocked[bi];
+    const next = [];
+    for (let si = 0; si < slots.length; si++) {
+      const slot = slots[si];
+      if (block.right <= slot.left || block.left >= slot.right) {
+        next.push(slot);
+        continue;
+      }
+      if (block.left > slot.left) next.push({ left: slot.left, right: block.left });
+      if (block.right < slot.right) next.push({ left: block.right, right: slot.right });
+    }
+    slots = next;
+  }
+  if (minSlotWidth > 0) {
+    return slots.filter((s) => s.right - s.left >= minSlotWidth);
+  }
+  return slots;
+}
+function computeCharPositions(lineBreaks, segments, lineHeight) {
+  const positions = [];
+  const graphemeSegmenter2 = new Intl.Segmenter(void 0, {
+    granularity: "grapheme"
+  });
+  for (let lineIdx = 0; lineIdx < lineBreaks.lines.length; lineIdx++) {
+    const line = lineBreaks.lines[lineIdx];
+    const y = lineIdx * lineHeight;
+    let x = 0;
+    for (let si = line.startSegment; si < segments.length; si++) {
+      const seg = segments[si];
+      if (seg.kind === "soft-hyphen" || seg.kind === "hard-break") {
+        if (si >= line.endSegment && line.endGrapheme === 0) break;
+        continue;
+      }
+      const graphemes = [...graphemeSegmenter2.segment(seg.text)].map((g) => g.segment);
+      if (graphemes.length === 0) continue;
+      const startG = si === line.startSegment ? line.startGrapheme : 0;
+      let endG;
+      if (si < line.endSegment) {
+        endG = graphemes.length;
+      } else if (si === line.endSegment && line.endGrapheme > 0) {
+        endG = line.endGrapheme;
+      } else {
+        break;
+      }
+      for (let g = startG; g < endG; g++) {
+        const gWidth = seg.graphemeWidths ? seg.graphemeWidths[g] : seg.width / graphemes.length;
+        positions.push({ x, y, width: gWidth, height: lineHeight, line: lineIdx });
+        x += gWidth;
+      }
+    }
+  }
+  return positions;
+}
+function reactiveLayout(opts) {
+  const { adapter, name = "reactive-layout" } = opts;
+  const g = new Graph(name);
+  const measureCache = /* @__PURE__ */ new Map();
+  const textNode = node([], { name: "text", initial: opts.text ?? "" });
+  const fontNode = node([], {
+    name: "font",
+    initial: opts.font ?? "16px sans-serif"
+  });
+  const lineHeightNode = node([], {
+    name: "line-height",
+    initial: opts.lineHeight ?? 20
+  });
+  const maxWidthNode = node([], {
+    name: "max-width",
+    initial: Math.max(0, opts.maxWidth ?? 800)
+  });
+  function graphemeWidthsEqual(a, b) {
+    if (a === null || b === null) return a === b;
+    if (a.length !== b.length) return false;
+    for (let i = 0; i < a.length; i++) {
+      if (a[i] !== b[i]) return false;
+    }
+    return true;
+  }
+  const segmentsNode = node(
+    [textNode, fontNode],
+    (data, actions, ctx) => {
+      const b0 = data[0];
+      const textVal = b0 != null && b0.length > 0 ? b0.at(-1) : ctx.prevData[0];
+      const b1 = data[1];
+      const fontVal = b1 != null && b1.length > 0 ? b1.at(-1) : ctx.prevData[1];
+      const t0 = monotonicNs();
+      const measureStats = { hits: 0, misses: 0 };
+      const result = analyzeAndMeasure(
+        textVal,
+        fontVal,
+        adapter,
+        measureCache,
+        measureStats
+      );
+      const elapsed = monotonicNs() - t0;
+      const lookups = measureStats.hits + measureStats.misses;
+      const hitRate = lookups === 0 ? 1 : measureStats.hits / lookups;
+      const meta = segmentsNode.meta;
+      if (meta) {
+        emitToMeta(meta["cache-hit-rate"], hitRate);
+        emitToMeta(meta["segment-count"], result.length);
+        emitToMeta(meta["layout-time-ns"], elapsed);
+      }
+      actions.emit(result);
+      const flush = () => {
+        measureCache.clear();
+        adapter.clearCache?.();
+      };
+      return { onDeactivation: flush, onInvalidate: flush };
+    },
+    {
+      name: "segments",
+      describeKind: "derived",
+      meta: {
+        "cache-hit-rate": 0,
+        "segment-count": 0,
+        "layout-time-ns": 0
+      },
+      equals: (a, b) => {
+        const sa = a;
+        const sb = b;
+        if (sa == null || sb == null) return sa === sb;
+        if (sa.length !== sb.length) return false;
+        for (let i = 0; i < sa.length; i++) {
+          const pa = sa[i];
+          const pb = sb[i];
+          if (pa.text !== pb.text || pa.width !== pb.width || pa.kind !== pb.kind || !graphemeWidthsEqual(pa.graphemeWidths ?? null, pb.graphemeWidths ?? null))
+            return false;
+        }
+        return true;
+      }
+    }
+  );
+  const lineBreaksNode = node(
+    [segmentsNode, maxWidthNode, fontNode],
+    (batchData, actions, ctx) => {
+      const data = batchData.map(
+        (batch, i) => batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i]
+      );
+      actions.emit(
+        computeLineBreaks(
+          data[0],
+          data[1],
+          adapter,
+          data[2],
+          measureCache
+        )
+      );
+    },
+    {
+      name: "line-breaks",
+      describeKind: "derived",
+      equals: (a, b) => {
+        const la = a;
+        const lb = b;
+        if (la == null || lb == null) return la === lb;
+        if (la.lineCount !== lb.lineCount) return false;
+        for (let i = 0; i < la.lines.length; i++) {
+          const lineA = la.lines[i];
+          const lineB = lb.lines[i];
+          if (lineA.text !== lineB.text || lineA.width !== lineB.width || lineA.startSegment !== lineB.startSegment || lineA.startGrapheme !== lineB.startGrapheme || lineA.endSegment !== lineB.endSegment || lineA.endGrapheme !== lineB.endGrapheme)
+            return false;
+        }
+        return true;
+      }
+    }
+  );
+  const heightNode = node(
+    [lineBreaksNode, lineHeightNode],
+    (batchData, actions, ctx) => {
+      const data = batchData.map(
+        (batch, i) => batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i]
+      );
+      actions.emit(data[0].lineCount * data[1]);
+    },
+    { describeKind: "derived", name: "height" }
+  );
+  const charPositionsNode = node(
+    [lineBreaksNode, segmentsNode, lineHeightNode],
+    (batchData, actions, ctx) => {
+      const data = batchData.map(
+        (batch, i) => batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i]
+      );
+      actions.emit(
+        computeCharPositions(
+          data[0],
+          data[1],
+          data[2]
+        )
+      );
+    },
+    {
+      name: "char-positions",
+      describeKind: "derived",
+      equals: (a, b) => {
+        const ca = a;
+        const cb = b;
+        if (ca == null || cb == null) return ca === cb;
+        if (ca.length !== cb.length) return false;
+        for (let i = 0; i < ca.length; i++) {
+          if (ca[i].x !== cb[i].x || ca[i].y !== cb[i].y || ca[i].width !== cb[i].width)
+            return false;
+        }
+        return true;
+      }
+    }
+  );
+  g.add(textNode, { name: "text" });
+  g.add(fontNode, { name: "font" });
+  g.add(lineHeightNode, { name: "line-height" });
+  g.add(maxWidthNode, { name: "max-width" });
+  g.add(segmentsNode, { name: "segments" });
+  g.add(lineBreaksNode, { name: "line-breaks" });
+  g.add(heightNode, { name: "height" });
+  g.add(charPositionsNode, { name: "char-positions" });
+  return {
+    graph: g,
+    setText: (text) => g.set("text", text),
+    setFont: (font) => g.set("font", font),
+    setLineHeight: (lh) => g.set("line-height", lh),
+    setMaxWidth: (mw) => g.set("max-width", Math.max(0, mw)),
+    segments: segmentsNode,
+    lineBreaks: lineBreaksNode,
+    height: heightNode,
+    charPositions: charPositionsNode
+  };
+}
+
+export {
+  analyzeAndMeasure,
+  computeLineBreaks,
+  layoutNextLine,
+  carveTextLineSlots,
+  computeCharPositions,
+  reactiveLayout
+};
+//# sourceMappingURL=chunk-3PSLNJDU.js.map