@graphrefly/graphrefly 0.27.0 → 0.29.0

package/dist/chunk-GTE6PWRZ.js

@@ -1,866 +0,0 @@
-import {
-  emitToMeta
-} from "./chunk-JSCT3CR4.js";
-import {
-  Graph
-} from "./chunk-PF7GRZMW.js";
-import {
-  derived,
-  monotonicNs,
-  node,
-  state
-} from "./chunk-PHOUUNK7.js";
-
-// src/patterns/reactive-layout/reactive-layout.ts
-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 || !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 = state(opts.text ?? "", { name: "text" });
-  const fontNode = state(opts.font ?? "16px sans-serif", {
-    name: "font"
-  });
-  const lineHeightNode = state(opts.lineHeight ?? 20, {
-    name: "line-height"
-  });
-  const maxWidthNode = state(Math.max(0, opts.maxWidth ?? 800), {
-    name: "max-width"
-  });
-  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);
-      return () => {
-        measureCache.clear();
-        adapter.clearCache?.();
-      };
-    },
-    {
-      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 = derived(
-    [segmentsNode, maxWidthNode, fontNode],
-    ([segs, mw, font]) => {
-      return computeLineBreaks(
-        segs,
-        mw,
-        adapter,
-        font,
-        measureCache
-      );
-    },
-    {
-      name: "line-breaks",
-      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 = derived(
-    [lineBreaksNode, lineHeightNode],
-    ([lb, lh]) => lb.lineCount * lh,
-    { name: "height" }
-  );
-  const charPositionsNode = derived(
-    [lineBreaksNode, segmentsNode, lineHeightNode],
-    ([lb, segs, lh]) => {
-      return computeCharPositions(lb, segs, lh);
-    },
-    {
-      name: "char-positions",
-      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("text", textNode);
-  g.add("font", fontNode);
-  g.add("line-height", lineHeightNode);
-  g.add("max-width", maxWidthNode);
-  g.add("segments", segmentsNode);
-  g.add("line-breaks", lineBreaksNode);
-  g.add("height", heightNode);
-  g.add("char-positions", charPositionsNode);
-  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-GTE6PWRZ.js.map