@portel/photon 1.16.1 → 1.17.1

package/dist/beam.bundle.js

@@ -3710,18 +3710,18 @@ function buildStacks(layouts2) {
 function setLayoutDims(layouts2, params) {
   const stacks = buildStacks(layouts2);
   const { vBoxMaxWidth, hBoxMaxHeight } = params;
-  let i7, ilen, layout;
+  let i7, ilen, layout2;
   for (i7 = 0, ilen = layouts2.length; i7 < ilen; ++i7) {
-    layout = layouts2[i7];
-    const { fullSize } = layout.box;
-    const stack = stacks[layout.stack];
-    const factor = stack && layout.stackWeight / stack.weight;
-    if (layout.horizontal) {
-      layout.width = factor ? factor * vBoxMaxWidth : fullSize && params.availableWidth;
-      layout.height = hBoxMaxHeight;
+    layout2 = layouts2[i7];
+    const { fullSize } = layout2.box;
+    const stack = stacks[layout2.stack];
+    const factor = stack && layout2.stackWeight / stack.weight;
+    if (layout2.horizontal) {
+      layout2.width = factor ? factor * vBoxMaxWidth : fullSize && params.availableWidth;
+      layout2.height = hBoxMaxHeight;
     } else {
-      layout.width = vBoxMaxWidth;
-      layout.height = factor ? factor * hBoxMaxHeight : fullSize && params.availableHeight;
+      layout2.width = vBoxMaxWidth;
+      layout2.height = factor ? factor * hBoxMaxHeight : fullSize && params.availableHeight;
     }
   }
   return stacks;
@@ -3753,20 +3753,20 @@ function updateMaxPadding(maxPadding, boxPadding) {
   maxPadding.bottom = Math.max(maxPadding.bottom, boxPadding.bottom);
   maxPadding.right = Math.max(maxPadding.right, boxPadding.right);
 }
-function updateDims(chartArea, params, layout, stacks) {
-  const { pos, box } = layout;
+function updateDims(chartArea, params, layout2, stacks) {
+  const { pos, box } = layout2;
   const maxPadding = chartArea.maxPadding;
   if (!isObject(pos)) {
-    if (layout.size) {
-      chartArea[pos] -= layout.size;
+    if (layout2.size) {
+      chartArea[pos] -= layout2.size;
     }
-    const stack = stacks[layout.stack] || {
+    const stack = stacks[layout2.stack] || {
       size: 0,
       count: 1
     };
-    stack.size = Math.max(stack.size, layout.horizontal ? box.height : box.width);
-    layout.size = stack.size / stack.count;
-    chartArea[pos] += layout.size;
+    stack.size = Math.max(stack.size, layout2.horizontal ? box.height : box.width);
+    layout2.size = stack.size / stack.count;
+    chartArea[pos] += layout2.size;
   }
   if (box.getPadding) {
     updateMaxPadding(maxPadding, box.getPadding());
@@ -3777,7 +3777,7 @@ function updateDims(chartArea, params, layout, stacks) {
   const heightChanged = newHeight !== chartArea.h;
   chartArea.w = newWidth;
   chartArea.h = newHeight;
-  return layout.horizontal ? {
+  return layout2.horizontal ? {
     same: widthChanged,
     other: heightChanged
   } : {
@@ -3821,16 +3821,16 @@ function getMargins(horizontal, chartArea) {
 }
 function fitBoxes(boxes, chartArea, params, stacks) {
   const refitBoxes = [];
-  let i7, ilen, layout, box, refit, changed;
+  let i7, ilen, layout2, box, refit, changed;
   for (i7 = 0, ilen = boxes.length, refit = 0; i7 < ilen; ++i7) {
-    layout = boxes[i7];
-    box = layout.box;
-    box.update(layout.width || chartArea.w, layout.height || chartArea.h, getMargins(layout.horizontal, chartArea));
-    const { same, other } = updateDims(chartArea, params, layout, stacks);
+    layout2 = boxes[i7];
+    box = layout2.box;
+    box.update(layout2.width || chartArea.w, layout2.height || chartArea.h, getMargins(layout2.horizontal, chartArea));
+    const { same, other } = updateDims(chartArea, params, layout2, stacks);
     refit |= same && refitBoxes.length;
     changed = changed || other;
     if (!box.fullSize) {
-      refitBoxes.push(layout);
+      refitBoxes.push(layout2);
     }
   }
   return refit && fitBoxes(refitBoxes, chartArea, params, stacks) || changed;
@@ -3846,15 +3846,15 @@ function setBoxDims(box, left, top2, width, height) {
 function placeBoxes(boxes, chartArea, params, stacks) {
   const userPadding = params.padding;
   let { x: x3, y: y5 } = chartArea;
-  for (const layout of boxes) {
-    const box = layout.box;
-    const stack = stacks[layout.stack] || {
+  for (const layout2 of boxes) {
+    const box = layout2.box;
+    const stack = stacks[layout2.stack] || {
       count: 1,
       placed: 0,
       weight: 1
     };
-    const weight = layout.stackWeight / stack.weight || 1;
-    if (layout.horizontal) {
+    const weight = layout2.stackWeight / stack.weight || 1;
+    if (layout2.horizontal) {
       const width = chartArea.w * weight;
       const height = stack.size || box.height;
       if (defined(stack.start)) {
@@ -8909,8 +8909,8 @@ var init_chart = __esm({
           height: chartArea.h,
           width: chartArea.w
         };
-        each(boxes.chartArea, (layout) => {
-          const box = layout.box;
+        each(boxes.chartArea, (layout2) => {
+          const box = layout2.box;
           Object.assign(box, chart.chartArea);
           box.update(chartArea.w, chartArea.h, {
             left: 0,
@@ -14559,6 +14559,2876 @@ var init_chart = __esm({
   }
 });
 
+// node_modules/@chenglou/pretext/dist/bidi.js
+function classifyChar(charCode) {
+  if (charCode <= 255)
+    return baseTypes[charCode];
+  if (1424 <= charCode && charCode <= 1524)
+    return "R";
+  if (1536 <= charCode && charCode <= 1791)
+    return arabicTypes[charCode & 255];
+  if (1792 <= charCode && charCode <= 2220)
+    return "AL";
+  return "L";
+}
+function computeBidiLevels(str) {
+  const len = str.length;
+  if (len === 0)
+    return null;
+  const types2 = new Array(len);
+  let numBidi = 0;
+  for (let i7 = 0; i7 < len; i7++) {
+    const t8 = classifyChar(str.charCodeAt(i7));
+    if (t8 === "R" || t8 === "AL" || t8 === "AN")
+      numBidi++;
+    types2[i7] = t8;
+  }
+  if (numBidi === 0)
+    return null;
+  const startLevel = len / numBidi < 0.3 ? 0 : 1;
+  const levels = new Int8Array(len);
+  for (let i7 = 0; i7 < len; i7++)
+    levels[i7] = startLevel;
+  const e8 = startLevel & 1 ? "R" : "L";
+  const sor = e8;
+  let lastType = sor;
+  for (let i7 = 0; i7 < len; i7++) {
+    if (types2[i7] === "NSM")
+      types2[i7] = lastType;
+    else
+      lastType = types2[i7];
+  }
+  lastType = sor;
+  for (let i7 = 0; i7 < len; i7++) {
+    const t8 = types2[i7];
+    if (t8 === "EN")
+      types2[i7] = lastType === "AL" ? "AN" : "EN";
+    else if (t8 === "R" || t8 === "L" || t8 === "AL")
+      lastType = t8;
+  }
+  for (let i7 = 0; i7 < len; i7++) {
+    if (types2[i7] === "AL")
+      types2[i7] = "R";
+  }
+  for (let i7 = 1; i7 < len - 1; i7++) {
+    if (types2[i7] === "ES" && types2[i7 - 1] === "EN" && types2[i7 + 1] === "EN") {
+      types2[i7] = "EN";
+    }
+    if (types2[i7] === "CS" && (types2[i7 - 1] === "EN" || types2[i7 - 1] === "AN") && types2[i7 + 1] === types2[i7 - 1]) {
+      types2[i7] = types2[i7 - 1];
+    }
+  }
+  for (let i7 = 0; i7 < len; i7++) {
+    if (types2[i7] !== "EN")
+      continue;
+    let j2;
+    for (j2 = i7 - 1; j2 >= 0 && types2[j2] === "ET"; j2--)
+      types2[j2] = "EN";
+    for (j2 = i7 + 1; j2 < len && types2[j2] === "ET"; j2++)
+      types2[j2] = "EN";
+  }
+  for (let i7 = 0; i7 < len; i7++) {
+    const t8 = types2[i7];
+    if (t8 === "WS" || t8 === "ES" || t8 === "ET" || t8 === "CS")
+      types2[i7] = "ON";
+  }
+  lastType = sor;
+  for (let i7 = 0; i7 < len; i7++) {
+    const t8 = types2[i7];
+    if (t8 === "EN")
+      types2[i7] = lastType === "L" ? "L" : "EN";
+    else if (t8 === "R" || t8 === "L")
+      lastType = t8;
+  }
+  for (let i7 = 0; i7 < len; i7++) {
+    if (types2[i7] !== "ON")
+      continue;
+    let end = i7 + 1;
+    while (end < len && types2[end] === "ON")
+      end++;
+    const before = i7 > 0 ? types2[i7 - 1] : sor;
+    const after = end < len ? types2[end] : sor;
+    const bDir = before !== "L" ? "R" : "L";
+    const aDir = after !== "L" ? "R" : "L";
+    if (bDir === aDir) {
+      for (let j2 = i7; j2 < end; j2++)
+        types2[j2] = bDir;
+    }
+    i7 = end - 1;
+  }
+  for (let i7 = 0; i7 < len; i7++) {
+    if (types2[i7] === "ON")
+      types2[i7] = e8;
+  }
+  for (let i7 = 0; i7 < len; i7++) {
+    const t8 = types2[i7];
+    if ((levels[i7] & 1) === 0) {
+      if (t8 === "R")
+        levels[i7]++;
+      else if (t8 === "AN" || t8 === "EN")
+        levels[i7] += 2;
+    } else if (t8 === "L" || t8 === "AN" || t8 === "EN") {
+      levels[i7]++;
+    }
+  }
+  return levels;
+}
+function computeSegmentLevels(normalized, segStarts) {
+  const bidiLevels = computeBidiLevels(normalized);
+  if (bidiLevels === null)
+    return null;
+  const segLevels = new Int8Array(segStarts.length);
+  for (let i7 = 0; i7 < segStarts.length; i7++) {
+    segLevels[i7] = bidiLevels[segStarts[i7]];
+  }
+  return segLevels;
+}
+var baseTypes, arabicTypes;
+var init_bidi = __esm({
+  "node_modules/@chenglou/pretext/dist/bidi.js"() {
+    "use strict";
+    baseTypes = [
+      "BN",
+      "BN",
+      "BN",
+      "BN",
+      "BN",
+      "BN",
+      "BN",
+      "BN",
+      "BN",
+      "S",
+      "B",
+      "S",
+      "WS",
+      "B",
+      "BN",
+      "BN",
+      "BN",
+      "BN",
+      "BN",
+      "BN",
+      "BN",
+      "BN",
+      "BN",
+      "BN",
+      "BN",
+      "BN",
+      "BN",
+      "BN",
+      "B",
+      "B",
+      "B",
+      "S",
+      "WS",
+      "ON",
+      "ON",
+      "ET",
+      "ET",
+      "ET",
+      "ON",
+      "ON",
+      "ON",
+      "ON",
+      "ON",
+      "ON",
+      "CS",
+      "ON",
+      "CS",
+      "ON",
+      "EN",
+      "EN",
+      "EN",
+      "EN",
+      "EN",
+      "EN",
+      "EN",
+      "EN",
+      "EN",
+      "EN",
+      "ON",
+      "ON",
+      "ON",
+      "ON",
+      "ON",
+      "ON",
+      "ON",
+      "L",
+      "L",
+      "L",
+      "L",
+      "L",
+      "L",
+      "L",
+      "L",
+      "L",
+      "L",
+      "L",
+      "L",
+      "L",
+      "L",
+      "L",
+      "L",
+      "L",
+      "L",
+      "L",
+      "L",
+      "L",
+      "L",
+      "L",
+      "L",
+      "L",
+      "L",
+      "ON",
+      "ON",
+      "ON",
+      "ON",
+      "ON",
+      "ON",
+      "L",
+      "L",
+      "L",
+      "L",
+      "L",
+      "L",
+      "L",
+      "L",
+      "L",
+      "L",
+      "L",
+      "L",
+      "L",
+      "L",
+      "L",
+      "L",
+      "L",
+      "L",
+      "L",
+      "L",
+      "L",
+      "L",
+      "L",
+      "L",
+      "L",
+      "L",
+      "ON",
+      "ON",
+      "ON",
+      "ON",
+      "BN",
+      "BN",
+      "BN",
+      "BN",
+      "BN",
+      "BN",
+      "B",
+      "BN",
+      "BN",
+      "BN",
+      "BN",
+      "BN",
+      "BN",
+      "BN",
+      "BN",
+      "BN",
+      "BN",
+      "BN",
+      "BN",
+      "BN",
+      "BN",
+      "BN",
+      "BN",
+      "BN",
+      "BN",
+      "BN",
+      "BN",
+      "BN",
+      "BN",
+      "BN",
+      "BN",
+      "BN",
+      "BN",
+      "CS",
+      "ON",
+      "ET",
+      "ET",
+      "ET",
+      "ET",
+      "ON",
+      "ON",
+      "ON",
+      "ON",
+      "L",
+      "ON",
+      "ON",
+      "ON",
+      "ON",
+      "ON",
+      "ET",
+      "ET",
+      "EN",
+      "EN",
+      "ON",
+      "L",
+      "ON",
+      "ON",
+      "ON",
+      "EN",
+      "L",
+      "ON",
+      "ON",
+      "ON",
+      "ON",
+      "ON",
+      "L",
+      "L",
+      "L",
+      "L",
+      "L",
+      "L",
+      "L",
+      "L",
+      "L",
+      "L",
+      "L",
+      "L",
+      "L",
+      "L",
+      "L",
+      "L",
+      "L",
+      "L",
+      "L",
+      "L",
+      "L",
+      "L",
+      "L",
+      "ON",
+      "L",
+      "L",
+      "L",
+      "L",
+      "L",
+      "L",
+      "L",
+      "L",
+      "L",
+      "L",
+      "L",
+      "L",
+      "L",
+      "L",
+      "L",
+      "L",
+      "L",
+      "L",
+      "L",
+      "L",
+      "L",
+      "L",
+      "L",
+      "L",
+      "L",
+      "L",
+      "L",
+      "L",
+      "L",
+      "L",
+      "L",
+      "ON",
+      "L",
+      "L",
+      "L",
+      "L",
+      "L",
+      "L",
+      "L",
+      "L"
+    ];
+    arabicTypes = [
+      "AL",
+      "AL",
+      "AL",
+      "AL",
+      "AL",
+      "AL",
+      "AL",
+      "AL",
+      "AL",
+      "AL",
+      "AL",
+      "AL",
+      "CS",
+      "AL",
+      "ON",
+      "ON",
+      "NSM",
+      "NSM",
+      "NSM",
+      "NSM",
+      "NSM",
+      "NSM",
+      "AL",
+      "AL",
+      "AL",
+      "AL",
+      "AL",
+      "AL",
+      "AL",
+      "AL",
+      "AL",
+      "AL",
+      "AL",
+      "AL",
+      "AL",
+      "AL",
+      "AL",
+      "AL",
+      "AL",
+      "AL",
+      "AL",
+      "AL",
+      "AL",
+      "AL",
+      "AL",
+      "AL",
+      "AL",
+      "AL",
+      "AL",
+      "AL",
+      "AL",
+      "AL",
+      "AL",
+      "AL",
+      "AL",
+      "AL",
+      "AL",
+      "AL",
+      "AL",
+      "AL",
+      "AL",
+      "AL",
+      "AL",
+      "AL",
+      "AL",
+      "AL",
+      "AL",
+      "AL",
+      "AL",
+      "AL",
+      "AL",
+      "AL",
+      "AL",
+      "AL",
+      "AL",
+      "NSM",
+      "NSM",
+      "NSM",
+      "NSM",
+      "NSM",
+      "NSM",
+      "NSM",
+      "NSM",
+      "NSM",
+      "NSM",
+      "NSM",
+      "NSM",
+      "NSM",
+      "NSM",
+      "AL",
+      "AL",
+      "AL",
+      "AL",
+      "AL",
+      "AL",
+      "AL",
+      "AN",
+      "AN",
+      "AN",
+      "AN",
+      "AN",
+      "AN",
+      "AN",
+      "AN",
+      "AN",
+      "AN",
+      "ET",
+      "AN",
+      "AN",
+      "AL",
+      "AL",
+      "AL",
+      "NSM",
+      "AL",
+      "AL",
+      "AL",
+      "AL",
+      "AL",
+      "AL",
+      "AL",
+      "AL",
+      "AL",
+      "AL",
+      "AL",
+      "AL",
+      "AL",
+      "AL",
+      "AL",
+      "AL",
+      "AL",
+      "AL",
+      "AL",
+      "AL",
+      "AL",
+      "AL",
+      "AL",
+      "AL",
+      "AL",
+      "AL",
+      "AL",
+      "AL",
+      "AL",
+      "AL",
+      "AL",
+      "AL",
+      "AL",
+      "AL",
+      "AL",
+      "AL",
+      "AL",
+      "AL",
+      "AL",
+      "AL",
+      "AL",
+      "AL",
+      "AL",
+      "AL",
+      "AL",
+      "AL",
+      "AL",
+      "AL",
+      "AL",
+      "AL",
+      "AL",
+      "AL",
+      "AL",
+      "AL",
+      "AL",
+      "AL",
+      "AL",
+      "AL",
+      "AL",
+      "AL",
+      "AL",
+      "AL",
+      "AL",
+      "AL",
+      "AL",
+      "AL",
+      "AL",
+      "AL",
+      "AL",
+      "AL",
+      "AL",
+      "AL",
+      "AL",
+      "AL",
+      "AL",
+      "AL",
+      "AL",
+      "AL",
+      "AL",
+      "AL",
+      "AL",
+      "AL",
+      "AL",
+      "AL",
+      "AL",
+      "AL",
+      "AL",
+      "AL",
+      "AL",
+      "AL",
+      "AL",
+      "AL",
+      "AL",
+      "AL",
+      "AL",
+      "AL",
+      "AL",
+      "AL",
+      "AL",
+      "AL",
+      "AL",
+      "NSM",
+      "NSM",
+      "NSM",
+      "NSM",
+      "NSM",
+      "NSM",
+      "NSM",
+      "NSM",
+      "NSM",
+      "NSM",
+      "NSM",
+      "NSM",
+      "NSM",
+      "NSM",
+      "NSM",
+      "NSM",
+      "NSM",
+      "NSM",
+      "NSM",
+      "ON",
+      "NSM",
+      "NSM",
+      "NSM",
+      "NSM",
+      "AL",
+      "AL",
+      "AL",
+      "AL",
+      "AL",
+      "AL",
+      "AL",
+      "AL",
+      "AL",
+      "AL",
+      "AL",
+      "AL",
+      "AL",
+      "AL",
+      "AL",
+      "AL",
+      "AL",
+      "AL"
+    ];
+  }
+});
+
+// node_modules/@chenglou/pretext/dist/analysis.js
+function getWhiteSpaceProfile(whiteSpace) {
+  const mode = whiteSpace ?? "normal";
+  return mode === "pre-wrap" ? { mode, preserveOrdinarySpaces: true, preserveHardBreaks: true } : { mode, preserveOrdinarySpaces: false, preserveHardBreaks: false };
+}
+function normalizeWhitespaceNormal(text) {
+  if (!needsWhitespaceNormalizationRe.test(text))
+    return text;
+  let normalized = text.replace(collapsibleWhitespaceRunRe, " ");
+  if (normalized.charCodeAt(0) === 32) {
+    normalized = normalized.slice(1);
+  }
+  if (normalized.length > 0 && normalized.charCodeAt(normalized.length - 1) === 32) {
+    normalized = normalized.slice(0, -1);
+  }
+  return normalized;
+}
+function normalizeWhitespacePreWrap(text) {
+  if (!/[\r\f]/.test(text))
+    return text.replace(/\r\n/g, "\n");
+  return text.replace(/\r\n/g, "\n").replace(/[\r\f]/g, "\n");
+}
+function getSharedWordSegmenter() {
+  if (sharedWordSegmenter === null) {
+    sharedWordSegmenter = new Intl.Segmenter(segmenterLocale, { granularity: "word" });
+  }
+  return sharedWordSegmenter;
+}
+function clearAnalysisCaches() {
+  sharedWordSegmenter = null;
+}
+function containsArabicScript(text) {
+  return arabicScriptRe.test(text);
+}
+function isCJK(s5) {
+  for (const ch of s5) {
+    const c5 = ch.codePointAt(0);
+    if (c5 >= 19968 && c5 <= 40959 || c5 >= 13312 && c5 <= 19903 || c5 >= 131072 && c5 <= 173791 || c5 >= 173824 && c5 <= 177983 || c5 >= 177984 && c5 <= 178207 || c5 >= 178208 && c5 <= 183983 || c5 >= 183984 && c5 <= 191471 || c5 >= 196608 && c5 <= 201551 || c5 >= 63744 && c5 <= 64255 || c5 >= 194560 && c5 <= 195103 || c5 >= 12288 && c5 <= 12351 || c5 >= 12352 && c5 <= 12447 || c5 >= 12448 && c5 <= 12543 || c5 >= 44032 && c5 <= 55215 || c5 >= 65280 && c5 <= 65519) {
+      return true;
+    }
+  }
+  return false;
+}
+function isLeftStickyPunctuationSegment(segment) {
+  if (isEscapedQuoteClusterSegment(segment))
+    return true;
+  let sawPunctuation = false;
+  for (const ch of segment) {
+    if (leftStickyPunctuation.has(ch)) {
+      sawPunctuation = true;
+      continue;
+    }
+    if (sawPunctuation && combiningMarkRe.test(ch))
+      continue;
+    return false;
+  }
+  return sawPunctuation;
+}
+function isCJKLineStartProhibitedSegment(segment) {
+  for (const ch of segment) {
+    if (!kinsokuStart.has(ch) && !leftStickyPunctuation.has(ch))
+      return false;
+  }
+  return segment.length > 0;
+}
+function isForwardStickyClusterSegment(segment) {
+  if (isEscapedQuoteClusterSegment(segment))
+    return true;
+  for (const ch of segment) {
+    if (!kinsokuEnd.has(ch) && !forwardStickyGlue.has(ch) && !combiningMarkRe.test(ch))
+      return false;
+  }
+  return segment.length > 0;
+}
+function isEscapedQuoteClusterSegment(segment) {
+  let sawQuote = false;
+  for (const ch of segment) {
+    if (ch === "\\" || combiningMarkRe.test(ch))
+      continue;
+    if (kinsokuEnd.has(ch) || leftStickyPunctuation.has(ch) || forwardStickyGlue.has(ch)) {
+      sawQuote = true;
+      continue;
+    }
+    return false;
+  }
+  return sawQuote;
+}
+function splitTrailingForwardStickyCluster(text) {
+  const chars = Array.from(text);
+  let splitIndex = chars.length;
+  while (splitIndex > 0) {
+    const ch = chars[splitIndex - 1];
+    if (combiningMarkRe.test(ch)) {
+      splitIndex--;
+      continue;
+    }
+    if (kinsokuEnd.has(ch) || forwardStickyGlue.has(ch)) {
+      splitIndex--;
+      continue;
+    }
+    break;
+  }
+  if (splitIndex <= 0 || splitIndex === chars.length)
+    return null;
+  return {
+    head: chars.slice(0, splitIndex).join(""),
+    tail: chars.slice(splitIndex).join("")
+  };
+}
+function isRepeatedSingleCharRun(segment, ch) {
+  if (segment.length === 0)
+    return false;
+  for (const part of segment) {
+    if (part !== ch)
+      return false;
+  }
+  return true;
+}
+function endsWithArabicNoSpacePunctuation(segment) {
+  if (!containsArabicScript(segment) || segment.length === 0)
+    return false;
+  return arabicNoSpaceTrailingPunctuation.has(segment[segment.length - 1]);
+}
+function endsWithMyanmarMedialGlue(segment) {
+  if (segment.length === 0)
+    return false;
+  return myanmarMedialGlue.has(segment[segment.length - 1]);
+}
+function splitLeadingSpaceAndMarks(segment) {
+  if (segment.length < 2 || segment[0] !== " ")
+    return null;
+  const marks2 = segment.slice(1);
+  if (/^\p{M}+$/u.test(marks2)) {
+    return { space: " ", marks: marks2 };
+  }
+  return null;
+}
+function endsWithClosingQuote(text) {
+  for (let i7 = text.length - 1; i7 >= 0; i7--) {
+    const ch = text[i7];
+    if (closingQuoteChars.has(ch))
+      return true;
+    if (!leftStickyPunctuation.has(ch))
+      return false;
+  }
+  return false;
+}
+function classifySegmentBreakChar(ch, whiteSpaceProfile) {
+  if (whiteSpaceProfile.preserveOrdinarySpaces || whiteSpaceProfile.preserveHardBreaks) {
+    if (ch === " ")
+      return "preserved-space";
+    if (ch === "	")
+      return "tab";
+    if (whiteSpaceProfile.preserveHardBreaks && ch === "\n")
+      return "hard-break";
+  }
+  if (ch === " ")
+    return "space";
+  if (ch === "\xA0" || ch === "\u202F" || ch === "\u2060" || ch === "\uFEFF") {
+    return "glue";
+  }
+  if (ch === "\u200B")
+    return "zero-width-break";
+  if (ch === "\xAD")
+    return "soft-hyphen";
+  return "text";
+}
+function splitSegmentByBreakKind(segment, isWordLike, start, whiteSpaceProfile) {
+  const pieces = [];
+  let currentKind = null;
+  let currentText = "";
+  let currentStart = start;
+  let currentWordLike = false;
+  let offset = 0;
+  for (const ch of segment) {
+    const kind = classifySegmentBreakChar(ch, whiteSpaceProfile);
+    const wordLike = kind === "text" && isWordLike;
+    if (currentKind !== null && kind === currentKind && wordLike === currentWordLike) {
+      currentText += ch;
+      offset += ch.length;
+      continue;
+    }
+    if (currentKind !== null) {
+      pieces.push({
+        text: currentText,
+        isWordLike: currentWordLike,
+        kind: currentKind,
+        start: currentStart
+      });
+    }
+    currentKind = kind;
+    currentText = ch;
+    currentStart = start + offset;
+    currentWordLike = wordLike;
+    offset += ch.length;
+  }
+  if (currentKind !== null) {
+    pieces.push({
+      text: currentText,
+      isWordLike: currentWordLike,
+      kind: currentKind,
+      start: currentStart
+    });
+  }
+  return pieces;
+}
+function isTextRunBoundary(kind) {
+  return kind === "space" || kind === "preserved-space" || kind === "zero-width-break" || kind === "hard-break";
+}
+function isUrlLikeRunStart(segmentation, index2) {
+  const text = segmentation.texts[index2];
+  if (text.startsWith("www."))
+    return true;
+  return urlSchemeSegmentRe.test(text) && index2 + 1 < segmentation.len && segmentation.kinds[index2 + 1] === "text" && segmentation.texts[index2 + 1] === "//";
+}
+function isUrlQueryBoundarySegment(text) {
+  return text.includes("?") && (text.includes("://") || text.startsWith("www."));
+}
+function mergeUrlLikeRuns(segmentation) {
+  const texts = segmentation.texts.slice();
+  const isWordLike = segmentation.isWordLike.slice();
+  const kinds = segmentation.kinds.slice();
+  const starts = segmentation.starts.slice();
+  for (let i7 = 0; i7 < segmentation.len; i7++) {
+    if (kinds[i7] !== "text" || !isUrlLikeRunStart(segmentation, i7))
+      continue;
+    let j2 = i7 + 1;
+    while (j2 < segmentation.len && !isTextRunBoundary(kinds[j2])) {
+      texts[i7] += texts[j2];
+      isWordLike[i7] = true;
+      const endsQueryPrefix = texts[j2].includes("?");
+      kinds[j2] = "text";
+      texts[j2] = "";
+      j2++;
+      if (endsQueryPrefix)
+        break;
+    }
+  }
+  let compactLen = 0;
+  for (let read = 0; read < texts.length; read++) {
+    const text = texts[read];
+    if (text.length === 0)
+      continue;
+    if (compactLen !== read) {
+      texts[compactLen] = text;
+      isWordLike[compactLen] = isWordLike[read];
+      kinds[compactLen] = kinds[read];
+      starts[compactLen] = starts[read];
+    }
+    compactLen++;
+  }
+  texts.length = compactLen;
+  isWordLike.length = compactLen;
+  kinds.length = compactLen;
+  starts.length = compactLen;
+  return {
+    len: compactLen,
+    texts,
+    isWordLike,
+    kinds,
+    starts
+  };
+}
+function mergeUrlQueryRuns(segmentation) {
+  const texts = [];
+  const isWordLike = [];
+  const kinds = [];
+  const starts = [];
+  for (let i7 = 0; i7 < segmentation.len; i7++) {
+    const text = segmentation.texts[i7];
+    texts.push(text);
+    isWordLike.push(segmentation.isWordLike[i7]);
+    kinds.push(segmentation.kinds[i7]);
+    starts.push(segmentation.starts[i7]);
+    if (!isUrlQueryBoundarySegment(text))
+      continue;
+    const nextIndex = i7 + 1;
+    if (nextIndex >= segmentation.len || isTextRunBoundary(segmentation.kinds[nextIndex])) {
+      continue;
+    }
+    let queryText = "";
+    const queryStart = segmentation.starts[nextIndex];
+    let j2 = nextIndex;
+    while (j2 < segmentation.len && !isTextRunBoundary(segmentation.kinds[j2])) {
+      queryText += segmentation.texts[j2];
+      j2++;
+    }
+    if (queryText.length > 0) {
+      texts.push(queryText);
+      isWordLike.push(true);
+      kinds.push("text");
+      starts.push(queryStart);
+      i7 = j2 - 1;
+    }
+  }
+  return {
+    len: texts.length,
+    texts,
+    isWordLike,
+    kinds,
+    starts
+  };
+}
+function segmentContainsDecimalDigit(text) {
+  for (const ch of text) {
+    if (decimalDigitRe.test(ch))
+      return true;
+  }
+  return false;
+}
+function isNumericRunSegment(text) {
+  if (text.length === 0)
+    return false;
+  for (const ch of text) {
+    if (decimalDigitRe.test(ch) || numericJoinerChars.has(ch))
+      continue;
+    return false;
+  }
+  return true;
+}
+function mergeNumericRuns(segmentation) {
+  const texts = [];
+  const isWordLike = [];
+  const kinds = [];
+  const starts = [];
+  for (let i7 = 0; i7 < segmentation.len; i7++) {
+    const text = segmentation.texts[i7];
+    const kind = segmentation.kinds[i7];
+    if (kind === "text" && isNumericRunSegment(text) && segmentContainsDecimalDigit(text)) {
+      let mergedText = text;
+      let j2 = i7 + 1;
+      while (j2 < segmentation.len && segmentation.kinds[j2] === "text" && isNumericRunSegment(segmentation.texts[j2])) {
+        mergedText += segmentation.texts[j2];
+        j2++;
+      }
+      texts.push(mergedText);
+      isWordLike.push(true);
+      kinds.push("text");
+      starts.push(segmentation.starts[i7]);
+      i7 = j2 - 1;
+      continue;
+    }
+    texts.push(text);
+    isWordLike.push(segmentation.isWordLike[i7]);
+    kinds.push(kind);
+    starts.push(segmentation.starts[i7]);
+  }
+  return {
+    len: texts.length,
+    texts,
+    isWordLike,
+    kinds,
+    starts
+  };
+}
+function mergeAsciiPunctuationChains(segmentation) {
+  const texts = [];
+  const isWordLike = [];
+  const kinds = [];
+  const starts = [];
+  for (let i7 = 0; i7 < segmentation.len; i7++) {
+    const text = segmentation.texts[i7];
+    const kind = segmentation.kinds[i7];
+    const wordLike = segmentation.isWordLike[i7];
+    if (kind === "text" && wordLike && asciiPunctuationChainSegmentRe.test(text)) {
+      let mergedText = text;
+      let j2 = i7 + 1;
+      while (asciiPunctuationChainTrailingJoinersRe.test(mergedText) && j2 < segmentation.len && segmentation.kinds[j2] === "text" && segmentation.isWordLike[j2] && asciiPunctuationChainSegmentRe.test(segmentation.texts[j2])) {
+        mergedText += segmentation.texts[j2];
+        j2++;
+      }
+      texts.push(mergedText);
+      isWordLike.push(true);
+      kinds.push("text");
+      starts.push(segmentation.starts[i7]);
+      i7 = j2 - 1;
+      continue;
+    }
+    texts.push(text);
+    isWordLike.push(wordLike);
+    kinds.push(kind);
+    starts.push(segmentation.starts[i7]);
+  }
+  return {
+    len: texts.length,
+    texts,
+    isWordLike,
+    kinds,
+    starts
+  };
+}
+function splitHyphenatedNumericRuns(segmentation) {
+  const texts = [];
+  const isWordLike = [];
+  const kinds = [];
+  const starts = [];
+  for (let i7 = 0; i7 < segmentation.len; i7++) {
+    const text = segmentation.texts[i7];
+    if (segmentation.kinds[i7] === "text" && text.includes("-")) {
+      const parts = text.split("-");
+      let shouldSplit = parts.length > 1;
+      for (let j2 = 0; j2 < parts.length; j2++) {
+        const part = parts[j2];
+        if (!shouldSplit)
+          break;
+        if (part.length === 0 || !segmentContainsDecimalDigit(part) || !isNumericRunSegment(part)) {
+          shouldSplit = false;
+        }
+      }
+      if (shouldSplit) {
+        let offset = 0;
+        for (let j2 = 0; j2 < parts.length; j2++) {
+          const part = parts[j2];
+          const splitText = j2 < parts.length - 1 ? `${part}-` : part;
+          texts.push(splitText);
+          isWordLike.push(true);
+          kinds.push("text");
+          starts.push(segmentation.starts[i7] + offset);
+          offset += splitText.length;
+        }
+        continue;
+      }
+    }
+    texts.push(text);
+    isWordLike.push(segmentation.isWordLike[i7]);
+    kinds.push(segmentation.kinds[i7]);
+    starts.push(segmentation.starts[i7]);
+  }
+  return {
+    len: texts.length,
+    texts,
+    isWordLike,
+    kinds,
+    starts
+  };
+}
+function mergeGlueConnectedTextRuns(segmentation) {
+  const texts = [];
+  const isWordLike = [];
+  const kinds = [];
+  const starts = [];
+  let read = 0;
+  while (read < segmentation.len) {
+    let text = segmentation.texts[read];
+    let wordLike = segmentation.isWordLike[read];
+    let kind = segmentation.kinds[read];
+    let start = segmentation.starts[read];
+    if (kind === "glue") {
+      let glueText = text;
+      const glueStart = start;
+      read++;
+      while (read < segmentation.len && segmentation.kinds[read] === "glue") {
+        glueText += segmentation.texts[read];
+        read++;
+      }
+      if (read < segmentation.len && segmentation.kinds[read] === "text") {
+        text = glueText + segmentation.texts[read];
+        wordLike = segmentation.isWordLike[read];
+        kind = "text";
+        start = glueStart;
+        read++;
+      } else {
+        texts.push(glueText);
+        isWordLike.push(false);
+        kinds.push("glue");
+        starts.push(glueStart);
+        continue;
+      }
+    } else {
+      read++;
+    }
+    if (kind === "text") {
+      while (read < segmentation.len && segmentation.kinds[read] === "glue") {
+        let glueText = "";
+        while (read < segmentation.len && segmentation.kinds[read] === "glue") {
+          glueText += segmentation.texts[read];
+          read++;
+        }
+        if (read < segmentation.len && segmentation.kinds[read] === "text") {
+          text += glueText + segmentation.texts[read];
+          wordLike = wordLike || segmentation.isWordLike[read];
+          read++;
+          continue;
+        }
+        text += glueText;
+      }
+    }
+    texts.push(text);
+    isWordLike.push(wordLike);
+    kinds.push(kind);
+    starts.push(start);
+  }
+  return {
+    len: texts.length,
+    texts,
+    isWordLike,
+    kinds,
+    starts
+  };
+}
+function carryTrailingForwardStickyAcrossCJKBoundary(segmentation) {
+  const texts = segmentation.texts.slice();
+  const isWordLike = segmentation.isWordLike.slice();
+  const kinds = segmentation.kinds.slice();
+  const starts = segmentation.starts.slice();
+  for (let i7 = 0; i7 < texts.length - 1; i7++) {
+    if (kinds[i7] !== "text" || kinds[i7 + 1] !== "text")
+      continue;
+    if (!isCJK(texts[i7]) || !isCJK(texts[i7 + 1]))
+      continue;
+    const split = splitTrailingForwardStickyCluster(texts[i7]);
+    if (split === null)
+      continue;
+    texts[i7] = split.head;
+    texts[i7 + 1] = split.tail + texts[i7 + 1];
+    starts[i7 + 1] = starts[i7] + split.head.length;
+  }
+  return {
+    len: texts.length,
+    texts,
+    isWordLike,
+    kinds,
+    starts
+  };
+}
+function buildMergedSegmentation(normalized, profile, whiteSpaceProfile) {
+  const wordSegmenter = getSharedWordSegmenter();
+  let mergedLen = 0;
+  const mergedTexts = [];
+  const mergedWordLike = [];
+  const mergedKinds = [];
+  const mergedStarts = [];
+  for (const s5 of wordSegmenter.segment(normalized)) {
+    for (const piece of splitSegmentByBreakKind(s5.segment, s5.isWordLike ?? false, s5.index, whiteSpaceProfile)) {
+      const isText = piece.kind === "text";
+      if (profile.carryCJKAfterClosingQuote && isText && mergedLen > 0 && mergedKinds[mergedLen - 1] === "text" && isCJK(piece.text) && isCJK(mergedTexts[mergedLen - 1]) && endsWithClosingQuote(mergedTexts[mergedLen - 1])) {
+        mergedTexts[mergedLen - 1] += piece.text;
+        mergedWordLike[mergedLen - 1] = mergedWordLike[mergedLen - 1] || piece.isWordLike;
+      } else if (isText && mergedLen > 0 && mergedKinds[mergedLen - 1] === "text" && isCJKLineStartProhibitedSegment(piece.text) && isCJK(mergedTexts[mergedLen - 1])) {
+        mergedTexts[mergedLen - 1] += piece.text;
+        mergedWordLike[mergedLen - 1] = mergedWordLike[mergedLen - 1] || piece.isWordLike;
+      } else if (isText && mergedLen > 0 && mergedKinds[mergedLen - 1] === "text" && endsWithMyanmarMedialGlue(mergedTexts[mergedLen - 1])) {
+        mergedTexts[mergedLen - 1] += piece.text;
+        mergedWordLike[mergedLen - 1] = mergedWordLike[mergedLen - 1] || piece.isWordLike;
+      } else if (isText && mergedLen > 0 && mergedKinds[mergedLen - 1] === "text" && piece.isWordLike && containsArabicScript(piece.text) && endsWithArabicNoSpacePunctuation(mergedTexts[mergedLen - 1])) {
+        mergedTexts[mergedLen - 1] += piece.text;
+        mergedWordLike[mergedLen - 1] = true;
+      } else if (isText && !piece.isWordLike && mergedLen > 0 && mergedKinds[mergedLen - 1] === "text" && piece.text.length === 1 && piece.text !== "-" && piece.text !== "\u2014" && isRepeatedSingleCharRun(mergedTexts[mergedLen - 1], piece.text)) {
+        mergedTexts[mergedLen - 1] += piece.text;
+      } else if (isText && !piece.isWordLike && mergedLen > 0 && mergedKinds[mergedLen - 1] === "text" && (isLeftStickyPunctuationSegment(piece.text) || piece.text === "-" && mergedWordLike[mergedLen - 1])) {
+        mergedTexts[mergedLen - 1] += piece.text;
+      } else {
+        mergedTexts[mergedLen] = piece.text;
+        mergedWordLike[mergedLen] = piece.isWordLike;
+        mergedKinds[mergedLen] = piece.kind;
+        mergedStarts[mergedLen] = piece.start;
+        mergedLen++;
+      }
+    }
+  }
+  for (let i7 = 1; i7 < mergedLen; i7++) {
+    if (mergedKinds[i7] === "text" && !mergedWordLike[i7] && isEscapedQuoteClusterSegment(mergedTexts[i7]) && mergedKinds[i7 - 1] === "text") {
+      mergedTexts[i7 - 1] += mergedTexts[i7];
+      mergedWordLike[i7 - 1] = mergedWordLike[i7 - 1] || mergedWordLike[i7];
+      mergedTexts[i7] = "";
+    }
+  }
+  for (let i7 = mergedLen - 2; i7 >= 0; i7--) {
+    if (mergedKinds[i7] === "text" && !mergedWordLike[i7] && isForwardStickyClusterSegment(mergedTexts[i7])) {
+      let j2 = i7 + 1;
+      while (j2 < mergedLen && mergedTexts[j2] === "")
+        j2++;
+      if (j2 < mergedLen && mergedKinds[j2] === "text") {
+        mergedTexts[j2] = mergedTexts[i7] + mergedTexts[j2];
+        mergedStarts[j2] = mergedStarts[i7];
+        mergedTexts[i7] = "";
+      }
+    }
+  }
+  let compactLen = 0;
+  for (let read = 0; read < mergedLen; read++) {
+    const text = mergedTexts[read];
+    if (text.length === 0)
+      continue;
+    if (compactLen !== read) {
+      mergedTexts[compactLen] = text;
+      mergedWordLike[compactLen] = mergedWordLike[read];
+      mergedKinds[compactLen] = mergedKinds[read];
+      mergedStarts[compactLen] = mergedStarts[read];
+    }
+    compactLen++;
+  }
+  mergedTexts.length = compactLen;
+  mergedWordLike.length = compactLen;
+  mergedKinds.length = compactLen;
+  mergedStarts.length = compactLen;
+  const compacted = mergeGlueConnectedTextRuns({
+    len: compactLen,
+    texts: mergedTexts,
+    isWordLike: mergedWordLike,
+    kinds: mergedKinds,
+    starts: mergedStarts
+  });
+  const withMergedUrls = carryTrailingForwardStickyAcrossCJKBoundary(mergeAsciiPunctuationChains(splitHyphenatedNumericRuns(mergeNumericRuns(mergeUrlQueryRuns(mergeUrlLikeRuns(compacted))))));
+  for (let i7 = 0; i7 < withMergedUrls.len - 1; i7++) {
+    const split = splitLeadingSpaceAndMarks(withMergedUrls.texts[i7]);
+    if (split === null)
+      continue;
+    if (withMergedUrls.kinds[i7] !== "space" && withMergedUrls.kinds[i7] !== "preserved-space" || withMergedUrls.kinds[i7 + 1] !== "text" || !containsArabicScript(withMergedUrls.texts[i7 + 1])) {
+      continue;
+    }
+    withMergedUrls.texts[i7] = split.space;
+    withMergedUrls.isWordLike[i7] = false;
+    withMergedUrls.kinds[i7] = withMergedUrls.kinds[i7] === "preserved-space" ? "preserved-space" : "space";
+    withMergedUrls.texts[i7 + 1] = split.marks + withMergedUrls.texts[i7 + 1];
+    withMergedUrls.starts[i7 + 1] = withMergedUrls.starts[i7] + split.space.length;
+  }
+  return withMergedUrls;
+}
+function compileAnalysisChunks(segmentation, whiteSpaceProfile) {
+  if (segmentation.len === 0)
+    return [];
+  if (!whiteSpaceProfile.preserveHardBreaks) {
+    return [{
+      startSegmentIndex: 0,
+      endSegmentIndex: segmentation.len,
+      consumedEndSegmentIndex: segmentation.len
+    }];
+  }
+  const chunks = [];
+  let startSegmentIndex = 0;
+  for (let i7 = 0; i7 < segmentation.len; i7++) {
+    if (segmentation.kinds[i7] !== "hard-break")
+      continue;
+    chunks.push({
+      startSegmentIndex,
+      endSegmentIndex: i7,
+      consumedEndSegmentIndex: i7 + 1
+    });
+    startSegmentIndex = i7 + 1;
+  }
+  if (startSegmentIndex < segmentation.len) {
+    chunks.push({
+      startSegmentIndex,
+      endSegmentIndex: segmentation.len,
+      consumedEndSegmentIndex: segmentation.len
+    });
+  }
+  return chunks;
+}
+function analyzeText(text, profile, whiteSpace = "normal") {
+  const whiteSpaceProfile = getWhiteSpaceProfile(whiteSpace);
+  const normalized = whiteSpaceProfile.mode === "pre-wrap" ? normalizeWhitespacePreWrap(text) : normalizeWhitespaceNormal(text);
+  if (normalized.length === 0) {
+    return {
+      normalized,
+      chunks: [],
+      len: 0,
+      texts: [],
+      isWordLike: [],
+      kinds: [],
+      starts: []
+    };
+  }
+  const segmentation = buildMergedSegmentation(normalized, profile, whiteSpaceProfile);
+  return {
+    normalized,
+    chunks: compileAnalysisChunks(segmentation, whiteSpaceProfile),
+    ...segmentation
+  };
+}
+var collapsibleWhitespaceRunRe, needsWhitespaceNormalizationRe, sharedWordSegmenter, segmenterLocale, arabicScriptRe, combiningMarkRe, decimalDigitRe, kinsokuStart, kinsokuEnd, forwardStickyGlue, leftStickyPunctuation, arabicNoSpaceTrailingPunctuation, myanmarMedialGlue, closingQuoteChars, urlSchemeSegmentRe, numericJoinerChars, asciiPunctuationChainSegmentRe, asciiPunctuationChainTrailingJoinersRe;
+var init_analysis = __esm({
+  "node_modules/@chenglou/pretext/dist/analysis.js"() {
+    "use strict";
+    collapsibleWhitespaceRunRe = /[ \t\n\r\f]+/g;
+    needsWhitespaceNormalizationRe = /[\t\n\r\f]| {2,}|^ | $/;
+    sharedWordSegmenter = null;
+    arabicScriptRe = /\p{Script=Arabic}/u;
+    combiningMarkRe = /\p{M}/u;
+    decimalDigitRe = /\p{Nd}/u;
+    kinsokuStart = /* @__PURE__ */ new Set([
+      "\uFF0C",
+      "\uFF0E",
+      "\uFF01",
+      "\uFF1A",
+      "\uFF1B",
+      "\uFF1F",
+      "\u3001",
+      "\u3002",
+      "\u30FB",
+      "\uFF09",
+      "\u3015",
+      "\u3009",
+      "\u300B",
+      "\u300D",
+      "\u300F",
+      "\u3011",
+      "\u3017",
+      "\u3019",
+      "\u301B",
+      "\u30FC",
+      "\u3005",
+      "\u303B",
+      "\u309D",
+      "\u309E",
+      "\u30FD",
+      "\u30FE"
+    ]);
+    kinsokuEnd = /* @__PURE__ */ new Set([
+      '"',
+      "(",
+      "[",
+      "{",
+      "\u201C",
+      "\u2018",
+      "\xAB",
+      "\u2039",
+      "\uFF08",
+      "\u3014",
+      "\u3008",
+      "\u300A",
+      "\u300C",
+      "\u300E",
+      "\u3010",
+      "\u3016",
+      "\u3018",
+      "\u301A"
+    ]);
+    forwardStickyGlue = /* @__PURE__ */ new Set([
+      "'",
+      "\u2019"
+    ]);
+    leftStickyPunctuation = /* @__PURE__ */ new Set([
+      ".",
+      ",",
+      "!",
+      "?",
+      ":",
+      ";",
+      "\u060C",
+      "\u061B",
+      "\u061F",
+      "\u0964",
+      "\u0965",
+      "\u104A",
+      "\u104B",
+      "\u104C",
+      "\u104D",
+      "\u104F",
+      ")",
+      "]",
+      "}",
+      "%",
+      '"',
+      "\u201D",
+      "\u2019",
+      "\xBB",
+      "\u203A",
+      "\u2026"
+    ]);
+    arabicNoSpaceTrailingPunctuation = /* @__PURE__ */ new Set([
+      ":",
+      ".",
+      "\u060C",
+      "\u061B"
+    ]);
+    myanmarMedialGlue = /* @__PURE__ */ new Set([
+      "\u104F"
+    ]);
+    closingQuoteChars = /* @__PURE__ */ new Set([
+      "\u201D",
+      "\u2019",
+      "\xBB",
+      "\u203A",
+      "\u300D",
+      "\u300F",
+      "\u3011",
+      "\u300B",
+      "\u3009",
+      "\u3015",
+      "\uFF09"
+    ]);
+    urlSchemeSegmentRe = /^[A-Za-z][A-Za-z0-9+.-]*:$/;
+    numericJoinerChars = /* @__PURE__ */ new Set([
+      ":",
+      "-",
+      "/",
+      "\xD7",
+      ",",
+      ".",
+      "+",
+      "\u2013",
+      "\u2014"
+    ]);
+    asciiPunctuationChainSegmentRe = /^[A-Za-z0-9_]+[,:;]*$/;
+    asciiPunctuationChainTrailingJoinersRe = /[,:;]+$/;
+  }
+});
+
+// node_modules/@chenglou/pretext/dist/measurement.js
+function getMeasureContext() {
+  if (measureContext !== null)
+    return measureContext;
+  if (typeof OffscreenCanvas !== "undefined") {
+    measureContext = new OffscreenCanvas(1, 1).getContext("2d");
+    return measureContext;
+  }
+  if (typeof document !== "undefined") {
+    measureContext = document.createElement("canvas").getContext("2d");
+    return measureContext;
+  }
+  throw new Error("Text measurement requires OffscreenCanvas or a DOM canvas context.");
+}
+function getSegmentMetricCache(font) {
+  let cache2 = segmentMetricCaches.get(font);
+  if (!cache2) {
+    cache2 = /* @__PURE__ */ new Map();
+    segmentMetricCaches.set(font, cache2);
+  }
+  return cache2;
+}
+function getSegmentMetrics(seg, cache2) {
+  let metrics = cache2.get(seg);
+  if (metrics === void 0) {
+    const ctx = getMeasureContext();
+    metrics = {
+      width: ctx.measureText(seg).width,
+      containsCJK: isCJK(seg)
+    };
+    cache2.set(seg, metrics);
+  }
+  return metrics;
+}
+function getEngineProfile() {
+  if (cachedEngineProfile !== null)
+    return cachedEngineProfile;
+  if (typeof navigator === "undefined") {
+    cachedEngineProfile = {
+      lineFitEpsilon: 5e-3,
+      carryCJKAfterClosingQuote: false,
+      preferPrefixWidthsForBreakableRuns: false,
+      preferEarlySoftHyphenBreak: false
+    };
+    return cachedEngineProfile;
+  }
+  const ua = navigator.userAgent;
+  const vendor = navigator.vendor;
+  const isSafari = vendor === "Apple Computer, Inc." && ua.includes("Safari/") && !ua.includes("Chrome/") && !ua.includes("Chromium/") && !ua.includes("CriOS/") && !ua.includes("FxiOS/") && !ua.includes("EdgiOS/");
+  const isChromium = ua.includes("Chrome/") || ua.includes("Chromium/") || ua.includes("CriOS/") || ua.includes("Edg/");
+  cachedEngineProfile = {
+    lineFitEpsilon: isSafari ? 1 / 64 : 5e-3,
+    carryCJKAfterClosingQuote: isChromium,
+    preferPrefixWidthsForBreakableRuns: isSafari,
+    preferEarlySoftHyphenBreak: isSafari
+  };
+  return cachedEngineProfile;
+}
+function parseFontSize(font) {
+  const m3 = font.match(/(\d+(?:\.\d+)?)\s*px/);
+  return m3 ? parseFloat(m3[1]) : 16;
+}
+function getSharedGraphemeSegmenter() {
+  if (sharedGraphemeSegmenter === null) {
+    sharedGraphemeSegmenter = new Intl.Segmenter(void 0, { granularity: "grapheme" });
+  }
+  return sharedGraphemeSegmenter;
+}
+function isEmojiGrapheme(g3) {
+  return emojiPresentationRe.test(g3) || g3.includes("\uFE0F");
+}
+function textMayContainEmoji(text) {
+  return maybeEmojiRe.test(text);
+}
+function getEmojiCorrection(font, fontSize2) {
+  let correction = emojiCorrectionCache.get(font);
+  if (correction !== void 0)
+    return correction;
+  const ctx = getMeasureContext();
+  ctx.font = font;
+  const canvasW = ctx.measureText("\u{1F600}").width;
+  correction = 0;
+  if (canvasW > fontSize2 + 0.5 && typeof document !== "undefined" && document.body !== null) {
+    const span = document.createElement("span");
+    span.style.font = font;
+    span.style.display = "inline-block";
+    span.style.visibility = "hidden";
+    span.style.position = "absolute";
+    span.textContent = "\u{1F600}";
+    document.body.appendChild(span);
+    const domW = span.getBoundingClientRect().width;
+    document.body.removeChild(span);
+    if (canvasW - domW > 0.5) {
+      correction = canvasW - domW;
+    }
+  }
+  emojiCorrectionCache.set(font, correction);
+  return correction;
+}
+function countEmojiGraphemes(text) {
+  let count = 0;
+  const graphemeSegmenter = getSharedGraphemeSegmenter();
+  for (const g3 of graphemeSegmenter.segment(text)) {
+    if (isEmojiGrapheme(g3.segment))
+      count++;
+  }
+  return count;
+}
+function getEmojiCount(seg, metrics) {
+  if (metrics.emojiCount === void 0) {
+    metrics.emojiCount = countEmojiGraphemes(seg);
+  }
+  return metrics.emojiCount;
+}
+function getCorrectedSegmentWidth(seg, metrics, emojiCorrection) {
+  if (emojiCorrection === 0)
+    return metrics.width;
+  return metrics.width - getEmojiCount(seg, metrics) * emojiCorrection;
+}
+function getSegmentGraphemeWidths(seg, metrics, cache2, emojiCorrection) {
+  if (metrics.graphemeWidths !== void 0)
+    return metrics.graphemeWidths;
+  const widths = [];
+  const graphemeSegmenter = getSharedGraphemeSegmenter();
+  for (const gs of graphemeSegmenter.segment(seg)) {
+    const graphemeMetrics = getSegmentMetrics(gs.segment, cache2);
+    widths.push(getCorrectedSegmentWidth(gs.segment, graphemeMetrics, emojiCorrection));
+  }
+  metrics.graphemeWidths = widths.length > 1 ? widths : null;
+  return metrics.graphemeWidths;
+}
+function getSegmentGraphemePrefixWidths(seg, metrics, cache2, emojiCorrection) {
+  if (metrics.graphemePrefixWidths !== void 0)
+    return metrics.graphemePrefixWidths;
+  const prefixWidths = [];
+  const graphemeSegmenter = getSharedGraphemeSegmenter();
+  let prefix = "";
+  for (const gs of graphemeSegmenter.segment(seg)) {
+    prefix += gs.segment;
+    const prefixMetrics = getSegmentMetrics(prefix, cache2);
+    prefixWidths.push(getCorrectedSegmentWidth(prefix, prefixMetrics, emojiCorrection));
+  }
+  metrics.graphemePrefixWidths = prefixWidths.length > 1 ? prefixWidths : null;
+  return metrics.graphemePrefixWidths;
+}
+function getFontMeasurementState(font, needsEmojiCorrection) {
+  const ctx = getMeasureContext();
+  ctx.font = font;
+  const cache2 = getSegmentMetricCache(font);
+  const fontSize2 = parseFontSize(font);
+  const emojiCorrection = needsEmojiCorrection ? getEmojiCorrection(font, fontSize2) : 0;
+  return { cache: cache2, fontSize: fontSize2, emojiCorrection };
+}
+function clearMeasurementCaches() {
+  segmentMetricCaches.clear();
+  emojiCorrectionCache.clear();
+  sharedGraphemeSegmenter = null;
+}
+var measureContext, segmentMetricCaches, cachedEngineProfile, emojiPresentationRe, maybeEmojiRe, sharedGraphemeSegmenter, emojiCorrectionCache;
+var init_measurement = __esm({
+  "node_modules/@chenglou/pretext/dist/measurement.js"() {
+    "use strict";
+    init_analysis();
+    measureContext = null;
+    segmentMetricCaches = /* @__PURE__ */ new Map();
+    cachedEngineProfile = null;
+    emojiPresentationRe = /\p{Emoji_Presentation}/u;
+    maybeEmojiRe = /[\p{Emoji_Presentation}\p{Extended_Pictographic}\p{Regional_Indicator}\uFE0F\u20E3]/u;
+    sharedGraphemeSegmenter = null;
+    emojiCorrectionCache = /* @__PURE__ */ new Map();
+  }
+});
+
+// node_modules/@chenglou/pretext/dist/line-break.js
+function canBreakAfter(kind) {
+  return kind === "space" || kind === "preserved-space" || kind === "tab" || kind === "zero-width-break" || kind === "soft-hyphen";
+}
+function isSimpleCollapsibleSpace(kind) {
+  return kind === "space";
+}
+function getTabAdvance(lineWidth, tabStopAdvance) {
+  if (tabStopAdvance <= 0)
+    return 0;
+  const remainder = lineWidth % tabStopAdvance;
+  if (Math.abs(remainder) <= 1e-6)
+    return tabStopAdvance;
+  return tabStopAdvance - remainder;
+}
+function getBreakableAdvance(graphemeWidths, graphemePrefixWidths, graphemeIndex, preferPrefixWidths) {
+  if (!preferPrefixWidths || graphemePrefixWidths === null) {
+    return graphemeWidths[graphemeIndex];
+  }
+  return graphemePrefixWidths[graphemeIndex] - (graphemeIndex > 0 ? graphemePrefixWidths[graphemeIndex - 1] : 0);
+}
+function fitSoftHyphenBreak(graphemeWidths, initialWidth, maxWidth, lineFitEpsilon, discretionaryHyphenWidth, cumulativeWidths) {
+  let fitCount = 0;
+  let fittedWidth = initialWidth;
+  while (fitCount < graphemeWidths.length) {
+    const nextWidth = cumulativeWidths ? initialWidth + graphemeWidths[fitCount] : fittedWidth + graphemeWidths[fitCount];
+    const nextLineWidth = fitCount + 1 < graphemeWidths.length ? nextWidth + discretionaryHyphenWidth : nextWidth;
+    if (nextLineWidth > maxWidth + lineFitEpsilon)
+      break;
+    fittedWidth = nextWidth;
+    fitCount++;
+  }
+  return { fitCount, fittedWidth };
+}
+function findChunkIndexForStart(prepared, segmentIndex) {
+  for (let i7 = 0; i7 < prepared.chunks.length; i7++) {
+    const chunk = prepared.chunks[i7];
+    if (segmentIndex < chunk.consumedEndSegmentIndex)
+      return i7;
+  }
+  return -1;
+}
+function normalizeLineStart(prepared, start) {
+  let segmentIndex = start.segmentIndex;
+  const graphemeIndex = start.graphemeIndex;
+  if (segmentIndex >= prepared.widths.length)
+    return null;
+  if (graphemeIndex > 0)
+    return start;
+  const chunkIndex = findChunkIndexForStart(prepared, segmentIndex);
+  if (chunkIndex < 0)
+    return null;
+  const chunk = prepared.chunks[chunkIndex];
+  if (chunk.startSegmentIndex === chunk.endSegmentIndex && segmentIndex === chunk.startSegmentIndex) {
+    return { segmentIndex, graphemeIndex: 0 };
+  }
+  if (segmentIndex < chunk.startSegmentIndex)
+    segmentIndex = chunk.startSegmentIndex;
+  while (segmentIndex < chunk.endSegmentIndex) {
+    const kind = prepared.kinds[segmentIndex];
+    if (kind !== "space" && kind !== "zero-width-break" && kind !== "soft-hyphen") {
+      return { segmentIndex, graphemeIndex: 0 };
+    }
+    segmentIndex++;
+  }
+  if (chunk.consumedEndSegmentIndex >= prepared.widths.length)
+    return null;
+  return { segmentIndex: chunk.consumedEndSegmentIndex, graphemeIndex: 0 };
+}
+function countPreparedLines(prepared, maxWidth) {
+  if (prepared.simpleLineWalkFastPath) {
+    return countPreparedLinesSimple(prepared, maxWidth);
+  }
+  return walkPreparedLines(prepared, maxWidth);
+}
+function countPreparedLinesSimple(prepared, maxWidth) {
+  const { widths, kinds, breakableWidths, breakablePrefixWidths } = prepared;
+  if (widths.length === 0)
+    return 0;
+  const engineProfile = getEngineProfile();
+  const lineFitEpsilon = engineProfile.lineFitEpsilon;
+  let lineCount = 0;
+  let lineW = 0;
+  let hasContent2 = false;
+  function placeOnFreshLine(segmentIndex) {
+    const w3 = widths[segmentIndex];
+    if (w3 > maxWidth && breakableWidths[segmentIndex] !== null) {
+      const gWidths = breakableWidths[segmentIndex];
+      const gPrefixWidths = breakablePrefixWidths[segmentIndex] ?? null;
+      lineW = 0;
+      for (let g3 = 0; g3 < gWidths.length; g3++) {
+        const gw = getBreakableAdvance(gWidths, gPrefixWidths, g3, engineProfile.preferPrefixWidthsForBreakableRuns);
+        if (lineW > 0 && lineW + gw > maxWidth + lineFitEpsilon) {
+          lineCount++;
+          lineW = gw;
+        } else {
+          if (lineW === 0)
+            lineCount++;
+          lineW += gw;
+        }
+      }
+    } else {
+      lineW = w3;
+      lineCount++;
+    }
+    hasContent2 = true;
+  }
+  for (let i7 = 0; i7 < widths.length; i7++) {
+    const w3 = widths[i7];
+    const kind = kinds[i7];
+    if (!hasContent2) {
+      placeOnFreshLine(i7);
+      continue;
+    }
+    const newW = lineW + w3;
+    if (newW > maxWidth + lineFitEpsilon) {
+      if (isSimpleCollapsibleSpace(kind))
+        continue;
+      lineW = 0;
+      hasContent2 = false;
+      placeOnFreshLine(i7);
+      continue;
+    }
+    lineW = newW;
+  }
+  if (!hasContent2)
+    return lineCount + 1;
+  return lineCount;
+}
+function walkPreparedLinesSimple(prepared, maxWidth, onLine) {
+  const { widths, kinds, breakableWidths, breakablePrefixWidths } = prepared;
+  if (widths.length === 0)
+    return 0;
+  const engineProfile = getEngineProfile();
+  const lineFitEpsilon = engineProfile.lineFitEpsilon;
+  let lineCount = 0;
+  let lineW = 0;
+  let hasContent2 = false;
+  let lineStartSegmentIndex = 0;
+  let lineStartGraphemeIndex = 0;
+  let lineEndSegmentIndex = 0;
+  let lineEndGraphemeIndex = 0;
+  let pendingBreakSegmentIndex = -1;
+  let pendingBreakPaintWidth = 0;
+  function clearPendingBreak() {
+    pendingBreakSegmentIndex = -1;
+    pendingBreakPaintWidth = 0;
+  }
+  function emitCurrentLine(endSegmentIndex = lineEndSegmentIndex, endGraphemeIndex = lineEndGraphemeIndex, width = lineW) {
+    lineCount++;
+    onLine?.({
+      startSegmentIndex: lineStartSegmentIndex,
+      startGraphemeIndex: lineStartGraphemeIndex,
+      endSegmentIndex,
+      endGraphemeIndex,
+      width
+    });
+    lineW = 0;
+    hasContent2 = false;
+    clearPendingBreak();
+  }
+  function startLineAtSegment(segmentIndex, width) {
+    hasContent2 = true;
+    lineStartSegmentIndex = segmentIndex;
+    lineStartGraphemeIndex = 0;
+    lineEndSegmentIndex = segmentIndex + 1;
+    lineEndGraphemeIndex = 0;
+    lineW = width;
+  }
+  function startLineAtGrapheme(segmentIndex, graphemeIndex, width) {
+    hasContent2 = true;
+    lineStartSegmentIndex = segmentIndex;
+    lineStartGraphemeIndex = graphemeIndex;
+    lineEndSegmentIndex = segmentIndex;
+    lineEndGraphemeIndex = graphemeIndex + 1;
+    lineW = width;
+  }
+  function appendWholeSegment(segmentIndex, width) {
+    if (!hasContent2) {
+      startLineAtSegment(segmentIndex, width);
+      return;
+    }
+    lineW += width;
+    lineEndSegmentIndex = segmentIndex + 1;
+    lineEndGraphemeIndex = 0;
+  }
+  function updatePendingBreak(segmentIndex, segmentWidth) {
+    if (!canBreakAfter(kinds[segmentIndex]))
+      return;
+    pendingBreakSegmentIndex = segmentIndex + 1;
+    pendingBreakPaintWidth = lineW - segmentWidth;
+  }
+  function appendBreakableSegment(segmentIndex) {
+    appendBreakableSegmentFrom(segmentIndex, 0);
+  }
+  function appendBreakableSegmentFrom(segmentIndex, startGraphemeIndex) {
+    const gWidths = breakableWidths[segmentIndex];
+    const gPrefixWidths = breakablePrefixWidths[segmentIndex] ?? null;
+    for (let g3 = startGraphemeIndex; g3 < gWidths.length; g3++) {
+      const gw = getBreakableAdvance(gWidths, gPrefixWidths, g3, engineProfile.preferPrefixWidthsForBreakableRuns);
+      if (!hasContent2) {
+        startLineAtGrapheme(segmentIndex, g3, gw);
+        continue;
+      }
+      if (lineW + gw > maxWidth + lineFitEpsilon) {
+        emitCurrentLine();
+        startLineAtGrapheme(segmentIndex, g3, gw);
+      } else {
+        lineW += gw;
+        lineEndSegmentIndex = segmentIndex;
+        lineEndGraphemeIndex = g3 + 1;
+      }
+    }
+    if (hasContent2 && lineEndSegmentIndex === segmentIndex && lineEndGraphemeIndex === gWidths.length) {
+      lineEndSegmentIndex = segmentIndex + 1;
+      lineEndGraphemeIndex = 0;
+    }
+  }
+  let i7 = 0;
+  while (i7 < widths.length) {
+    const w3 = widths[i7];
+    const kind = kinds[i7];
+    if (!hasContent2) {
+      if (w3 > maxWidth && breakableWidths[i7] !== null) {
+        appendBreakableSegment(i7);
+      } else {
+        startLineAtSegment(i7, w3);
+      }
+      updatePendingBreak(i7, w3);
+      i7++;
+      continue;
+    }
+    const newW = lineW + w3;
+    if (newW > maxWidth + lineFitEpsilon) {
+      if (canBreakAfter(kind)) {
+        appendWholeSegment(i7, w3);
+        emitCurrentLine(i7 + 1, 0, lineW - w3);
+        i7++;
+        continue;
+      }
+      if (pendingBreakSegmentIndex >= 0) {
+        emitCurrentLine(pendingBreakSegmentIndex, 0, pendingBreakPaintWidth);
+        continue;
+      }
+      if (w3 > maxWidth && breakableWidths[i7] !== null) {
+        emitCurrentLine();
+        appendBreakableSegment(i7);
+        i7++;
+        continue;
+      }
+      emitCurrentLine();
+      continue;
+    }
+    appendWholeSegment(i7, w3);
+    updatePendingBreak(i7, w3);
+    i7++;
+  }
+  if (hasContent2)
+    emitCurrentLine();
+  return lineCount;
+}
+function walkPreparedLines(prepared, maxWidth, onLine) {
+  if (prepared.simpleLineWalkFastPath) {
+    return walkPreparedLinesSimple(prepared, maxWidth, onLine);
+  }
+  const { widths, lineEndFitAdvances, lineEndPaintAdvances, kinds, breakableWidths, breakablePrefixWidths, discretionaryHyphenWidth, tabStopAdvance, chunks } = prepared;
+  if (widths.length === 0 || chunks.length === 0)
+    return 0;
+  const engineProfile = getEngineProfile();
+  const lineFitEpsilon = engineProfile.lineFitEpsilon;
+  let lineCount = 0;
+  let lineW = 0;
+  let hasContent2 = false;
+  let lineStartSegmentIndex = 0;
+  let lineStartGraphemeIndex = 0;
+  let lineEndSegmentIndex = 0;
+  let lineEndGraphemeIndex = 0;
+  let pendingBreakSegmentIndex = -1;
+  let pendingBreakFitWidth = 0;
+  let pendingBreakPaintWidth = 0;
+  let pendingBreakKind = null;
+  function clearPendingBreak() {
+    pendingBreakSegmentIndex = -1;
+    pendingBreakFitWidth = 0;
+    pendingBreakPaintWidth = 0;
+    pendingBreakKind = null;
+  }
+  function emitCurrentLine(endSegmentIndex = lineEndSegmentIndex, endGraphemeIndex = lineEndGraphemeIndex, width = lineW) {
+    lineCount++;
+    onLine?.({
+      startSegmentIndex: lineStartSegmentIndex,
+      startGraphemeIndex: lineStartGraphemeIndex,
+      endSegmentIndex,
+      endGraphemeIndex,
+      width
+    });
+    lineW = 0;
+    hasContent2 = false;
+    clearPendingBreak();
+  }
+  function startLineAtSegment(segmentIndex, width) {
+    hasContent2 = true;
+    lineStartSegmentIndex = segmentIndex;
+    lineStartGraphemeIndex = 0;
+    lineEndSegmentIndex = segmentIndex + 1;
+    lineEndGraphemeIndex = 0;
+    lineW = width;
+  }
+  function startLineAtGrapheme(segmentIndex, graphemeIndex, width) {
+    hasContent2 = true;
+    lineStartSegmentIndex = segmentIndex;
+    lineStartGraphemeIndex = graphemeIndex;
+    lineEndSegmentIndex = segmentIndex;
+    lineEndGraphemeIndex = graphemeIndex + 1;
+    lineW = width;
+  }
+  function appendWholeSegment(segmentIndex, width) {
+    if (!hasContent2) {
+      startLineAtSegment(segmentIndex, width);
+      return;
+    }
+    lineW += width;
+    lineEndSegmentIndex = segmentIndex + 1;
+    lineEndGraphemeIndex = 0;
+  }
+  function updatePendingBreakForWholeSegment(segmentIndex, segmentWidth) {
+    if (!canBreakAfter(kinds[segmentIndex]))
+      return;
+    const fitAdvance = kinds[segmentIndex] === "tab" ? 0 : lineEndFitAdvances[segmentIndex];
+    const paintAdvance = kinds[segmentIndex] === "tab" ? segmentWidth : lineEndPaintAdvances[segmentIndex];
+    pendingBreakSegmentIndex = segmentIndex + 1;
+    pendingBreakFitWidth = lineW - segmentWidth + fitAdvance;
+    pendingBreakPaintWidth = lineW - segmentWidth + paintAdvance;
+    pendingBreakKind = kinds[segmentIndex];
+  }
+  function appendBreakableSegment(segmentIndex) {
+    appendBreakableSegmentFrom(segmentIndex, 0);
+  }
+  function appendBreakableSegmentFrom(segmentIndex, startGraphemeIndex) {
+    const gWidths = breakableWidths[segmentIndex];
+    const gPrefixWidths = breakablePrefixWidths[segmentIndex] ?? null;
+    for (let g3 = startGraphemeIndex; g3 < gWidths.length; g3++) {
+      const gw = getBreakableAdvance(gWidths, gPrefixWidths, g3, engineProfile.preferPrefixWidthsForBreakableRuns);
+      if (!hasContent2) {
+        startLineAtGrapheme(segmentIndex, g3, gw);
+        continue;
+      }
+      if (lineW + gw > maxWidth + lineFitEpsilon) {
+        emitCurrentLine();
+        startLineAtGrapheme(segmentIndex, g3, gw);
+      } else {
+        lineW += gw;
+        lineEndSegmentIndex = segmentIndex;
+        lineEndGraphemeIndex = g3 + 1;
+      }
+    }
+    if (hasContent2 && lineEndSegmentIndex === segmentIndex && lineEndGraphemeIndex === gWidths.length) {
+      lineEndSegmentIndex = segmentIndex + 1;
+      lineEndGraphemeIndex = 0;
+    }
+  }
+  function continueSoftHyphenBreakableSegment(segmentIndex) {
+    if (pendingBreakKind !== "soft-hyphen")
+      return false;
+    const gWidths = breakableWidths[segmentIndex];
+    if (gWidths === null)
+      return false;
+    const fitWidths = engineProfile.preferPrefixWidthsForBreakableRuns ? breakablePrefixWidths[segmentIndex] ?? gWidths : gWidths;
+    const usesPrefixWidths = fitWidths !== gWidths;
+    const { fitCount, fittedWidth } = fitSoftHyphenBreak(fitWidths, lineW, maxWidth, lineFitEpsilon, discretionaryHyphenWidth, usesPrefixWidths);
+    if (fitCount === 0)
+      return false;
+    lineW = fittedWidth;
+    lineEndSegmentIndex = segmentIndex;
+    lineEndGraphemeIndex = fitCount;
+    clearPendingBreak();
+    if (fitCount === gWidths.length) {
+      lineEndSegmentIndex = segmentIndex + 1;
+      lineEndGraphemeIndex = 0;
+      return true;
+    }
+    emitCurrentLine(segmentIndex, fitCount, fittedWidth + discretionaryHyphenWidth);
+    appendBreakableSegmentFrom(segmentIndex, fitCount);
+    return true;
+  }
+  function emitEmptyChunk(chunk) {
+    lineCount++;
+    onLine?.({
+      startSegmentIndex: chunk.startSegmentIndex,
+      startGraphemeIndex: 0,
+      endSegmentIndex: chunk.consumedEndSegmentIndex,
+      endGraphemeIndex: 0,
+      width: 0
+    });
+    clearPendingBreak();
+  }
+  for (let chunkIndex = 0; chunkIndex < chunks.length; chunkIndex++) {
+    const chunk = chunks[chunkIndex];
+    if (chunk.startSegmentIndex === chunk.endSegmentIndex) {
+      emitEmptyChunk(chunk);
+      continue;
+    }
+    hasContent2 = false;
+    lineW = 0;
+    lineStartSegmentIndex = chunk.startSegmentIndex;
+    lineStartGraphemeIndex = 0;
+    lineEndSegmentIndex = chunk.startSegmentIndex;
+    lineEndGraphemeIndex = 0;
+    clearPendingBreak();
+    let i7 = chunk.startSegmentIndex;
+    while (i7 < chunk.endSegmentIndex) {
+      const kind = kinds[i7];
+      const w3 = kind === "tab" ? getTabAdvance(lineW, tabStopAdvance) : widths[i7];
+      if (kind === "soft-hyphen") {
+        if (hasContent2) {
+          lineEndSegmentIndex = i7 + 1;
+          lineEndGraphemeIndex = 0;
+          pendingBreakSegmentIndex = i7 + 1;
+          pendingBreakFitWidth = lineW + discretionaryHyphenWidth;
+          pendingBreakPaintWidth = lineW + discretionaryHyphenWidth;
+          pendingBreakKind = kind;
+        }
+        i7++;
+        continue;
+      }
+      if (!hasContent2) {
+        if (w3 > maxWidth && breakableWidths[i7] !== null) {
+          appendBreakableSegment(i7);
+        } else {
+          startLineAtSegment(i7, w3);
+        }
+        updatePendingBreakForWholeSegment(i7, w3);
+        i7++;
+        continue;
+      }
+      const newW = lineW + w3;
+      if (newW > maxWidth + lineFitEpsilon) {
+        const currentBreakFitWidth = lineW + (kind === "tab" ? 0 : lineEndFitAdvances[i7]);
+        const currentBreakPaintWidth = lineW + (kind === "tab" ? w3 : lineEndPaintAdvances[i7]);
+        if (pendingBreakKind === "soft-hyphen" && engineProfile.preferEarlySoftHyphenBreak && pendingBreakFitWidth <= maxWidth + lineFitEpsilon) {
+          emitCurrentLine(pendingBreakSegmentIndex, 0, pendingBreakPaintWidth);
+          continue;
+        }
+        if (pendingBreakKind === "soft-hyphen" && continueSoftHyphenBreakableSegment(i7)) {
+          i7++;
+          continue;
+        }
+        if (canBreakAfter(kind) && currentBreakFitWidth <= maxWidth + lineFitEpsilon) {
+          appendWholeSegment(i7, w3);
+          emitCurrentLine(i7 + 1, 0, currentBreakPaintWidth);
+          i7++;
+          continue;
+        }
+        if (pendingBreakSegmentIndex >= 0 && pendingBreakFitWidth <= maxWidth + lineFitEpsilon) {
+          emitCurrentLine(pendingBreakSegmentIndex, 0, pendingBreakPaintWidth);
+          continue;
+        }
+        if (w3 > maxWidth && breakableWidths[i7] !== null) {
+          emitCurrentLine();
+          appendBreakableSegment(i7);
+          i7++;
+          continue;
+        }
+        emitCurrentLine();
+        continue;
+      }
+      appendWholeSegment(i7, w3);
+      updatePendingBreakForWholeSegment(i7, w3);
+      i7++;
+    }
+    if (hasContent2) {
+      const finalPaintWidth = pendingBreakSegmentIndex === chunk.consumedEndSegmentIndex ? pendingBreakPaintWidth : lineW;
+      emitCurrentLine(chunk.consumedEndSegmentIndex, 0, finalPaintWidth);
+    }
+  }
+  return lineCount;
+}
+function layoutNextLineRange(prepared, start, maxWidth) {
+  const normalizedStart = normalizeLineStart(prepared, start);
+  if (normalizedStart === null)
+    return null;
+  if (prepared.simpleLineWalkFastPath) {
+    return layoutNextLineRangeSimple(prepared, normalizedStart, maxWidth);
+  }
+  const chunkIndex = findChunkIndexForStart(prepared, normalizedStart.segmentIndex);
+  if (chunkIndex < 0)
+    return null;
+  const chunk = prepared.chunks[chunkIndex];
+  if (chunk.startSegmentIndex === chunk.endSegmentIndex) {
+    return {
+      startSegmentIndex: chunk.startSegmentIndex,
+      startGraphemeIndex: 0,
+      endSegmentIndex: chunk.consumedEndSegmentIndex,
+      endGraphemeIndex: 0,
+      width: 0
+    };
+  }
+  const { widths, lineEndFitAdvances, lineEndPaintAdvances, kinds, breakableWidths, breakablePrefixWidths, discretionaryHyphenWidth, tabStopAdvance } = prepared;
+  const engineProfile = getEngineProfile();
+  const lineFitEpsilon = engineProfile.lineFitEpsilon;
+  let lineW = 0;
+  let hasContent2 = false;
+  const lineStartSegmentIndex = normalizedStart.segmentIndex;
+  const lineStartGraphemeIndex = normalizedStart.graphemeIndex;
+  let lineEndSegmentIndex = lineStartSegmentIndex;
+  let lineEndGraphemeIndex = lineStartGraphemeIndex;
+  let pendingBreakSegmentIndex = -1;
+  let pendingBreakFitWidth = 0;
+  let pendingBreakPaintWidth = 0;
+  let pendingBreakKind = null;
+  function clearPendingBreak() {
+    pendingBreakSegmentIndex = -1;
+    pendingBreakFitWidth = 0;
+    pendingBreakPaintWidth = 0;
+    pendingBreakKind = null;
+  }
+  function finishLine(endSegmentIndex = lineEndSegmentIndex, endGraphemeIndex = lineEndGraphemeIndex, width = lineW) {
+    if (!hasContent2)
+      return null;
+    return {
+      startSegmentIndex: lineStartSegmentIndex,
+      startGraphemeIndex: lineStartGraphemeIndex,
+      endSegmentIndex,
+      endGraphemeIndex,
+      width
+    };
+  }
+  function startLineAtSegment(segmentIndex, width) {
+    hasContent2 = true;
+    lineEndSegmentIndex = segmentIndex + 1;
+    lineEndGraphemeIndex = 0;
+    lineW = width;
+  }
+  function startLineAtGrapheme(segmentIndex, graphemeIndex, width) {
+    hasContent2 = true;
+    lineEndSegmentIndex = segmentIndex;
+    lineEndGraphemeIndex = graphemeIndex + 1;
+    lineW = width;
+  }
+  function appendWholeSegment(segmentIndex, width) {
+    if (!hasContent2) {
+      startLineAtSegment(segmentIndex, width);
+      return;
+    }
+    lineW += width;
+    lineEndSegmentIndex = segmentIndex + 1;
+    lineEndGraphemeIndex = 0;
+  }
+  function updatePendingBreakForWholeSegment(segmentIndex, segmentWidth) {
+    if (!canBreakAfter(kinds[segmentIndex]))
+      return;
+    const fitAdvance = kinds[segmentIndex] === "tab" ? 0 : lineEndFitAdvances[segmentIndex];
+    const paintAdvance = kinds[segmentIndex] === "tab" ? segmentWidth : lineEndPaintAdvances[segmentIndex];
+    pendingBreakSegmentIndex = segmentIndex + 1;
+    pendingBreakFitWidth = lineW - segmentWidth + fitAdvance;
+    pendingBreakPaintWidth = lineW - segmentWidth + paintAdvance;
+    pendingBreakKind = kinds[segmentIndex];
+  }
+  function appendBreakableSegmentFrom(segmentIndex, startGraphemeIndex) {
+    const gWidths = breakableWidths[segmentIndex];
+    const gPrefixWidths = breakablePrefixWidths[segmentIndex] ?? null;
+    for (let g3 = startGraphemeIndex; g3 < gWidths.length; g3++) {
+      const gw = getBreakableAdvance(gWidths, gPrefixWidths, g3, engineProfile.preferPrefixWidthsForBreakableRuns);
+      if (!hasContent2) {
+        startLineAtGrapheme(segmentIndex, g3, gw);
+        continue;
+      }
+      if (lineW + gw > maxWidth + lineFitEpsilon) {
+        return finishLine();
+      }
+      lineW += gw;
+      lineEndSegmentIndex = segmentIndex;
+      lineEndGraphemeIndex = g3 + 1;
+    }
+    if (hasContent2 && lineEndSegmentIndex === segmentIndex && lineEndGraphemeIndex === gWidths.length) {
+      lineEndSegmentIndex = segmentIndex + 1;
+      lineEndGraphemeIndex = 0;
+    }
+    return null;
+  }
+  function maybeFinishAtSoftHyphen(segmentIndex) {
+    if (pendingBreakKind !== "soft-hyphen" || pendingBreakSegmentIndex < 0)
+      return null;
+    const gWidths = breakableWidths[segmentIndex] ?? null;
+    if (gWidths !== null) {
+      const fitWidths = engineProfile.preferPrefixWidthsForBreakableRuns ? breakablePrefixWidths[segmentIndex] ?? gWidths : gWidths;
+      const usesPrefixWidths = fitWidths !== gWidths;
+      const { fitCount, fittedWidth } = fitSoftHyphenBreak(fitWidths, lineW, maxWidth, lineFitEpsilon, discretionaryHyphenWidth, usesPrefixWidths);
+      if (fitCount === gWidths.length) {
+        lineW = fittedWidth;
+        lineEndSegmentIndex = segmentIndex + 1;
+        lineEndGraphemeIndex = 0;
+        clearPendingBreak();
+        return null;
+      }
+      if (fitCount > 0) {
+        return finishLine(segmentIndex, fitCount, fittedWidth + discretionaryHyphenWidth);
+      }
+    }
+    if (pendingBreakFitWidth <= maxWidth + lineFitEpsilon) {
+      return finishLine(pendingBreakSegmentIndex, 0, pendingBreakPaintWidth);
+    }
+    return null;
+  }
+  for (let i7 = normalizedStart.segmentIndex; i7 < chunk.endSegmentIndex; i7++) {
+    const kind = kinds[i7];
+    const startGraphemeIndex = i7 === normalizedStart.segmentIndex ? normalizedStart.graphemeIndex : 0;
+    const w3 = kind === "tab" ? getTabAdvance(lineW, tabStopAdvance) : widths[i7];
+    if (kind === "soft-hyphen" && startGraphemeIndex === 0) {
+      if (hasContent2) {
+        lineEndSegmentIndex = i7 + 1;
+        lineEndGraphemeIndex = 0;
+        pendingBreakSegmentIndex = i7 + 1;
+        pendingBreakFitWidth = lineW + discretionaryHyphenWidth;
+        pendingBreakPaintWidth = lineW + discretionaryHyphenWidth;
+        pendingBreakKind = kind;
+      }
+      continue;
+    }
+    if (!hasContent2) {
+      if (startGraphemeIndex > 0) {
+        const line = appendBreakableSegmentFrom(i7, startGraphemeIndex);
+        if (line !== null)
+          return line;
+      } else if (w3 > maxWidth && breakableWidths[i7] !== null) {
+        const line = appendBreakableSegmentFrom(i7, 0);
+        if (line !== null)
+          return line;
+      } else {
+        startLineAtSegment(i7, w3);
+      }
+      updatePendingBreakForWholeSegment(i7, w3);
+      continue;
+    }
+    const newW = lineW + w3;
+    if (newW > maxWidth + lineFitEpsilon) {
+      const currentBreakFitWidth = lineW + (kind === "tab" ? 0 : lineEndFitAdvances[i7]);
+      const currentBreakPaintWidth = lineW + (kind === "tab" ? w3 : lineEndPaintAdvances[i7]);
+      if (pendingBreakKind === "soft-hyphen" && engineProfile.preferEarlySoftHyphenBreak && pendingBreakFitWidth <= maxWidth + lineFitEpsilon) {
+        return finishLine(pendingBreakSegmentIndex, 0, pendingBreakPaintWidth);
+      }
+      const softBreakLine = maybeFinishAtSoftHyphen(i7);
+      if (softBreakLine !== null)
+        return softBreakLine;
+      if (canBreakAfter(kind) && currentBreakFitWidth <= maxWidth + lineFitEpsilon) {
+        appendWholeSegment(i7, w3);
+        return finishLine(i7 + 1, 0, currentBreakPaintWidth);
+      }
+      if (pendingBreakSegmentIndex >= 0 && pendingBreakFitWidth <= maxWidth + lineFitEpsilon) {
+        return finishLine(pendingBreakSegmentIndex, 0, pendingBreakPaintWidth);
+      }
+      if (w3 > maxWidth && breakableWidths[i7] !== null) {
+        const currentLine = finishLine();
+        if (currentLine !== null)
+          return currentLine;
+        const line = appendBreakableSegmentFrom(i7, 0);
+        if (line !== null)
+          return line;
+      }
+      return finishLine();
+    }
+    appendWholeSegment(i7, w3);
+    updatePendingBreakForWholeSegment(i7, w3);
+  }
+  if (pendingBreakSegmentIndex === chunk.consumedEndSegmentIndex && lineEndGraphemeIndex === 0) {
+    return finishLine(chunk.consumedEndSegmentIndex, 0, pendingBreakPaintWidth);
+  }
+  return finishLine(chunk.consumedEndSegmentIndex, 0, lineW);
+}
+function layoutNextLineRangeSimple(prepared, normalizedStart, maxWidth) {
+  const { widths, kinds, breakableWidths, breakablePrefixWidths } = prepared;
+  const engineProfile = getEngineProfile();
+  const lineFitEpsilon = engineProfile.lineFitEpsilon;
+  let lineW = 0;
+  let hasContent2 = false;
+  const lineStartSegmentIndex = normalizedStart.segmentIndex;
+  const lineStartGraphemeIndex = normalizedStart.graphemeIndex;
+  let lineEndSegmentIndex = lineStartSegmentIndex;
+  let lineEndGraphemeIndex = lineStartGraphemeIndex;
+  let pendingBreakSegmentIndex = -1;
+  let pendingBreakPaintWidth = 0;
+  function finishLine(endSegmentIndex = lineEndSegmentIndex, endGraphemeIndex = lineEndGraphemeIndex, width = lineW) {
+    if (!hasContent2)
+      return null;
+    return {
+      startSegmentIndex: lineStartSegmentIndex,
+      startGraphemeIndex: lineStartGraphemeIndex,
+      endSegmentIndex,
+      endGraphemeIndex,
+      width
+    };
+  }
+  function startLineAtSegment(segmentIndex, width) {
+    hasContent2 = true;
+    lineEndSegmentIndex = segmentIndex + 1;
+    lineEndGraphemeIndex = 0;
+    lineW = width;
+  }
+  function startLineAtGrapheme(segmentIndex, graphemeIndex, width) {
+    hasContent2 = true;
+    lineEndSegmentIndex = segmentIndex;
+    lineEndGraphemeIndex = graphemeIndex + 1;
+    lineW = width;
+  }
+  function appendWholeSegment(segmentIndex, width) {
+    if (!hasContent2) {
+      startLineAtSegment(segmentIndex, width);
+      return;
+    }
+    lineW += width;
+    lineEndSegmentIndex = segmentIndex + 1;
+    lineEndGraphemeIndex = 0;
+  }
+  function updatePendingBreak(segmentIndex, segmentWidth) {
+    if (!canBreakAfter(kinds[segmentIndex]))
+      return;
+    pendingBreakSegmentIndex = segmentIndex + 1;
+    pendingBreakPaintWidth = lineW - segmentWidth;
+  }
+  function appendBreakableSegmentFrom(segmentIndex, startGraphemeIndex) {
+    const gWidths = breakableWidths[segmentIndex];
+    const gPrefixWidths = breakablePrefixWidths[segmentIndex] ?? null;
+    for (let g3 = startGraphemeIndex; g3 < gWidths.length; g3++) {
+      const gw = getBreakableAdvance(gWidths, gPrefixWidths, g3, engineProfile.preferPrefixWidthsForBreakableRuns);
+      if (!hasContent2) {
+        startLineAtGrapheme(segmentIndex, g3, gw);
+        continue;
+      }
+      if (lineW + gw > maxWidth + lineFitEpsilon) {
+        return finishLine();
+      }
+      lineW += gw;
+      lineEndSegmentIndex = segmentIndex;
+      lineEndGraphemeIndex = g3 + 1;
+    }
+    if (hasContent2 && lineEndSegmentIndex === segmentIndex && lineEndGraphemeIndex === gWidths.length) {
+      lineEndSegmentIndex = segmentIndex + 1;
+      lineEndGraphemeIndex = 0;
+    }
+    return null;
+  }
+  for (let i7 = normalizedStart.segmentIndex; i7 < widths.length; i7++) {
+    const w3 = widths[i7];
+    const kind = kinds[i7];
+    const startGraphemeIndex = i7 === normalizedStart.segmentIndex ? normalizedStart.graphemeIndex : 0;
+    if (!hasContent2) {
+      if (startGraphemeIndex > 0) {
+        const line = appendBreakableSegmentFrom(i7, startGraphemeIndex);
+        if (line !== null)
+          return line;
+      } else if (w3 > maxWidth && breakableWidths[i7] !== null) {
+        const line = appendBreakableSegmentFrom(i7, 0);
+        if (line !== null)
+          return line;
+      } else {
+        startLineAtSegment(i7, w3);
+      }
+      updatePendingBreak(i7, w3);
+      continue;
+    }
+    const newW = lineW + w3;
+    if (newW > maxWidth + lineFitEpsilon) {
+      if (canBreakAfter(kind)) {
+        appendWholeSegment(i7, w3);
+        return finishLine(i7 + 1, 0, lineW - w3);
+      }
+      if (pendingBreakSegmentIndex >= 0) {
+        return finishLine(pendingBreakSegmentIndex, 0, pendingBreakPaintWidth);
+      }
+      if (w3 > maxWidth && breakableWidths[i7] !== null) {
+        const currentLine = finishLine();
+        if (currentLine !== null)
+          return currentLine;
+        const line = appendBreakableSegmentFrom(i7, 0);
+        if (line !== null)
+          return line;
+      }
+      return finishLine();
+    }
+    appendWholeSegment(i7, w3);
+    updatePendingBreak(i7, w3);
+  }
+  return finishLine();
+}
+var init_line_break = __esm({
+  "node_modules/@chenglou/pretext/dist/line-break.js"() {
+    "use strict";
+    init_measurement();
+  }
+});
+
+// node_modules/@chenglou/pretext/dist/layout.js
+function getSharedGraphemeSegmenter2() {
+  if (sharedGraphemeSegmenter2 === null) {
+    sharedGraphemeSegmenter2 = new Intl.Segmenter(void 0, { granularity: "grapheme" });
+  }
+  return sharedGraphemeSegmenter2;
+}
+function createEmptyPrepared(includeSegments) {
+  if (includeSegments) {
+    return {
+      widths: [],
+      lineEndFitAdvances: [],
+      lineEndPaintAdvances: [],
+      kinds: [],
+      simpleLineWalkFastPath: true,
+      segLevels: null,
+      breakableWidths: [],
+      breakablePrefixWidths: [],
+      discretionaryHyphenWidth: 0,
+      tabStopAdvance: 0,
+      chunks: [],
+      segments: []
+    };
+  }
+  return {
+    widths: [],
+    lineEndFitAdvances: [],
+    lineEndPaintAdvances: [],
+    kinds: [],
+    simpleLineWalkFastPath: true,
+    segLevels: null,
+    breakableWidths: [],
+    breakablePrefixWidths: [],
+    discretionaryHyphenWidth: 0,
+    tabStopAdvance: 0,
+    chunks: []
+  };
+}
+function measureAnalysis(analysis, font, includeSegments) {
+  const graphemeSegmenter = getSharedGraphemeSegmenter2();
+  const engineProfile = getEngineProfile();
+  const { cache: cache2, emojiCorrection } = getFontMeasurementState(font, textMayContainEmoji(analysis.normalized));
+  const discretionaryHyphenWidth = getCorrectedSegmentWidth("-", getSegmentMetrics("-", cache2), emojiCorrection);
+  const spaceWidth = getCorrectedSegmentWidth(" ", getSegmentMetrics(" ", cache2), emojiCorrection);
+  const tabStopAdvance = spaceWidth * 8;
+  if (analysis.len === 0)
+    return createEmptyPrepared(includeSegments);
+  const widths = [];
+  const lineEndFitAdvances = [];
+  const lineEndPaintAdvances = [];
+  const kinds = [];
+  let simpleLineWalkFastPath = analysis.chunks.length <= 1;
+  const segStarts = includeSegments ? [] : null;
+  const breakableWidths = [];
+  const breakablePrefixWidths = [];
+  const segments = includeSegments ? [] : null;
+  const preparedStartByAnalysisIndex = Array.from({ length: analysis.len });
+  const preparedEndByAnalysisIndex = Array.from({ length: analysis.len });
+  function pushMeasuredSegment(text, width, lineEndFitAdvance, lineEndPaintAdvance, kind, start, breakable, breakablePrefix) {
+    if (kind !== "text" && kind !== "space" && kind !== "zero-width-break") {
+      simpleLineWalkFastPath = false;
+    }
+    widths.push(width);
+    lineEndFitAdvances.push(lineEndFitAdvance);
+    lineEndPaintAdvances.push(lineEndPaintAdvance);
+    kinds.push(kind);
+    segStarts?.push(start);
+    breakableWidths.push(breakable);
+    breakablePrefixWidths.push(breakablePrefix);
+    if (segments !== null)
+      segments.push(text);
+  }
+  for (let mi2 = 0; mi2 < analysis.len; mi2++) {
+    preparedStartByAnalysisIndex[mi2] = widths.length;
+    const segText = analysis.texts[mi2];
+    const segWordLike = analysis.isWordLike[mi2];
+    const segKind = analysis.kinds[mi2];
+    const segStart = analysis.starts[mi2];
+    if (segKind === "soft-hyphen") {
+      pushMeasuredSegment(segText, 0, discretionaryHyphenWidth, discretionaryHyphenWidth, segKind, segStart, null, null);
+      preparedEndByAnalysisIndex[mi2] = widths.length;
+      continue;
+    }
+    if (segKind === "hard-break") {
+      pushMeasuredSegment(segText, 0, 0, 0, segKind, segStart, null, null);
+      preparedEndByAnalysisIndex[mi2] = widths.length;
+      continue;
+    }
+    if (segKind === "tab") {
+      pushMeasuredSegment(segText, 0, 0, 0, segKind, segStart, null, null);
+      preparedEndByAnalysisIndex[mi2] = widths.length;
+      continue;
+    }
+    const segMetrics = getSegmentMetrics(segText, cache2);
+    if (segKind === "text" && segMetrics.containsCJK) {
+      let unitText = "";
+      let unitStart = 0;
+      for (const gs of graphemeSegmenter.segment(segText)) {
+        const grapheme = gs.segment;
+        if (unitText.length === 0) {
+          unitText = grapheme;
+          unitStart = gs.index;
+          continue;
+        }
+        if (kinsokuEnd.has(unitText) || kinsokuStart.has(grapheme) || leftStickyPunctuation.has(grapheme) || engineProfile.carryCJKAfterClosingQuote && isCJK(grapheme) && endsWithClosingQuote(unitText)) {
+          unitText += grapheme;
+          continue;
+        }
+        const unitMetrics = getSegmentMetrics(unitText, cache2);
+        const w5 = getCorrectedSegmentWidth(unitText, unitMetrics, emojiCorrection);
+        pushMeasuredSegment(unitText, w5, w5, w5, "text", segStart + unitStart, null, null);
+        unitText = grapheme;
+        unitStart = gs.index;
+      }
+      if (unitText.length > 0) {
+        const unitMetrics = getSegmentMetrics(unitText, cache2);
+        const w5 = getCorrectedSegmentWidth(unitText, unitMetrics, emojiCorrection);
+        pushMeasuredSegment(unitText, w5, w5, w5, "text", segStart + unitStart, null, null);
+      }
+      preparedEndByAnalysisIndex[mi2] = widths.length;
+      continue;
+    }
+    const w3 = getCorrectedSegmentWidth(segText, segMetrics, emojiCorrection);
+    const lineEndFitAdvance = segKind === "space" || segKind === "preserved-space" || segKind === "zero-width-break" ? 0 : w3;
+    const lineEndPaintAdvance = segKind === "space" || segKind === "zero-width-break" ? 0 : w3;
+    if (segWordLike && segText.length > 1) {
+      const graphemeWidths = getSegmentGraphemeWidths(segText, segMetrics, cache2, emojiCorrection);
+      const graphemePrefixWidths = engineProfile.preferPrefixWidthsForBreakableRuns ? getSegmentGraphemePrefixWidths(segText, segMetrics, cache2, emojiCorrection) : null;
+      pushMeasuredSegment(segText, w3, lineEndFitAdvance, lineEndPaintAdvance, segKind, segStart, graphemeWidths, graphemePrefixWidths);
+    } else {
+      pushMeasuredSegment(segText, w3, lineEndFitAdvance, lineEndPaintAdvance, segKind, segStart, null, null);
+    }
+    preparedEndByAnalysisIndex[mi2] = widths.length;
+  }
+  const chunks = mapAnalysisChunksToPreparedChunks(analysis.chunks, preparedStartByAnalysisIndex, preparedEndByAnalysisIndex);
+  const segLevels = segStarts === null ? null : computeSegmentLevels(analysis.normalized, segStarts);
+  if (segments !== null) {
+    return {
+      widths,
+      lineEndFitAdvances,
+      lineEndPaintAdvances,
+      kinds,
+      simpleLineWalkFastPath,
+      segLevels,
+      breakableWidths,
+      breakablePrefixWidths,
+      discretionaryHyphenWidth,
+      tabStopAdvance,
+      chunks,
+      segments
+    };
+  }
+  return {
+    widths,
+    lineEndFitAdvances,
+    lineEndPaintAdvances,
+    kinds,
+    simpleLineWalkFastPath,
+    segLevels,
+    breakableWidths,
+    breakablePrefixWidths,
+    discretionaryHyphenWidth,
+    tabStopAdvance,
+    chunks
+  };
+}
+function mapAnalysisChunksToPreparedChunks(chunks, preparedStartByAnalysisIndex, preparedEndByAnalysisIndex) {
+  const preparedChunks = [];
+  for (let i7 = 0; i7 < chunks.length; i7++) {
+    const chunk = chunks[i7];
+    const startSegmentIndex = chunk.startSegmentIndex < preparedStartByAnalysisIndex.length ? preparedStartByAnalysisIndex[chunk.startSegmentIndex] : preparedEndByAnalysisIndex[preparedEndByAnalysisIndex.length - 1] ?? 0;
+    const endSegmentIndex = chunk.endSegmentIndex < preparedStartByAnalysisIndex.length ? preparedStartByAnalysisIndex[chunk.endSegmentIndex] : preparedEndByAnalysisIndex[preparedEndByAnalysisIndex.length - 1] ?? 0;
+    const consumedEndSegmentIndex = chunk.consumedEndSegmentIndex < preparedStartByAnalysisIndex.length ? preparedStartByAnalysisIndex[chunk.consumedEndSegmentIndex] : preparedEndByAnalysisIndex[preparedEndByAnalysisIndex.length - 1] ?? 0;
+    preparedChunks.push({
+      startSegmentIndex,
+      endSegmentIndex,
+      consumedEndSegmentIndex
+    });
+  }
+  return preparedChunks;
+}
+function prepareInternal(text, font, includeSegments, options) {
+  const analysis = analyzeText(text, getEngineProfile(), options?.whiteSpace);
+  return measureAnalysis(analysis, font, includeSegments);
+}
+function prepare(text, font, options) {
+  return prepareInternal(text, font, false, options);
+}
+function prepareWithSegments(text, font, options) {
+  return prepareInternal(text, font, true, options);
+}
+function getInternalPrepared(prepared) {
+  return prepared;
+}
+function layout(prepared, maxWidth, lineHeight2) {
+  const lineCount = countPreparedLines(getInternalPrepared(prepared), maxWidth);
+  return { lineCount, height: lineCount * lineHeight2 };
+}
+function getSegmentGraphemes(segmentIndex, segments, cache2) {
+  let graphemes = cache2.get(segmentIndex);
+  if (graphemes !== void 0)
+    return graphemes;
+  graphemes = [];
+  const graphemeSegmenter = getSharedGraphemeSegmenter2();
+  for (const gs of graphemeSegmenter.segment(segments[segmentIndex])) {
+    graphemes.push(gs.segment);
+  }
+  cache2.set(segmentIndex, graphemes);
+  return graphemes;
+}
+function getLineTextCache(prepared) {
+  let cache2 = sharedLineTextCaches.get(prepared);
+  if (cache2 !== void 0)
+    return cache2;
+  cache2 = /* @__PURE__ */ new Map();
+  sharedLineTextCaches.set(prepared, cache2);
+  return cache2;
+}
+function lineHasDiscretionaryHyphen(kinds, startSegmentIndex, startGraphemeIndex, endSegmentIndex) {
+  return endSegmentIndex > 0 && kinds[endSegmentIndex - 1] === "soft-hyphen" && !(startSegmentIndex === endSegmentIndex && startGraphemeIndex > 0);
+}
+function buildLineTextFromRange(segments, kinds, cache2, startSegmentIndex, startGraphemeIndex, endSegmentIndex, endGraphemeIndex) {
+  let text = "";
+  const endsWithDiscretionaryHyphen = lineHasDiscretionaryHyphen(kinds, startSegmentIndex, startGraphemeIndex, endSegmentIndex);
+  for (let i7 = startSegmentIndex; i7 < endSegmentIndex; i7++) {
+    if (kinds[i7] === "soft-hyphen" || kinds[i7] === "hard-break")
+      continue;
+    if (i7 === startSegmentIndex && startGraphemeIndex > 0) {
+      text += getSegmentGraphemes(i7, segments, cache2).slice(startGraphemeIndex).join("");
+    } else {
+      text += segments[i7];
+    }
+  }
+  if (endGraphemeIndex > 0) {
+    if (endsWithDiscretionaryHyphen)
+      text += "-";
+    text += getSegmentGraphemes(endSegmentIndex, segments, cache2).slice(startSegmentIndex === endSegmentIndex ? startGraphemeIndex : 0, endGraphemeIndex).join("");
+  } else if (endsWithDiscretionaryHyphen) {
+    text += "-";
+  }
+  return text;
+}
+function createLayoutLine(prepared, cache2, width, startSegmentIndex, startGraphemeIndex, endSegmentIndex, endGraphemeIndex) {
+  return {
+    text: buildLineTextFromRange(prepared.segments, prepared.kinds, cache2, startSegmentIndex, startGraphemeIndex, endSegmentIndex, endGraphemeIndex),
+    width,
+    start: {
+      segmentIndex: startSegmentIndex,
+      graphemeIndex: startGraphemeIndex
+    },
+    end: {
+      segmentIndex: endSegmentIndex,
+      graphemeIndex: endGraphemeIndex
+    }
+  };
+}
+function materializeLayoutLine(prepared, cache2, line) {
+  return createLayoutLine(prepared, cache2, line.width, line.startSegmentIndex, line.startGraphemeIndex, line.endSegmentIndex, line.endGraphemeIndex);
+}
+function toLayoutLineRange(line) {
+  return {
+    width: line.width,
+    start: {
+      segmentIndex: line.startSegmentIndex,
+      graphemeIndex: line.startGraphemeIndex
+    },
+    end: {
+      segmentIndex: line.endSegmentIndex,
+      graphemeIndex: line.endGraphemeIndex
+    }
+  };
+}
+function stepLineRange(prepared, start, maxWidth) {
+  const line = layoutNextLineRange(prepared, start, maxWidth);
+  if (line === null)
+    return null;
+  return toLayoutLineRange(line);
+}
+function materializeLine(prepared, line) {
+  return createLayoutLine(prepared, getLineTextCache(prepared), line.width, line.start.segmentIndex, line.start.graphemeIndex, line.end.segmentIndex, line.end.graphemeIndex);
+}
+function walkLineRanges(prepared, maxWidth, onLine) {
+  if (prepared.widths.length === 0)
+    return 0;
+  return walkPreparedLines(getInternalPrepared(prepared), maxWidth, (line) => {
+    onLine(toLayoutLineRange(line));
+  });
+}
+function layoutNextLine(prepared, start, maxWidth) {
+  const line = stepLineRange(prepared, start, maxWidth);
+  if (line === null)
+    return null;
+  return materializeLine(prepared, line);
+}
+function layoutWithLines(prepared, maxWidth, lineHeight2) {
+  const lines = [];
+  if (prepared.widths.length === 0)
+    return { lineCount: 0, height: 0, lines };
+  const graphemeCache = getLineTextCache(prepared);
+  const lineCount = walkPreparedLines(getInternalPrepared(prepared), maxWidth, (line) => {
+    lines.push(materializeLayoutLine(prepared, graphemeCache, line));
+  });
+  return { lineCount, height: lineCount * lineHeight2, lines };
+}
+function clearCache() {
+  clearAnalysisCaches();
+  sharedGraphemeSegmenter2 = null;
+  sharedLineTextCaches = /* @__PURE__ */ new WeakMap();
+  clearMeasurementCaches();
+}
+var sharedGraphemeSegmenter2, sharedLineTextCaches;
+var init_layout = __esm({
+  "node_modules/@chenglou/pretext/dist/layout.js"() {
+    "use strict";
+    init_bidi();
+    init_analysis();
+    init_measurement();
+    init_line_break();
+    sharedGraphemeSegmenter2 = null;
+    sharedLineTextCaches = /* @__PURE__ */ new WeakMap();
+  }
+});
+
+// src/auto-ui/frontend/services/text-layout.ts
+var text_layout_exports = {};
+__export(text_layout_exports, {
+  clearCache: () => clearCache,
+  fitFontSize: () => fitFontSize,
+  fitWidth: () => fitWidth,
+  flowTextAroundObstacles: () => flowTextAroundObstacles,
+  layout: () => layout,
+  layoutColumns: () => layoutColumns,
+  layoutNextLine: () => layoutNextLine,
+  layoutWithLines: () => layoutWithLines,
+  measureHeight: () => measureHeight,
+  prepare: () => prepare,
+  prepareWithSegments: () => prepareWithSegments,
+  walkLineRanges: () => walkLineRanges
+});
+function measureHeight(text, font, maxWidth, lineHeight2) {
+  const p5 = prepare(text, font);
+  return layout(p5, maxWidth, lineHeight2).height;
+}
+function fitWidth(text, font, lineHeight2, targetLines, minWidth = 40, maxWidth = 2e3) {
+  const p5 = prepare(text, font);
+  let lo2 = minWidth;
+  let hi2 = maxWidth;
+  const maxResult = layout(p5, hi2, lineHeight2);
+  if (maxResult.lineCount > targetLines) return hi2;
+  while (hi2 - lo2 > 1) {
+    const mid = (lo2 + hi2) / 2;
+    const result = layout(p5, mid, lineHeight2);
+    if (result.lineCount <= targetLines) {
+      hi2 = mid;
+    } else {
+      lo2 = mid;
+    }
+  }
+  return hi2;
+}
+function fitFontSize(text, fontFamily2, maxWidth, maxHeight, lineHeightRatio = 1.5, minSize = 8, maxSize = 120) {
+  let lo2 = minSize;
+  let hi2 = maxSize;
+  while (hi2 - lo2 > 0.5) {
+    const mid = (lo2 + hi2) / 2;
+    const font = `${mid}px ${fontFamily2}`;
+    const lh = mid * lineHeightRatio;
+    const p5 = prepare(text, font);
+    const result = layout(p5, maxWidth, lh);
+    if (result.height <= maxHeight) {
+      lo2 = mid;
+    } else {
+      hi2 = mid;
+    }
+  }
+  return Math.floor(lo2);
+}
+function flowTextAroundObstacles(text, font, containerWidth, lineHeight2, obstacles) {
+  const prepared = prepareWithSegments(text, font);
+  const lines = [];
+  let cursor2 = { segmentIndex: 0, graphemeIndex: 0 };
+  let y5 = 0;
+  while (true) {
+    const { x: x3, width } = getAvailableSpan(y5, lineHeight2, containerWidth, obstacles);
+    if (width < 20) {
+      y5 += lineHeight2;
+      continue;
+    }
+    const line = layoutNextLine(prepared, cursor2, width);
+    if (!line) break;
+    lines.push({
+      text: line.text,
+      x: x3,
+      y: y5,
+      width: line.width
+    });
+    cursor2 = line.end;
+    y5 += lineHeight2;
+  }
+  return lines;
+}
+function getAvailableSpan(y5, lineHeight2, containerWidth, obstacles) {
+  let left = 0;
+  let right = containerWidth;
+  for (const obs of obstacles) {
+    const pad = obs.padding ?? 8;
+    const obsTop = obs.y - pad;
+    const obsBottom = obs.y + obs.height + pad;
+    const obsLeft = obs.x - pad;
+    const obsRight = obs.x + obs.width + pad;
+    if (y5 + lineHeight2 > obsTop && y5 < obsBottom) {
+      if (obsLeft <= left + 10) {
+        left = Math.max(left, obsRight);
+      } else if (obsRight >= right - 10) {
+        right = Math.min(right, obsLeft);
+      } else {
+        const leftGap = obsLeft - left;
+        const rightGap = right - obsRight;
+        if (leftGap >= rightGap) {
+          right = obsLeft;
+        } else {
+          left = obsRight;
+        }
+      }
+    }
+  }
+  return { x: left, width: Math.max(0, right - left) };
+}
+function layoutColumns(text, font, totalWidth, lineHeight2, columnCount, gap = 24) {
+  const colWidth = (totalWidth - gap * (columnCount - 1)) / columnCount;
+  const prepared = prepareWithSegments(text, font);
+  const singleCol = layoutWithLines(prepared, colWidth, lineHeight2);
+  const targetHeight = Math.ceil(singleCol.height / columnCount);
+  const columns = [];
+  let cursor2 = { segmentIndex: 0, graphemeIndex: 0 };
+  for (let col = 0; col < columnCount; col++) {
+    const colLines = [];
+    const colX = col * (colWidth + gap);
+    let y5 = 0;
+    while (y5 < targetHeight + lineHeight2) {
+      const line = layoutNextLine(prepared, cursor2, colWidth);
+      if (!line) break;
+      colLines.push({ text: line.text, x: colX, y: y5, width: line.width });
+      cursor2 = line.end;
+      y5 += lineHeight2;
+    }
+    columns.push(colLines);
+    if (!layoutNextLine(prepared, cursor2, colWidth)) break;
+  }
+  const maxColHeight = Math.max(...columns.map((col) => col.length * lineHeight2));
+  return { columns, totalHeight: maxColHeight };
+}
+var init_text_layout = __esm({
+  "src/auto-ui/frontend/services/text-layout.ts"() {
+    "use strict";
+    init_layout();
+  }
+});
+
 // node_modules/@lit/reactive-element/css-tag.js
 var t = globalThis;
 var e = t.ShadowRoot && (void 0 === t.ShadyCSS || t.ShadyCSS.nativeShadow) && "adoptedStyleSheets" in Document.prototype && "replace" in CSSStyleSheet.prototype;
@@ -16006,6 +18876,91 @@ var motion = i`
     }
   }
 
+  /* ═══ SKELETON LOADING ═══ */
+
+  @keyframes skeleton-shimmer {
+    0% {
+      background-position: -200% 0;
+    }
+    100% {
+      background-position: 200% 0;
+    }
+  }
+
+  .skeleton {
+    background: linear-gradient(
+      90deg,
+      var(--bg-glass, rgba(255, 255, 255, 0.03)) 25%,
+      var(--bg-tertiary, rgba(255, 255, 255, 0.06)) 50%,
+      var(--bg-glass, rgba(255, 255, 255, 0.03)) 75%
+    );
+    background-size: 200% 100%;
+    animation: skeleton-shimmer 1.8s ease-in-out infinite;
+    border-radius: var(--radius-sm, 4px);
+  }
+
+  .skeleton-line {
+    height: 14px;
+    margin-bottom: 8px;
+  }
+
+  .skeleton-line.short {
+    width: 40%;
+  }
+  .skeleton-line.medium {
+    width: 65%;
+  }
+  .skeleton-line.long {
+    width: 90%;
+  }
+
+  .skeleton-block {
+    height: 100px;
+    margin-bottom: 12px;
+  }
+
+  .skeleton-circle {
+    width: 36px;
+    height: 36px;
+    border-radius: 50%;
+  }
+
+  /* Pre-built skeleton layouts */
+  .skeleton-list {
+    display: flex;
+    flex-direction: column;
+    gap: 1px;
+    padding: 4px 0;
+  }
+
+  .skeleton-list-item {
+    display: flex;
+    align-items: center;
+    gap: 10px;
+    padding: 10px 12px;
+  }
+
+  .skeleton-list-item .skeleton-line {
+    margin-bottom: 0;
+  }
+
+  .skeleton-table {
+    display: flex;
+    flex-direction: column;
+    gap: 2px;
+  }
+
+  .skeleton-table-row {
+    display: flex;
+    gap: 12px;
+    padding: 8px 12px;
+  }
+
+  .skeleton-table-row .skeleton-line {
+    flex: 1;
+    margin-bottom: 0;
+  }
+
   /* ═══ SLIDE TRANSITIONS (for @format slides) ═══ */
 
   .motion-slide-transition-fade {
@@ -16107,6 +19062,10 @@ var ToastManager = class extends i4 {
                   <path d="M18 6L6 18M6 6l12 12" />
                 </svg>
               </button>
+              ${toast.duration > 0 ? b2`<div
+                    class="toast-progress"
+                    style="animation-duration:${toast.duration}ms"
+                  ></div>` : ""}
             </div>
           `
     )}
@@ -16250,6 +19209,48 @@ ToastManager.styles = [
         background: var(--bg-glass);
         border-color: var(--accent-secondary);
       }
+
+      /* Progress countdown bar */
+      .toast-progress {
+        position: absolute;
+        bottom: 0;
+        left: 0;
+        height: 2px;
+        border-radius: 0 0 var(--radius-sm) var(--radius-sm);
+        animation: toast-countdown linear forwards;
+      }
+
+      @keyframes toast-countdown {
+        from {
+          width: 100%;
+        }
+        to {
+          width: 0%;
+        }
+      }
+
+      .toast.success .toast-progress {
+        background: var(--color-success);
+      }
+      .toast.error .toast-progress {
+        background: var(--color-error);
+      }
+      .toast.info .toast-progress {
+        background: var(--accent-secondary);
+      }
+      .toast.warning .toast-progress {
+        background: var(--color-warning);
+      }
+
+      .toast {
+        position: relative;
+        overflow: hidden;
+      }
+
+      /* Pause countdown on hover */
+      .toast:hover .toast-progress {
+        animation-play-state: paused;
+      }
     `
 ];
 ToastManager.instance = null;
@@ -20753,10 +23754,26 @@ var BeamApp = class extends i4 {
   /**
    * Handle clicking a global static method card
    */
+  _triggerPageTransition() {
+    const mainArea = this.shadowRoot?.querySelector(".main-area");
+    if (mainArea) {
+      mainArea.classList.remove("page-transitioning");
+      void mainArea.offsetWidth;
+      mainArea.classList.add("page-transitioning");
+      mainArea.addEventListener(
+        "animationend",
+        () => {
+          mainArea.classList.remove("page-transitioning");
+        },
+        { once: true }
+      );
+    }
+  }
   _handleGlobalMethodSelect(photon, method) {
     this._teardownActiveCustomUI();
     if (this._selectedPhoton?.name !== photon.name) {
       this._closeSecondPanel();
+      this._triggerPageTransition();
     }
     this._selectedPhoton = photon;
     this._lastFormParams = {};
@@ -23107,9 +26124,11 @@ ${photon.errorMessage || "Unknown error"}</pre
             .layoutHints=${this._selectedMethod?.layoutHints}
             .photonName=${this._selectedPhoton?.name}
             .theme=${this._theme}
+            .loading=${this._isExecuting && !this._lastResult}
             .live=${this._currentCollectionName !== null}
             .resultKey=${this._selectedPhoton && this._selectedMethod ? `${this._selectedPhoton.name}/${this._selectedMethod.name}` : void 0}
             @share=${() => this._handleShareResult()}
+            @checklist-action=${(e8) => this._handleChecklistAction(e8)}
           ></result-viewer>
         </div>
       `;
@@ -23312,16 +26331,16 @@ ${photon.errorMessage || "Unknown error"}</pre
               ></invoke-form>
               ${this._viewMode === "full" ? b2`
                     <div class="form-chrome">
-                      <button
-                        class="btn-secondary"
-                        @click=${() => {
+                      ${hasParams ? b2`<button
+                            class="btn-secondary"
+                            @click=${() => {
       const form = this.shadowRoot?.querySelector("invoke-form");
       form?.handleCancel();
     }}
-                        ?disabled=${opts.executing}
-                      >
-                        Cancel
-                      </button>
+                            ?disabled=${opts.executing}
+                          >
+                            Cancel
+                          </button>` : ""}
                       <button
                         class="btn-primary"
                         @click=${() => {
@@ -23361,7 +26380,7 @@ ${photon.errorMessage || "Unknown error"}</pre
                 ></custom-ui-renderer>
               ` : b2`
                 ${this._viewMode === "full" && opts.method?.outputFormat !== "slides" && !opts.appSurface ? b2`<div class="result-chrome">
-                      <span class="result-chrome-title">Result</span>
+                      <span class="result-chrome-title"></span>
                       <div class="result-chrome-actions">
                         <button
                           @click=${() => {
@@ -23391,6 +26410,7 @@ ${photon.errorMessage || "Unknown error"}</pre
                   .live=${this._currentCollectionName !== null}
                   .resultKey=${opts.photon && opts.method ? `${opts.photon.name}/${opts.method.name}` : void 0}
                   @share=${() => this._handleShareResult()}
+                  @checklist-action=${(e8) => this._handleChecklistAction(e8)}
                 ></result-viewer>
               ` : b2`
               <div class="empty-state-inline result-empty">
@@ -24116,6 +27136,16 @@ ${photon.errorMessage || "Unknown error"}</pre
       iframe.contentWindow?.postMessage(message, "*");
     });
   }
+  // ===== Checklist Interactive Actions =====
+  async _handleChecklistAction(e8) {
+    const { action, args } = e8.detail;
+    if (!this._selectedPhoton) return;
+    const toolName = `${this._selectedPhoton.name}/${action}`;
+    try {
+      await mcpClient.callTool(toolName, args);
+    } catch {
+    }
+  }
   // ===== Share Result Link =====
   _handleShareResult() {
     if (!this._selectedPhoton || !this._selectedMethod) {
@@ -25609,6 +28639,22 @@ BeamApp.styles = [
         padding: var(--space-lg);
       }
 
+      /* Page transition when switching photons */
+      @keyframes page-enter {
+        from {
+          opacity: 0;
+          transform: translateY(6px);
+        }
+        to {
+          opacity: 1;
+          transform: translateY(0);
+        }
+      }
+
+      .main-area.page-transitioning {
+        animation: page-enter 0.2s var(--motion-ease-out, ease-out) both;
+      }
+
       .main-toolbar {
         display: flex;
         justify-content: space-between;
@@ -28243,6 +31289,8 @@ BeamSidebar.styles = [
       .photon-item.active {
         background: linear-gradient(90deg, var(--glow-primary), transparent);
         border-left: 2px solid var(--accent-primary);
+        color: var(--accent-primary);
+        font-weight: 500;
       }
 
       .photon-item.flash-highlight {
@@ -28264,12 +31312,10 @@ BeamSidebar.styles = [
 
       @keyframes warmth-fade {
         0% {
-          background: var(--color-warning);
-          opacity: 0.15;
+          background: hsla(38, 100%, 50%, 0.15);
         }
         100% {
-          background: var(--color-warning);
-          opacity: 0;
+          background: transparent;
         }
       }
 
@@ -32056,6 +35102,7 @@ var ResultViewer = class extends i4 {
     super(...arguments);
     this.result = null;
     this.theme = "dark";
+    this.loading = false;
     this._filterQuery = "";
     this._sortColumn = null;
     this._sortDirection = "asc";
@@ -32080,6 +35127,10 @@ var ResultViewer = class extends i4 {
     this._internalResult = null;
     // Layout determined by UI type unwrapping in updated() — consumed once by _selectLayout()
     this._unwrappedLayout = null;
+    this._checklistHideDone = false;
+    this._checklistDragIdx = null;
+    this._checklistToggledIdx = null;
+    this._checklistToggledDone = false;
     // Bridge old result across null-gap during execute cycles
     this._previousResult = null;
     // Recency heat: track when items were last added/updated
@@ -32584,26 +35635,47 @@ var ResultViewer = class extends i4 {
       }
     });
   }
+  _renderSkeleton() {
+    return b2`
+      <div class="container">
+        <div class="content content-structured" data-enter="fade-in">
+          <div class="skeleton-list">
+            ${[90, 70, 80, 55, 65].map(
+      (w3, i7) => b2`
+                <div class="skeleton-list-item" style="animation-delay:${i7 * 60}ms">
+                  <div class="skeleton skeleton-circle"></div>
+                  <div style="flex:1">
+                    <div class="skeleton skeleton-line" style="width:${w3}%"></div>
+                  </div>
+                </div>
+              `
+    )}
+          </div>
+        </div>
+      </div>
+    `;
+  }
   render() {
+    if (this.loading) return this._renderSkeleton();
     if (this.result === null || this.result === void 0) return b2``;
-    const layout = this._selectLayout();
+    const layout2 = this._selectLayout();
     const filteredData = this._getFilteredData();
     const totalCount = this._getTotalCount();
     const filteredCount = this._getFilteredCount(filteredData);
     const isFiltered = this._filterQuery.trim() !== "";
-    const isHtmlUiMode = layout === "html";
+    const isHtmlUiMode = layout2 === "html";
     if (isHtmlUiMode) {
       return b2`
-        <div class="html-ui-container">${this._renderContent(layout, filteredData)}</div>
+        <div class="html-ui-container">${this._renderContent(layout2, filteredData)}</div>
       `;
     }
     return b2`
       <div class="container">
         <div
-          class="content ${this._isTextLayout(layout) ? "content-text" : "content-structured"}"
+          class="content ${this._isTextLayout(layout2) ? "content-text" : "content-structured"}"
           data-enter="scale-in"
         >
-          ${this._renderContent(layout, filteredData)}
+          ${this._renderContent(layout2, filteredData)}
         </div>
       </div>
 
@@ -32809,8 +35881,8 @@ var ResultViewer = class extends i4 {
     const after = text.slice(index2 + query.length);
     return b2`${before}<span class="highlight">${match}</span>${this._highlightText(after)}`;
   }
-  _isTextLayout(layout) {
-    return layout === "json" || layout === "text" || layout === "code" || layout === "mermaid" || layout === "tree";
+  _isTextLayout(layout2) {
+    return layout2 === "json" || layout2 === "text" || layout2 === "code" || layout2 === "mermaid" || layout2 === "tree";
   }
   /**
    * Unwrap a purpose-driven UI type (Table, Chart, Stats, Cards, Progress)
@@ -32948,9 +36020,9 @@ var ResultViewer = class extends i4 {
   }
   _selectLayout() {
     if (this._unwrappedLayout) {
-      const layout = this._unwrappedLayout;
+      const layout2 = this._unwrappedLayout;
       this._unwrappedLayout = null;
-      return layout;
+      return layout2;
     }
     if (this.outputFormat) {
       const format = this.outputFormat.toLowerCase();
@@ -32980,7 +36052,9 @@ var ResultViewer = class extends i4 {
         "stack",
         "columns",
         "qr",
-        "slides"
+        "slides",
+        "checklist",
+        "article"
       ].includes(format)) {
         return format;
       }
@@ -33016,6 +36090,7 @@ var ResultViewer = class extends i4 {
       }
       if (data.every((item) => typeof item === "object" && item !== null)) {
         const sample2 = data[0];
+        if (this._isChecklistShaped(data)) return "checklist";
         if (this._isCartShaped(data)) return "cart";
         if (data.length >= 3) {
           const hasDate = this._hasDateLikeFields(sample2);
@@ -33112,9 +36187,9 @@ var ResultViewer = class extends i4 {
    * should fall through to the default (JSON) view instead of producing
    * a broken or nonsensical rendering.
    */
-  _matchesFormat(layout, data) {
+  _matchesFormat(layout2, data) {
     if (data === null || data === void 0) return true;
-    switch (layout) {
+    switch (layout2) {
       case "qr":
         if (typeof data === "string") return true;
         if (typeof data === "object") {
@@ -33134,21 +36209,25 @@ var ResultViewer = class extends i4 {
         return typeof data === "string";
       case "slides":
         return typeof data === "string";
+      case "checklist":
+        return Array.isArray(data);
+      case "article":
+        return typeof data === "object" && data !== null && typeof data.text === "string";
       default:
         return true;
     }
   }
-  _renderContent(layout, filteredData) {
+  _renderContent(layout2, filteredData) {
     if (filteredData === null) {
       return b2`<div class="empty-state">No matches found</div>`;
     }
     if (filteredData && filteredData._error) {
       return this._renderErrorCard(filteredData.message || "Unknown error");
     }
-    if (!this._matchesFormat(layout, filteredData)) {
+    if (!this._matchesFormat(layout2, filteredData)) {
       return this._renderJson(filteredData);
     }
-    switch (layout) {
+    switch (layout2) {
       case "table":
         return this._renderTable(filteredData);
       case "list":
@@ -33195,6 +36274,10 @@ var ResultViewer = class extends i4 {
         return this._renderMermaid(filteredData);
       case "slides":
         return this._renderSlides(filteredData);
+      case "checklist":
+        return this._renderChecklist(filteredData);
+      case "article":
+        return this._renderArticle(filteredData);
       case "json":
       default:
         return this._renderJson(filteredData);
@@ -34258,7 +37341,7 @@ ${bridge}
     color: var(--color-on-surface-variant, inherit);
     border-bottom: 1px solid var(--color-outline-variant, rgba(128,128,128,0.1)); flex-shrink: 0; }
   .slide-body { flex: 1; padding: 16px 32px 12px; overflow: hidden;
-    display: flex; flex-direction: column; justify-content: start; }
+    display: flex; flex-direction: column; justify-content: center; }
   /* Title slides: vertically centered when content is minimal */
   .slide-body.title-slide { justify-content: center; align-items: flex-start; }
   /* Content slides: title anchored at top, remaining content distributed below
@@ -34285,7 +37368,7 @@ ${bridge}
   a { color: var(--color-primary, var(--accent, #79aef0)); }
   strong { color: var(--color-on-surface, var(--text-primary, inherit)); }
   /* Columns */
-  .slide-cols { display: grid; gap: 24px; height: 100%; align-items: start; }
+  .slide-cols { display: grid; gap: 24px; height: 100%; align-items: center; }
   .slide-cols-2 { grid-template-columns: 1fr 1fr; }
   .slide-cols-3 { grid-template-columns: 1fr 1fr 1fr; }
   .slide-cols-4 { grid-template-columns: 1fr 1fr 1fr 1fr; }
@@ -34314,9 +37397,10 @@ ${bridge}
   th, td { padding: 8px 12px; border-bottom: 1px solid var(--color-outline-variant, var(--border-muted, rgba(128,128,128,0.2))); text-align: left; }
   th { font-weight: 600; font-size: 0.85em; text-transform: uppercase; letter-spacing: 0.5px;
     color: var(--color-on-surface-variant, var(--text-secondary, #b3b3b3)); }
-  code { font-family: var(--font-mono, 'JetBrains Mono', 'Fira Code', monospace); font-size: 0.9em; }
+  code { font-family: var(--font-mono, 'JetBrains Mono', 'Fira Code', monospace); font-size: 1em; }
   pre { background: var(--color-surface-container, var(--bg-secondary, rgba(0,0,0,0.3)));
-    padding: 12px; border-radius: var(--radius-md, 8px); overflow-x: auto; position: relative; }
+    padding: 16px; border-radius: var(--radius-md, 8px); overflow-x: auto; position: relative;
+    font-size: 1.05em; line-height: 1.5; }
   .code-block-wrapper { position: relative; margin: 1em 0; }
   .code-block-wrapper pre { margin: 0; }
   .code-block-wrapper .language-label { position: absolute; top: 0; right: 0;
@@ -35639,6 +38723,35 @@ ${footerText || pageNum ? `<div class="slide-footer"><span>${footerText || ""}</
     try {
       const iframe = content2.querySelector(".slide-bridge-frame");
       if (iframe) return;
+      const padV = document.fullscreenElement ? 128 : 96;
+      const padH = document.fullscreenElement ? 240 : 128;
+      const viewH = viewport.clientHeight - padV;
+      const viewW = viewport.clientWidth - padH;
+      if (viewH <= 0 || viewW <= 0) return;
+      const pretext = window.__pretextModule;
+      const hasEmbeds = content2.querySelector(
+        "iframe, [data-method], canvas, svg, img, table, pre"
+      );
+      if (pretext && !hasEmbeds) {
+        const textContent = content2.textContent || "";
+        if (textContent.trim()) {
+          const fontSize2 = 18;
+          const font = `${fontSize2}px -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, sans-serif`;
+          const lineHeight2 = fontSize2 * 1.6;
+          const result = pretext.layout(pretext.prepare(textContent, font), viewW, lineHeight2);
+          const contentH2 = result.height + 48;
+          if (contentH2 > 0) {
+            const zoom2 = Math.min(viewH / contentH2, 1.5);
+            const clampedZoom2 = Math.max(0.5, Math.min(2.5, zoom2));
+            const newZoom2 = Math.abs(clampedZoom2 - 1) > 0.02 ? String(clampedZoom2) : "";
+            if (newZoom2 !== this._slidesLastZoom) {
+              this._slidesLastZoom = newZoom2;
+              content2.style.zoom = newZoom2;
+            }
+            return;
+          }
+        }
+      }
       let prerender = root.querySelector(".slides-prerender");
       if (!prerender) {
         prerender = document.createElement("div");
@@ -35652,15 +38765,9 @@ ${footerText || pageNum ? `<div class="slide-footer"><span>${footerText || ""}</
         el2.replaceWith(placeholder);
       });
       prerender.style.zoom = "1";
-      const padV = document.fullscreenElement ? 128 : 96;
-      const padH = document.fullscreenElement ? 240 : 128;
-      const viewH = viewport.clientHeight - padV;
-      const viewW = viewport.clientWidth - padH;
       const contentH = prerender.scrollHeight;
       const contentW = prerender.scrollWidth;
-      if (contentH <= 0 || viewH <= 0 || contentW <= 0 || viewW <= 0) {
-        return;
-      }
+      if (contentH <= 0 || contentW <= 0) return;
       const scaleH = viewH / contentH;
       const scaleW = viewW / contentW;
       const zoom = Math.min(scaleH, scaleW);
@@ -36123,6 +39230,309 @@ ${footerText || pageNum ? `<div class="slide-footer"><span>${footerText || ""}</
           </div>` : ""}
     </div>`;
   }
+  // ── Checklist Renderer ──
+  /** FLIP animation: record positions, let Lit re-render, animate from old→new */
+  _checklistFlip() {
+    const container = this.shadowRoot?.querySelector(".checklist-wrap");
+    if (!container) return;
+    const items = container.querySelectorAll(".checklist-item");
+    const oldRects = /* @__PURE__ */ new Map();
+    items.forEach((el2) => oldRects.set(el2, el2.getBoundingClientRect()));
+    requestAnimationFrame(() => {
+      const newItems = container.querySelectorAll(".checklist-item");
+      newItems.forEach((el2) => {
+        const oldRect = oldRects.get(el2);
+        if (!oldRect) return;
+        const newRect = el2.getBoundingClientRect();
+        const deltaY = oldRect.top - newRect.top;
+        if (Math.abs(deltaY) < 1) return;
+        el2.style.transform = `translateY(${deltaY}px)`;
+        el2.style.transition = "none";
+        requestAnimationFrame(() => {
+          el2.style.transition = "transform 0.3s cubic-bezier(0.2, 0, 0, 1)";
+          el2.style.transform = "";
+          el2.addEventListener(
+            "transitionend",
+            () => {
+              el2.style.transition = "";
+            },
+            { once: true }
+          );
+        });
+      });
+    });
+  }
+  _checklistTextKey(item) {
+    return item.text || item.title || item.name || item.task || item.label || "";
+  }
+  _checklistIsDone(item) {
+    return !!(item.done || item.completed || item.checked);
+  }
+  _checklistSorted(items) {
+    const undone = items.filter((i7) => !this._checklistIsDone(i7));
+    const done = items.filter((i7) => this._checklistIsDone(i7));
+    return [...undone, ...done];
+  }
+  _checklistToggle(item, idx) {
+    const text = this._checklistTextKey(item);
+    const newDone = !this._checklistIsDone(item);
+    this._checklistToggledIdx = idx;
+    this._checklistToggledDone = newDone;
+    this._checklistFlip();
+    if ("done" in item) item.done = newDone;
+    else if ("completed" in item) item.completed = newDone;
+    else if ("checked" in item) item.checked = newDone;
+    else item.done = newDone;
+    this.requestUpdate();
+    setTimeout(() => {
+      this._checklistToggledIdx = null;
+    }, 350);
+    this.dispatchEvent(
+      new CustomEvent("checklist-action", {
+        bubbles: true,
+        composed: true,
+        detail: { action: "check", args: { text, done: newDone } }
+      })
+    );
+  }
+  _checklistDragStart(e8, idx) {
+    this._checklistDragIdx = idx;
+    const el2 = e8.currentTarget;
+    requestAnimationFrame(() => el2.classList.add("dragging"));
+    if (e8.dataTransfer) {
+      e8.dataTransfer.effectAllowed = "move";
+    }
+  }
+  _checklistDrop(items, dropIdx) {
+    const dragIdx = this._checklistDragIdx;
+    if (dragIdx === null || dragIdx === dropIdx) {
+      this._checklistDragIdx = null;
+      return;
+    }
+    this._checklistFlip();
+    const moved = items.splice(dragIdx, 1)[0];
+    items.splice(dropIdx, 0, moved);
+    this._checklistDragIdx = null;
+    this.requestUpdate();
+    const order = items.map((i7) => this._checklistTextKey(i7));
+    this.dispatchEvent(
+      new CustomEvent("checklist-action", {
+        bubbles: true,
+        composed: true,
+        detail: { action: "reorder", args: { order } }
+      })
+    );
+  }
+  _renderChecklistItem(item, data, renderIdx) {
+    const idx = data.indexOf(item);
+    const done = this._checklistIsDone(item);
+    const isToggled = this._checklistToggledIdx === idx;
+    const toggleClass = isToggled ? this._checklistToggledDone ? "just-checked" : "just-unchecked" : "";
+    const checkSvg = w`<svg class="cb-check" viewBox="0 0 12 12" fill="none" stroke="#fff" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><path d="M2.5 6l2.5 2.5 4.5-5"/></svg>`;
+    return b2`
+      <div
+        class="checklist-item ${done ? "done" : ""} ${toggleClass} entering"
+        style="animation-delay:${renderIdx * 25}ms"
+        draggable="true"
+        @dragstart=${(e8) => this._checklistDragStart(e8, idx)}
+        @dragend=${(e8) => {
+      e8.currentTarget.classList.remove("dragging");
+      this._checklistDragIdx = null;
+    }}
+        @dragover=${(e8) => {
+      e8.preventDefault();
+      if (e8.dataTransfer) e8.dataTransfer.dropEffect = "move";
+      e8.currentTarget.classList.add("drag-over");
+    }}
+        @dragleave=${(e8) => {
+      e8.currentTarget.classList.remove("drag-over");
+    }}
+        @drop=${(e8) => {
+      e8.preventDefault();
+      e8.currentTarget.classList.remove("drag-over");
+      this._checklistDrop(data, idx);
+    }}
+      >
+        <span class="drag-handle"
+          >${w`<svg viewBox="0 0 16 16"><circle cx="5" cy="4" r="1.5"/><circle cx="11" cy="4" r="1.5"/><circle cx="5" cy="8" r="1.5"/><circle cx="11" cy="8" r="1.5"/><circle cx="5" cy="12" r="1.5"/><circle cx="11" cy="12" r="1.5"/></svg>`}</span
+        >
+        <div
+          class="checklist-cb"
+          tabindex="0"
+          role="checkbox"
+          aria-checked="${done}"
+          @click=${() => this._checklistToggle(item, idx)}
+          @keydown=${(e8) => {
+      if (e8.key === " " || e8.key === "Enter") {
+        e8.preventDefault();
+        this._checklistToggle(item, idx);
+      }
+    }}
+        >
+          ${checkSvg}
+        </div>
+        <span class="checklist-text">${this._checklistTextKey(item)}</span>
+      </div>
+    `;
+  }
+  _renderChecklist(data) {
+    if (!Array.isArray(data) || data.length === 0) {
+      return b2`<div class="empty-state">No items</div>`;
+    }
+    const undone = data.filter((i7) => !this._checklistIsDone(i7));
+    const done = data.filter((i7) => this._checklistIsDone(i7));
+    const doneCount = done.length;
+    const total = data.length;
+    const pct = total > 0 ? doneCount / total * 100 : 0;
+    return b2`
+      <div class="checklist-wrap">
+        <div class="checklist-header">
+          <span class="checklist-counter">${doneCount} of ${total} done</span>
+          <label class="checklist-hide-label">
+            <input
+              type="checkbox"
+              .checked=${this._checklistHideDone}
+              @change=${(e8) => {
+      this._checklistHideDone = e8.target.checked;
+    }}
+              style="display:none"
+            />
+            ${this._checklistHideDone ? w`<svg width="14" height="14" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"><path d="M1 12s4-8 11-8 11 8 11 8-4 8-11 8-11-8-11-8z"/><circle cx="12" cy="12" r="3"/><line x1="2" y1="2" x2="22" y2="22"/></svg>` : w`<svg width="14" height="14" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"><path d="M1 12s4-8 11-8 11 8 11 8-4 8-11 8-11-8-11-8z"/><circle cx="12" cy="12" r="3"/></svg>`}
+            <span>${this._checklistHideDone ? "Show completed" : "Hide completed"}</span>
+          </label>
+        </div>
+        <div class="checklist-progress">
+          <div class="checklist-progress-fill" style="width:${pct}%"></div>
+        </div>
+
+        ${undone.length > 0 ? undone.map((item, i7) => this._renderChecklistItem(item, data, i7)) : doneCount < total ? "" : ""}
+        ${doneCount > 0 && !this._checklistHideDone ? b2`<div class="checklist-section">
+              Completed${doneCount < total ? ` (${doneCount})` : ""}
+            </div>` : ""}
+        ${!this._checklistHideDone ? done.map(
+      (item, i7) => this._renderChecklistItem(item, data, undone.length + i7)
+    ) : ""}
+        ${this._checklistHideDone && doneCount === total && total > 0 ? b2`<div class="checklist-all-done">
+              <div class="done-icon">&#10003;</div>
+              All ${total} items completed
+            </div>` : ""}
+      </div>
+    `;
+  }
+  // ── Article Renderer (Pretext-powered magazine layout) ──
+  _renderArticle(data) {
+    if (!data || typeof data.text !== "string") {
+      return b2`<div class="empty-state">No article content</div>`;
+    }
+    const text = data.text;
+    const images = data.images || [];
+    if (images.length > 0) {
+      try {
+        return this._renderArticleCanvas(text, images);
+      } catch {
+      }
+    }
+    return this._renderArticleFallback(text, images);
+  }
+  _renderArticleCanvas(text, images) {
+    const pretext = window.__pretextModule;
+    if (!pretext) {
+      void Promise.resolve().then(() => (init_text_layout(), text_layout_exports)).then((mod) => {
+        window.__pretextModule = mod;
+        this.requestUpdate();
+      });
+      return this._renderArticleFallback(text, images);
+    }
+    const containerWidth = this.shadowRoot?.querySelector(".content")?.clientWidth ?? 600;
+    const fontSize2 = 15;
+    const lineHeight2 = fontSize2 * 1.6;
+    const font = `${fontSize2}px -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, sans-serif`;
+    const padding = 12;
+    const obstacles = [];
+    const imagePositions = [];
+    images.forEach((img, i7) => {
+      const imgW = Math.min(img.width || 200, containerWidth * 0.4);
+      const imgH = img.height ? imgW / (img.width || 200) * img.height : imgW * 0.75;
+      const side = img.position || (i7 % 2 === 0 ? "right" : "left");
+      const x3 = side === "right" ? containerWidth - imgW : 0;
+      const y5 = i7 * (imgH + lineHeight2 * 4) + lineHeight2 * 2;
+      obstacles.push({ x: x3, y: y5, width: imgW, height: imgH, padding });
+      imagePositions.push({ x: x3, y: y5, w: imgW, h: imgH, url: img.url, caption: img.caption });
+    });
+    const flowLines = pretext.flowTextAroundObstacles(
+      text,
+      font,
+      containerWidth,
+      lineHeight2,
+      obstacles
+    );
+    const lastLine = flowLines[flowLines.length - 1];
+    const totalHeight = lastLine ? lastLine.y + lineHeight2 + padding : lineHeight2;
+    const canvasHeight = Math.max(totalHeight, ...imagePositions.map((p5) => p5.y + p5.h + padding));
+    const canvasId = `article-canvas-${Date.now()}`;
+    void this.updateComplete.then(() => {
+      const canvas = this.shadowRoot?.querySelector(`#${canvasId}`);
+      if (!canvas) return;
+      const dpr = window.devicePixelRatio || 1;
+      canvas.width = containerWidth * dpr;
+      canvas.height = canvasHeight * dpr;
+      canvas.style.height = `${canvasHeight}px`;
+      const ctx = canvas.getContext("2d");
+      ctx.scale(dpr, dpr);
+      const isDark = document.documentElement.getAttribute("data-theme") !== "light";
+      ctx.fillStyle = isDark ? "#e0e0e0" : "#1a1a1a";
+      ctx.font = font;
+      ctx.textBaseline = "top";
+      for (const line of flowLines) {
+        ctx.fillText(line.text, line.x, line.y + (lineHeight2 - fontSize2) / 2);
+      }
+    });
+    return b2`
+      <div class="article-container">
+        <canvas id="${canvasId}" style="width:100%"></canvas>
+        ${imagePositions.map(
+      (img) => b2`
+            <div
+              class="article-image"
+              style="left:${img.x}px; top:${img.y}px; width:${img.w}px; height:${img.h}px;"
+            >
+              <img src="${img.url}" alt="" loading="lazy" />
+              ${img.caption ? b2`<div class="caption">${img.caption}</div>` : ""}
+            </div>
+          `
+    )}
+      </div>
+    `;
+  }
+  _renderArticleFallback(text, images) {
+    const paragraphs = text.split(/\n\n+/).filter((p5) => p5.trim());
+    const hasImages = images.length > 0;
+    return b2`
+      <div class="article-fallback ${!hasImages ? "two-column" : ""}">
+        ${images.map(
+      (img, i7) => b2`
+            <div
+              class="article-float ${img.position || (i7 % 2 === 0 ? "right" : "left")}"
+              style="max-width: ${img.width ? Math.min(img.width, 280) + "px" : "280px"}"
+            >
+              <img src="${img.url}" alt="" loading="lazy" />
+              ${img.caption ? b2`<div class="caption">${img.caption}</div>` : ""}
+            </div>
+          `
+    )}
+        ${paragraphs.map(
+      (p5, i7) => b2`<p
+              style="margin-bottom: 1em;${i7 === 0 ? "font-size: 1.05em; font-weight: 400;" : ""}"
+            >
+              ${i7 === 0 ? b2`<span
+                      style="float:left;font-size:3.2em;line-height:0.8;padding-right:8px;padding-top:4px;font-weight:600;color:var(--accent);"
+                      >${p5.charAt(0)}</span
+                    >${p5.slice(1)}` : p5}
+            </p>`
+    )}
+      </div>
+    `;
+  }
   _renderJson(data) {
     const jsonStr = JSON.stringify(data, null, 2);
     const highlighted = jsonStr.replace(
@@ -36443,9 +39853,9 @@ ${str}</pre
   isTabularData() {
     return Array.isArray(this.result) && this.result.length > 0 && typeof this.result[0] === "object" && this.result[0] !== null;
   }
-  getDownloadLabel(layout) {
-    if (!layout) layout = this._selectLayout();
-    switch (layout) {
+  getDownloadLabel(layout2) {
+    if (!layout2) layout2 = this._selectLayout();
+    switch (layout2) {
       case "markdown":
         return "MD";
       case "mermaid":
@@ -36458,13 +39868,13 @@ ${str}</pre
         return "JSON";
     }
   }
-  downloadSmart(layout) {
-    if (!layout) layout = this._selectLayout();
+  downloadSmart(layout2) {
+    if (!layout2) layout2 = this._selectLayout();
     let content2;
     let mimeType;
     let extension;
     const timestamp = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
-    switch (layout) {
+    switch (layout2) {
       case "markdown":
         content2 = String(this.result);
         mimeType = "text/markdown";
@@ -37045,6 +40455,18 @@ ${str}</pre
   // ═══════════════════════════════════════════════════════════════════════════
   // Cart Detection & Rendering
   // ═══════════════════════════════════════════════════════════════════════════
+  _isChecklistShaped(data) {
+    if (!Array.isArray(data) || data.length === 0) return false;
+    const textFields = ["text", "title", "name", "task", "label"];
+    const doneFields = ["done", "completed", "checked"];
+    return data.every((item) => {
+      if (!item || typeof item !== "object") return false;
+      const keys2 = Object.keys(item).map((k3) => k3.toLowerCase());
+      const hasText = textFields.some((f5) => keys2.includes(f5));
+      const hasDone = doneFields.some((f5) => keys2.includes(f5));
+      return hasText && hasDone;
+    });
+  }
   _isCartShaped(data) {
     if (Array.isArray(data)) {
       return data.length > 0 && data.every(
@@ -37125,19 +40547,19 @@ ${str}</pre
    * Render a value using a specific layout type (for composable containers).
    * Falls back to auto-detection if no layout specified.
    */
-  _renderInner(data, layout) {
+  _renderInner(data, layout2) {
     if (data === null || data === void 0) {
       return b2`<div class="empty-state">No data</div>`;
     }
-    if (layout) {
-      if (layout.startsWith("chart:")) {
+    if (layout2) {
+      if (layout2.startsWith("chart:")) {
         const origFormat = this.outputFormat;
-        this.outputFormat = layout;
+        this.outputFormat = layout2;
         const result = this._renderContent("chart", data);
         this.outputFormat = origFormat;
         return result;
       }
-      return this._renderContent(layout, data);
+      return this._renderContent(layout2, data);
     }
     return this._renderDashboardPanel(data);
   }
@@ -37779,6 +41201,397 @@ ResultViewer.styles = [
         flex-shrink: 0;
       }
 
+      /* ═══ Checklist — commercial-grade UI ═══ */
+      .checklist-wrap {
+        border-radius: var(--radius-md, 8px);
+        overflow: hidden;
+        border: 1px solid var(--border-glass);
+      }
+
+      .checklist-header {
+        display: flex;
+        justify-content: space-between;
+        align-items: center;
+        padding: 10px 16px;
+        font-size: 12px;
+        color: var(--t-muted);
+        background: var(--bg-glass);
+      }
+
+      .checklist-counter {
+        font-variant-numeric: tabular-nums;
+        font-weight: 500;
+      }
+
+      .checklist-hide-label {
+        cursor: pointer;
+        user-select: none;
+        display: flex;
+        align-items: center;
+        gap: 6px;
+        font-size: 11px;
+        text-transform: uppercase;
+        letter-spacing: 0.04em;
+        transition: color 0.15s;
+      }
+
+      .checklist-hide-label:hover {
+        color: var(--t-primary);
+      }
+
+      /* Progress bar */
+      .checklist-progress {
+        height: 3px;
+        background: var(--bg-glass);
+      }
+
+      .checklist-progress-fill {
+        height: 100%;
+        background: var(--accent);
+        transition: width 0.5s cubic-bezier(0.16, 1, 0.3, 1);
+      }
+
+      /* Section separator */
+      .checklist-section {
+        padding: 8px 16px;
+        font-size: 11px;
+        font-weight: 600;
+        text-transform: uppercase;
+        letter-spacing: 0.05em;
+        color: var(--t-muted);
+        background: var(--bg-glass);
+        display: flex;
+        align-items: center;
+        gap: 10px;
+        border-top: 1px solid var(--border-glass);
+        border-bottom: 1px solid color-mix(in srgb, var(--border-glass) 50%, transparent);
+      }
+
+      .checklist-section::before {
+        content: '';
+        width: 4px;
+        height: 4px;
+        border-radius: 50%;
+        background: var(--t-muted);
+        opacity: 0.5;
+      }
+
+      .checklist-section::after {
+        content: '';
+        flex: 1;
+        height: 1px;
+        background: var(--border-glass);
+      }
+
+      /* Items */
+      .checklist-item {
+        display: flex;
+        align-items: center;
+        gap: 12px;
+        padding: 12px 16px;
+        background: var(--bg-panel);
+        cursor: grab;
+        user-select: none;
+        transition:
+          transform 0.3s cubic-bezier(0.2, 0, 0, 1),
+          opacity 0.3s ease,
+          background 0.15s ease;
+      }
+
+      .checklist-item + .checklist-item {
+        border-top: 1px solid color-mix(in srgb, var(--border-glass) 40%, transparent);
+      }
+
+      .checklist-item:hover {
+        background: var(--bg-glass);
+      }
+
+      .checklist-item:active {
+        cursor: grabbing;
+      }
+
+      .checklist-item.done {
+        opacity: 0.7;
+      }
+
+      /* Custom checkbox — no native checkbox */
+      .checklist-cb {
+        width: 20px;
+        height: 20px;
+        border-radius: 6px;
+        border: 2px solid var(--t-muted);
+        flex-shrink: 0;
+        cursor: pointer;
+        display: flex;
+        align-items: center;
+        justify-content: center;
+        transition: all 0.2s cubic-bezier(0.34, 1.56, 0.64, 1);
+        background: transparent;
+      }
+
+      .checklist-cb:hover {
+        border-color: var(--accent);
+        background: color-mix(in srgb, var(--accent) 10%, transparent);
+      }
+
+      .checklist-cb:active {
+        transform: scale(0.85);
+      }
+
+      .checklist-cb:focus-visible {
+        outline: 2px solid var(--accent);
+        outline-offset: 2px;
+      }
+
+      .checklist-cb .cb-check {
+        width: 12px;
+        height: 12px;
+        opacity: 0;
+        transform: scale(0);
+        transition: all 0.2s cubic-bezier(0.34, 1.56, 0.64, 1);
+      }
+
+      .checklist-item.done .checklist-cb {
+        border-color: var(--accent);
+        background: var(--accent);
+      }
+
+      .checklist-item.done .checklist-cb .cb-check {
+        opacity: 1;
+        transform: scale(1);
+      }
+
+      /* Drag handle */
+      .checklist-item .drag-handle {
+        cursor: grab;
+        flex-shrink: 0;
+        opacity: 0;
+        transition: opacity 0.15s;
+        display: flex;
+        align-items: center;
+      }
+
+      .checklist-item .drag-handle svg {
+        width: 14px;
+        height: 14px;
+        fill: var(--t-muted);
+      }
+
+      .checklist-item:hover .drag-handle {
+        opacity: 0.4;
+      }
+
+      /* Text */
+      .checklist-text {
+        flex: 1;
+        font-size: 14px;
+        color: var(--t-primary);
+        line-height: 1.4;
+        transition:
+          color 0.3s,
+          opacity 0.3s;
+      }
+
+      .checklist-item.done .checklist-text {
+        text-decoration: line-through;
+        text-decoration-color: var(--t-muted);
+        color: var(--t-muted);
+      }
+
+      /* Drag states */
+      .checklist-item.dragging {
+        opacity: 0.25;
+        transform: scale(0.98);
+      }
+
+      .checklist-item.drag-over {
+        box-shadow: inset 0 -2px 0 var(--accent);
+      }
+
+      /* Animations */
+      @keyframes checklist-check {
+        0% {
+          transform: scale(1);
+        }
+        30% {
+          transform: scale(1.03);
+        }
+        100% {
+          transform: scale(1);
+        }
+      }
+
+      @keyframes checklist-uncheck {
+        0% {
+          transform: scale(1);
+        }
+        30% {
+          transform: scale(0.97);
+        }
+        100% {
+          transform: scale(1);
+        }
+      }
+
+      .checklist-item.just-checked {
+        animation: checklist-check 0.3s var(--motion-ease-spring);
+      }
+
+      .checklist-item.just-unchecked {
+        animation: checklist-uncheck 0.3s var(--motion-ease-spring);
+      }
+
+      @keyframes checklist-enter {
+        from {
+          opacity: 0;
+          transform: translateY(6px);
+        }
+        to {
+          opacity: 1;
+          transform: translateY(0);
+        }
+      }
+
+      .checklist-item.entering {
+        animation: checklist-enter 0.2s var(--motion-ease-out) both;
+      }
+
+      /* All-done celebration */
+      .checklist-all-done {
+        padding: 32px 16px;
+        text-align: center;
+        color: var(--t-muted);
+        font-size: 14px;
+      }
+
+      .checklist-all-done .done-icon {
+        font-size: 28px;
+        margin-bottom: 8px;
+        opacity: 0.6;
+      }
+
+      @keyframes checklist-celebrate {
+        0% {
+          transform: scale(0.8);
+          opacity: 0;
+        }
+        50% {
+          transform: scale(1.05);
+        }
+        100% {
+          transform: scale(1);
+          opacity: 1;
+        }
+      }
+
+      .checklist-all-done {
+        animation: checklist-celebrate 0.4s var(--motion-ease-spring) both;
+      }
+
+      /* Article Styles (Pretext-powered magazine layout) */
+      .article-container {
+        position: relative;
+        line-height: 1.6;
+        font-size: 15px;
+        color: var(--t-primary);
+        overflow: hidden;
+      }
+
+      .article-container canvas {
+        display: block;
+        width: 100%;
+      }
+
+      .article-image {
+        position: absolute;
+        border-radius: var(--radius-sm);
+        overflow: hidden;
+        box-shadow: 0 4px 12px rgba(0, 0, 0, 0.15);
+        transition: box-shadow 0.2s;
+      }
+
+      .article-image:hover {
+        box-shadow: 0 8px 24px rgba(0, 0, 0, 0.25);
+      }
+
+      .article-image img {
+        width: 100%;
+        height: 100%;
+        object-fit: cover;
+        display: block;
+      }
+
+      .article-image .caption {
+        position: absolute;
+        bottom: 0;
+        left: 0;
+        right: 0;
+        padding: 6px 10px;
+        background: linear-gradient(transparent, rgba(0, 0, 0, 0.7));
+        color: #fff;
+        font-size: 11px;
+        font-style: italic;
+      }
+
+      .article-fallback {
+        line-height: 1.7;
+        font-size: 15px;
+        color: var(--t-primary);
+      }
+
+      .article-fallback.two-column {
+        column-count: 2;
+        column-gap: 32px;
+        column-rule: 1px solid color-mix(in srgb, var(--border-glass) 50%, transparent);
+      }
+
+      .article-fallback .article-float {
+        break-inside: avoid;
+        margin-bottom: 12px;
+        border-radius: var(--radius-sm);
+        overflow: hidden;
+        box-shadow: 0 4px 12px rgba(0, 0, 0, 0.15);
+      }
+
+      .article-fallback .article-float.left {
+        float: left;
+        margin: 0 20px 12px 0;
+        max-width: 45%;
+      }
+
+      .article-fallback .article-float.right {
+        float: right;
+        margin: 0 0 12px 20px;
+        max-width: 45%;
+      }
+
+      .article-fallback .article-float img {
+        width: 100%;
+        display: block;
+      }
+
+      .article-fallback .article-float .caption {
+        padding: 6px 10px;
+        font-size: 11px;
+        font-style: italic;
+        color: var(--t-muted);
+        background: var(--bg-glass);
+      }
+
+      @keyframes article-fade-in {
+        from {
+          opacity: 0;
+        }
+        to {
+          opacity: 1;
+        }
+      }
+
+      .article-container,
+      .article-fallback {
+        animation: article-fade-in 0.3s ease both;
+      }
+
       .status-badge {
         padding: 2px 8px;
         border-radius: var(--radius-full);
@@ -39326,6 +43139,9 @@ __decorateClass([
 __decorateClass([
   n4({ type: String, reflect: true, attribute: "data-theme" })
 ], ResultViewer.prototype, "theme", 2);
+__decorateClass([
+  n4({ type: Boolean })
+], ResultViewer.prototype, "loading", 2);
 __decorateClass([
   r5()
 ], ResultViewer.prototype, "_filterQuery", 2);
@@ -39377,6 +43193,18 @@ __decorateClass([
 __decorateClass([
   e7("#qr-container")
 ], ResultViewer.prototype, "_qrContainer", 2);
+__decorateClass([
+  r5()
+], ResultViewer.prototype, "_checklistHideDone", 2);
+__decorateClass([
+  r5()
+], ResultViewer.prototype, "_checklistDragIdx", 2);
+__decorateClass([
+  r5()
+], ResultViewer.prototype, "_checklistToggledIdx", 2);
+__decorateClass([
+  r5()
+], ResultViewer.prototype, "_checklistToggledDone", 2);
 __decorateClass([
   n4({ type: String })
 ], ResultViewer.prototype, "collectionProperty", 2);
@@ -42071,8 +45899,10 @@ var CustomUiRenderer = class extends i4 {
       try {
         const resource = await mcpClient2.readResource(uri);
         if (resource?.text) {
-          const isPT = resource.mimeType?.includes("photon-template=true") || uri.endsWith(".photon.html") || resource.uri?.endsWith(".photon.html");
-          return { html: resource.text, isPhotonTemplate: !!isPT };
+          const isMd = uri.endsWith(".photon.md") || resource.uri?.endsWith(".photon.md") || resource.mimeType?.includes("text/markdown");
+          const isPT = isMd || resource.mimeType?.includes("photon-template=true") || uri.endsWith(".photon.html") || resource.uri?.endsWith(".photon.html");
+          const html2 = isMd ? this._markdownToHtml(resource.text) : resource.text;
+          return { html: html2, isPhotonTemplate: !!isPT };
         }
       } catch (e8) {
         console.warn("MCP resources/read failed, falling back to HTTP:", e8);
@@ -42085,8 +45915,34 @@ var CustomUiRenderer = class extends i4 {
     const res = await fetch(url2, { signal: AbortSignal.timeout(1e4) });
     if (!res.ok) throw new Error(`Failed to load UI: ${res.statusText}`);
     const html = await res.text();
+    const isPhotonMarkdown = res.headers.get("X-Photon-Markdown") === "true";
     const isPhotonTemplate = res.headers.get("X-Photon-Template") === "true";
-    return { html, isPhotonTemplate };
+    const finalHtml = isPhotonMarkdown ? this._markdownToHtml(html) : html;
+    return { html: finalHtml, isPhotonTemplate };
+  }
+  /** Convert .photon.md content to HTML using marked (already loaded via CDN) */
+  _markdownToHtml(markdown) {
+    const marked2 = window.marked;
+    if (!marked2) {
+      return `<pre style="white-space:pre-wrap">${markdown}</pre>`;
+    }
+    let html = marked2.parse(markdown, { breaks: false, gfm: true });
+    html += `<style>
+      body { line-height: 1.7; max-width: 100%; }
+      h1, h2, h3 { margin: 1em 0 0.5em; }
+      p { margin: 0.5em 0; }
+      hr { border: none; border-top: 1px solid var(--color-outline-variant, #333); margin: 1.5em 0; }
+      code { background: var(--color-surface-container, #2a2a2a); padding: 2px 6px; border-radius: 3px; font-size: 0.9em; }
+      pre { background: var(--color-surface-container, #2a2a2a); padding: 12px; border-radius: 6px; overflow-x: auto; }
+      pre code { background: none; padding: 0; }
+      .card, [style*="border-radius"][style*="padding"] {
+        background: var(--color-surface-container, #1e1e1e);
+        border: 1px solid var(--color-outline-variant, #333);
+      }
+      [data-method] { min-height: 40px; margin: 8px 0; }
+      img { max-width: 100%; border-radius: 6px; }
+    </style>`;
+    return html;
   }
   render() {
     return b2`
@@ -92466,6 +96322,28 @@ ElicitationModal.styles = [
         display: none;
       }
 
+      @keyframes modal-backdrop-in {
+        from {
+          opacity: 0;
+          backdrop-filter: blur(0);
+        }
+        to {
+          opacity: 1;
+          backdrop-filter: blur(4px);
+        }
+      }
+
+      @keyframes modal-content-in {
+        from {
+          opacity: 0;
+          transform: scale(0.95) translateY(8px);
+        }
+        to {
+          opacity: 1;
+          transform: scale(1) translateY(0);
+        }
+      }
+
       :host([open]) {
         display: flex;
         position: fixed;
@@ -92475,6 +96353,7 @@ ElicitationModal.styles = [
         z-index: 10000;
         align-items: center;
         justify-content: center;
+        animation: modal-backdrop-in 0.2s ease-out both;
       }
 
       .modal-content {
@@ -92487,6 +96366,8 @@ ElicitationModal.styles = [
         max-height: 80vh;
         overflow-y: auto;
         box-shadow: 0 25px 50px -12px rgba(0, 0, 0, 0.25);
+        animation: modal-content-in 0.25s cubic-bezier(0.16, 1, 0.3, 1) both;
+        animation-delay: 0.05s;
       }
 
       h3 {
@@ -94747,6 +98628,26 @@ ForkDialog.styles = [
   theme,
   buttons,
   i`
+      @keyframes modal-backdrop-in {
+        from {
+          opacity: 0;
+        }
+        to {
+          opacity: 1;
+        }
+      }
+
+      @keyframes modal-content-in {
+        from {
+          opacity: 0;
+          transform: scale(0.95) translateY(8px);
+        }
+        to {
+          opacity: 1;
+          transform: scale(1) translateY(0);
+        }
+      }
+
       :host {
         display: flex;
         position: fixed;
@@ -94756,6 +98657,7 @@ ForkDialog.styles = [
         z-index: 10000;
         align-items: center;
         justify-content: center;
+        animation: modal-backdrop-in 0.2s ease-out both;
       }
 
       .modal-content {
@@ -94768,6 +98670,8 @@ ForkDialog.styles = [
         max-height: 80vh;
         overflow-y: auto;
         box-shadow: 0 25px 50px -12px rgba(0, 0, 0, 0.25);
+        animation: modal-content-in 0.25s cubic-bezier(0.16, 1, 0.3, 1) both;
+        animation-delay: 0.05s;
       }
 
       h3 {