@graphrefly/graphrefly 0.1.0

package/dist/chunk-Z4Y4FMQN.js

@@ -0,0 +1,1097 @@
+import {
+  Graph
+} from "./chunk-6W5SGIGB.js";
+import {
+  DATA,
+  INVALIDATE,
+  TEARDOWN,
+  __export,
+  derived,
+  emitWithBatch,
+  monotonicNs,
+  state
+} from "./chunk-5X3LAO3B.js";
+
+// src/patterns/reactive-layout/index.ts
+var reactive_layout_exports = {};
+__export(reactive_layout_exports, {
+  CanvasMeasureAdapter: () => CanvasMeasureAdapter,
+  CliMeasureAdapter: () => CliMeasureAdapter,
+  ImageSizeAdapter: () => ImageSizeAdapter,
+  NodeCanvasMeasureAdapter: () => NodeCanvasMeasureAdapter,
+  PrecomputedAdapter: () => PrecomputedAdapter,
+  SvgBoundsAdapter: () => SvgBoundsAdapter,
+  analyzeAndMeasure: () => analyzeAndMeasure,
+  computeBlockFlow: () => computeBlockFlow,
+  computeCharPositions: () => computeCharPositions,
+  computeLineBreaks: () => computeLineBreaks,
+  computeTotalHeight: () => computeTotalHeight,
+  measureBlock: () => measureBlock,
+  measureBlocks: () => measureBlocks,
+  reactiveBlockLayout: () => reactiveBlockLayout,
+  reactiveLayout: () => reactiveLayout
+});
+
+// src/patterns/reactive-layout/measurement-adapters.ts
+function cellWidth(code) {
+  if (code >= 768 && code <= 879 || // Combining Diacritical Marks
+  code >= 1155 && code <= 1161 || // Cyrillic combining marks
+  code >= 1425 && code <= 1469 || // Hebrew combining marks
+  code >= 1552 && code <= 1562 || // Arabic combining marks
+  code >= 1611 && code <= 1631 || // Arabic combining marks
+  code >= 1648 && code === 1648 || // Arabic superscript alef
+  code >= 1750 && code <= 1756 || // Arabic combining marks
+  code >= 1759 && code <= 1764 || // Arabic combining marks
+  code >= 1767 && code <= 1768 || // Arabic combining marks
+  code >= 1770 && code <= 1773 || // Arabic combining marks
+  code >= 1840 && code <= 1866 || // Syriac combining marks
+  code >= 1958 && code <= 1968 || // Thaana combining marks
+  code >= 2304 && code <= 2307 || // Devanagari combining marks
+  code >= 2362 && code <= 2383 || // Devanagari combining marks
+  code >= 2385 && code <= 2391 || // Devanagari combining marks
+  code >= 2402 && code <= 2403 || // Devanagari combining marks
+  code >= 2433 && code <= 2435 || // Bengali combining marks
+  code >= 2492 && code <= 2509 || // Bengali combining marks
+  code >= 2561 && code <= 2563 || // Gurmukhi combining marks
+  code >= 2620 && code <= 2641 || // Gurmukhi combining marks
+  code >= 2672 && code <= 2673 || // Gurmukhi combining marks
+  code >= 2677 && code === 2677 || // Gurmukhi combining mark
+  code >= 3633 && code === 3633 || // Thai combining mark
+  code >= 3636 && code <= 3642 || // Thai combining marks
+  code >= 3655 && code <= 3662 || // Thai combining marks
+  code >= 3761 && code === 3761 || // Lao combining mark
+  code >= 3764 && code <= 3772 || // Lao combining marks
+  code >= 3784 && code <= 3790 || // Lao combining marks
+  code >= 7616 && code <= 7679 || // Combining Diacritical Marks Supplement
+  code >= 8400 && code <= 8447 || // Combining Diacritical Marks for Symbols
+  code >= 65024 && code <= 65039 || // Variation Selectors
+  code >= 65056 && code <= 65071 || // Combining Half Marks
+  code === 8205) {
+    return 0;
+  }
+  if (code >= 4352 && code <= 4447 || // Hangul Jamo
+  code >= 8986 && code <= 8987 || // Watch, Hourglass
+  code >= 9001 && code <= 9002 || // Angle brackets
+  code >= 9193 && code <= 9203 || // Media control symbols
+  code >= 9208 && code <= 9210 || // Media control symbols
+  code >= 9725 && code <= 9726 || // Medium squares
+  code >= 9748 && code <= 9749 || // Umbrella, Hot Beverage
+  code >= 9800 && code <= 9811 || // Zodiac symbols
+  code === 9855 || // Wheelchair
+  code === 9875 || // Anchor
+  code === 9889 || // High Voltage
+  code >= 9898 && code <= 9899 || // Medium circles
+  code >= 9917 && code <= 9918 || // Soccer, Baseball
+  code >= 9924 && code <= 9925 || // Snowman, Sun behind cloud
+  code === 9934 || // Ophiuchus
+  code === 9940 || // No Entry
+  code === 9962 || // Church
+  code >= 9970 && code <= 9971 || // Fountain, Golf
+  code === 9973 || // Sailboat
+  code === 9978 || // Tent
+  code === 9981 || // Fuel Pump
+  code === 9986 || // Scissors
+  code === 9989 || // Check Mark
+  code >= 9992 && code <= 9997 || // Airplane...Writing Hand
+  code === 9999 || // Pencil
+  code >= 10067 && code <= 10069 || // Question marks
+  code === 10071 || // Exclamation
+  code >= 10133 && code <= 10135 || // Plus, Minus, Divide
+  code === 10160 || // Curly Loop
+  code === 10175 || // Double Curly Loop
+  code >= 10548 && code <= 10549 || // Arrows
+  code >= 11013 && code <= 11015 || // Arrows
+  code >= 11035 && code <= 11036 || // Squares
+  code === 11088 || // Star
+  code === 11093 || // Circle
+  code >= 11904 && code <= 12350 || // CJK Radicals, Symbols, Punctuation
+  code >= 12352 && code <= 12447 || // Hiragana
+  code >= 12448 && code <= 12543 || // Katakana
+  code >= 12549 && code <= 12591 || // Bopomofo
+  code >= 12593 && code <= 12686 || // Hangul Compatibility Jamo
+  code >= 12688 && code <= 12771 || // Kanbun, CJK Strokes
+  code >= 12784 && code <= 12830 || // Katakana Phonetic Extensions
+  code >= 12832 && code <= 12871 || // Enclosed CJK
+  code >= 12880 && code <= 19903 || // CJK Extensions + Unified block
+  code >= 19968 && code <= 40959 || // CJK Unified Ideographs
+  code >= 43360 && code <= 43388 || // Hangul Jamo Extended-A
+  code >= 44032 && code <= 55203 || // Hangul Syllables
+  code >= 63744 && code <= 64255 || // CJK Compatibility Ideographs
+  code >= 65040 && code <= 65049 || // Vertical forms
+  code >= 65072 && code <= 65131 || // CJK Compatibility Forms
+  code >= 65281 && code <= 65376 || // Fullwidth Forms (excl. halfwidth)
+  code >= 65504 && code <= 65510 || // Fullwidth Signs
+  code >= 126980 && code === 126980 || // Mahjong Red Dragon
+  code === 127183 || // Joker
+  code >= 127344 && code <= 127345 || // A/B buttons
+  code === 127358 || // O button
+  code === 127359 || // P button
+  code === 127374 || // AB button
+  code >= 127377 && code <= 127386 || // Squared symbols
+  code >= 127456 && code <= 127487 || // Regional Indicator Symbols
+  code >= 127488 && code <= 127490 || // Enclosed ideographic
+  code === 127514 || // Squared CJK
+  code === 127535 || // Squared CJK
+  code >= 127538 && code <= 127546 || // Squared CJK
+  code >= 127568 && code <= 127569 || // Circled ideographic
+  code >= 127744 && code <= 129535 || // Misc Symbols / Emoticons / Emoji
+  code >= 129536 && code <= 129791 || // Chess, Symbols Extended-A
+  code >= 129792 && code <= 130047 || // Symbols for Legacy Computing
+  code >= 131072 && code <= 196605 || // CJK Extension B-F (excl. nonchars)
+  code >= 196608 && code <= 262141) {
+    return 2;
+  }
+  return 1;
+}
+function countCells(text) {
+  let cells = 0;
+  for (const ch of text) {
+    cells += cellWidth(ch.codePointAt(0));
+  }
+  return cells;
+}
+var CliMeasureAdapter = class {
+  cellPx;
+  constructor(opts) {
+    this.cellPx = opts?.cellPx ?? 8;
+  }
+  measureSegment(text, _font) {
+    return { width: countCells(text) * this.cellPx };
+  }
+};
+var PrecomputedAdapterKeyError = class extends Error {
+  name = "KeyError";
+};
+var PrecomputedAdapter = class {
+  metrics;
+  fallback;
+  constructor(opts) {
+    this.metrics = opts.metrics;
+    const fb = opts.fallback ?? "per-char";
+    if (fb !== "per-char" && fb !== "error") {
+      throw new Error(
+        `fallback must be 'per-char' or 'error', got ${JSON.stringify(opts.fallback)}`
+      );
+    }
+    this.fallback = fb;
+  }
+  measureSegment(text, font) {
+    const fontMap = this.metrics[font];
+    if (fontMap) {
+      const w = fontMap[text];
+      if (w !== void 0) return { width: w };
+    }
+    if (this.fallback === "error") {
+      throw new PrecomputedAdapterKeyError(
+        `PrecomputedAdapter: no metrics for segment ${JSON.stringify(text)} in font ${JSON.stringify(font)}`
+      );
+    }
+    let total = 0;
+    if (fontMap) {
+      for (const ch of text) {
+        const cw = fontMap[ch];
+        if (cw !== void 0) {
+          total += cw;
+        }
+      }
+    }
+    return { width: total };
+  }
+};
+var CanvasMeasureAdapter = class {
+  ctx = null;
+  currentFont = "";
+  emojiCorrection;
+  constructor(opts) {
+    this.emojiCorrection = opts?.emojiCorrection ?? 1;
+  }
+  getContext() {
+    if (!this.ctx) {
+      if (typeof OffscreenCanvas === "undefined") {
+        throw new Error(
+          "CanvasMeasureAdapter requires a browser environment with OffscreenCanvas support. Use CliMeasureAdapter or NodeCanvasMeasureAdapter for Node.js."
+        );
+      }
+      const canvas = new OffscreenCanvas(0, 0);
+      const ctx = canvas.getContext("2d");
+      if (!ctx) throw new Error("CanvasMeasureAdapter: failed to get 2d context");
+      this.ctx = ctx;
+    }
+    return this.ctx;
+  }
+  measureSegment(text, font) {
+    const ctx = this.getContext();
+    if (font !== this.currentFont) {
+      ctx.font = font;
+      this.currentFont = font;
+    }
+    let width = ctx.measureText(text).width;
+    if (this.emojiCorrection !== 1 && /\p{Emoji_Presentation}/u.test(text)) {
+      width *= this.emojiCorrection;
+    }
+    return { width };
+  }
+  clearCache() {
+    this.currentFont = "";
+  }
+};
+var NodeCanvasMeasureAdapter = class {
+  ctx = null;
+  currentFont = "";
+  canvasModule;
+  constructor(canvasModule) {
+    this.canvasModule = canvasModule;
+  }
+  getContext() {
+    if (!this.ctx) {
+      const canvas = this.canvasModule.createCanvas(0, 0);
+      const ctx = canvas.getContext("2d");
+      if (!ctx) throw new Error("NodeCanvasMeasureAdapter: failed to get 2d context");
+      this.ctx = ctx;
+    }
+    return this.ctx;
+  }
+  measureSegment(text, font) {
+    const ctx = this.getContext();
+    if (font !== this.currentFont) {
+      ctx.font = font;
+      this.currentFont = font;
+    }
+    return { width: ctx.measureText(text).width };
+  }
+  clearCache() {
+    this.currentFont = "";
+  }
+};
+var SvgBoundsAdapter = class {
+  measureSvg(content) {
+    const viewBoxMatch = content.match(/viewBox\s*=\s*["']([^"']+)["']/);
+    if (viewBoxMatch) {
+      const parts = viewBoxMatch[1].trim().split(/[\s,]+/);
+      if (parts.length >= 4) {
+        const w = Number.parseFloat(parts[2]);
+        const h = Number.parseFloat(parts[3]);
+        if (Number.isFinite(w) && Number.isFinite(h) && w > 0 && h > 0) {
+          return { width: w, height: h };
+        }
+        throw new Error(
+          "SvgBoundsAdapter: viewBox width/height are missing, non-finite, or not positive"
+        );
+      }
+    }
+    const widthMatch = content.match(/<svg[^>]*\bwidth\s*=\s*["']?([\d.]+)/);
+    const heightMatch = content.match(/<svg[^>]*\bheight\s*=\s*["']?([\d.]+)/);
+    if (widthMatch && heightMatch) {
+      const w = Number.parseFloat(widthMatch[1]);
+      const h = Number.parseFloat(heightMatch[1]);
+      if (Number.isFinite(w) && Number.isFinite(h) && w > 0 && h > 0) {
+        return { width: w, height: h };
+      }
+      throw new Error(
+        "SvgBoundsAdapter: svg width/height attributes are non-finite or not positive"
+      );
+    }
+    throw new Error(
+      "SvgBoundsAdapter: cannot determine dimensions \u2014 SVG has no viewBox or width/height attributes"
+    );
+  }
+};
+var ImageSizeAdapter = class {
+  sizes;
+  constructor(sizes) {
+    this.sizes = new Map(Object.entries(sizes));
+  }
+  measureImage(src) {
+    const dims = this.sizes.get(src);
+    if (!dims) {
+      throw new Error(`ImageSizeAdapter: no dimensions registered for ${JSON.stringify(src)}`);
+    }
+    return { width: dims.width, height: dims.height };
+  }
+};
+
+// 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 graphemeSegmenter = 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;
+      w = adapter.measureSegment(seg, font).width;
+      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 graphemeSegmenter.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 graphemeSegmenter.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 emitLine(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 graphemeSegmenter = new Intl.Segmenter(void 0, {
+          granularity: "grapheme"
+        });
+        const graphemes = [...graphemeSegmenter.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 graphemeSegmenter = new Intl.Segmenter(void 0, {
+        granularity: "grapheme"
+      });
+      const graphemes = [...graphemeSegmenter.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 canBreakAfter(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) {
+        emitLine();
+      } 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 (canBreakAfter(seg.kind)) {
+        pendingBreakSeg = i + 1;
+        pendingBreakWidth = seg.kind === "space" ? lineW - w : lineW;
+      }
+      continue;
+    }
+    const newW = lineW + w;
+    if (newW > maxWidth + 5e-3) {
+      if (canBreakAfter(seg.kind)) {
+        lineW += w;
+        lineEndSeg = i + 1;
+        lineEndGrapheme = 0;
+        emitLine(i + 1, 0, seg.kind === "space" ? lineW - w : lineW);
+        continue;
+      }
+      if (pendingBreakSeg >= 0) {
+        emitLine(pendingBreakSeg, 0, pendingBreakWidth);
+        i--;
+        continue;
+      }
+      if (w > maxWidth && seg.graphemeWidths) {
+        emitLine();
+        appendBreakableSegment(i, 0, seg.graphemeWidths);
+        continue;
+      }
+      emitLine();
+      i--;
+      continue;
+    }
+    lineW = newW;
+    lineEndSeg = i + 1;
+    lineEndGrapheme = 0;
+    if (canBreakAfter(seg.kind)) {
+      pendingBreakSeg = i + 1;
+      pendingBreakWidth = seg.kind === "space" ? lineW - w : lineW;
+    }
+  }
+  if (hasContent) {
+    emitLine();
+  }
+  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) {
+        emitLine();
+        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 computeCharPositions(lineBreaks, segments, lineHeight) {
+  const positions = [];
+  const graphemeSegmenter = 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 = [...graphemeSegmenter.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 = derived(
+    [textNode, fontNode],
+    ([textVal, fontVal]) => {
+      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) {
+        const hr = hitRate;
+        const len = result.length;
+        const el = elapsed;
+        emitWithBatch((msgs) => meta["cache-hit-rate"]?.down(msgs), [[DATA, hr]], 3);
+        emitWithBatch((msgs) => meta["segment-count"]?.down(msgs), [[DATA, len]], 3);
+        emitWithBatch((msgs) => meta["layout-time-ns"]?.down(msgs), [[DATA, el]], 3);
+      }
+      return result;
+    },
+    {
+      name: "segments",
+      meta: {
+        "cache-hit-rate": 0,
+        "segment-count": 0,
+        "layout-time-ns": 0
+      },
+      onMessage(msg) {
+        if (msg[0] === INVALIDATE || msg[0] === TEARDOWN) {
+          measureCache.clear();
+          adapter.clearCache?.();
+        }
+        return false;
+      },
+      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);
+  g.connect("text", "segments");
+  g.connect("font", "segments");
+  g.connect("segments", "line-breaks");
+  g.connect("max-width", "line-breaks");
+  g.connect("font", "line-breaks");
+  g.connect("line-breaks", "height");
+  g.connect("line-height", "height");
+  g.connect("line-breaks", "char-positions");
+  g.connect("segments", "char-positions");
+  g.connect("line-height", "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
+  };
+}
+
+// src/patterns/reactive-layout/reactive-block-layout.ts
+function measureBlock(block, maxWidth, adapters, measureCache, defaultFont, defaultLineHeight, index) {
+  switch (block.type) {
+    case "text": {
+      const font = block.font ?? defaultFont;
+      const lineHeight = block.lineHeight ?? defaultLineHeight;
+      const segments = analyzeAndMeasure(block.text, font, adapters.text, measureCache);
+      const lineBreaks = computeLineBreaks(segments, maxWidth, adapters.text, font, measureCache);
+      const charPositions = computeCharPositions(lineBreaks, segments, lineHeight);
+      const height = lineBreaks.lineCount * lineHeight;
+      let width = 0;
+      for (const line of lineBreaks.lines) {
+        if (line.width > width) width = line.width;
+      }
+      return {
+        index,
+        type: "text",
+        width: Math.min(width, maxWidth),
+        height,
+        textSegments: segments,
+        textLineBreaks: lineBreaks,
+        textCharPositions: charPositions
+      };
+    }
+    case "image": {
+      let w;
+      let h;
+      if (block.naturalWidth != null && block.naturalHeight != null) {
+        w = block.naturalWidth;
+        h = block.naturalHeight;
+      } else if (adapters.image) {
+        const dims = adapters.image.measureImage(block.src);
+        w = dims.width;
+        h = dims.height;
+      } else {
+        throw new Error(
+          `Image block at index ${index} has no naturalWidth/naturalHeight and no ImageMeasurer adapter`
+        );
+      }
+      if (w > maxWidth) {
+        h = h * maxWidth / w;
+        w = maxWidth;
+      }
+      return { index, type: "image", width: w, height: h };
+    }
+    case "svg": {
+      let w;
+      let h;
+      if (block.viewBox) {
+        w = block.viewBox.width;
+        h = block.viewBox.height;
+      } else if (adapters.svg) {
+        const dims = adapters.svg.measureSvg(block.content);
+        w = dims.width;
+        h = dims.height;
+      } else {
+        throw new Error(`SVG block at index ${index} has no viewBox and no SvgMeasurer adapter`);
+      }
+      if (w > maxWidth) {
+        h = h * maxWidth / w;
+        w = maxWidth;
+      }
+      return { index, type: "svg", width: w, height: h };
+    }
+  }
+}
+function measureBlocks(blocks, maxWidth, adapters, measureCache, defaultFont, defaultLineHeight) {
+  return blocks.map(
+    (block, i) => measureBlock(block, maxWidth, adapters, measureCache, defaultFont, defaultLineHeight, i)
+  );
+}
+function computeBlockFlow(measured, gap) {
+  const result = [];
+  let y = 0;
+  for (let i = 0; i < measured.length; i++) {
+    const m = measured[i];
+    result.push({ ...m, x: 0, y });
+    y += m.height + (i < measured.length - 1 ? gap : 0);
+  }
+  return result;
+}
+function computeTotalHeight(flow) {
+  if (flow.length === 0) return 0;
+  const last = flow[flow.length - 1];
+  return last.y + last.height;
+}
+function reactiveBlockLayout(opts) {
+  const {
+    adapters,
+    name = "reactive-block-layout",
+    defaultFont = "16px sans-serif",
+    defaultLineHeight = 20
+  } = opts;
+  const g = new Graph(name);
+  const measureCache = /* @__PURE__ */ new Map();
+  const blocksNode = state(opts.blocks ?? [], { name: "blocks" });
+  const maxWidthNode = state(Math.max(0, opts.maxWidth ?? 800), { name: "max-width" });
+  const gapNode = state(opts.gap ?? 0, { name: "gap" });
+  const measuredBlocksNode = derived(
+    [blocksNode, maxWidthNode],
+    ([blocksVal, mwVal]) => {
+      const t0 = monotonicNs();
+      const result = measureBlocks(
+        blocksVal,
+        mwVal,
+        adapters,
+        measureCache,
+        defaultFont,
+        defaultLineHeight
+      );
+      const elapsed = monotonicNs() - t0;
+      const meta = measuredBlocksNode.meta;
+      if (meta) {
+        emitWithBatch((msgs) => meta["block-count"]?.down(msgs), [[DATA, result.length]], 3);
+        emitWithBatch((msgs) => meta["layout-time-ns"]?.down(msgs), [[DATA, elapsed]], 3);
+      }
+      return result;
+    },
+    {
+      name: "measured-blocks",
+      meta: { "block-count": 0, "layout-time-ns": 0 },
+      onMessage(msg, _depIndex, _actions) {
+        if (msg[0] === INVALIDATE || msg[0] === TEARDOWN) {
+          measureCache.clear();
+          adapters.text.clearCache?.();
+        }
+        return false;
+      },
+      equals: (a, b) => {
+        const ma = a;
+        const mb = b;
+        if (ma == null || mb == null) return ma === mb;
+        if (ma.length !== mb.length) return false;
+        for (let i = 0; i < ma.length; i++) {
+          const ba = ma[i];
+          const bb = mb[i];
+          if (ba.type !== bb.type || ba.width !== bb.width || ba.height !== bb.height || ba.index !== bb.index)
+            return false;
+        }
+        return true;
+      }
+    }
+  );
+  const blockFlowNode = derived(
+    [measuredBlocksNode, gapNode],
+    ([measured, gapVal]) => {
+      return computeBlockFlow(measured, gapVal);
+    },
+    {
+      name: "block-flow",
+      equals: (a, b) => {
+        const fa = a;
+        const fb = b;
+        if (fa == null || fb == null) return fa === fb;
+        if (fa.length !== fb.length) return false;
+        for (let i = 0; i < fa.length; i++) {
+          const pa = fa[i];
+          const pb = fb[i];
+          if (pa.x !== pb.x || pa.y !== pb.y || pa.width !== pb.width || pa.height !== pb.height)
+            return false;
+        }
+        return true;
+      }
+    }
+  );
+  const totalHeightNode = derived(
+    [blockFlowNode],
+    ([flow]) => computeTotalHeight(flow),
+    { name: "total-height" }
+  );
+  g.add("blocks", blocksNode);
+  g.add("max-width", maxWidthNode);
+  g.add("gap", gapNode);
+  g.add("measured-blocks", measuredBlocksNode);
+  g.add("block-flow", blockFlowNode);
+  g.add("total-height", totalHeightNode);
+  g.connect("blocks", "measured-blocks");
+  g.connect("max-width", "measured-blocks");
+  g.connect("measured-blocks", "block-flow");
+  g.connect("gap", "block-flow");
+  g.connect("block-flow", "total-height");
+  return {
+    graph: g,
+    setBlocks: (blocks) => g.set("blocks", blocks),
+    setMaxWidth: (mw) => g.set("max-width", Math.max(0, mw)),
+    setGap: (gap) => g.set("gap", gap),
+    measuredBlocks: measuredBlocksNode,
+    blockFlow: blockFlowNode,
+    totalHeight: totalHeightNode
+  };
+}
+
+export {
+  CliMeasureAdapter,
+  PrecomputedAdapter,
+  CanvasMeasureAdapter,
+  NodeCanvasMeasureAdapter,
+  SvgBoundsAdapter,
+  ImageSizeAdapter,
+  analyzeAndMeasure,
+  computeLineBreaks,
+  computeCharPositions,
+  reactiveLayout,
+  measureBlock,
+  measureBlocks,
+  computeBlockFlow,
+  computeTotalHeight,
+  reactiveBlockLayout,
+  reactive_layout_exports
+};
+//# sourceMappingURL=chunk-Z4Y4FMQN.js.map