@anlijiu/markmap 1.0.1 → 1.0.2

package/dist/markmap.js

@@ -7232,7 +7232,7 @@ a {
   }
   __name(_unsupportedIterableToArray, "_unsupportedIterableToArray");
   var _window = typeof window === "undefined" ? null : window;
-  var navigator = _window ? _window.navigator : null;
+  var navigator2 = _window ? _window.navigator : null;
   _window ? _window.document : null;
   var typeofstr = _typeof("");
   var typeofobj = _typeof({});
@@ -7310,7 +7310,7 @@ a {
     return object(obj) && fn$6(obj.then);
   }, "promise");
   var ms = /* @__PURE__ */ __name(function ms2() {
-    return navigator && navigator.userAgent.match(/msie|trident|edge/i);
+    return navigator2 && navigator2.userAgent.match(/msie|trident|edge/i);
   }, "ms");
   var memoize = /* @__PURE__ */ __name(function memoize2(fn3, keyFn) {
     if (!keyFn) {
@@ -39483,6 +39483,3757 @@ a {
     };
   }, "updateLows");
 
+  // ../../node_modules/.pnpm/@chenglou+pretext@0.0.5/node_modules/@chenglou/pretext/dist/generated/bidi-data.js
+  var latin1BidiTypes = [
+    "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",
+    "ES",
+    "CS",
+    "ES",
+    "CS",
+    "CS",
+    "EN",
+    "EN",
+    "EN",
+    "EN",
+    "EN",
+    "EN",
+    "EN",
+    "EN",
+    "EN",
+    "EN",
+    "CS",
+    "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",
+    "BN",
+    "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"
+  ];
+  var nonLatin1BidiRanges = [
+    [697, 698, "ON"],
+    [706, 719, "ON"],
+    [722, 735, "ON"],
+    [741, 749, "ON"],
+    [751, 767, "ON"],
+    [768, 879, "NSM"],
+    [884, 885, "ON"],
+    [894, 894, "ON"],
+    [900, 901, "ON"],
+    [903, 903, "ON"],
+    [1014, 1014, "ON"],
+    [1155, 1161, "NSM"],
+    [1418, 1418, "ON"],
+    [1421, 1422, "ON"],
+    [1423, 1423, "ET"],
+    [1424, 1424, "R"],
+    [1425, 1469, "NSM"],
+    [1470, 1470, "R"],
+    [1471, 1471, "NSM"],
+    [1472, 1472, "R"],
+    [1473, 1474, "NSM"],
+    [1475, 1475, "R"],
+    [1476, 1477, "NSM"],
+    [1478, 1478, "R"],
+    [1479, 1479, "NSM"],
+    [1480, 1535, "R"],
+    [1536, 1541, "AN"],
+    [1542, 1543, "ON"],
+    [1544, 1544, "AL"],
+    [1545, 1546, "ET"],
+    [1547, 1547, "AL"],
+    [1548, 1548, "CS"],
+    [1549, 1549, "AL"],
+    [1550, 1551, "ON"],
+    [1552, 1562, "NSM"],
+    [1563, 1610, "AL"],
+    [1611, 1631, "NSM"],
+    [1632, 1641, "AN"],
+    [1642, 1642, "ET"],
+    [1643, 1644, "AN"],
+    [1645, 1647, "AL"],
+    [1648, 1648, "NSM"],
+    [1649, 1749, "AL"],
+    [1750, 1756, "NSM"],
+    [1757, 1757, "AN"],
+    [1758, 1758, "ON"],
+    [1759, 1764, "NSM"],
+    [1765, 1766, "AL"],
+    [1767, 1768, "NSM"],
+    [1769, 1769, "ON"],
+    [1770, 1773, "NSM"],
+    [1774, 1775, "AL"],
+    [1776, 1785, "EN"],
+    [1786, 1808, "AL"],
+    [1809, 1809, "NSM"],
+    [1810, 1839, "AL"],
+    [1840, 1866, "NSM"],
+    [1867, 1957, "AL"],
+    [1958, 1968, "NSM"],
+    [1969, 1983, "AL"],
+    [1984, 2026, "R"],
+    [2027, 2035, "NSM"],
+    [2036, 2037, "R"],
+    [2038, 2041, "ON"],
+    [2042, 2044, "R"],
+    [2045, 2045, "NSM"],
+    [2046, 2069, "R"],
+    [2070, 2073, "NSM"],
+    [2074, 2074, "R"],
+    [2075, 2083, "NSM"],
+    [2084, 2084, "R"],
+    [2085, 2087, "NSM"],
+    [2088, 2088, "R"],
+    [2089, 2093, "NSM"],
+    [2094, 2136, "R"],
+    [2137, 2139, "NSM"],
+    [2140, 2143, "R"],
+    [2144, 2191, "AL"],
+    [2192, 2193, "AN"],
+    [2194, 2198, "AL"],
+    [2199, 2207, "NSM"],
+    [2208, 2249, "AL"],
+    [2250, 2273, "NSM"],
+    [2274, 2274, "AN"],
+    [2275, 2306, "NSM"],
+    [2362, 2362, "NSM"],
+    [2364, 2364, "NSM"],
+    [2369, 2376, "NSM"],
+    [2381, 2381, "NSM"],
+    [2385, 2391, "NSM"],
+    [2402, 2403, "NSM"],
+    [2433, 2433, "NSM"],
+    [2492, 2492, "NSM"],
+    [2497, 2500, "NSM"],
+    [2509, 2509, "NSM"],
+    [2530, 2531, "NSM"],
+    [2546, 2547, "ET"],
+    [2555, 2555, "ET"],
+    [2558, 2558, "NSM"],
+    [2561, 2562, "NSM"],
+    [2620, 2620, "NSM"],
+    [2625, 2626, "NSM"],
+    [2631, 2632, "NSM"],
+    [2635, 2637, "NSM"],
+    [2641, 2641, "NSM"],
+    [2672, 2673, "NSM"],
+    [2677, 2677, "NSM"],
+    [2689, 2690, "NSM"],
+    [2748, 2748, "NSM"],
+    [2753, 2757, "NSM"],
+    [2759, 2760, "NSM"],
+    [2765, 2765, "NSM"],
+    [2786, 2787, "NSM"],
+    [2801, 2801, "ET"],
+    [2810, 2815, "NSM"],
+    [2817, 2817, "NSM"],
+    [2876, 2876, "NSM"],
+    [2879, 2879, "NSM"],
+    [2881, 2884, "NSM"],
+    [2893, 2893, "NSM"],
+    [2901, 2902, "NSM"],
+    [2914, 2915, "NSM"],
+    [2946, 2946, "NSM"],
+    [3008, 3008, "NSM"],
+    [3021, 3021, "NSM"],
+    [3059, 3064, "ON"],
+    [3065, 3065, "ET"],
+    [3066, 3066, "ON"],
+    [3072, 3072, "NSM"],
+    [3076, 3076, "NSM"],
+    [3132, 3132, "NSM"],
+    [3134, 3136, "NSM"],
+    [3142, 3144, "NSM"],
+    [3146, 3149, "NSM"],
+    [3157, 3158, "NSM"],
+    [3170, 3171, "NSM"],
+    [3192, 3198, "ON"],
+    [3201, 3201, "NSM"],
+    [3260, 3260, "NSM"],
+    [3276, 3277, "NSM"],
+    [3298, 3299, "NSM"],
+    [3328, 3329, "NSM"],
+    [3387, 3388, "NSM"],
+    [3393, 3396, "NSM"],
+    [3405, 3405, "NSM"],
+    [3426, 3427, "NSM"],
+    [3457, 3457, "NSM"],
+    [3530, 3530, "NSM"],
+    [3538, 3540, "NSM"],
+    [3542, 3542, "NSM"],
+    [3633, 3633, "NSM"],
+    [3636, 3642, "NSM"],
+    [3647, 3647, "ET"],
+    [3655, 3662, "NSM"],
+    [3761, 3761, "NSM"],
+    [3764, 3772, "NSM"],
+    [3784, 3790, "NSM"],
+    [3864, 3865, "NSM"],
+    [3893, 3893, "NSM"],
+    [3895, 3895, "NSM"],
+    [3897, 3897, "NSM"],
+    [3898, 3901, "ON"],
+    [3953, 3966, "NSM"],
+    [3968, 3972, "NSM"],
+    [3974, 3975, "NSM"],
+    [3981, 3991, "NSM"],
+    [3993, 4028, "NSM"],
+    [4038, 4038, "NSM"],
+    [4141, 4144, "NSM"],
+    [4146, 4151, "NSM"],
+    [4153, 4154, "NSM"],
+    [4157, 4158, "NSM"],
+    [4184, 4185, "NSM"],
+    [4190, 4192, "NSM"],
+    [4209, 4212, "NSM"],
+    [4226, 4226, "NSM"],
+    [4229, 4230, "NSM"],
+    [4237, 4237, "NSM"],
+    [4253, 4253, "NSM"],
+    [4957, 4959, "NSM"],
+    [5008, 5017, "ON"],
+    [5120, 5120, "ON"],
+    [5760, 5760, "WS"],
+    [5787, 5788, "ON"],
+    [5906, 5908, "NSM"],
+    [5938, 5939, "NSM"],
+    [5970, 5971, "NSM"],
+    [6002, 6003, "NSM"],
+    [6068, 6069, "NSM"],
+    [6071, 6077, "NSM"],
+    [6086, 6086, "NSM"],
+    [6089, 6099, "NSM"],
+    [6107, 6107, "ET"],
+    [6109, 6109, "NSM"],
+    [6128, 6137, "ON"],
+    [6144, 6154, "ON"],
+    [6155, 6157, "NSM"],
+    [6158, 6158, "BN"],
+    [6159, 6159, "NSM"],
+    [6277, 6278, "NSM"],
+    [6313, 6313, "NSM"],
+    [6432, 6434, "NSM"],
+    [6439, 6440, "NSM"],
+    [6450, 6450, "NSM"],
+    [6457, 6459, "NSM"],
+    [6464, 6464, "ON"],
+    [6468, 6469, "ON"],
+    [6622, 6655, "ON"],
+    [6679, 6680, "NSM"],
+    [6683, 6683, "NSM"],
+    [6742, 6742, "NSM"],
+    [6744, 6750, "NSM"],
+    [6752, 6752, "NSM"],
+    [6754, 6754, "NSM"],
+    [6757, 6764, "NSM"],
+    [6771, 6780, "NSM"],
+    [6783, 6783, "NSM"],
+    [6832, 6877, "NSM"],
+    [6880, 6891, "NSM"],
+    [6912, 6915, "NSM"],
+    [6964, 6964, "NSM"],
+    [6966, 6970, "NSM"],
+    [6972, 6972, "NSM"],
+    [6978, 6978, "NSM"],
+    [7019, 7027, "NSM"],
+    [7040, 7041, "NSM"],
+    [7074, 7077, "NSM"],
+    [7080, 7081, "NSM"],
+    [7083, 7085, "NSM"],
+    [7142, 7142, "NSM"],
+    [7144, 7145, "NSM"],
+    [7149, 7149, "NSM"],
+    [7151, 7153, "NSM"],
+    [7212, 7219, "NSM"],
+    [7222, 7223, "NSM"],
+    [7376, 7378, "NSM"],
+    [7380, 7392, "NSM"],
+    [7394, 7400, "NSM"],
+    [7405, 7405, "NSM"],
+    [7412, 7412, "NSM"],
+    [7416, 7417, "NSM"],
+    [7616, 7679, "NSM"],
+    [8125, 8125, "ON"],
+    [8127, 8129, "ON"],
+    [8141, 8143, "ON"],
+    [8157, 8159, "ON"],
+    [8173, 8175, "ON"],
+    [8189, 8190, "ON"],
+    [8192, 8202, "WS"],
+    [8203, 8205, "BN"],
+    [8207, 8207, "R"],
+    [8208, 8231, "ON"],
+    [8232, 8232, "WS"],
+    [8233, 8233, "B"],
+    [8234, 8238, "BN"],
+    [8239, 8239, "CS"],
+    [8240, 8244, "ET"],
+    [8245, 8259, "ON"],
+    [8260, 8260, "CS"],
+    [8261, 8286, "ON"],
+    [8287, 8287, "WS"],
+    [8288, 8303, "BN"],
+    [8304, 8304, "EN"],
+    [8308, 8313, "EN"],
+    [8314, 8315, "ES"],
+    [8316, 8318, "ON"],
+    [8320, 8329, "EN"],
+    [8330, 8331, "ES"],
+    [8332, 8334, "ON"],
+    [8352, 8399, "ET"],
+    [8400, 8432, "NSM"],
+    [8448, 8449, "ON"],
+    [8451, 8454, "ON"],
+    [8456, 8457, "ON"],
+    [8468, 8468, "ON"],
+    [8470, 8472, "ON"],
+    [8478, 8483, "ON"],
+    [8485, 8485, "ON"],
+    [8487, 8487, "ON"],
+    [8489, 8489, "ON"],
+    [8494, 8494, "ET"],
+    [8506, 8507, "ON"],
+    [8512, 8516, "ON"],
+    [8522, 8525, "ON"],
+    [8528, 8543, "ON"],
+    [8585, 8587, "ON"],
+    [8592, 8721, "ON"],
+    [8722, 8722, "ES"],
+    [8723, 8723, "ET"],
+    [8724, 9013, "ON"],
+    [9083, 9108, "ON"],
+    [9110, 9257, "ON"],
+    [9280, 9290, "ON"],
+    [9312, 9351, "ON"],
+    [9352, 9371, "EN"],
+    [9450, 9899, "ON"],
+    [9901, 10239, "ON"],
+    [10496, 11123, "ON"],
+    [11126, 11263, "ON"],
+    [11493, 11498, "ON"],
+    [11503, 11505, "NSM"],
+    [11513, 11519, "ON"],
+    [11647, 11647, "NSM"],
+    [11744, 11775, "NSM"],
+    [11776, 11869, "ON"],
+    [11904, 11929, "ON"],
+    [11931, 12019, "ON"],
+    [12032, 12245, "ON"],
+    [12272, 12287, "ON"],
+    [12288, 12288, "WS"],
+    [12289, 12292, "ON"],
+    [12296, 12320, "ON"],
+    [12330, 12333, "NSM"],
+    [12336, 12336, "ON"],
+    [12342, 12343, "ON"],
+    [12349, 12351, "ON"],
+    [12441, 12442, "NSM"],
+    [12443, 12444, "ON"],
+    [12448, 12448, "ON"],
+    [12539, 12539, "ON"],
+    [12736, 12773, "ON"],
+    [12783, 12783, "ON"],
+    [12829, 12830, "ON"],
+    [12880, 12895, "ON"],
+    [12924, 12926, "ON"],
+    [12977, 12991, "ON"],
+    [13004, 13007, "ON"],
+    [13175, 13178, "ON"],
+    [13278, 13279, "ON"],
+    [13311, 13311, "ON"],
+    [19904, 19967, "ON"],
+    [42128, 42182, "ON"],
+    [42509, 42511, "ON"],
+    [42607, 42610, "NSM"],
+    [42611, 42611, "ON"],
+    [42612, 42621, "NSM"],
+    [42622, 42623, "ON"],
+    [42654, 42655, "NSM"],
+    [42736, 42737, "NSM"],
+    [42752, 42785, "ON"],
+    [42888, 42888, "ON"],
+    [43010, 43010, "NSM"],
+    [43014, 43014, "NSM"],
+    [43019, 43019, "NSM"],
+    [43045, 43046, "NSM"],
+    [43048, 43051, "ON"],
+    [43052, 43052, "NSM"],
+    [43064, 43065, "ET"],
+    [43124, 43127, "ON"],
+    [43204, 43205, "NSM"],
+    [43232, 43249, "NSM"],
+    [43263, 43263, "NSM"],
+    [43302, 43309, "NSM"],
+    [43335, 43345, "NSM"],
+    [43392, 43394, "NSM"],
+    [43443, 43443, "NSM"],
+    [43446, 43449, "NSM"],
+    [43452, 43453, "NSM"],
+    [43493, 43493, "NSM"],
+    [43561, 43566, "NSM"],
+    [43569, 43570, "NSM"],
+    [43573, 43574, "NSM"],
+    [43587, 43587, "NSM"],
+    [43596, 43596, "NSM"],
+    [43644, 43644, "NSM"],
+    [43696, 43696, "NSM"],
+    [43698, 43700, "NSM"],
+    [43703, 43704, "NSM"],
+    [43710, 43711, "NSM"],
+    [43713, 43713, "NSM"],
+    [43756, 43757, "NSM"],
+    [43766, 43766, "NSM"],
+    [43882, 43883, "ON"],
+    [44005, 44005, "NSM"],
+    [44008, 44008, "NSM"],
+    [44013, 44013, "NSM"],
+    [64285, 64285, "R"],
+    [64286, 64286, "NSM"],
+    [64287, 64296, "R"],
+    [64297, 64297, "ES"],
+    [64298, 64335, "R"],
+    [64336, 64450, "AL"],
+    [64451, 64466, "ON"],
+    [64467, 64829, "AL"],
+    [64830, 64847, "ON"],
+    [64848, 64911, "AL"],
+    [64912, 64913, "ON"],
+    [64914, 64967, "AL"],
+    [64968, 64975, "ON"],
+    [64976, 65007, "BN"],
+    [65008, 65020, "AL"],
+    [65021, 65023, "ON"],
+    [65024, 65039, "NSM"],
+    [65040, 65049, "ON"],
+    [65056, 65071, "NSM"],
+    [65072, 65103, "ON"],
+    [65104, 65104, "CS"],
+    [65105, 65105, "ON"],
+    [65106, 65106, "CS"],
+    [65108, 65108, "ON"],
+    [65109, 65109, "CS"],
+    [65110, 65118, "ON"],
+    [65119, 65119, "ET"],
+    [65120, 65121, "ON"],
+    [65122, 65123, "ES"],
+    [65124, 65126, "ON"],
+    [65128, 65128, "ON"],
+    [65129, 65130, "ET"],
+    [65131, 65131, "ON"],
+    [65136, 65278, "AL"],
+    [65279, 65279, "BN"],
+    [65281, 65282, "ON"],
+    [65283, 65285, "ET"],
+    [65286, 65290, "ON"],
+    [65291, 65291, "ES"],
+    [65292, 65292, "CS"],
+    [65293, 65293, "ES"],
+    [65294, 65295, "CS"],
+    [65296, 65305, "EN"],
+    [65306, 65306, "CS"],
+    [65307, 65312, "ON"],
+    [65339, 65344, "ON"],
+    [65371, 65381, "ON"],
+    [65504, 65505, "ET"],
+    [65506, 65508, "ON"],
+    [65509, 65510, "ET"],
+    [65512, 65518, "ON"],
+    [65520, 65528, "BN"],
+    [65529, 65533, "ON"],
+    [65534, 65535, "BN"],
+    [65793, 65793, "ON"],
+    [65856, 65932, "ON"],
+    [65936, 65948, "ON"],
+    [65952, 65952, "ON"],
+    [66045, 66045, "NSM"],
+    [66272, 66272, "NSM"],
+    [66273, 66299, "EN"],
+    [66422, 66426, "NSM"],
+    [67584, 67870, "R"],
+    [67871, 67871, "ON"],
+    [67872, 68096, "R"],
+    [68097, 68099, "NSM"],
+    [68100, 68100, "R"],
+    [68101, 68102, "NSM"],
+    [68103, 68107, "R"],
+    [68108, 68111, "NSM"],
+    [68112, 68151, "R"],
+    [68152, 68154, "NSM"],
+    [68155, 68158, "R"],
+    [68159, 68159, "NSM"],
+    [68160, 68324, "R"],
+    [68325, 68326, "NSM"],
+    [68327, 68408, "R"],
+    [68409, 68415, "ON"],
+    [68416, 68863, "R"],
+    [68864, 68899, "AL"],
+    [68900, 68903, "NSM"],
+    [68904, 68911, "AL"],
+    [68912, 68921, "AN"],
+    [68922, 68927, "AL"],
+    [68928, 68937, "AN"],
+    [68938, 68968, "R"],
+    [68969, 68973, "NSM"],
+    [68974, 68974, "ON"],
+    [68975, 69215, "R"],
+    [69216, 69246, "AN"],
+    [69247, 69290, "R"],
+    [69291, 69292, "NSM"],
+    [69293, 69311, "R"],
+    [69312, 69327, "AL"],
+    [69328, 69336, "ON"],
+    [69337, 69369, "AL"],
+    [69370, 69375, "NSM"],
+    [69376, 69423, "R"],
+    [69424, 69445, "AL"],
+    [69446, 69456, "NSM"],
+    [69457, 69487, "AL"],
+    [69488, 69505, "R"],
+    [69506, 69509, "NSM"],
+    [69510, 69631, "R"],
+    [69633, 69633, "NSM"],
+    [69688, 69702, "NSM"],
+    [69714, 69733, "ON"],
+    [69744, 69744, "NSM"],
+    [69747, 69748, "NSM"],
+    [69759, 69761, "NSM"],
+    [69811, 69814, "NSM"],
+    [69817, 69818, "NSM"],
+    [69826, 69826, "NSM"],
+    [69888, 69890, "NSM"],
+    [69927, 69931, "NSM"],
+    [69933, 69940, "NSM"],
+    [70003, 70003, "NSM"],
+    [70016, 70017, "NSM"],
+    [70070, 70078, "NSM"],
+    [70089, 70092, "NSM"],
+    [70095, 70095, "NSM"],
+    [70191, 70193, "NSM"],
+    [70196, 70196, "NSM"],
+    [70198, 70199, "NSM"],
+    [70206, 70206, "NSM"],
+    [70209, 70209, "NSM"],
+    [70367, 70367, "NSM"],
+    [70371, 70378, "NSM"],
+    [70400, 70401, "NSM"],
+    [70459, 70460, "NSM"],
+    [70464, 70464, "NSM"],
+    [70502, 70508, "NSM"],
+    [70512, 70516, "NSM"],
+    [70587, 70592, "NSM"],
+    [70606, 70606, "NSM"],
+    [70608, 70608, "NSM"],
+    [70610, 70610, "NSM"],
+    [70625, 70626, "NSM"],
+    [70712, 70719, "NSM"],
+    [70722, 70724, "NSM"],
+    [70726, 70726, "NSM"],
+    [70750, 70750, "NSM"],
+    [70835, 70840, "NSM"],
+    [70842, 70842, "NSM"],
+    [70847, 70848, "NSM"],
+    [70850, 70851, "NSM"],
+    [71090, 71093, "NSM"],
+    [71100, 71101, "NSM"],
+    [71103, 71104, "NSM"],
+    [71132, 71133, "NSM"],
+    [71219, 71226, "NSM"],
+    [71229, 71229, "NSM"],
+    [71231, 71232, "NSM"],
+    [71264, 71276, "ON"],
+    [71339, 71339, "NSM"],
+    [71341, 71341, "NSM"],
+    [71344, 71349, "NSM"],
+    [71351, 71351, "NSM"],
+    [71453, 71453, "NSM"],
+    [71455, 71455, "NSM"],
+    [71458, 71461, "NSM"],
+    [71463, 71467, "NSM"],
+    [71727, 71735, "NSM"],
+    [71737, 71738, "NSM"],
+    [71995, 71996, "NSM"],
+    [71998, 71998, "NSM"],
+    [72003, 72003, "NSM"],
+    [72148, 72151, "NSM"],
+    [72154, 72155, "NSM"],
+    [72160, 72160, "NSM"],
+    [72193, 72198, "NSM"],
+    [72201, 72202, "NSM"],
+    [72243, 72248, "NSM"],
+    [72251, 72254, "NSM"],
+    [72263, 72263, "NSM"],
+    [72273, 72278, "NSM"],
+    [72281, 72283, "NSM"],
+    [72330, 72342, "NSM"],
+    [72344, 72345, "NSM"],
+    [72544, 72544, "NSM"],
+    [72546, 72548, "NSM"],
+    [72550, 72550, "NSM"],
+    [72752, 72758, "NSM"],
+    [72760, 72765, "NSM"],
+    [72850, 72871, "NSM"],
+    [72874, 72880, "NSM"],
+    [72882, 72883, "NSM"],
+    [72885, 72886, "NSM"],
+    [73009, 73014, "NSM"],
+    [73018, 73018, "NSM"],
+    [73020, 73021, "NSM"],
+    [73023, 73029, "NSM"],
+    [73031, 73031, "NSM"],
+    [73104, 73105, "NSM"],
+    [73109, 73109, "NSM"],
+    [73111, 73111, "NSM"],
+    [73459, 73460, "NSM"],
+    [73472, 73473, "NSM"],
+    [73526, 73530, "NSM"],
+    [73536, 73536, "NSM"],
+    [73538, 73538, "NSM"],
+    [73562, 73562, "NSM"],
+    [73685, 73692, "ON"],
+    [73693, 73696, "ET"],
+    [73697, 73713, "ON"],
+    [78912, 78912, "NSM"],
+    [78919, 78933, "NSM"],
+    [90398, 90409, "NSM"],
+    [90413, 90415, "NSM"],
+    [92912, 92916, "NSM"],
+    [92976, 92982, "NSM"],
+    [94031, 94031, "NSM"],
+    [94095, 94098, "NSM"],
+    [94178, 94178, "ON"],
+    [94180, 94180, "NSM"],
+    [113821, 113822, "NSM"],
+    [113824, 113827, "BN"],
+    [117760, 117973, "ON"],
+    [118e3, 118009, "EN"],
+    [118010, 118012, "ON"],
+    [118016, 118451, "ON"],
+    [118458, 118480, "ON"],
+    [118496, 118512, "ON"],
+    [118528, 118573, "NSM"],
+    [118576, 118598, "NSM"],
+    [119143, 119145, "NSM"],
+    [119155, 119162, "BN"],
+    [119163, 119170, "NSM"],
+    [119173, 119179, "NSM"],
+    [119210, 119213, "NSM"],
+    [119273, 119274, "ON"],
+    [119296, 119361, "ON"],
+    [119362, 119364, "NSM"],
+    [119365, 119365, "ON"],
+    [119552, 119638, "ON"],
+    [120513, 120513, "ON"],
+    [120539, 120539, "ON"],
+    [120571, 120571, "ON"],
+    [120597, 120597, "ON"],
+    [120629, 120629, "ON"],
+    [120655, 120655, "ON"],
+    [120687, 120687, "ON"],
+    [120713, 120713, "ON"],
+    [120745, 120745, "ON"],
+    [120771, 120771, "ON"],
+    [120782, 120831, "EN"],
+    [121344, 121398, "NSM"],
+    [121403, 121452, "NSM"],
+    [121461, 121461, "NSM"],
+    [121476, 121476, "NSM"],
+    [121499, 121503, "NSM"],
+    [121505, 121519, "NSM"],
+    [122880, 122886, "NSM"],
+    [122888, 122904, "NSM"],
+    [122907, 122913, "NSM"],
+    [122915, 122916, "NSM"],
+    [122918, 122922, "NSM"],
+    [123023, 123023, "NSM"],
+    [123184, 123190, "NSM"],
+    [123566, 123566, "NSM"],
+    [123628, 123631, "NSM"],
+    [123647, 123647, "ET"],
+    [124140, 124143, "NSM"],
+    [124398, 124399, "NSM"],
+    [124643, 124643, "NSM"],
+    [124646, 124646, "NSM"],
+    [124654, 124655, "NSM"],
+    [124661, 124661, "NSM"],
+    [124928, 125135, "R"],
+    [125136, 125142, "NSM"],
+    [125143, 125251, "R"],
+    [125252, 125258, "NSM"],
+    [125259, 126063, "R"],
+    [126064, 126143, "AL"],
+    [126144, 126207, "R"],
+    [126208, 126287, "AL"],
+    [126288, 126463, "R"],
+    [126464, 126703, "AL"],
+    [126704, 126705, "ON"],
+    [126706, 126719, "AL"],
+    [126720, 126975, "R"],
+    [126976, 127019, "ON"],
+    [127024, 127123, "ON"],
+    [127136, 127150, "ON"],
+    [127153, 127167, "ON"],
+    [127169, 127183, "ON"],
+    [127185, 127221, "ON"],
+    [127232, 127242, "EN"],
+    [127243, 127247, "ON"],
+    [127279, 127279, "ON"],
+    [127338, 127343, "ON"],
+    [127405, 127405, "ON"],
+    [127584, 127589, "ON"],
+    [127744, 128728, "ON"],
+    [128732, 128748, "ON"],
+    [128752, 128764, "ON"],
+    [128768, 128985, "ON"],
+    [128992, 129003, "ON"],
+    [129008, 129008, "ON"],
+    [129024, 129035, "ON"],
+    [129040, 129095, "ON"],
+    [129104, 129113, "ON"],
+    [129120, 129159, "ON"],
+    [129168, 129197, "ON"],
+    [129200, 129211, "ON"],
+    [129216, 129217, "ON"],
+    [129232, 129240, "ON"],
+    [129280, 129623, "ON"],
+    [129632, 129645, "ON"],
+    [129648, 129660, "ON"],
+    [129664, 129674, "ON"],
+    [129678, 129734, "ON"],
+    [129736, 129736, "ON"],
+    [129741, 129756, "ON"],
+    [129759, 129770, "ON"],
+    [129775, 129784, "ON"],
+    [129792, 129938, "ON"],
+    [129940, 130031, "ON"],
+    [130032, 130041, "EN"],
+    [130042, 130042, "ON"],
+    [131070, 131071, "BN"],
+    [196606, 196607, "BN"],
+    [262142, 262143, "BN"],
+    [327678, 327679, "BN"],
+    [393214, 393215, "BN"],
+    [458750, 458751, "BN"],
+    [524286, 524287, "BN"],
+    [589822, 589823, "BN"],
+    [655358, 655359, "BN"],
+    [720894, 720895, "BN"],
+    [786430, 786431, "BN"],
+    [851966, 851967, "BN"],
+    [917502, 917759, "BN"],
+    [917760, 917999, "NSM"],
+    [918e3, 921599, "BN"],
+    [983038, 983039, "BN"],
+    [1048574, 1048575, "BN"],
+    [1114110, 1114111, "BN"]
+  ];
+
+  // ../../node_modules/.pnpm/@chenglou+pretext@0.0.5/node_modules/@chenglou/pretext/dist/bidi.js
+  function classifyCodePoint(codePoint) {
+    if (codePoint <= 255)
+      return latin1BidiTypes[codePoint];
+    let lo = 0;
+    let hi = nonLatin1BidiRanges.length - 1;
+    while (lo <= hi) {
+      const mid = lo + hi >> 1;
+      const range = nonLatin1BidiRanges[mid];
+      if (codePoint < range[0]) {
+        hi = mid - 1;
+        continue;
+      }
+      if (codePoint > range[1]) {
+        lo = mid + 1;
+        continue;
+      }
+      return range[2];
+    }
+    return "L";
+  }
+  __name(classifyCodePoint, "classifyCodePoint");
+  function computeBidiLevels(str) {
+    const len = str.length;
+    if (len === 0)
+      return null;
+    const types = new Array(len);
+    let sawBidi = false;
+    for (let i = 0; i < len; ) {
+      const first2 = str.charCodeAt(i);
+      let codePoint = first2;
+      let codeUnitLength = 1;
+      if (first2 >= 55296 && first2 <= 56319 && i + 1 < len) {
+        const second = str.charCodeAt(i + 1);
+        if (second >= 56320 && second <= 57343) {
+          codePoint = (first2 - 55296 << 10) + (second - 56320) + 65536;
+          codeUnitLength = 2;
+        }
+      }
+      const t2 = classifyCodePoint(codePoint);
+      if (t2 === "R" || t2 === "AL" || t2 === "AN")
+        sawBidi = true;
+      for (let j = 0; j < codeUnitLength; j++) {
+        types[i + j] = t2;
+      }
+      i += codeUnitLength;
+    }
+    if (!sawBidi)
+      return null;
+    let startLevel = 0;
+    for (let i = 0; i < len; i++) {
+      const t2 = types[i];
+      if (t2 === "L") {
+        startLevel = 0;
+        break;
+      }
+      if (t2 === "R" || t2 === "AL") {
+        startLevel = 1;
+        break;
+      }
+    }
+    const levels = new Int8Array(len);
+    for (let i = 0; i < len; i++)
+      levels[i] = startLevel;
+    const e = startLevel & 1 ? "R" : "L";
+    const sor = e;
+    let lastType = sor;
+    for (let i = 0; i < len; i++) {
+      if (types[i] === "NSM")
+        types[i] = lastType;
+      else
+        lastType = types[i];
+    }
+    lastType = sor;
+    for (let i = 0; i < len; i++) {
+      const t2 = types[i];
+      if (t2 === "EN")
+        types[i] = lastType === "AL" ? "AN" : "EN";
+      else if (t2 === "R" || t2 === "L" || t2 === "AL")
+        lastType = t2;
+    }
+    for (let i = 0; i < len; i++) {
+      if (types[i] === "AL")
+        types[i] = "R";
+    }
+    for (let i = 1; i < len - 1; i++) {
+      if (types[i] === "ES" && types[i - 1] === "EN" && types[i + 1] === "EN") {
+        types[i] = "EN";
+      }
+      if (types[i] === "CS" && (types[i - 1] === "EN" || types[i - 1] === "AN") && types[i + 1] === types[i - 1]) {
+        types[i] = types[i - 1];
+      }
+    }
+    for (let i = 0; i < len; i++) {
+      if (types[i] !== "EN")
+        continue;
+      let j;
+      for (j = i - 1; j >= 0 && types[j] === "ET"; j--)
+        types[j] = "EN";
+      for (j = i + 1; j < len && types[j] === "ET"; j++)
+        types[j] = "EN";
+    }
+    for (let i = 0; i < len; i++) {
+      const t2 = types[i];
+      if (t2 === "WS" || t2 === "ES" || t2 === "ET" || t2 === "CS")
+        types[i] = "ON";
+    }
+    lastType = sor;
+    for (let i = 0; i < len; i++) {
+      const t2 = types[i];
+      if (t2 === "EN")
+        types[i] = lastType === "L" ? "L" : "EN";
+      else if (t2 === "R" || t2 === "L")
+        lastType = t2;
+    }
+    for (let i = 0; i < len; i++) {
+      if (types[i] !== "ON")
+        continue;
+      let end = i + 1;
+      while (end < len && types[end] === "ON")
+        end++;
+      const before = i > 0 ? types[i - 1] : sor;
+      const after = end < len ? types[end] : sor;
+      const bDir = before !== "L" ? "R" : "L";
+      const aDir = after !== "L" ? "R" : "L";
+      if (bDir === aDir) {
+        for (let j = i; j < end; j++)
+          types[j] = bDir;
+      }
+      i = end - 1;
+    }
+    for (let i = 0; i < len; i++) {
+      if (types[i] === "ON")
+        types[i] = e;
+    }
+    for (let i = 0; i < len; i++) {
+      const t2 = types[i];
+      if ((levels[i] & 1) === 0) {
+        if (t2 === "R")
+          levels[i]++;
+        else if (t2 === "AN" || t2 === "EN")
+          levels[i] += 2;
+      } else if (t2 === "L" || t2 === "AN" || t2 === "EN") {
+        levels[i]++;
+      }
+    }
+    return levels;
+  }
+  __name(computeBidiLevels, "computeBidiLevels");
+  function computeSegmentLevels(normalized, segStarts) {
+    const bidiLevels = computeBidiLevels(normalized);
+    if (bidiLevels === null)
+      return null;
+    const segLevels = new Int8Array(segStarts.length);
+    for (let i = 0; i < segStarts.length; i++) {
+      segLevels[i] = bidiLevels[segStarts[i]];
+    }
+    return segLevels;
+  }
+  __name(computeSegmentLevels, "computeSegmentLevels");
+
+  // ../../node_modules/.pnpm/@chenglou+pretext@0.0.5/node_modules/@chenglou/pretext/dist/analysis.js
+  var collapsibleWhitespaceRunRe = /[ \t\n\r\f]+/g;
+  var needsWhitespaceNormalizationRe = /[\t\n\r\f]| {2,}|^ | $/;
+  function getWhiteSpaceProfile(whiteSpace) {
+    const mode = whiteSpace ?? "normal";
+    return mode === "pre-wrap" ? { mode, preserveOrdinarySpaces: true, preserveHardBreaks: true } : { mode, preserveOrdinarySpaces: false, preserveHardBreaks: false };
+  }
+  __name(getWhiteSpaceProfile, "getWhiteSpaceProfile");
+  function normalizeWhitespaceNormal(text2) {
+    if (!needsWhitespaceNormalizationRe.test(text2))
+      return text2;
+    let normalized = text2.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;
+  }
+  __name(normalizeWhitespaceNormal, "normalizeWhitespaceNormal");
+  function normalizeWhitespacePreWrap(text2) {
+    if (!/[\r\f]/.test(text2))
+      return text2.replace(/\r\n/g, "\n");
+    return text2.replace(/\r\n/g, "\n").replace(/[\r\f]/g, "\n");
+  }
+  __name(normalizeWhitespacePreWrap, "normalizeWhitespacePreWrap");
+  var sharedWordSegmenter = null;
+  var segmenterLocale;
+  function getSharedWordSegmenter() {
+    if (sharedWordSegmenter === null) {
+      sharedWordSegmenter = new Intl.Segmenter(segmenterLocale, { granularity: "word" });
+    }
+    return sharedWordSegmenter;
+  }
+  __name(getSharedWordSegmenter, "getSharedWordSegmenter");
+  var arabicScriptRe = /\p{Script=Arabic}/u;
+  var combiningMarkRe = /\p{M}/u;
+  var decimalDigitRe = /\p{Nd}/u;
+  function containsArabicScript(text2) {
+    return arabicScriptRe.test(text2);
+  }
+  __name(containsArabicScript, "containsArabicScript");
+  function isCJKCodePoint(codePoint) {
+    return codePoint >= 19968 && codePoint <= 40959 || codePoint >= 13312 && codePoint <= 19903 || codePoint >= 131072 && codePoint <= 173791 || codePoint >= 173824 && codePoint <= 177983 || codePoint >= 177984 && codePoint <= 178207 || codePoint >= 178208 && codePoint <= 183983 || codePoint >= 183984 && codePoint <= 191471 || codePoint >= 191472 && codePoint <= 192093 || codePoint >= 194560 && codePoint <= 195103 || codePoint >= 196608 && codePoint <= 201551 || codePoint >= 201552 && codePoint <= 205743 || codePoint >= 205744 && codePoint <= 210041 || codePoint >= 63744 && codePoint <= 64255 || codePoint >= 12288 && codePoint <= 12351 || codePoint >= 12352 && codePoint <= 12447 || codePoint >= 12448 && codePoint <= 12543 || codePoint >= 44032 && codePoint <= 55215 || codePoint >= 65280 && codePoint <= 65519;
+  }
+  __name(isCJKCodePoint, "isCJKCodePoint");
+  function isCJK(s) {
+    for (let i = 0; i < s.length; i++) {
+      const first2 = s.charCodeAt(i);
+      if (first2 < 12288)
+        continue;
+      if (first2 >= 55296 && first2 <= 56319 && i + 1 < s.length) {
+        const second = s.charCodeAt(i + 1);
+        if (second >= 56320 && second <= 57343) {
+          const codePoint = (first2 - 55296 << 10) + (second - 56320) + 65536;
+          if (isCJKCodePoint(codePoint))
+            return true;
+          i++;
+          continue;
+        }
+      }
+      if (isCJKCodePoint(first2))
+        return true;
+    }
+    return false;
+  }
+  __name(isCJK, "isCJK");
+  function endsWithLineStartProhibitedText(text2) {
+    const last2 = getLastCodePoint(text2);
+    return last2 !== null && (kinsokuStart.has(last2) || leftStickyPunctuation.has(last2));
+  }
+  __name(endsWithLineStartProhibitedText, "endsWithLineStartProhibitedText");
+  var keepAllGlueChars = /* @__PURE__ */ new Set([
+    "\xA0",
+    "\u202F",
+    "\u2060",
+    "\uFEFF"
+  ]);
+  function containsCJKText(text2) {
+    return isCJK(text2);
+  }
+  __name(containsCJKText, "containsCJKText");
+  function endsWithKeepAllGlueText(text2) {
+    const last2 = getLastCodePoint(text2);
+    return last2 !== null && keepAllGlueChars.has(last2);
+  }
+  __name(endsWithKeepAllGlueText, "endsWithKeepAllGlueText");
+  function canContinueKeepAllTextRun(previousText) {
+    return !endsWithLineStartProhibitedText(previousText) && !endsWithKeepAllGlueText(previousText);
+  }
+  __name(canContinueKeepAllTextRun, "canContinueKeepAllTextRun");
+  var 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"
+  ]);
+  var kinsokuEnd = /* @__PURE__ */ new Set([
+    '"',
+    "(",
+    "[",
+    "{",
+    "\u201C",
+    "\u2018",
+    "\xAB",
+    "\u2039",
+    "\uFF08",
+    "\u3014",
+    "\u3008",
+    "\u300A",
+    "\u300C",
+    "\u300E",
+    "\u3010",
+    "\u3016",
+    "\u3018",
+    "\u301A"
+  ]);
+  var forwardStickyGlue = /* @__PURE__ */ new Set([
+    "'",
+    "\u2019"
+  ]);
+  var leftStickyPunctuation = /* @__PURE__ */ new Set([
+    ".",
+    ",",
+    "!",
+    "?",
+    ":",
+    ";",
+    "\u060C",
+    "\u061B",
+    "\u061F",
+    "\u0964",
+    "\u0965",
+    "\u104A",
+    "\u104B",
+    "\u104C",
+    "\u104D",
+    "\u104F",
+    ")",
+    "]",
+    "}",
+    "%",
+    '"',
+    "\u201D",
+    "\u2019",
+    "\xBB",
+    "\u203A",
+    "\u2026"
+  ]);
+  var arabicNoSpaceTrailingPunctuation = /* @__PURE__ */ new Set([
+    ":",
+    ".",
+    "\u060C",
+    "\u061B"
+  ]);
+  var myanmarMedialGlue = /* @__PURE__ */ new Set([
+    "\u104F"
+  ]);
+  var closingQuoteChars = /* @__PURE__ */ new Set([
+    "\u201D",
+    "\u2019",
+    "\xBB",
+    "\u203A",
+    "\u300D",
+    "\u300F",
+    "\u3011",
+    "\u300B",
+    "\u3009",
+    "\u3015",
+    "\uFF09"
+  ]);
+  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;
+  }
+  __name(isLeftStickyPunctuationSegment, "isLeftStickyPunctuationSegment");
+  function isCJKLineStartProhibitedSegment(segment) {
+    for (const ch of segment) {
+      if (!kinsokuStart.has(ch) && !leftStickyPunctuation.has(ch))
+        return false;
+    }
+    return segment.length > 0;
+  }
+  __name(isCJKLineStartProhibitedSegment, "isCJKLineStartProhibitedSegment");
+  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;
+  }
+  __name(isForwardStickyClusterSegment, "isForwardStickyClusterSegment");
+  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;
+  }
+  __name(isEscapedQuoteClusterSegment, "isEscapedQuoteClusterSegment");
+  function previousCodePointStart(text2, end) {
+    const last2 = end - 1;
+    if (last2 <= 0)
+      return Math.max(last2, 0);
+    const lastCodeUnit = text2.charCodeAt(last2);
+    if (lastCodeUnit < 56320 || lastCodeUnit > 57343)
+      return last2;
+    const maybeHigh = last2 - 1;
+    if (maybeHigh < 0)
+      return last2;
+    const highCodeUnit = text2.charCodeAt(maybeHigh);
+    return highCodeUnit >= 55296 && highCodeUnit <= 56319 ? maybeHigh : last2;
+  }
+  __name(previousCodePointStart, "previousCodePointStart");
+  function getLastCodePoint(text2) {
+    if (text2.length === 0)
+      return null;
+    const start = previousCodePointStart(text2, text2.length);
+    return text2.slice(start);
+  }
+  __name(getLastCodePoint, "getLastCodePoint");
+  function splitTrailingForwardStickyCluster(text2) {
+    const chars = Array.from(text2);
+    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("")
+    };
+  }
+  __name(splitTrailingForwardStickyCluster, "splitTrailingForwardStickyCluster");
+  function getRepeatableSingleCharRunChar(text2, isWordLike, kind) {
+    return kind === "text" && !isWordLike && text2.length === 1 && text2 !== "-" && text2 !== "\u2014" ? text2 : null;
+  }
+  __name(getRepeatableSingleCharRunChar, "getRepeatableSingleCharRunChar");
+  function materializeDeferredSingleCharRun(texts, chars, lengths, index) {
+    const ch = chars[index];
+    const text2 = texts[index];
+    if (ch == null)
+      return text2;
+    const length2 = lengths[index];
+    if (text2.length === length2)
+      return text2;
+    const materialized = ch.repeat(length2);
+    texts[index] = materialized;
+    return materialized;
+  }
+  __name(materializeDeferredSingleCharRun, "materializeDeferredSingleCharRun");
+  function hasArabicNoSpacePunctuation(containsArabic, lastCodePoint) {
+    return containsArabic && lastCodePoint !== null && arabicNoSpaceTrailingPunctuation.has(lastCodePoint);
+  }
+  __name(hasArabicNoSpacePunctuation, "hasArabicNoSpacePunctuation");
+  function endsWithMyanmarMedialGlue(segment) {
+    const lastCodePoint = getLastCodePoint(segment);
+    return lastCodePoint !== null && myanmarMedialGlue.has(lastCodePoint);
+  }
+  __name(endsWithMyanmarMedialGlue, "endsWithMyanmarMedialGlue");
+  function splitLeadingSpaceAndMarks(segment) {
+    if (segment.length < 2 || segment[0] !== " ")
+      return null;
+    const marks = segment.slice(1);
+    if (/^\p{M}+$/u.test(marks)) {
+      return { space: " ", marks };
+    }
+    return null;
+  }
+  __name(splitLeadingSpaceAndMarks, "splitLeadingSpaceAndMarks");
+  function endsWithClosingQuote(text2) {
+    let end = text2.length;
+    while (end > 0) {
+      const start = previousCodePointStart(text2, end);
+      const ch = text2.slice(start, end);
+      if (closingQuoteChars.has(ch))
+        return true;
+      if (!leftStickyPunctuation.has(ch))
+        return false;
+      end = start;
+    }
+    return false;
+  }
+  __name(endsWithClosingQuote, "endsWithClosingQuote");
+  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";
+  }
+  __name(classifySegmentBreakChar, "classifySegmentBreakChar");
+  var breakCharRe = /[\x20\t\n\xA0\xAD\u200B\u202F\u2060\uFEFF]/;
+  function joinTextParts(parts) {
+    return parts.length === 1 ? parts[0] : parts.join("");
+  }
+  __name(joinTextParts, "joinTextParts");
+  function joinReversedPrefixParts(prefixParts, tail) {
+    const parts = [];
+    for (let i = prefixParts.length - 1; i >= 0; i--) {
+      parts.push(prefixParts[i]);
+    }
+    parts.push(tail);
+    return joinTextParts(parts);
+  }
+  __name(joinReversedPrefixParts, "joinReversedPrefixParts");
+  function splitSegmentByBreakKind(segment, isWordLike, start, whiteSpaceProfile) {
+    if (!breakCharRe.test(segment)) {
+      return [{ text: segment, isWordLike, kind: "text", start }];
+    }
+    const pieces = [];
+    let currentKind = null;
+    let currentTextParts = [];
+    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) {
+        currentTextParts.push(ch);
+        offset += ch.length;
+        continue;
+      }
+      if (currentKind !== null) {
+        pieces.push({
+          text: joinTextParts(currentTextParts),
+          isWordLike: currentWordLike,
+          kind: currentKind,
+          start: currentStart
+        });
+      }
+      currentKind = kind;
+      currentTextParts = [ch];
+      currentStart = start + offset;
+      currentWordLike = wordLike;
+      offset += ch.length;
+    }
+    if (currentKind !== null) {
+      pieces.push({
+        text: joinTextParts(currentTextParts),
+        isWordLike: currentWordLike,
+        kind: currentKind,
+        start: currentStart
+      });
+    }
+    return pieces;
+  }
+  __name(splitSegmentByBreakKind, "splitSegmentByBreakKind");
+  function isTextRunBoundary(kind) {
+    return kind === "space" || kind === "preserved-space" || kind === "zero-width-break" || kind === "hard-break";
+  }
+  __name(isTextRunBoundary, "isTextRunBoundary");
+  var urlSchemeSegmentRe = /^[A-Za-z][A-Za-z0-9+.-]*:$/;
+  function isUrlLikeRunStart(segmentation, index) {
+    const text2 = segmentation.texts[index];
+    if (text2.startsWith("www."))
+      return true;
+    return urlSchemeSegmentRe.test(text2) && index + 1 < segmentation.len && segmentation.kinds[index + 1] === "text" && segmentation.texts[index + 1] === "//";
+  }
+  __name(isUrlLikeRunStart, "isUrlLikeRunStart");
+  function isUrlQueryBoundarySegment(text2) {
+    return text2.includes("?") && (text2.includes("://") || text2.startsWith("www."));
+  }
+  __name(isUrlQueryBoundarySegment, "isUrlQueryBoundarySegment");
+  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 i = 0; i < segmentation.len; i++) {
+      if (kinds[i] !== "text" || !isUrlLikeRunStart(segmentation, i))
+        continue;
+      const mergedParts = [texts[i]];
+      let j = i + 1;
+      while (j < segmentation.len && !isTextRunBoundary(kinds[j])) {
+        mergedParts.push(texts[j]);
+        isWordLike[i] = true;
+        const endsQueryPrefix = texts[j].includes("?");
+        kinds[j] = "text";
+        texts[j] = "";
+        j++;
+        if (endsQueryPrefix)
+          break;
+      }
+      texts[i] = joinTextParts(mergedParts);
+    }
+    let compactLen = 0;
+    for (let read = 0; read < texts.length; read++) {
+      const text2 = texts[read];
+      if (text2.length === 0)
+        continue;
+      if (compactLen !== read) {
+        texts[compactLen] = text2;
+        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
+    };
+  }
+  __name(mergeUrlLikeRuns, "mergeUrlLikeRuns");
+  function mergeUrlQueryRuns(segmentation) {
+    const texts = [];
+    const isWordLike = [];
+    const kinds = [];
+    const starts = [];
+    for (let i = 0; i < segmentation.len; i++) {
+      const text2 = segmentation.texts[i];
+      texts.push(text2);
+      isWordLike.push(segmentation.isWordLike[i]);
+      kinds.push(segmentation.kinds[i]);
+      starts.push(segmentation.starts[i]);
+      if (!isUrlQueryBoundarySegment(text2))
+        continue;
+      const nextIndex = i + 1;
+      if (nextIndex >= segmentation.len || isTextRunBoundary(segmentation.kinds[nextIndex])) {
+        continue;
+      }
+      const queryParts = [];
+      const queryStart = segmentation.starts[nextIndex];
+      let j = nextIndex;
+      while (j < segmentation.len && !isTextRunBoundary(segmentation.kinds[j])) {
+        queryParts.push(segmentation.texts[j]);
+        j++;
+      }
+      if (queryParts.length > 0) {
+        texts.push(joinTextParts(queryParts));
+        isWordLike.push(true);
+        kinds.push("text");
+        starts.push(queryStart);
+        i = j - 1;
+      }
+    }
+    return {
+      len: texts.length,
+      texts,
+      isWordLike,
+      kinds,
+      starts
+    };
+  }
+  __name(mergeUrlQueryRuns, "mergeUrlQueryRuns");
+  var numericJoinerChars = /* @__PURE__ */ new Set([
+    ":",
+    "-",
+    "/",
+    "\xD7",
+    ",",
+    ".",
+    "+",
+    "\u2013",
+    "\u2014"
+  ]);
+  var asciiPunctuationChainSegmentRe = /^[A-Za-z0-9_]+[,:;]*$/;
+  var asciiPunctuationChainTrailingJoinersRe = /[,:;]+$/;
+  function segmentContainsDecimalDigit(text2) {
+    for (const ch of text2) {
+      if (decimalDigitRe.test(ch))
+        return true;
+    }
+    return false;
+  }
+  __name(segmentContainsDecimalDigit, "segmentContainsDecimalDigit");
+  function isNumericRunSegment(text2) {
+    if (text2.length === 0)
+      return false;
+    for (const ch of text2) {
+      if (decimalDigitRe.test(ch) || numericJoinerChars.has(ch))
+        continue;
+      return false;
+    }
+    return true;
+  }
+  __name(isNumericRunSegment, "isNumericRunSegment");
+  function mergeNumericRuns(segmentation) {
+    const texts = [];
+    const isWordLike = [];
+    const kinds = [];
+    const starts = [];
+    for (let i = 0; i < segmentation.len; i++) {
+      const text2 = segmentation.texts[i];
+      const kind = segmentation.kinds[i];
+      if (kind === "text" && isNumericRunSegment(text2) && segmentContainsDecimalDigit(text2)) {
+        const mergedParts = [text2];
+        let j = i + 1;
+        while (j < segmentation.len && segmentation.kinds[j] === "text" && isNumericRunSegment(segmentation.texts[j])) {
+          mergedParts.push(segmentation.texts[j]);
+          j++;
+        }
+        texts.push(joinTextParts(mergedParts));
+        isWordLike.push(true);
+        kinds.push("text");
+        starts.push(segmentation.starts[i]);
+        i = j - 1;
+        continue;
+      }
+      texts.push(text2);
+      isWordLike.push(segmentation.isWordLike[i]);
+      kinds.push(kind);
+      starts.push(segmentation.starts[i]);
+    }
+    return {
+      len: texts.length,
+      texts,
+      isWordLike,
+      kinds,
+      starts
+    };
+  }
+  __name(mergeNumericRuns, "mergeNumericRuns");
+  function mergeAsciiPunctuationChains(segmentation) {
+    const texts = [];
+    const isWordLike = [];
+    const kinds = [];
+    const starts = [];
+    for (let i = 0; i < segmentation.len; i++) {
+      const text2 = segmentation.texts[i];
+      const kind = segmentation.kinds[i];
+      const wordLike = segmentation.isWordLike[i];
+      if (kind === "text" && wordLike && asciiPunctuationChainSegmentRe.test(text2)) {
+        const mergedParts = [text2];
+        let endsWithJoiners = asciiPunctuationChainTrailingJoinersRe.test(text2);
+        let j = i + 1;
+        while (endsWithJoiners && j < segmentation.len && segmentation.kinds[j] === "text" && segmentation.isWordLike[j] && asciiPunctuationChainSegmentRe.test(segmentation.texts[j])) {
+          const nextText = segmentation.texts[j];
+          mergedParts.push(nextText);
+          endsWithJoiners = asciiPunctuationChainTrailingJoinersRe.test(nextText);
+          j++;
+        }
+        texts.push(joinTextParts(mergedParts));
+        isWordLike.push(true);
+        kinds.push("text");
+        starts.push(segmentation.starts[i]);
+        i = j - 1;
+        continue;
+      }
+      texts.push(text2);
+      isWordLike.push(wordLike);
+      kinds.push(kind);
+      starts.push(segmentation.starts[i]);
+    }
+    return {
+      len: texts.length,
+      texts,
+      isWordLike,
+      kinds,
+      starts
+    };
+  }
+  __name(mergeAsciiPunctuationChains, "mergeAsciiPunctuationChains");
+  function splitHyphenatedNumericRuns(segmentation) {
+    const texts = [];
+    const isWordLike = [];
+    const kinds = [];
+    const starts = [];
+    for (let i = 0; i < segmentation.len; i++) {
+      const text2 = segmentation.texts[i];
+      if (segmentation.kinds[i] === "text" && text2.includes("-")) {
+        const parts = text2.split("-");
+        let shouldSplit = parts.length > 1;
+        for (let j = 0; j < parts.length; j++) {
+          const part = parts[j];
+          if (!shouldSplit)
+            break;
+          if (part.length === 0 || !segmentContainsDecimalDigit(part) || !isNumericRunSegment(part)) {
+            shouldSplit = false;
+          }
+        }
+        if (shouldSplit) {
+          let offset = 0;
+          for (let j = 0; j < parts.length; j++) {
+            const part = parts[j];
+            const splitText = j < parts.length - 1 ? `${part}-` : part;
+            texts.push(splitText);
+            isWordLike.push(true);
+            kinds.push("text");
+            starts.push(segmentation.starts[i] + offset);
+            offset += splitText.length;
+          }
+          continue;
+        }
+      }
+      texts.push(text2);
+      isWordLike.push(segmentation.isWordLike[i]);
+      kinds.push(segmentation.kinds[i]);
+      starts.push(segmentation.starts[i]);
+    }
+    return {
+      len: texts.length,
+      texts,
+      isWordLike,
+      kinds,
+      starts
+    };
+  }
+  __name(splitHyphenatedNumericRuns, "splitHyphenatedNumericRuns");
+  function mergeGlueConnectedTextRuns(segmentation) {
+    const texts = [];
+    const isWordLike = [];
+    const kinds = [];
+    const starts = [];
+    let read = 0;
+    while (read < segmentation.len) {
+      const textParts = [segmentation.texts[read]];
+      let wordLike = segmentation.isWordLike[read];
+      let kind = segmentation.kinds[read];
+      let start = segmentation.starts[read];
+      if (kind === "glue") {
+        const glueParts = [textParts[0]];
+        const glueStart = start;
+        read++;
+        while (read < segmentation.len && segmentation.kinds[read] === "glue") {
+          glueParts.push(segmentation.texts[read]);
+          read++;
+        }
+        const glueText = joinTextParts(glueParts);
+        if (read < segmentation.len && segmentation.kinds[read] === "text") {
+          textParts[0] = glueText;
+          textParts.push(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") {
+          const glueParts = [];
+          while (read < segmentation.len && segmentation.kinds[read] === "glue") {
+            glueParts.push(segmentation.texts[read]);
+            read++;
+          }
+          const glueText = joinTextParts(glueParts);
+          if (read < segmentation.len && segmentation.kinds[read] === "text") {
+            textParts.push(glueText, segmentation.texts[read]);
+            wordLike = wordLike || segmentation.isWordLike[read];
+            read++;
+            continue;
+          }
+          textParts.push(glueText);
+        }
+      }
+      texts.push(joinTextParts(textParts));
+      isWordLike.push(wordLike);
+      kinds.push(kind);
+      starts.push(start);
+    }
+    return {
+      len: texts.length,
+      texts,
+      isWordLike,
+      kinds,
+      starts
+    };
+  }
+  __name(mergeGlueConnectedTextRuns, "mergeGlueConnectedTextRuns");
+  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 i = 0; i < texts.length - 1; i++) {
+      if (kinds[i] !== "text" || kinds[i + 1] !== "text")
+        continue;
+      if (!isCJK(texts[i]) || !isCJK(texts[i + 1]))
+        continue;
+      const split = splitTrailingForwardStickyCluster(texts[i]);
+      if (split === null)
+        continue;
+      texts[i] = split.head;
+      texts[i + 1] = split.tail + texts[i + 1];
+      starts[i + 1] = starts[i] + split.head.length;
+    }
+    return {
+      len: texts.length,
+      texts,
+      isWordLike,
+      kinds,
+      starts
+    };
+  }
+  __name(carryTrailingForwardStickyAcrossCJKBoundary, "carryTrailingForwardStickyAcrossCJKBoundary");
+  function buildMergedSegmentation(normalized, profile, whiteSpaceProfile) {
+    const wordSegmenter = getSharedWordSegmenter();
+    let mergedLen = 0;
+    const mergedTexts = [];
+    const mergedTextParts = [];
+    const mergedWordLike = [];
+    const mergedKinds = [];
+    const mergedStarts = [];
+    const mergedSingleCharRunChars = [];
+    const mergedSingleCharRunLengths = [];
+    const mergedContainsCJK = [];
+    const mergedContainsArabicScript = [];
+    const mergedEndsWithClosingQuote = [];
+    const mergedEndsWithMyanmarMedialGlue = [];
+    const mergedHasArabicNoSpacePunctuation = [];
+    for (const s of wordSegmenter.segment(normalized)) {
+      for (const piece of splitSegmentByBreakKind(s.segment, s.isWordLike ?? false, s.index, whiteSpaceProfile)) {
+        let appendPieceToPrevious2 = function() {
+          if (mergedSingleCharRunChars[prevIndex] !== null) {
+            mergedTextParts[prevIndex] = [
+              materializeDeferredSingleCharRun(mergedTexts, mergedSingleCharRunChars, mergedSingleCharRunLengths, prevIndex)
+            ];
+            mergedSingleCharRunChars[prevIndex] = null;
+          }
+          mergedTextParts[prevIndex].push(piece.text);
+          mergedWordLike[prevIndex] = mergedWordLike[prevIndex] || piece.isWordLike;
+          mergedContainsCJK[prevIndex] = mergedContainsCJK[prevIndex] || pieceContainsCJK;
+          mergedContainsArabicScript[prevIndex] = mergedContainsArabicScript[prevIndex] || pieceContainsArabicScript;
+          mergedEndsWithClosingQuote[prevIndex] = pieceEndsWithClosingQuote;
+          mergedEndsWithMyanmarMedialGlue[prevIndex] = pieceEndsWithMyanmarMedialGlue;
+          mergedHasArabicNoSpacePunctuation[prevIndex] = hasArabicNoSpacePunctuation(mergedContainsArabicScript[prevIndex], pieceLastCodePoint);
+        };
+        var appendPieceToPrevious = appendPieceToPrevious2;
+        __name(appendPieceToPrevious2, "appendPieceToPrevious");
+        const isText = piece.kind === "text";
+        const repeatableSingleCharRunChar = getRepeatableSingleCharRunChar(piece.text, piece.isWordLike, piece.kind);
+        const pieceContainsCJK = isCJK(piece.text);
+        const pieceContainsArabicScript = containsArabicScript(piece.text);
+        const pieceLastCodePoint = getLastCodePoint(piece.text);
+        const pieceEndsWithClosingQuote = endsWithClosingQuote(piece.text);
+        const pieceEndsWithMyanmarMedialGlue = endsWithMyanmarMedialGlue(piece.text);
+        const prevIndex = mergedLen - 1;
+        if (profile.carryCJKAfterClosingQuote && isText && mergedLen > 0 && mergedKinds[prevIndex] === "text" && pieceContainsCJK && mergedContainsCJK[prevIndex] && mergedEndsWithClosingQuote[prevIndex]) {
+          appendPieceToPrevious2();
+        } else if (isText && mergedLen > 0 && mergedKinds[prevIndex] === "text" && isCJKLineStartProhibitedSegment(piece.text) && mergedContainsCJK[prevIndex]) {
+          appendPieceToPrevious2();
+        } else if (isText && mergedLen > 0 && mergedKinds[prevIndex] === "text" && mergedEndsWithMyanmarMedialGlue[prevIndex]) {
+          appendPieceToPrevious2();
+        } else if (isText && mergedLen > 0 && mergedKinds[prevIndex] === "text" && piece.isWordLike && pieceContainsArabicScript && mergedHasArabicNoSpacePunctuation[prevIndex]) {
+          appendPieceToPrevious2();
+          mergedWordLike[prevIndex] = true;
+        } else if (repeatableSingleCharRunChar !== null && mergedLen > 0 && mergedKinds[prevIndex] === "text" && mergedSingleCharRunChars[prevIndex] === repeatableSingleCharRunChar) {
+          mergedSingleCharRunLengths[prevIndex] = (mergedSingleCharRunLengths[prevIndex] ?? 1) + 1;
+        } else if (isText && !piece.isWordLike && mergedLen > 0 && mergedKinds[prevIndex] === "text" && (isLeftStickyPunctuationSegment(piece.text) || piece.text === "-" && mergedWordLike[prevIndex])) {
+          appendPieceToPrevious2();
+        } else {
+          mergedTexts[mergedLen] = piece.text;
+          mergedTextParts[mergedLen] = [piece.text];
+          mergedWordLike[mergedLen] = piece.isWordLike;
+          mergedKinds[mergedLen] = piece.kind;
+          mergedStarts[mergedLen] = piece.start;
+          mergedSingleCharRunChars[mergedLen] = repeatableSingleCharRunChar;
+          mergedSingleCharRunLengths[mergedLen] = repeatableSingleCharRunChar === null ? 0 : 1;
+          mergedContainsCJK[mergedLen] = pieceContainsCJK;
+          mergedContainsArabicScript[mergedLen] = pieceContainsArabicScript;
+          mergedEndsWithClosingQuote[mergedLen] = pieceEndsWithClosingQuote;
+          mergedEndsWithMyanmarMedialGlue[mergedLen] = pieceEndsWithMyanmarMedialGlue;
+          mergedHasArabicNoSpacePunctuation[mergedLen] = hasArabicNoSpacePunctuation(pieceContainsArabicScript, pieceLastCodePoint);
+          mergedLen++;
+        }
+      }
+    }
+    for (let i = 0; i < mergedLen; i++) {
+      if (mergedSingleCharRunChars[i] !== null) {
+        mergedTexts[i] = materializeDeferredSingleCharRun(mergedTexts, mergedSingleCharRunChars, mergedSingleCharRunLengths, i);
+        continue;
+      }
+      mergedTexts[i] = joinTextParts(mergedTextParts[i]);
+    }
+    for (let i = 1; i < mergedLen; i++) {
+      if (mergedKinds[i] === "text" && !mergedWordLike[i] && isEscapedQuoteClusterSegment(mergedTexts[i]) && mergedKinds[i - 1] === "text") {
+        mergedTexts[i - 1] += mergedTexts[i];
+        mergedWordLike[i - 1] = mergedWordLike[i - 1] || mergedWordLike[i];
+        mergedTexts[i] = "";
+      }
+    }
+    const forwardStickyPrefixParts = Array.from({ length: mergedLen }, () => null);
+    let nextLiveIndex = -1;
+    for (let i = mergedLen - 1; i >= 0; i--) {
+      const text2 = mergedTexts[i];
+      if (text2.length === 0)
+        continue;
+      if (mergedKinds[i] === "text" && !mergedWordLike[i] && isForwardStickyClusterSegment(text2) && nextLiveIndex >= 0 && mergedKinds[nextLiveIndex] === "text") {
+        const prefixParts = forwardStickyPrefixParts[nextLiveIndex] ?? [];
+        prefixParts.push(text2);
+        forwardStickyPrefixParts[nextLiveIndex] = prefixParts;
+        mergedStarts[nextLiveIndex] = mergedStarts[i];
+        mergedTexts[i] = "";
+        continue;
+      }
+      nextLiveIndex = i;
+    }
+    for (let i = 0; i < mergedLen; i++) {
+      const prefixParts = forwardStickyPrefixParts[i];
+      if (prefixParts == null)
+        continue;
+      mergedTexts[i] = joinReversedPrefixParts(prefixParts, mergedTexts[i]);
+    }
+    let compactLen = 0;
+    for (let read = 0; read < mergedLen; read++) {
+      const text2 = mergedTexts[read];
+      if (text2.length === 0)
+        continue;
+      if (compactLen !== read) {
+        mergedTexts[compactLen] = text2;
+        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 i = 0; i < withMergedUrls.len - 1; i++) {
+      const split = splitLeadingSpaceAndMarks(withMergedUrls.texts[i]);
+      if (split === null)
+        continue;
+      if (withMergedUrls.kinds[i] !== "space" && withMergedUrls.kinds[i] !== "preserved-space" || withMergedUrls.kinds[i + 1] !== "text" || !containsArabicScript(withMergedUrls.texts[i + 1])) {
+        continue;
+      }
+      withMergedUrls.texts[i] = split.space;
+      withMergedUrls.isWordLike[i] = false;
+      withMergedUrls.kinds[i] = withMergedUrls.kinds[i] === "preserved-space" ? "preserved-space" : "space";
+      withMergedUrls.texts[i + 1] = split.marks + withMergedUrls.texts[i + 1];
+      withMergedUrls.starts[i + 1] = withMergedUrls.starts[i] + split.space.length;
+    }
+    return withMergedUrls;
+  }
+  __name(buildMergedSegmentation, "buildMergedSegmentation");
+  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 i = 0; i < segmentation.len; i++) {
+      if (segmentation.kinds[i] !== "hard-break")
+        continue;
+      chunks.push({
+        startSegmentIndex,
+        endSegmentIndex: i,
+        consumedEndSegmentIndex: i + 1
+      });
+      startSegmentIndex = i + 1;
+    }
+    if (startSegmentIndex < segmentation.len) {
+      chunks.push({
+        startSegmentIndex,
+        endSegmentIndex: segmentation.len,
+        consumedEndSegmentIndex: segmentation.len
+      });
+    }
+    return chunks;
+  }
+  __name(compileAnalysisChunks, "compileAnalysisChunks");
+  function mergeKeepAllTextSegments(segmentation) {
+    if (segmentation.len <= 1)
+      return segmentation;
+    const texts = [];
+    const isWordLike = [];
+    const kinds = [];
+    const starts = [];
+    let pendingTextParts = null;
+    let pendingWordLike = false;
+    let pendingStart = 0;
+    let pendingContainsCJK = false;
+    let pendingCanContinue = false;
+    function flushPendingText() {
+      if (pendingTextParts === null)
+        return;
+      texts.push(joinTextParts(pendingTextParts));
+      isWordLike.push(pendingWordLike);
+      kinds.push("text");
+      starts.push(pendingStart);
+      pendingTextParts = null;
+    }
+    __name(flushPendingText, "flushPendingText");
+    for (let i = 0; i < segmentation.len; i++) {
+      const text2 = segmentation.texts[i];
+      const kind = segmentation.kinds[i];
+      const wordLike = segmentation.isWordLike[i];
+      const start = segmentation.starts[i];
+      if (kind === "text") {
+        const textContainsCJK = containsCJKText(text2);
+        const textCanContinue = canContinueKeepAllTextRun(text2);
+        if (pendingTextParts !== null && pendingContainsCJK && pendingCanContinue) {
+          pendingTextParts.push(text2);
+          pendingWordLike = pendingWordLike || wordLike;
+          pendingContainsCJK = pendingContainsCJK || textContainsCJK;
+          pendingCanContinue = textCanContinue;
+          continue;
+        }
+        flushPendingText();
+        pendingTextParts = [text2];
+        pendingWordLike = wordLike;
+        pendingStart = start;
+        pendingContainsCJK = textContainsCJK;
+        pendingCanContinue = textCanContinue;
+        continue;
+      }
+      flushPendingText();
+      texts.push(text2);
+      isWordLike.push(wordLike);
+      kinds.push(kind);
+      starts.push(start);
+    }
+    flushPendingText();
+    return {
+      len: texts.length,
+      texts,
+      isWordLike,
+      kinds,
+      starts
+    };
+  }
+  __name(mergeKeepAllTextSegments, "mergeKeepAllTextSegments");
+  function analyzeText(text2, profile, whiteSpace = "normal", wordBreak = "normal") {
+    const whiteSpaceProfile = getWhiteSpaceProfile(whiteSpace);
+    const normalized = whiteSpaceProfile.mode === "pre-wrap" ? normalizeWhitespacePreWrap(text2) : normalizeWhitespaceNormal(text2);
+    if (normalized.length === 0) {
+      return {
+        normalized,
+        chunks: [],
+        len: 0,
+        texts: [],
+        isWordLike: [],
+        kinds: [],
+        starts: []
+      };
+    }
+    const segmentation = wordBreak === "keep-all" ? mergeKeepAllTextSegments(buildMergedSegmentation(normalized, profile, whiteSpaceProfile)) : buildMergedSegmentation(normalized, profile, whiteSpaceProfile);
+    return {
+      normalized,
+      chunks: compileAnalysisChunks(segmentation, whiteSpaceProfile),
+      ...segmentation
+    };
+  }
+  __name(analyzeText, "analyzeText");
+
+  // ../../node_modules/.pnpm/@chenglou+pretext@0.0.5/node_modules/@chenglou/pretext/dist/measurement.js
+  var measureContext = null;
+  var segmentMetricCaches = /* @__PURE__ */ new Map();
+  var cachedEngineProfile = null;
+  var MAX_PREFIX_FIT_GRAPHEMES = 96;
+  var emojiPresentationRe = /\p{Emoji_Presentation}/u;
+  var maybeEmojiRe = /[\p{Emoji_Presentation}\p{Extended_Pictographic}\p{Regional_Indicator}\uFE0F\u20E3]/u;
+  var sharedGraphemeSegmenter = null;
+  var emojiCorrectionCache = /* @__PURE__ */ new Map();
+  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.");
+  }
+  __name(getMeasureContext, "getMeasureContext");
+  function getSegmentMetricCache(font) {
+    let cache3 = segmentMetricCaches.get(font);
+    if (!cache3) {
+      cache3 = /* @__PURE__ */ new Map();
+      segmentMetricCaches.set(font, cache3);
+    }
+    return cache3;
+  }
+  __name(getSegmentMetricCache, "getSegmentMetricCache");
+  function getSegmentMetrics(seg, cache3) {
+    let metrics = cache3.get(seg);
+    if (metrics === void 0) {
+      const ctx = getMeasureContext();
+      metrics = {
+        width: ctx.measureText(seg).width,
+        containsCJK: isCJK(seg)
+      };
+      cache3.set(seg, metrics);
+    }
+    return metrics;
+  }
+  __name(getSegmentMetrics, "getSegmentMetrics");
+  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;
+  }
+  __name(getEngineProfile, "getEngineProfile");
+  function parseFontSize(font) {
+    const m = font.match(/(\d+(?:\.\d+)?)\s*px/);
+    return m ? parseFloat(m[1]) : 16;
+  }
+  __name(parseFontSize, "parseFontSize");
+  function getSharedGraphemeSegmenter() {
+    if (sharedGraphemeSegmenter === null) {
+      sharedGraphemeSegmenter = new Intl.Segmenter(void 0, { granularity: "grapheme" });
+    }
+    return sharedGraphemeSegmenter;
+  }
+  __name(getSharedGraphemeSegmenter, "getSharedGraphemeSegmenter");
+  function isEmojiGrapheme(g) {
+    return emojiPresentationRe.test(g) || g.includes("\uFE0F");
+  }
+  __name(isEmojiGrapheme, "isEmojiGrapheme");
+  function textMayContainEmoji(text2) {
+    return maybeEmojiRe.test(text2);
+  }
+  __name(textMayContainEmoji, "textMayContainEmoji");
+  function getEmojiCorrection(font, fontSize) {
+    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 > fontSize + 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;
+  }
+  __name(getEmojiCorrection, "getEmojiCorrection");
+  function countEmojiGraphemes(text2) {
+    let count2 = 0;
+    const graphemeSegmenter = getSharedGraphemeSegmenter();
+    for (const g of graphemeSegmenter.segment(text2)) {
+      if (isEmojiGrapheme(g.segment))
+        count2++;
+    }
+    return count2;
+  }
+  __name(countEmojiGraphemes, "countEmojiGraphemes");
+  function getEmojiCount(seg, metrics) {
+    if (metrics.emojiCount === void 0) {
+      metrics.emojiCount = countEmojiGraphemes(seg);
+    }
+    return metrics.emojiCount;
+  }
+  __name(getEmojiCount, "getEmojiCount");
+  function getCorrectedSegmentWidth(seg, metrics, emojiCorrection) {
+    if (emojiCorrection === 0)
+      return metrics.width;
+    return metrics.width - getEmojiCount(seg, metrics) * emojiCorrection;
+  }
+  __name(getCorrectedSegmentWidth, "getCorrectedSegmentWidth");
+  function getSegmentBreakableFitAdvances(seg, metrics, cache3, emojiCorrection, mode) {
+    if (metrics.breakableFitAdvances !== void 0)
+      return metrics.breakableFitAdvances;
+    const graphemeSegmenter = getSharedGraphemeSegmenter();
+    const graphemes = [];
+    for (const gs of graphemeSegmenter.segment(seg)) {
+      graphemes.push(gs.segment);
+    }
+    if (graphemes.length <= 1) {
+      metrics.breakableFitAdvances = null;
+      return metrics.breakableFitAdvances;
+    }
+    if (mode === "sum-graphemes") {
+      const advances2 = [];
+      for (const grapheme of graphemes) {
+        const graphemeMetrics = getSegmentMetrics(grapheme, cache3);
+        advances2.push(getCorrectedSegmentWidth(grapheme, graphemeMetrics, emojiCorrection));
+      }
+      metrics.breakableFitAdvances = advances2;
+      return metrics.breakableFitAdvances;
+    }
+    if (mode === "pair-context" || graphemes.length > MAX_PREFIX_FIT_GRAPHEMES) {
+      const advances2 = [];
+      let previousGrapheme = null;
+      let previousWidth = 0;
+      for (const grapheme of graphemes) {
+        const graphemeMetrics = getSegmentMetrics(grapheme, cache3);
+        const currentWidth = getCorrectedSegmentWidth(grapheme, graphemeMetrics, emojiCorrection);
+        if (previousGrapheme === null) {
+          advances2.push(currentWidth);
+        } else {
+          const pair = previousGrapheme + grapheme;
+          const pairMetrics = getSegmentMetrics(pair, cache3);
+          advances2.push(getCorrectedSegmentWidth(pair, pairMetrics, emojiCorrection) - previousWidth);
+        }
+        previousGrapheme = grapheme;
+        previousWidth = currentWidth;
+      }
+      metrics.breakableFitAdvances = advances2;
+      return metrics.breakableFitAdvances;
+    }
+    const advances = [];
+    let prefix = "";
+    let prefixWidth = 0;
+    for (const grapheme of graphemes) {
+      prefix += grapheme;
+      const prefixMetrics = getSegmentMetrics(prefix, cache3);
+      const nextPrefixWidth = getCorrectedSegmentWidth(prefix, prefixMetrics, emojiCorrection);
+      advances.push(nextPrefixWidth - prefixWidth);
+      prefixWidth = nextPrefixWidth;
+    }
+    metrics.breakableFitAdvances = advances;
+    return metrics.breakableFitAdvances;
+  }
+  __name(getSegmentBreakableFitAdvances, "getSegmentBreakableFitAdvances");
+  function getFontMeasurementState(font, needsEmojiCorrection) {
+    const ctx = getMeasureContext();
+    ctx.font = font;
+    const cache3 = getSegmentMetricCache(font);
+    const fontSize = parseFontSize(font);
+    const emojiCorrection = needsEmojiCorrection ? getEmojiCorrection(font, fontSize) : 0;
+    return { cache: cache3, fontSize, emojiCorrection };
+  }
+  __name(getFontMeasurementState, "getFontMeasurementState");
+
+  // ../../node_modules/.pnpm/@chenglou+pretext@0.0.5/node_modules/@chenglou/pretext/dist/line-break.js
+  function normalizeSimpleLineStartSegmentIndex(prepared, segmentIndex) {
+    while (segmentIndex < prepared.widths.length) {
+      const kind = prepared.kinds[segmentIndex];
+      if (kind !== "space" && kind !== "zero-width-break" && kind !== "soft-hyphen")
+        break;
+      segmentIndex++;
+    }
+    return segmentIndex;
+  }
+  __name(normalizeSimpleLineStartSegmentIndex, "normalizeSimpleLineStartSegmentIndex");
+  function getTabAdvance(lineWidth, tabStopAdvance) {
+    if (tabStopAdvance <= 0)
+      return 0;
+    const remainder = lineWidth % tabStopAdvance;
+    if (Math.abs(remainder) <= 1e-6)
+      return tabStopAdvance;
+    return tabStopAdvance - remainder;
+  }
+  __name(getTabAdvance, "getTabAdvance");
+  function fitSoftHyphenBreak(graphemeFitAdvances, initialWidth, maxWidth, lineFitEpsilon, discretionaryHyphenWidth) {
+    let fitCount = 0;
+    let fittedWidth = initialWidth;
+    while (fitCount < graphemeFitAdvances.length) {
+      const nextWidth = fittedWidth + graphemeFitAdvances[fitCount];
+      const nextLineWidth = fitCount + 1 < graphemeFitAdvances.length ? nextWidth + discretionaryHyphenWidth : nextWidth;
+      if (nextLineWidth > maxWidth + lineFitEpsilon)
+        break;
+      fittedWidth = nextWidth;
+      fitCount++;
+    }
+    return { fitCount, fittedWidth };
+  }
+  __name(fitSoftHyphenBreak, "fitSoftHyphenBreak");
+  function findChunkIndexForStart(prepared, segmentIndex) {
+    let lo = 0;
+    let hi = prepared.chunks.length;
+    while (lo < hi) {
+      const mid = Math.floor((lo + hi) / 2);
+      if (segmentIndex < prepared.chunks[mid].consumedEndSegmentIndex) {
+        hi = mid;
+      } else {
+        lo = mid + 1;
+      }
+    }
+    return lo < prepared.chunks.length ? lo : -1;
+  }
+  __name(findChunkIndexForStart, "findChunkIndexForStart");
+  function normalizeLineStartInChunk(prepared, chunkIndex, cursor) {
+    let segmentIndex = cursor.segmentIndex;
+    if (cursor.graphemeIndex > 0)
+      return chunkIndex;
+    const chunk = prepared.chunks[chunkIndex];
+    if (chunk.startSegmentIndex === chunk.endSegmentIndex && segmentIndex === chunk.startSegmentIndex) {
+      cursor.segmentIndex = segmentIndex;
+      cursor.graphemeIndex = 0;
+      return chunkIndex;
+    }
+    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") {
+        cursor.segmentIndex = segmentIndex;
+        cursor.graphemeIndex = 0;
+        return chunkIndex;
+      }
+      segmentIndex++;
+    }
+    if (chunk.consumedEndSegmentIndex >= prepared.widths.length)
+      return -1;
+    cursor.segmentIndex = chunk.consumedEndSegmentIndex;
+    cursor.graphemeIndex = 0;
+    return chunkIndex + 1;
+  }
+  __name(normalizeLineStartInChunk, "normalizeLineStartInChunk");
+  function normalizeLineStartChunkIndex(prepared, cursor) {
+    if (cursor.segmentIndex >= prepared.widths.length)
+      return -1;
+    const chunkIndex = findChunkIndexForStart(prepared, cursor.segmentIndex);
+    if (chunkIndex < 0)
+      return -1;
+    return normalizeLineStartInChunk(prepared, chunkIndex, cursor);
+  }
+  __name(normalizeLineStartChunkIndex, "normalizeLineStartChunkIndex");
+  function walkPreparedLinesSimple(prepared, maxWidth, onLine) {
+    const { widths, kinds, breakableFitAdvances } = prepared;
+    if (widths.length === 0)
+      return 0;
+    const engineProfile = getEngineProfile();
+    const lineFitEpsilon = engineProfile.lineFitEpsilon;
+    const fitLimit = maxWidth + lineFitEpsilon;
+    let lineCount = 0;
+    let lineW = 0;
+    let hasContent = 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;
+    }
+    __name(clearPendingBreak, "clearPendingBreak");
+    function emitCurrentLine(endSegmentIndex = lineEndSegmentIndex, endGraphemeIndex = lineEndGraphemeIndex, width2 = lineW) {
+      lineCount++;
+      onLine?.({
+        startSegmentIndex: lineStartSegmentIndex,
+        startGraphemeIndex: lineStartGraphemeIndex,
+        endSegmentIndex,
+        endGraphemeIndex,
+        width: width2
+      });
+      lineW = 0;
+      hasContent = false;
+      clearPendingBreak();
+    }
+    __name(emitCurrentLine, "emitCurrentLine");
+    function startLineAtSegment(segmentIndex, width2) {
+      hasContent = true;
+      lineStartSegmentIndex = segmentIndex;
+      lineStartGraphemeIndex = 0;
+      lineEndSegmentIndex = segmentIndex + 1;
+      lineEndGraphemeIndex = 0;
+      lineW = width2;
+    }
+    __name(startLineAtSegment, "startLineAtSegment");
+    function startLineAtGrapheme(segmentIndex, graphemeIndex, width2) {
+      hasContent = true;
+      lineStartSegmentIndex = segmentIndex;
+      lineStartGraphemeIndex = graphemeIndex;
+      lineEndSegmentIndex = segmentIndex;
+      lineEndGraphemeIndex = graphemeIndex + 1;
+      lineW = width2;
+    }
+    __name(startLineAtGrapheme, "startLineAtGrapheme");
+    function appendWholeSegment(segmentIndex, width2) {
+      if (!hasContent) {
+        startLineAtSegment(segmentIndex, width2);
+        return;
+      }
+      lineW += width2;
+      lineEndSegmentIndex = segmentIndex + 1;
+      lineEndGraphemeIndex = 0;
+    }
+    __name(appendWholeSegment, "appendWholeSegment");
+    function appendBreakableSegmentFrom(segmentIndex, startGraphemeIndex) {
+      const fitAdvances = breakableFitAdvances[segmentIndex];
+      for (let g = startGraphemeIndex; g < fitAdvances.length; g++) {
+        const gw = fitAdvances[g];
+        if (!hasContent) {
+          startLineAtGrapheme(segmentIndex, g, gw);
+        } else if (lineW + gw > fitLimit) {
+          emitCurrentLine();
+          startLineAtGrapheme(segmentIndex, g, gw);
+        } else {
+          lineW += gw;
+          lineEndSegmentIndex = segmentIndex;
+          lineEndGraphemeIndex = g + 1;
+        }
+      }
+      if (hasContent && lineEndSegmentIndex === segmentIndex && lineEndGraphemeIndex === fitAdvances.length) {
+        lineEndSegmentIndex = segmentIndex + 1;
+        lineEndGraphemeIndex = 0;
+      }
+    }
+    __name(appendBreakableSegmentFrom, "appendBreakableSegmentFrom");
+    let i = 0;
+    while (i < widths.length) {
+      if (!hasContent) {
+        i = normalizeSimpleLineStartSegmentIndex(prepared, i);
+        if (i >= widths.length)
+          break;
+      }
+      const w = widths[i];
+      const kind = kinds[i];
+      const breakAfter = kind === "space" || kind === "preserved-space" || kind === "tab" || kind === "zero-width-break" || kind === "soft-hyphen";
+      if (!hasContent) {
+        if (w > maxWidth && breakableFitAdvances[i] !== null) {
+          appendBreakableSegmentFrom(i, 0);
+        } else {
+          startLineAtSegment(i, w);
+        }
+        if (breakAfter) {
+          pendingBreakSegmentIndex = i + 1;
+          pendingBreakPaintWidth = lineW - w;
+        }
+        i++;
+        continue;
+      }
+      const newW = lineW + w;
+      if (newW > fitLimit) {
+        if (breakAfter) {
+          appendWholeSegment(i, w);
+          emitCurrentLine(i + 1, 0, lineW - w);
+          i++;
+          continue;
+        }
+        if (pendingBreakSegmentIndex >= 0) {
+          if (lineEndSegmentIndex > pendingBreakSegmentIndex || lineEndSegmentIndex === pendingBreakSegmentIndex && lineEndGraphemeIndex > 0) {
+            emitCurrentLine();
+            continue;
+          }
+          emitCurrentLine(pendingBreakSegmentIndex, 0, pendingBreakPaintWidth);
+          continue;
+        }
+        if (w > maxWidth && breakableFitAdvances[i] !== null) {
+          emitCurrentLine();
+          appendBreakableSegmentFrom(i, 0);
+          i++;
+          continue;
+        }
+        emitCurrentLine();
+        continue;
+      }
+      appendWholeSegment(i, w);
+      if (breakAfter) {
+        pendingBreakSegmentIndex = i + 1;
+        pendingBreakPaintWidth = lineW - w;
+      }
+      i++;
+    }
+    if (hasContent)
+      emitCurrentLine();
+    return lineCount;
+  }
+  __name(walkPreparedLinesSimple, "walkPreparedLinesSimple");
+  function walkPreparedLines(prepared, maxWidth, onLine) {
+    if (prepared.simpleLineWalkFastPath) {
+      return walkPreparedLinesSimple(prepared, maxWidth, onLine);
+    }
+    const { widths, lineEndFitAdvances, lineEndPaintAdvances, kinds, breakableFitAdvances, discretionaryHyphenWidth, tabStopAdvance, chunks } = prepared;
+    if (widths.length === 0 || chunks.length === 0)
+      return 0;
+    const engineProfile = getEngineProfile();
+    const lineFitEpsilon = engineProfile.lineFitEpsilon;
+    const fitLimit = maxWidth + lineFitEpsilon;
+    let lineCount = 0;
+    let lineW = 0;
+    let hasContent = 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;
+    }
+    __name(clearPendingBreak, "clearPendingBreak");
+    function emitCurrentLine(endSegmentIndex = lineEndSegmentIndex, endGraphemeIndex = lineEndGraphemeIndex, width2 = lineW) {
+      lineCount++;
+      onLine?.({
+        startSegmentIndex: lineStartSegmentIndex,
+        startGraphemeIndex: lineStartGraphemeIndex,
+        endSegmentIndex,
+        endGraphemeIndex,
+        width: width2
+      });
+      lineW = 0;
+      hasContent = false;
+      clearPendingBreak();
+    }
+    __name(emitCurrentLine, "emitCurrentLine");
+    function startLineAtSegment(segmentIndex, width2) {
+      hasContent = true;
+      lineStartSegmentIndex = segmentIndex;
+      lineStartGraphemeIndex = 0;
+      lineEndSegmentIndex = segmentIndex + 1;
+      lineEndGraphemeIndex = 0;
+      lineW = width2;
+    }
+    __name(startLineAtSegment, "startLineAtSegment");
+    function startLineAtGrapheme(segmentIndex, graphemeIndex, width2) {
+      hasContent = true;
+      lineStartSegmentIndex = segmentIndex;
+      lineStartGraphemeIndex = graphemeIndex;
+      lineEndSegmentIndex = segmentIndex;
+      lineEndGraphemeIndex = graphemeIndex + 1;
+      lineW = width2;
+    }
+    __name(startLineAtGrapheme, "startLineAtGrapheme");
+    function appendWholeSegment(segmentIndex, width2) {
+      if (!hasContent) {
+        startLineAtSegment(segmentIndex, width2);
+        return;
+      }
+      lineW += width2;
+      lineEndSegmentIndex = segmentIndex + 1;
+      lineEndGraphemeIndex = 0;
+    }
+    __name(appendWholeSegment, "appendWholeSegment");
+    function updatePendingBreakForWholeSegment(kind, breakAfter, segmentIndex, segmentWidth) {
+      if (!breakAfter)
+        return;
+      const fitAdvance = kind === "tab" ? 0 : lineEndFitAdvances[segmentIndex];
+      const paintAdvance = kind === "tab" ? segmentWidth : lineEndPaintAdvances[segmentIndex];
+      pendingBreakSegmentIndex = segmentIndex + 1;
+      pendingBreakFitWidth = lineW - segmentWidth + fitAdvance;
+      pendingBreakPaintWidth = lineW - segmentWidth + paintAdvance;
+      pendingBreakKind = kind;
+    }
+    __name(updatePendingBreakForWholeSegment, "updatePendingBreakForWholeSegment");
+    function appendBreakableSegmentFrom(segmentIndex, startGraphemeIndex) {
+      const fitAdvances = breakableFitAdvances[segmentIndex];
+      for (let g = startGraphemeIndex; g < fitAdvances.length; g++) {
+        const gw = fitAdvances[g];
+        if (!hasContent) {
+          startLineAtGrapheme(segmentIndex, g, gw);
+        } else if (lineW + gw > fitLimit) {
+          emitCurrentLine();
+          startLineAtGrapheme(segmentIndex, g, gw);
+        } else {
+          lineW += gw;
+          lineEndSegmentIndex = segmentIndex;
+          lineEndGraphemeIndex = g + 1;
+        }
+      }
+      if (hasContent && lineEndSegmentIndex === segmentIndex && lineEndGraphemeIndex === fitAdvances.length) {
+        lineEndSegmentIndex = segmentIndex + 1;
+        lineEndGraphemeIndex = 0;
+      }
+    }
+    __name(appendBreakableSegmentFrom, "appendBreakableSegmentFrom");
+    function continueSoftHyphenBreakableSegment(segmentIndex) {
+      if (pendingBreakKind !== "soft-hyphen")
+        return false;
+      const fitWidths = breakableFitAdvances[segmentIndex];
+      if (fitWidths == null)
+        return false;
+      const { fitCount, fittedWidth } = fitSoftHyphenBreak(fitWidths, lineW, maxWidth, lineFitEpsilon, discretionaryHyphenWidth);
+      if (fitCount === 0)
+        return false;
+      lineW = fittedWidth;
+      lineEndSegmentIndex = segmentIndex;
+      lineEndGraphemeIndex = fitCount;
+      clearPendingBreak();
+      if (fitCount === fitWidths.length) {
+        lineEndSegmentIndex = segmentIndex + 1;
+        lineEndGraphemeIndex = 0;
+        return true;
+      }
+      emitCurrentLine(segmentIndex, fitCount, fittedWidth + discretionaryHyphenWidth);
+      appendBreakableSegmentFrom(segmentIndex, fitCount);
+      return true;
+    }
+    __name(continueSoftHyphenBreakableSegment, "continueSoftHyphenBreakableSegment");
+    function emitEmptyChunk(chunk) {
+      lineCount++;
+      onLine?.({
+        startSegmentIndex: chunk.startSegmentIndex,
+        startGraphemeIndex: 0,
+        endSegmentIndex: chunk.consumedEndSegmentIndex,
+        endGraphemeIndex: 0,
+        width: 0
+      });
+      clearPendingBreak();
+    }
+    __name(emitEmptyChunk, "emitEmptyChunk");
+    for (let chunkIndex = 0; chunkIndex < chunks.length; chunkIndex++) {
+      const chunk = chunks[chunkIndex];
+      if (chunk.startSegmentIndex === chunk.endSegmentIndex) {
+        emitEmptyChunk(chunk);
+        continue;
+      }
+      hasContent = false;
+      lineW = 0;
+      lineStartSegmentIndex = chunk.startSegmentIndex;
+      lineStartGraphemeIndex = 0;
+      lineEndSegmentIndex = chunk.startSegmentIndex;
+      lineEndGraphemeIndex = 0;
+      clearPendingBreak();
+      let i = chunk.startSegmentIndex;
+      while (i < chunk.endSegmentIndex) {
+        const kind = kinds[i];
+        const breakAfter = kind === "space" || kind === "preserved-space" || kind === "tab" || kind === "zero-width-break" || kind === "soft-hyphen";
+        const w = kind === "tab" ? getTabAdvance(lineW, tabStopAdvance) : widths[i];
+        if (kind === "soft-hyphen") {
+          if (hasContent) {
+            lineEndSegmentIndex = i + 1;
+            lineEndGraphemeIndex = 0;
+            pendingBreakSegmentIndex = i + 1;
+            pendingBreakFitWidth = lineW + discretionaryHyphenWidth;
+            pendingBreakPaintWidth = lineW + discretionaryHyphenWidth;
+            pendingBreakKind = kind;
+          }
+          i++;
+          continue;
+        }
+        if (!hasContent) {
+          if (w > maxWidth && breakableFitAdvances[i] !== null) {
+            appendBreakableSegmentFrom(i, 0);
+          } else {
+            startLineAtSegment(i, w);
+          }
+          updatePendingBreakForWholeSegment(kind, breakAfter, i, w);
+          i++;
+          continue;
+        }
+        const newW = lineW + w;
+        if (newW > fitLimit) {
+          const currentBreakFitWidth = lineW + (kind === "tab" ? 0 : lineEndFitAdvances[i]);
+          const currentBreakPaintWidth = lineW + (kind === "tab" ? w : lineEndPaintAdvances[i]);
+          if (pendingBreakKind === "soft-hyphen" && engineProfile.preferEarlySoftHyphenBreak && pendingBreakFitWidth <= fitLimit) {
+            emitCurrentLine(pendingBreakSegmentIndex, 0, pendingBreakPaintWidth);
+            continue;
+          }
+          if (pendingBreakKind === "soft-hyphen" && continueSoftHyphenBreakableSegment(i)) {
+            i++;
+            continue;
+          }
+          if (breakAfter && currentBreakFitWidth <= fitLimit) {
+            appendWholeSegment(i, w);
+            emitCurrentLine(i + 1, 0, currentBreakPaintWidth);
+            i++;
+            continue;
+          }
+          if (pendingBreakSegmentIndex >= 0 && pendingBreakFitWidth <= fitLimit) {
+            if (lineEndSegmentIndex > pendingBreakSegmentIndex || lineEndSegmentIndex === pendingBreakSegmentIndex && lineEndGraphemeIndex > 0) {
+              emitCurrentLine();
+              continue;
+            }
+            const nextSegmentIndex = pendingBreakSegmentIndex;
+            emitCurrentLine(nextSegmentIndex, 0, pendingBreakPaintWidth);
+            i = nextSegmentIndex;
+            continue;
+          }
+          if (w > maxWidth && breakableFitAdvances[i] !== null) {
+            emitCurrentLine();
+            appendBreakableSegmentFrom(i, 0);
+            i++;
+            continue;
+          }
+          emitCurrentLine();
+          continue;
+        }
+        appendWholeSegment(i, w);
+        updatePendingBreakForWholeSegment(kind, breakAfter, i, w);
+        i++;
+      }
+      if (hasContent) {
+        const finalPaintWidth = pendingBreakSegmentIndex === chunk.consumedEndSegmentIndex ? pendingBreakPaintWidth : lineW;
+        emitCurrentLine(chunk.consumedEndSegmentIndex, 0, finalPaintWidth);
+      }
+    }
+    return lineCount;
+  }
+  __name(walkPreparedLines, "walkPreparedLines");
+  function stepPreparedChunkLineGeometry(prepared, cursor, chunkIndex, maxWidth) {
+    const chunk = prepared.chunks[chunkIndex];
+    if (chunk.startSegmentIndex === chunk.endSegmentIndex) {
+      cursor.segmentIndex = chunk.consumedEndSegmentIndex;
+      cursor.graphemeIndex = 0;
+      return 0;
+    }
+    const { widths, lineEndFitAdvances, lineEndPaintAdvances, kinds, breakableFitAdvances, discretionaryHyphenWidth, tabStopAdvance } = prepared;
+    const engineProfile = getEngineProfile();
+    const lineFitEpsilon = engineProfile.lineFitEpsilon;
+    const fitLimit = maxWidth + lineFitEpsilon;
+    let lineW = 0;
+    let hasContent = false;
+    let lineEndSegmentIndex = cursor.segmentIndex;
+    let lineEndGraphemeIndex = cursor.graphemeIndex;
+    let pendingBreakSegmentIndex = -1;
+    let pendingBreakFitWidth = 0;
+    let pendingBreakPaintWidth = 0;
+    let pendingBreakKind = null;
+    function clearPendingBreak() {
+      pendingBreakSegmentIndex = -1;
+      pendingBreakFitWidth = 0;
+      pendingBreakPaintWidth = 0;
+      pendingBreakKind = null;
+    }
+    __name(clearPendingBreak, "clearPendingBreak");
+    function finishLine(endSegmentIndex = lineEndSegmentIndex, endGraphemeIndex = lineEndGraphemeIndex, width2 = lineW) {
+      if (!hasContent)
+        return null;
+      cursor.segmentIndex = endSegmentIndex;
+      cursor.graphemeIndex = endGraphemeIndex;
+      return width2;
+    }
+    __name(finishLine, "finishLine");
+    function startLineAtSegment(segmentIndex, width2) {
+      hasContent = true;
+      lineEndSegmentIndex = segmentIndex + 1;
+      lineEndGraphemeIndex = 0;
+      lineW = width2;
+    }
+    __name(startLineAtSegment, "startLineAtSegment");
+    function startLineAtGrapheme(segmentIndex, graphemeIndex, width2) {
+      hasContent = true;
+      lineEndSegmentIndex = segmentIndex;
+      lineEndGraphemeIndex = graphemeIndex + 1;
+      lineW = width2;
+    }
+    __name(startLineAtGrapheme, "startLineAtGrapheme");
+    function appendWholeSegment(segmentIndex, width2) {
+      if (!hasContent) {
+        startLineAtSegment(segmentIndex, width2);
+        return;
+      }
+      lineW += width2;
+      lineEndSegmentIndex = segmentIndex + 1;
+      lineEndGraphemeIndex = 0;
+    }
+    __name(appendWholeSegment, "appendWholeSegment");
+    function updatePendingBreakForWholeSegment(kind, breakAfter, segmentIndex, segmentWidth) {
+      if (!breakAfter)
+        return;
+      const fitAdvance = kind === "tab" ? 0 : lineEndFitAdvances[segmentIndex];
+      const paintAdvance = kind === "tab" ? segmentWidth : lineEndPaintAdvances[segmentIndex];
+      pendingBreakSegmentIndex = segmentIndex + 1;
+      pendingBreakFitWidth = lineW - segmentWidth + fitAdvance;
+      pendingBreakPaintWidth = lineW - segmentWidth + paintAdvance;
+      pendingBreakKind = kind;
+    }
+    __name(updatePendingBreakForWholeSegment, "updatePendingBreakForWholeSegment");
+    function appendBreakableSegmentFrom(segmentIndex, startGraphemeIndex) {
+      const fitAdvances = breakableFitAdvances[segmentIndex];
+      for (let g = startGraphemeIndex; g < fitAdvances.length; g++) {
+        const gw = fitAdvances[g];
+        if (!hasContent) {
+          startLineAtGrapheme(segmentIndex, g, gw);
+        } else {
+          if (lineW + gw > fitLimit) {
+            return finishLine();
+          }
+          lineW += gw;
+          lineEndSegmentIndex = segmentIndex;
+          lineEndGraphemeIndex = g + 1;
+        }
+      }
+      if (hasContent && lineEndSegmentIndex === segmentIndex && lineEndGraphemeIndex === fitAdvances.length) {
+        lineEndSegmentIndex = segmentIndex + 1;
+        lineEndGraphemeIndex = 0;
+      }
+      return null;
+    }
+    __name(appendBreakableSegmentFrom, "appendBreakableSegmentFrom");
+    function maybeFinishAtSoftHyphen(segmentIndex) {
+      if (pendingBreakKind !== "soft-hyphen" || pendingBreakSegmentIndex < 0)
+        return null;
+      const fitWidths = breakableFitAdvances[segmentIndex] ?? null;
+      if (fitWidths !== null) {
+        const { fitCount, fittedWidth } = fitSoftHyphenBreak(fitWidths, lineW, maxWidth, lineFitEpsilon, discretionaryHyphenWidth);
+        if (fitCount === fitWidths.length) {
+          lineW = fittedWidth;
+          lineEndSegmentIndex = segmentIndex + 1;
+          lineEndGraphemeIndex = 0;
+          clearPendingBreak();
+          return null;
+        }
+        if (fitCount > 0) {
+          return finishLine(segmentIndex, fitCount, fittedWidth + discretionaryHyphenWidth);
+        }
+      }
+      if (pendingBreakFitWidth <= fitLimit) {
+        return finishLine(pendingBreakSegmentIndex, 0, pendingBreakPaintWidth);
+      }
+      return null;
+    }
+    __name(maybeFinishAtSoftHyphen, "maybeFinishAtSoftHyphen");
+    for (let i = cursor.segmentIndex; i < chunk.endSegmentIndex; i++) {
+      const kind = kinds[i];
+      const breakAfter = kind === "space" || kind === "preserved-space" || kind === "tab" || kind === "zero-width-break" || kind === "soft-hyphen";
+      const startGraphemeIndex = i === cursor.segmentIndex ? cursor.graphemeIndex : 0;
+      const w = kind === "tab" ? getTabAdvance(lineW, tabStopAdvance) : widths[i];
+      if (kind === "soft-hyphen" && startGraphemeIndex === 0) {
+        if (hasContent) {
+          lineEndSegmentIndex = i + 1;
+          lineEndGraphemeIndex = 0;
+          pendingBreakSegmentIndex = i + 1;
+          pendingBreakFitWidth = lineW + discretionaryHyphenWidth;
+          pendingBreakPaintWidth = lineW + discretionaryHyphenWidth;
+          pendingBreakKind = kind;
+        }
+        continue;
+      }
+      if (!hasContent) {
+        if (startGraphemeIndex > 0) {
+          const line2 = appendBreakableSegmentFrom(i, startGraphemeIndex);
+          if (line2 !== null)
+            return line2;
+        } else if (w > maxWidth && breakableFitAdvances[i] !== null) {
+          const line2 = appendBreakableSegmentFrom(i, 0);
+          if (line2 !== null)
+            return line2;
+        } else {
+          startLineAtSegment(i, w);
+        }
+        updatePendingBreakForWholeSegment(kind, breakAfter, i, w);
+        continue;
+      }
+      const newW = lineW + w;
+      if (newW > fitLimit) {
+        const currentBreakFitWidth = lineW + (kind === "tab" ? 0 : lineEndFitAdvances[i]);
+        const currentBreakPaintWidth = lineW + (kind === "tab" ? w : lineEndPaintAdvances[i]);
+        if (pendingBreakKind === "soft-hyphen" && engineProfile.preferEarlySoftHyphenBreak && pendingBreakFitWidth <= fitLimit) {
+          return finishLine(pendingBreakSegmentIndex, 0, pendingBreakPaintWidth);
+        }
+        const softBreakLine = maybeFinishAtSoftHyphen(i);
+        if (softBreakLine !== null)
+          return softBreakLine;
+        if (breakAfter && currentBreakFitWidth <= fitLimit) {
+          appendWholeSegment(i, w);
+          return finishLine(i + 1, 0, currentBreakPaintWidth);
+        }
+        if (pendingBreakSegmentIndex >= 0 && pendingBreakFitWidth <= fitLimit) {
+          if (lineEndSegmentIndex > pendingBreakSegmentIndex || lineEndSegmentIndex === pendingBreakSegmentIndex && lineEndGraphemeIndex > 0) {
+            return finishLine();
+          }
+          return finishLine(pendingBreakSegmentIndex, 0, pendingBreakPaintWidth);
+        }
+        if (w > maxWidth && breakableFitAdvances[i] !== null) {
+          const currentLine = finishLine();
+          if (currentLine !== null)
+            return currentLine;
+          const line2 = appendBreakableSegmentFrom(i, 0);
+          if (line2 !== null)
+            return line2;
+        }
+        return finishLine();
+      }
+      appendWholeSegment(i, w);
+      updatePendingBreakForWholeSegment(kind, breakAfter, i, w);
+    }
+    if (pendingBreakSegmentIndex === chunk.consumedEndSegmentIndex && lineEndGraphemeIndex === 0) {
+      return finishLine(chunk.consumedEndSegmentIndex, 0, pendingBreakPaintWidth);
+    }
+    return finishLine(chunk.consumedEndSegmentIndex, 0, lineW);
+  }
+  __name(stepPreparedChunkLineGeometry, "stepPreparedChunkLineGeometry");
+  function stepPreparedSimpleLineGeometry(prepared, cursor, maxWidth) {
+    const { widths, kinds, breakableFitAdvances } = prepared;
+    const engineProfile = getEngineProfile();
+    const lineFitEpsilon = engineProfile.lineFitEpsilon;
+    const fitLimit = maxWidth + lineFitEpsilon;
+    let lineW = 0;
+    let hasContent = false;
+    let lineEndSegmentIndex = cursor.segmentIndex;
+    let lineEndGraphemeIndex = cursor.graphemeIndex;
+    let pendingBreakSegmentIndex = -1;
+    let pendingBreakPaintWidth = 0;
+    for (let i = cursor.segmentIndex; i < widths.length; i++) {
+      const w = widths[i];
+      const kind = kinds[i];
+      const breakAfter = kind === "space" || kind === "preserved-space" || kind === "tab" || kind === "zero-width-break" || kind === "soft-hyphen";
+      const startGraphemeIndex = i === cursor.segmentIndex ? cursor.graphemeIndex : 0;
+      const breakableFitAdvance = breakableFitAdvances[i];
+      if (!hasContent) {
+        if (startGraphemeIndex > 0 || w > maxWidth && breakableFitAdvance !== null) {
+          const fitAdvances = breakableFitAdvance;
+          const firstGraphemeWidth = fitAdvances[startGraphemeIndex];
+          hasContent = true;
+          lineW = firstGraphemeWidth;
+          lineEndSegmentIndex = i;
+          lineEndGraphemeIndex = startGraphemeIndex + 1;
+          for (let g = startGraphemeIndex + 1; g < fitAdvances.length; g++) {
+            const gw = fitAdvances[g];
+            if (lineW + gw > fitLimit) {
+              cursor.segmentIndex = lineEndSegmentIndex;
+              cursor.graphemeIndex = lineEndGraphemeIndex;
+              return lineW;
+            }
+            lineW += gw;
+            lineEndSegmentIndex = i;
+            lineEndGraphemeIndex = g + 1;
+          }
+          if (lineEndSegmentIndex === i && lineEndGraphemeIndex === fitAdvances.length) {
+            lineEndSegmentIndex = i + 1;
+            lineEndGraphemeIndex = 0;
+          }
+        } else {
+          hasContent = true;
+          lineW = w;
+          lineEndSegmentIndex = i + 1;
+          lineEndGraphemeIndex = 0;
+        }
+        if (breakAfter) {
+          pendingBreakSegmentIndex = i + 1;
+          pendingBreakPaintWidth = lineW - w;
+        }
+        continue;
+      }
+      if (lineW + w > fitLimit) {
+        if (breakAfter) {
+          cursor.segmentIndex = i + 1;
+          cursor.graphemeIndex = 0;
+          return lineW;
+        }
+        if (pendingBreakSegmentIndex >= 0) {
+          if (lineEndSegmentIndex > pendingBreakSegmentIndex || lineEndSegmentIndex === pendingBreakSegmentIndex && lineEndGraphemeIndex > 0) {
+            cursor.segmentIndex = lineEndSegmentIndex;
+            cursor.graphemeIndex = lineEndGraphemeIndex;
+            return lineW;
+          }
+          cursor.segmentIndex = pendingBreakSegmentIndex;
+          cursor.graphemeIndex = 0;
+          return pendingBreakPaintWidth;
+        }
+        cursor.segmentIndex = lineEndSegmentIndex;
+        cursor.graphemeIndex = lineEndGraphemeIndex;
+        return lineW;
+      }
+      lineW += w;
+      lineEndSegmentIndex = i + 1;
+      lineEndGraphemeIndex = 0;
+      if (breakAfter) {
+        pendingBreakSegmentIndex = i + 1;
+        pendingBreakPaintWidth = lineW - w;
+      }
+    }
+    if (!hasContent)
+      return null;
+    cursor.segmentIndex = lineEndSegmentIndex;
+    cursor.graphemeIndex = lineEndGraphemeIndex;
+    return lineW;
+  }
+  __name(stepPreparedSimpleLineGeometry, "stepPreparedSimpleLineGeometry");
+  function layoutNextLineRange(prepared, start, maxWidth) {
+    const end = {
+      segmentIndex: start.segmentIndex,
+      graphemeIndex: start.graphemeIndex
+    };
+    const chunkIndex = normalizeLineStartChunkIndex(prepared, end);
+    if (chunkIndex < 0)
+      return null;
+    const lineStartSegmentIndex = end.segmentIndex;
+    const lineStartGraphemeIndex = end.graphemeIndex;
+    const width2 = prepared.simpleLineWalkFastPath ? stepPreparedSimpleLineGeometry(prepared, end, maxWidth) : stepPreparedChunkLineGeometry(prepared, end, chunkIndex, maxWidth);
+    if (width2 === null)
+      return null;
+    return {
+      startSegmentIndex: lineStartSegmentIndex,
+      startGraphemeIndex: lineStartGraphemeIndex,
+      endSegmentIndex: end.segmentIndex,
+      endGraphemeIndex: end.graphemeIndex,
+      width: width2
+    };
+  }
+  __name(layoutNextLineRange, "layoutNextLineRange");
+
+  // ../../node_modules/.pnpm/@chenglou+pretext@0.0.5/node_modules/@chenglou/pretext/dist/layout.js
+  var sharedGraphemeSegmenter2 = null;
+  var sharedLineTextCaches = /* @__PURE__ */ new WeakMap();
+  function getSharedGraphemeSegmenter2() {
+    if (sharedGraphemeSegmenter2 === null) {
+      sharedGraphemeSegmenter2 = new Intl.Segmenter(void 0, { granularity: "grapheme" });
+    }
+    return sharedGraphemeSegmenter2;
+  }
+  __name(getSharedGraphemeSegmenter2, "getSharedGraphemeSegmenter");
+  function createEmptyPrepared(includeSegments) {
+    if (includeSegments) {
+      return {
+        widths: [],
+        lineEndFitAdvances: [],
+        lineEndPaintAdvances: [],
+        kinds: [],
+        simpleLineWalkFastPath: true,
+        segLevels: null,
+        breakableFitAdvances: [],
+        discretionaryHyphenWidth: 0,
+        tabStopAdvance: 0,
+        chunks: [],
+        segments: []
+      };
+    }
+    return {
+      widths: [],
+      lineEndFitAdvances: [],
+      lineEndPaintAdvances: [],
+      kinds: [],
+      simpleLineWalkFastPath: true,
+      segLevels: null,
+      breakableFitAdvances: [],
+      discretionaryHyphenWidth: 0,
+      tabStopAdvance: 0,
+      chunks: []
+    };
+  }
+  __name(createEmptyPrepared, "createEmptyPrepared");
+  function buildBaseCjkUnits(segText, engineProfile) {
+    const units = [];
+    let unitParts = [];
+    let unitStart = 0;
+    let unitContainsCJK = false;
+    let unitEndsWithClosingQuote = false;
+    let unitIsSingleKinsokuEnd = false;
+    function pushUnit() {
+      if (unitParts.length === 0)
+        return;
+      units.push({
+        text: unitParts.length === 1 ? unitParts[0] : unitParts.join(""),
+        start: unitStart
+      });
+      unitParts = [];
+      unitContainsCJK = false;
+      unitEndsWithClosingQuote = false;
+      unitIsSingleKinsokuEnd = false;
+    }
+    __name(pushUnit, "pushUnit");
+    function startUnit(grapheme, start, graphemeContainsCJK) {
+      unitParts = [grapheme];
+      unitStart = start;
+      unitContainsCJK = graphemeContainsCJK;
+      unitEndsWithClosingQuote = endsWithClosingQuote(grapheme);
+      unitIsSingleKinsokuEnd = kinsokuEnd.has(grapheme);
+    }
+    __name(startUnit, "startUnit");
+    function appendToUnit(grapheme, graphemeContainsCJK) {
+      unitParts.push(grapheme);
+      unitContainsCJK = unitContainsCJK || graphemeContainsCJK;
+      const graphemeEndsWithClosingQuote = endsWithClosingQuote(grapheme);
+      if (grapheme.length === 1 && leftStickyPunctuation.has(grapheme)) {
+        unitEndsWithClosingQuote = unitEndsWithClosingQuote || graphemeEndsWithClosingQuote;
+      } else {
+        unitEndsWithClosingQuote = graphemeEndsWithClosingQuote;
+      }
+      unitIsSingleKinsokuEnd = false;
+    }
+    __name(appendToUnit, "appendToUnit");
+    for (const gs of getSharedGraphemeSegmenter2().segment(segText)) {
+      const grapheme = gs.segment;
+      const graphemeContainsCJK = isCJK(grapheme);
+      if (unitParts.length === 0) {
+        startUnit(grapheme, gs.index, graphemeContainsCJK);
+        continue;
+      }
+      if (unitIsSingleKinsokuEnd || kinsokuStart.has(grapheme) || leftStickyPunctuation.has(grapheme) || engineProfile.carryCJKAfterClosingQuote && graphemeContainsCJK && unitEndsWithClosingQuote) {
+        appendToUnit(grapheme, graphemeContainsCJK);
+        continue;
+      }
+      if (!unitContainsCJK && !graphemeContainsCJK) {
+        appendToUnit(grapheme, graphemeContainsCJK);
+        continue;
+      }
+      pushUnit();
+      startUnit(grapheme, gs.index, graphemeContainsCJK);
+    }
+    pushUnit();
+    return units;
+  }
+  __name(buildBaseCjkUnits, "buildBaseCjkUnits");
+  function mergeKeepAllTextUnits(units) {
+    if (units.length <= 1)
+      return units;
+    const merged = [];
+    let currentTextParts = [units[0].text];
+    let currentStart = units[0].start;
+    let currentContainsCJK = isCJK(units[0].text);
+    let currentCanContinue = canContinueKeepAllTextRun(units[0].text);
+    function flushCurrent() {
+      merged.push({
+        text: currentTextParts.length === 1 ? currentTextParts[0] : currentTextParts.join(""),
+        start: currentStart
+      });
+    }
+    __name(flushCurrent, "flushCurrent");
+    for (let i = 1; i < units.length; i++) {
+      const next3 = units[i];
+      const nextContainsCJK = isCJK(next3.text);
+      const nextCanContinue = canContinueKeepAllTextRun(next3.text);
+      if (currentContainsCJK && currentCanContinue) {
+        currentTextParts.push(next3.text);
+        currentContainsCJK = currentContainsCJK || nextContainsCJK;
+        currentCanContinue = nextCanContinue;
+        continue;
+      }
+      flushCurrent();
+      currentTextParts = [next3.text];
+      currentStart = next3.start;
+      currentContainsCJK = nextContainsCJK;
+      currentCanContinue = nextCanContinue;
+    }
+    flushCurrent();
+    return merged;
+  }
+  __name(mergeKeepAllTextUnits, "mergeKeepAllTextUnits");
+  function measureAnalysis(analysis, font, includeSegments, wordBreak) {
+    const engineProfile = getEngineProfile();
+    const { cache: cache3, emojiCorrection } = getFontMeasurementState(font, textMayContainEmoji(analysis.normalized));
+    const discretionaryHyphenWidth = getCorrectedSegmentWidth("-", getSegmentMetrics("-", cache3), emojiCorrection);
+    const spaceWidth = getCorrectedSegmentWidth(" ", getSegmentMetrics(" ", cache3), 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 breakableFitAdvances = [];
+    const segments = includeSegments ? [] : null;
+    const preparedStartByAnalysisIndex = Array.from({ length: analysis.len });
+    function pushMeasuredSegment(text2, width2, lineEndFitAdvance, lineEndPaintAdvance, kind, start, breakableFitAdvance) {
+      if (kind !== "text" && kind !== "space" && kind !== "zero-width-break") {
+        simpleLineWalkFastPath = false;
+      }
+      widths.push(width2);
+      lineEndFitAdvances.push(lineEndFitAdvance);
+      lineEndPaintAdvances.push(lineEndPaintAdvance);
+      kinds.push(kind);
+      segStarts?.push(start);
+      breakableFitAdvances.push(breakableFitAdvance);
+      if (segments !== null)
+        segments.push(text2);
+    }
+    __name(pushMeasuredSegment, "pushMeasuredSegment");
+    function pushMeasuredTextSegment(text2, kind, start, wordLike, allowOverflowBreaks) {
+      const textMetrics = getSegmentMetrics(text2, cache3);
+      const width2 = getCorrectedSegmentWidth(text2, textMetrics, emojiCorrection);
+      const lineEndFitAdvance = kind === "space" || kind === "preserved-space" || kind === "zero-width-break" ? 0 : width2;
+      const lineEndPaintAdvance = kind === "space" || kind === "zero-width-break" ? 0 : width2;
+      if (allowOverflowBreaks && wordLike && text2.length > 1) {
+        let fitMode = "sum-graphemes";
+        if (isNumericRunSegment(text2)) {
+          fitMode = "pair-context";
+        } else if (engineProfile.preferPrefixWidthsForBreakableRuns) {
+          fitMode = "segment-prefixes";
+        }
+        const fitAdvances = getSegmentBreakableFitAdvances(text2, textMetrics, cache3, emojiCorrection, fitMode);
+        pushMeasuredSegment(text2, width2, lineEndFitAdvance, lineEndPaintAdvance, kind, start, fitAdvances);
+        return;
+      }
+      pushMeasuredSegment(text2, width2, lineEndFitAdvance, lineEndPaintAdvance, kind, start, null);
+    }
+    __name(pushMeasuredTextSegment, "pushMeasuredTextSegment");
+    for (let mi = 0; mi < analysis.len; mi++) {
+      preparedStartByAnalysisIndex[mi] = widths.length;
+      const segText = analysis.texts[mi];
+      const segWordLike = analysis.isWordLike[mi];
+      const segKind = analysis.kinds[mi];
+      const segStart = analysis.starts[mi];
+      if (segKind === "soft-hyphen") {
+        pushMeasuredSegment(segText, 0, discretionaryHyphenWidth, discretionaryHyphenWidth, segKind, segStart, null);
+        continue;
+      }
+      if (segKind === "hard-break") {
+        pushMeasuredSegment(segText, 0, 0, 0, segKind, segStart, null);
+        continue;
+      }
+      if (segKind === "tab") {
+        pushMeasuredSegment(segText, 0, 0, 0, segKind, segStart, null);
+        continue;
+      }
+      const segMetrics = getSegmentMetrics(segText, cache3);
+      if (segKind === "text" && segMetrics.containsCJK) {
+        const baseUnits = buildBaseCjkUnits(segText, engineProfile);
+        const measuredUnits = wordBreak === "keep-all" ? mergeKeepAllTextUnits(baseUnits) : baseUnits;
+        for (let i = 0; i < measuredUnits.length; i++) {
+          const unit = measuredUnits[i];
+          pushMeasuredTextSegment(unit.text, "text", segStart + unit.start, segWordLike, wordBreak === "keep-all" || !isCJK(unit.text));
+        }
+        continue;
+      }
+      pushMeasuredTextSegment(segText, segKind, segStart, segWordLike, true);
+    }
+    const chunks = mapAnalysisChunksToPreparedChunks(analysis.chunks, preparedStartByAnalysisIndex, widths.length);
+    const segLevels = segStarts === null ? null : computeSegmentLevels(analysis.normalized, segStarts);
+    if (segments !== null) {
+      return {
+        widths,
+        lineEndFitAdvances,
+        lineEndPaintAdvances,
+        kinds,
+        simpleLineWalkFastPath,
+        segLevels,
+        breakableFitAdvances,
+        discretionaryHyphenWidth,
+        tabStopAdvance,
+        chunks,
+        segments
+      };
+    }
+    return {
+      widths,
+      lineEndFitAdvances,
+      lineEndPaintAdvances,
+      kinds,
+      simpleLineWalkFastPath,
+      segLevels,
+      breakableFitAdvances,
+      discretionaryHyphenWidth,
+      tabStopAdvance,
+      chunks
+    };
+  }
+  __name(measureAnalysis, "measureAnalysis");
+  function mapAnalysisChunksToPreparedChunks(chunks, preparedStartByAnalysisIndex, preparedEndSegmentIndex) {
+    const preparedChunks = [];
+    for (let i = 0; i < chunks.length; i++) {
+      const chunk = chunks[i];
+      const startSegmentIndex = chunk.startSegmentIndex < preparedStartByAnalysisIndex.length ? preparedStartByAnalysisIndex[chunk.startSegmentIndex] : preparedEndSegmentIndex;
+      const endSegmentIndex = chunk.endSegmentIndex < preparedStartByAnalysisIndex.length ? preparedStartByAnalysisIndex[chunk.endSegmentIndex] : preparedEndSegmentIndex;
+      const consumedEndSegmentIndex = chunk.consumedEndSegmentIndex < preparedStartByAnalysisIndex.length ? preparedStartByAnalysisIndex[chunk.consumedEndSegmentIndex] : preparedEndSegmentIndex;
+      preparedChunks.push({
+        startSegmentIndex,
+        endSegmentIndex,
+        consumedEndSegmentIndex
+      });
+    }
+    return preparedChunks;
+  }
+  __name(mapAnalysisChunksToPreparedChunks, "mapAnalysisChunksToPreparedChunks");
+  function prepareInternal(text2, font, includeSegments, options2) {
+    const wordBreak = options2?.wordBreak ?? "normal";
+    const analysis = analyzeText(text2, getEngineProfile(), options2?.whiteSpace, wordBreak);
+    return measureAnalysis(analysis, font, includeSegments, wordBreak);
+  }
+  __name(prepareInternal, "prepareInternal");
+  function prepareWithSegments(text2, font, options2) {
+    return prepareInternal(text2, font, true, options2);
+  }
+  __name(prepareWithSegments, "prepareWithSegments");
+  function getInternalPrepared(prepared) {
+    return prepared;
+  }
+  __name(getInternalPrepared, "getInternalPrepared");
+  function getSegmentGraphemes(segmentIndex, segments, cache3) {
+    let graphemes = cache3.get(segmentIndex);
+    if (graphemes !== void 0)
+      return graphemes;
+    graphemes = [];
+    const graphemeSegmenter = getSharedGraphemeSegmenter2();
+    for (const gs of graphemeSegmenter.segment(segments[segmentIndex])) {
+      graphemes.push(gs.segment);
+    }
+    cache3.set(segmentIndex, graphemes);
+    return graphemes;
+  }
+  __name(getSegmentGraphemes, "getSegmentGraphemes");
+  function getLineTextCache(prepared) {
+    let cache3 = sharedLineTextCaches.get(prepared);
+    if (cache3 !== void 0)
+      return cache3;
+    cache3 = /* @__PURE__ */ new Map();
+    sharedLineTextCaches.set(prepared, cache3);
+    return cache3;
+  }
+  __name(getLineTextCache, "getLineTextCache");
+  function lineHasDiscretionaryHyphen(kinds, startSegmentIndex, startGraphemeIndex, endSegmentIndex) {
+    return endSegmentIndex > 0 && kinds[endSegmentIndex - 1] === "soft-hyphen" && !(startSegmentIndex === endSegmentIndex && startGraphemeIndex > 0);
+  }
+  __name(lineHasDiscretionaryHyphen, "lineHasDiscretionaryHyphen");
+  function buildLineTextFromRange(segments, kinds, cache3, startSegmentIndex, startGraphemeIndex, endSegmentIndex, endGraphemeIndex) {
+    let text2 = "";
+    const endsWithDiscretionaryHyphen = lineHasDiscretionaryHyphen(kinds, startSegmentIndex, startGraphemeIndex, endSegmentIndex);
+    for (let i = startSegmentIndex; i < endSegmentIndex; i++) {
+      if (kinds[i] === "soft-hyphen" || kinds[i] === "hard-break")
+        continue;
+      if (i === startSegmentIndex && startGraphemeIndex > 0) {
+        text2 += getSegmentGraphemes(i, segments, cache3).slice(startGraphemeIndex).join("");
+      } else {
+        text2 += segments[i];
+      }
+    }
+    if (endGraphemeIndex > 0) {
+      if (endsWithDiscretionaryHyphen)
+        text2 += "-";
+      text2 += getSegmentGraphemes(endSegmentIndex, segments, cache3).slice(startSegmentIndex === endSegmentIndex ? startGraphemeIndex : 0, endGraphemeIndex).join("");
+    } else if (endsWithDiscretionaryHyphen) {
+      text2 += "-";
+    }
+    return text2;
+  }
+  __name(buildLineTextFromRange, "buildLineTextFromRange");
+  function createLayoutLine(prepared, cache3, width2, startSegmentIndex, startGraphemeIndex, endSegmentIndex, endGraphemeIndex) {
+    return {
+      text: buildLineTextFromRange(prepared.segments, prepared.kinds, cache3, startSegmentIndex, startGraphemeIndex, endSegmentIndex, endGraphemeIndex),
+      width: width2,
+      start: {
+        segmentIndex: startSegmentIndex,
+        graphemeIndex: startGraphemeIndex
+      },
+      end: {
+        segmentIndex: endSegmentIndex,
+        graphemeIndex: endGraphemeIndex
+      }
+    };
+  }
+  __name(createLayoutLine, "createLayoutLine");
+  function toLayoutLineRange(line2) {
+    return {
+      width: line2.width,
+      start: {
+        segmentIndex: line2.startSegmentIndex,
+        graphemeIndex: line2.startGraphemeIndex
+      },
+      end: {
+        segmentIndex: line2.endSegmentIndex,
+        graphemeIndex: line2.endGraphemeIndex
+      }
+    };
+  }
+  __name(toLayoutLineRange, "toLayoutLineRange");
+  function materializeLineRange(prepared, line2) {
+    return createLayoutLine(prepared, getLineTextCache(prepared), line2.width, line2.start.segmentIndex, line2.start.graphemeIndex, line2.end.segmentIndex, line2.end.graphemeIndex);
+  }
+  __name(materializeLineRange, "materializeLineRange");
+  function walkLineRanges(prepared, maxWidth, onLine) {
+    if (prepared.widths.length === 0)
+      return 0;
+    return walkPreparedLines(getInternalPrepared(prepared), maxWidth, (line2) => {
+      onLine(toLayoutLineRange(line2));
+    });
+  }
+  __name(walkLineRanges, "walkLineRanges");
+  function measureNaturalWidth(prepared) {
+    let maxWidth = 0;
+    walkLineRanges(prepared, Number.POSITIVE_INFINITY, (line2) => {
+      if (line2.width > maxWidth)
+        maxWidth = line2.width;
+    });
+    return maxWidth;
+  }
+  __name(measureNaturalWidth, "measureNaturalWidth");
+
+  // ../../node_modules/.pnpm/@chenglou+pretext@0.0.5/node_modules/@chenglou/pretext/dist/rich-inline.js
+  var COLLAPSIBLE_BOUNDARY_RE = /[ \t\n\f\r]+/;
+  var LEADING_COLLAPSIBLE_BOUNDARY_RE = /^[ \t\n\f\r]+/;
+  var TRAILING_COLLAPSIBLE_BOUNDARY_RE = /[ \t\n\f\r]+$/;
+  var EMPTY_LAYOUT_CURSOR = { segmentIndex: 0, graphemeIndex: 0 };
+  var RICH_INLINE_START_CURSOR = {
+    itemIndex: 0,
+    segmentIndex: 0,
+    graphemeIndex: 0
+  };
+  function getInternalPreparedRichInline(prepared) {
+    return prepared;
+  }
+  __name(getInternalPreparedRichInline, "getInternalPreparedRichInline");
+  function cloneCursor(cursor) {
+    return {
+      segmentIndex: cursor.segmentIndex,
+      graphemeIndex: cursor.graphemeIndex
+    };
+  }
+  __name(cloneCursor, "cloneCursor");
+  function isLineStartCursor(cursor) {
+    return cursor.segmentIndex === 0 && cursor.graphemeIndex === 0;
+  }
+  __name(isLineStartCursor, "isLineStartCursor");
+  function getCollapsedSpaceWidth(font, cache3) {
+    const cached = cache3.get(font);
+    if (cached !== void 0)
+      return cached;
+    const joinedWidth = measureNaturalWidth(prepareWithSegments("A A", font));
+    const compactWidth = measureNaturalWidth(prepareWithSegments("AA", font));
+    const collapsedWidth = Math.max(0, joinedWidth - compactWidth);
+    cache3.set(font, collapsedWidth);
+    return collapsedWidth;
+  }
+  __name(getCollapsedSpaceWidth, "getCollapsedSpaceWidth");
+  function prepareWholeItemLine(prepared) {
+    const line2 = layoutNextLineRange(prepared, EMPTY_LAYOUT_CURSOR, Number.POSITIVE_INFINITY);
+    if (line2 === null)
+      return null;
+    return {
+      endGraphemeIndex: line2.endGraphemeIndex,
+      endSegmentIndex: line2.endSegmentIndex,
+      width: line2.width
+    };
+  }
+  __name(prepareWholeItemLine, "prepareWholeItemLine");
+  function endsInsideFirstSegment(segmentIndex, graphemeIndex) {
+    return segmentIndex === 0 && graphemeIndex > 0;
+  }
+  __name(endsInsideFirstSegment, "endsInsideFirstSegment");
+  function prepareRichInline(items) {
+    const preparedItems = [];
+    const itemsBySourceItemIndex = Array.from({ length: items.length });
+    const collapsedSpaceWidthCache = /* @__PURE__ */ new Map();
+    let pendingGapWidth = 0;
+    for (let index = 0; index < items.length; index++) {
+      const item = items[index];
+      const hasLeadingWhitespace = LEADING_COLLAPSIBLE_BOUNDARY_RE.test(item.text);
+      const hasTrailingWhitespace = TRAILING_COLLAPSIBLE_BOUNDARY_RE.test(item.text);
+      const trimmedText = item.text.replace(LEADING_COLLAPSIBLE_BOUNDARY_RE, "").replace(TRAILING_COLLAPSIBLE_BOUNDARY_RE, "");
+      if (trimmedText.length === 0) {
+        if (COLLAPSIBLE_BOUNDARY_RE.test(item.text) && pendingGapWidth === 0) {
+          pendingGapWidth = getCollapsedSpaceWidth(item.font, collapsedSpaceWidthCache);
+        }
+        continue;
+      }
+      const gapBefore = pendingGapWidth > 0 ? pendingGapWidth : hasLeadingWhitespace ? getCollapsedSpaceWidth(item.font, collapsedSpaceWidthCache) : 0;
+      const prepared = prepareWithSegments(trimmedText, item.font);
+      const wholeLine = prepareWholeItemLine(prepared);
+      if (wholeLine === null) {
+        pendingGapWidth = hasTrailingWhitespace ? getCollapsedSpaceWidth(item.font, collapsedSpaceWidthCache) : 0;
+        continue;
+      }
+      const preparedItem = {
+        break: item.break ?? "normal",
+        endGraphemeIndex: wholeLine.endGraphemeIndex,
+        endSegmentIndex: wholeLine.endSegmentIndex,
+        extraWidth: item.extraWidth ?? 0,
+        gapBefore,
+        naturalWidth: wholeLine.width,
+        prepared,
+        sourceItemIndex: index
+      };
+      preparedItems.push(preparedItem);
+      itemsBySourceItemIndex[index] = preparedItem;
+      pendingGapWidth = hasTrailingWhitespace ? getCollapsedSpaceWidth(item.font, collapsedSpaceWidthCache) : 0;
+    }
+    return {
+      items: preparedItems,
+      itemsBySourceItemIndex
+    };
+  }
+  __name(prepareRichInline, "prepareRichInline");
+  function stepRichInlineLine(flow, maxWidth, cursor, collectFragment) {
+    if (flow.items.length === 0 || cursor.itemIndex >= flow.items.length)
+      return null;
+    const safeWidth = Math.max(1, maxWidth);
+    let lineWidth = 0;
+    let remainingWidth = safeWidth;
+    let itemIndex = cursor.itemIndex;
+    const textCursor = {
+      segmentIndex: cursor.segmentIndex,
+      graphemeIndex: cursor.graphemeIndex
+    };
+    lineLoop: while (itemIndex < flow.items.length) {
+      const item = flow.items[itemIndex];
+      if (!isLineStartCursor(textCursor) && textCursor.segmentIndex === item.endSegmentIndex && textCursor.graphemeIndex === item.endGraphemeIndex) {
+        itemIndex++;
+        textCursor.segmentIndex = 0;
+        textCursor.graphemeIndex = 0;
+        continue;
+      }
+      const gapBefore = lineWidth === 0 ? 0 : item.gapBefore;
+      const atItemStart = isLineStartCursor(textCursor);
+      if (item.break === "never") {
+        if (!atItemStart) {
+          itemIndex++;
+          textCursor.segmentIndex = 0;
+          textCursor.graphemeIndex = 0;
+          continue;
+        }
+        const occupiedWidth = item.naturalWidth + item.extraWidth;
+        const totalWidth = gapBefore + occupiedWidth;
+        if (lineWidth > 0 && totalWidth > remainingWidth)
+          break lineLoop;
+        collectFragment?.(item, gapBefore, occupiedWidth, cloneCursor(EMPTY_LAYOUT_CURSOR), {
+          segmentIndex: item.endSegmentIndex,
+          graphemeIndex: item.endGraphemeIndex
+        });
+        lineWidth += totalWidth;
+        remainingWidth = Math.max(0, safeWidth - lineWidth);
+        itemIndex++;
+        textCursor.segmentIndex = 0;
+        textCursor.graphemeIndex = 0;
+        continue;
+      }
+      const reservedWidth = gapBefore + item.extraWidth;
+      if (lineWidth > 0 && reservedWidth >= remainingWidth)
+        break lineLoop;
+      if (atItemStart) {
+        const totalWidth = reservedWidth + item.naturalWidth;
+        if (totalWidth <= remainingWidth) {
+          collectFragment?.(item, gapBefore, item.naturalWidth + item.extraWidth, cloneCursor(EMPTY_LAYOUT_CURSOR), {
+            segmentIndex: item.endSegmentIndex,
+            graphemeIndex: item.endGraphemeIndex
+          });
+          lineWidth += totalWidth;
+          remainingWidth = Math.max(0, safeWidth - lineWidth);
+          itemIndex++;
+          textCursor.segmentIndex = 0;
+          textCursor.graphemeIndex = 0;
+          continue;
+        }
+      }
+      const availableWidth = Math.max(1, remainingWidth - reservedWidth);
+      const line2 = layoutNextLineRange(item.prepared, textCursor, availableWidth);
+      if (line2 === null) {
+        itemIndex++;
+        textCursor.segmentIndex = 0;
+        textCursor.graphemeIndex = 0;
+        continue;
+      }
+      if (textCursor.segmentIndex === line2.endSegmentIndex && textCursor.graphemeIndex === line2.endGraphemeIndex) {
+        itemIndex++;
+        textCursor.segmentIndex = 0;
+        textCursor.graphemeIndex = 0;
+        continue;
+      }
+      if (lineWidth > 0 && atItemStart && gapBefore > 0 && endsInsideFirstSegment(line2.endSegmentIndex, line2.endGraphemeIndex)) {
+        const freshLine = layoutNextLineRange(item.prepared, EMPTY_LAYOUT_CURSOR, Math.max(1, safeWidth - item.extraWidth));
+        if (freshLine !== null && (freshLine.endSegmentIndex > line2.endSegmentIndex || freshLine.endSegmentIndex === line2.endSegmentIndex && freshLine.endGraphemeIndex > line2.endGraphemeIndex)) {
+          break lineLoop;
+        }
+      }
+      collectFragment?.(item, gapBefore, line2.width + item.extraWidth, cloneCursor(textCursor), {
+        segmentIndex: line2.endSegmentIndex,
+        graphemeIndex: line2.endGraphemeIndex
+      });
+      lineWidth += gapBefore + line2.width + item.extraWidth;
+      remainingWidth = Math.max(0, safeWidth - lineWidth);
+      if (line2.endSegmentIndex === item.endSegmentIndex && line2.endGraphemeIndex === item.endGraphemeIndex) {
+        itemIndex++;
+        textCursor.segmentIndex = 0;
+        textCursor.graphemeIndex = 0;
+        continue;
+      }
+      textCursor.segmentIndex = line2.endSegmentIndex;
+      textCursor.graphemeIndex = line2.endGraphemeIndex;
+      break;
+    }
+    if (lineWidth === 0)
+      return null;
+    cursor.itemIndex = itemIndex;
+    cursor.segmentIndex = textCursor.segmentIndex;
+    cursor.graphemeIndex = textCursor.graphemeIndex;
+    return lineWidth;
+  }
+  __name(stepRichInlineLine, "stepRichInlineLine");
+  function layoutNextRichInlineLineRange(prepared, maxWidth, start = RICH_INLINE_START_CURSOR) {
+    const flow = getInternalPreparedRichInline(prepared);
+    const end = {
+      itemIndex: start.itemIndex,
+      segmentIndex: start.segmentIndex,
+      graphemeIndex: start.graphemeIndex
+    };
+    const fragments = [];
+    const width2 = stepRichInlineLine(flow, maxWidth, end, (item, gapBefore, occupiedWidth, fragmentStart, fragmentEnd) => {
+      fragments.push({
+        itemIndex: item.sourceItemIndex,
+        gapBefore,
+        occupiedWidth,
+        start: fragmentStart,
+        end: fragmentEnd
+      });
+    });
+    if (width2 === null)
+      return null;
+    return {
+      fragments,
+      width: width2,
+      end
+    };
+  }
+  __name(layoutNextRichInlineLineRange, "layoutNextRichInlineLineRange");
+  function materializeFragmentText(item, fragment) {
+    const line2 = materializeLineRange(item.prepared, {
+      width: fragment.occupiedWidth - item.extraWidth,
+      start: fragment.start,
+      end: fragment.end
+    });
+    return line2.text;
+  }
+  __name(materializeFragmentText, "materializeFragmentText");
+  function materializeRichInlineLineRange(prepared, line2) {
+    const flow = getInternalPreparedRichInline(prepared);
+    return {
+      fragments: line2.fragments.map((fragment) => {
+        const item = flow.itemsBySourceItemIndex[fragment.itemIndex];
+        if (item === void 0)
+          throw new Error("Missing rich-text inline item for fragment");
+        return {
+          ...fragment,
+          text: materializeFragmentText(item, fragment)
+        };
+      }),
+      width: line2.width,
+      end: line2.end
+    };
+  }
+  __name(materializeRichInlineLineRange, "materializeRichInlineLineRange");
+
   // ../../node_modules/.pnpm/html-void-elements@3.0.0/node_modules/html-void-elements/index.js
   var htmlVoidElements = [
     "area",
@@ -42295,99 +46046,6 @@ a {
   }
   __name(closedDialog, "closedDialog");
 
-  // src/splitText.ts
-  function splitTextToChars(text2) {
-    if (Intl.Segmenter) {
-      return [...new Intl.Segmenter().segment(text2)].map((s) => s.segment);
-    }
-    return [...text2];
-  }
-  __name(splitTextToChars, "splitTextToChars");
-  function splitWordToFitWidth(checkFit, word) {
-    const characters3 = splitTextToChars(word.content);
-    return splitWordToFitWidthRecursion(checkFit, [], characters3, word.type);
-  }
-  __name(splitWordToFitWidth, "splitWordToFitWidth");
-  function splitWordToFitWidthRecursion(checkFit, usedChars, remainingChars, type) {
-    if (remainingChars.length === 0) {
-      return [
-        { content: usedChars.join(""), type },
-        { content: "", type }
-      ];
-    }
-    const [nextChar, ...rest] = remainingChars;
-    const newWord = [...usedChars, nextChar];
-    if (checkFit({
-      type: "text_line",
-      words: [{ content: newWord.join(""), type }]
-    })) {
-      return splitWordToFitWidthRecursion(checkFit, newWord, rest, type);
-    }
-    if (usedChars.length === 0 && nextChar) {
-      usedChars.push(nextChar);
-      remainingChars.shift();
-    }
-    return [
-      { content: usedChars.join(""), type },
-      { content: remainingChars.join(""), type }
-    ];
-  }
-  __name(splitWordToFitWidthRecursion, "splitWordToFitWidthRecursion");
-  function splitLineToFitWidth(line2, checkFit) {
-    if (line2.words.some(({ content }) => content.includes("\n"))) {
-      throw new Error("splitLineToFitWidth does not support newlines in the line");
-    }
-    return splitLineToFitWidthRecursion(line2, checkFit);
-  }
-  __name(splitLineToFitWidth, "splitLineToFitWidth");
-  function splitLineToFitWidthRecursion(line2, checkFit, lines = [], newLine = []) {
-    let words = line2.words;
-    if (words.length === 0) {
-      if (newLine.length > 0) {
-        lines.push({
-          type: "text_line",
-          words: newLine
-        });
-      }
-      return lines.length > 0 ? lines : [];
-    }
-    let joiner = "";
-    if (words[0].content === " ") {
-      joiner = " ";
-      words.shift();
-    }
-    const nextWord = words.shift() ?? { content: " ", type: "normal" };
-    const lineWithNextWord = {
-      type: "text_line",
-      words: [...newLine]
-    };
-    if (joiner !== "") {
-      lineWithNextWord.words.push({ content: joiner, type: "normal" });
-    }
-    lineWithNextWord.words.push(nextWord);
-    if (checkFit(lineWithNextWord)) {
-      return splitLineToFitWidthRecursion(line2, checkFit, lines, lineWithNextWord.words);
-    }
-    if (newLine.length > 0) {
-      lines.push({
-        type: "text_line",
-        words: [...newLine]
-      });
-      line2.words.unshift(nextWord);
-    } else if (nextWord.content) {
-      const [word, rest] = splitWordToFitWidth(checkFit, nextWord);
-      lines.push({
-        type: "text_line",
-        words: [word]
-      });
-      if (rest.content) {
-        line2.words.unshift(rest);
-      }
-    }
-    return splitLineToFitWidthRecursion(line2, checkFit, lines);
-  }
-  __name(splitLineToFitWidthRecursion, "splitLineToFitWidthRecursion");
-
   // src/utils.ts
   var decodeEntities = /* @__PURE__ */ __name(function(text2) {
     return text2.replace(/fl°°/g, "&#").replace(/fl°/g, "&").replace(/¶ß/g, ";");
@@ -42589,19 +46247,130 @@ a {
   }, "walkTree");
 
   // src/text.ts
+  var DEFAULT_FONT_FAMILY = '"trebuchet ms", verdana, arial, sans-serif';
+  var DEFAULT_LINE_HEIGHT_EM = 1.1;
+  function getWordFontStyle(wordType) {
+    return {
+      fontStyle: wordType === "emphasis" ? "italic" : "normal",
+      fontWeight: wordType === "strong" ? "bold" : "normal"
+    };
+  }
+  __name(getWordFontStyle, "getWordFontStyle");
+  function createCanvasFont(word, fontSize, fontFamily) {
+    const { fontStyle, fontWeight } = getWordFontStyle(word.type);
+    return [fontStyle, fontWeight, `${fontSize}px`, fontFamily].join(" ");
+  }
+  __name(createCanvasFont, "createCanvasFont");
+  function splitTextToGraphemes(text2) {
+    if (Intl.Segmenter) {
+      return [...new Intl.Segmenter(void 0, { granularity: "grapheme" }).segment(text2)].map(
+        (segment) => segment.segment
+      );
+    }
+    return [...text2];
+  }
+  __name(splitTextToGraphemes, "splitTextToGraphemes");
+  function measureWordWidth(word, fontSize, fontFamily, content = word.content) {
+    return measureNaturalWidth(prepareWithSegments(content, createCanvasFont(word, fontSize, fontFamily)));
+  }
+  __name(measureWordWidth, "measureWordWidth");
+  function splitOversizedWordWithPretext(word, width2, fontSize, fontFamily) {
+    const graphemes = splitTextToGraphemes(word.content);
+    if (graphemes.length === 0) return [];
+    const lines = [];
+    let current = "";
+    for (const grapheme of graphemes) {
+      const candidate = `${current}${grapheme}`;
+      const candidateWidth = measureWordWidth(word, fontSize, fontFamily, candidate);
+      if (candidateWidth <= width2 || current.length === 0) {
+        current = candidate;
+        continue;
+      }
+      lines.push({
+        fragments: [{
+          gapBefore: 0,
+          text: current,
+          word
+        }],
+        width: measureWordWidth(word, fontSize, fontFamily, current)
+      });
+      current = grapheme;
+    }
+    if (current.length > 0) {
+      lines.push({
+        fragments: [{
+          gapBefore: 0,
+          text: current,
+          word
+        }],
+        width: measureWordWidth(word, fontSize, fontFamily, current)
+      });
+    }
+    return lines;
+  }
+  __name(splitOversizedWordWithPretext, "splitOversizedWordWithPretext");
+  function createRichInlineItems(line2, fontSize, fontFamily) {
+    return line2.words.map((word, index) => ({
+      break: "never",
+      font: createCanvasFont(word, fontSize, fontFamily),
+      text: index === 0 ? word.content : ` ${word.content}`
+    }));
+  }
+  __name(createRichInlineItems, "createRichInlineItems");
+  function layoutTextLineWithPretext(line2, width2, fontSize, fontFamily) {
+    const items = createRichInlineItems(line2, fontSize, fontFamily);
+    if (items.length === 0) return [];
+    const prepared = prepareRichInline(items);
+    const wrappedLines = [];
+    let cursor;
+    while (true) {
+      const lineRange = layoutNextRichInlineLineRange(prepared, width2, cursor);
+      if (!lineRange) break;
+      const materializedLine = materializeRichInlineLineRange(prepared, lineRange);
+      const nextLine = {
+        fragments: materializedLine.fragments.map((fragment) => ({
+          gapBefore: fragment.gapBefore,
+          text: fragment.text,
+          word: line2.words[fragment.itemIndex]
+        })),
+        width: materializedLine.width
+      };
+      if (nextLine.width > width2 && nextLine.fragments.length === 1) {
+        wrappedLines.push(
+          ...splitOversizedWordWithPretext(
+            nextLine.fragments[0].word,
+            width2,
+            fontSize,
+            fontFamily
+          )
+        );
+      } else {
+        wrappedLines.push(nextLine);
+      }
+      cursor = lineRange.end;
+    }
+    return wrappedLines;
+  }
+  __name(layoutTextLineWithPretext, "layoutTextLineWithPretext");
+  function measureTextLineWithPretext(line2, width2, fontSize, fontFamily = DEFAULT_FONT_FAMILY) {
+    const lines = layoutTextLineWithPretext(line2, width2, fontSize, fontFamily);
+    const measuredWidth = lines.reduce((currentWidth, wrappedLine) => {
+      return Math.max(currentWidth, wrappedLine.width);
+    }, 0);
+    return {
+      height: Math.max(
+        DEFAULT_LINE_HEIGHT_EM * fontSize,
+        lines.length * DEFAULT_LINE_HEIGHT_EM * fontSize
+      ),
+      lines,
+      width: measuredWidth
+    };
+  }
+  __name(measureTextLineWithPretext, "measureTextLineWithPretext");
   function createTspan(textElement, lineIndex, lineHeight) {
     return textElement.append("tspan").attr("class", "text-outer-tspan").attr("x", 0).attr("y", lineIndex * lineHeight - 0.1 + "em").attr("dy", lineHeight + "em");
   }
   __name(createTspan, "createTspan");
-  function computeWidthOfText(parentNode, lineHeight, line2) {
-    const testElement = parentNode.append("text");
-    const testSpan = createTspan(testElement, 1, lineHeight);
-    updateTextContentAndStyles(testSpan, line2.words);
-    const textLength = testSpan.node().getComputedTextLength();
-    testElement.remove();
-    return textLength;
-  }
-  __name(computeWidthOfText, "computeWidthOfText");
   function updateTextContentAndStyles(tspan, wrappedLine) {
     tspan.text("");
     wrappedLine.forEach((word, index) => {
@@ -42615,6 +46384,17 @@ a {
     });
   }
   __name(updateTextContentAndStyles, "updateTextContentAndStyles");
+  function updateTextContentAndStylesFromFragments(tspan, wrappedLine) {
+    tspan.text("");
+    wrappedLine.forEach((fragment) => {
+      const { fontStyle, fontWeight } = getWordFontStyle(fragment.word.type);
+      const innerTspan = tspan.append("tspan").attr("font-style", fontStyle).attr("class", "text-inner-tspan").attr("font-weight", fontWeight);
+      if (fragment.word.type === "delete") innerTspan.attr("text-decoration", "line-through");
+      if (fragment.gapBefore > 0) innerTspan.attr("dx", fragment.gapBefore);
+      innerTspan.text(fragment.text);
+    });
+  }
+  __name(updateTextContentAndStylesFromFragments, "updateTextContentAndStylesFromFragments");
   function addImageObject(element5, node2, width2, y2) {
     const img = element5.append("image");
     img.attr("href", node2.src);
@@ -42632,6 +46412,11 @@ a {
       let desc = img.append("desc");
       desc.text(node2.alt);
     }
+    return {
+      h: node2.height,
+      node: img.node(),
+      w: node2.width
+    };
   }
   __name(addImageObject, "addImageObject");
   function addHtmlSpan(element5, node2, width2, classes2, y2, addBackground = false) {
@@ -42797,30 +46582,20 @@ a {
     });
     return lines;
   }, "hastToLines");
-  function createFormattedText(width2, g, structuredBlocks, addBackground = false, txtColor = "currentColor") {
+  function createFormattedText(width2, g, structuredBlocks, addBackground = false, txtColor = "currentColor", fontSize = 16, fontFamily = DEFAULT_FONT_FAMILY) {
     const labelGroup = g.append("g");
-    const lineHeight = 1.1;
+    const lineHeight = DEFAULT_LINE_HEIGHT_EM;
     const bkg = labelGroup.insert("rect").attr("class", "background");
-    let textElement = void 0;
-    let y2 = -10;
-    let maxWidth = width2;
-    let i = 0;
+    let y2 = 0;
+    let maxWidth = 0;
+    let usedPretext = true;
     for (const line2 of structuredBlocks) {
       if (line2.type === "image") {
-        if (textElement) {
-          y2 += 1.5 * textElement.node().getBBox().height;
-        } else if (i === 0) {
-          y2 = 0;
-        }
         const result = addImageObject(labelGroup, line2, width2, y2);
         addBackground = true;
+        maxWidth = Math.max(maxWidth, result.w);
+        y2 += result.h;
       } else if (line2.type === "raw_html") {
-        if (textElement) {
-          y2 += 1.5 * textElement.node().getBBox().height;
-        } else if (i === 0) {
-          y2 = 0;
-        }
-        textElement = void 0;
         const decodedReplacedText = line2.raw;
         const htmlnode = {
           isNode: true,
@@ -42830,29 +46605,41 @@ a {
         const result = addHtmlSpan(labelGroup, htmlnode, width2, "", y2, false);
         log.debug("addHtmlSpan result w: ", result.w, ", h:", result.h);
         const { w, h } = result;
-        if (w > maxWidth) maxWidth = w;
+        maxWidth = Math.max(maxWidth, w);
+        y2 += h;
       } else {
-        if (textElement === void 0) {
-          textElement = labelGroup.append("text").attr("y", y2).attr("fill", txtColor);
-        }
-        ;
-        let lineIndex = 0;
-        const checkWidth = /* @__PURE__ */ __name((line3) => computeWidthOfText(labelGroup, lineHeight, line3) <= width2, "checkWidth");
-        const linesUnderWidth = checkWidth(line2) ? [line2] : splitLineToFitWidth(line2, checkWidth);
-        for (const preparedLine of linesUnderWidth) {
-          const tspan = createTspan(textElement, lineIndex, lineHeight);
-          updateTextContentAndStyles(tspan, preparedLine.words);
-          lineIndex++;
+        const textElement = labelGroup.append("text").attr("y", y2).attr("fill", txtColor);
+        try {
+          const measuredText = measureTextLineWithPretext(line2, width2, fontSize, fontFamily);
+          for (const [lineIndex, preparedLine] of measuredText.lines.entries()) {
+            const tspan = createTspan(textElement, lineIndex, lineHeight);
+            updateTextContentAndStylesFromFragments(tspan, preparedLine.fragments);
+            maxWidth = Math.max(maxWidth, preparedLine.width);
+          }
+          y2 += measuredText.height;
+        } catch (error3) {
+          log.warn("pretext layout failed, falling back to DOM text rendering", error3);
+          usedPretext = false;
+          const tspan = createTspan(textElement, 0, lineHeight);
+          updateTextContentAndStyles(tspan, line2.words);
+          const bbox = textElement.node().getBBox();
+          maxWidth = Math.max(maxWidth, bbox.width);
+          y2 += bbox.height;
         }
       }
-      ++i;
     }
     if (addBackground) {
-      const bbox = labelGroup.node().getBBox();
       const padding = 2;
-      bkg.attr("x", -padding).attr("y", -padding).attr("width", bbox.width + 2 * padding).attr("height", bbox.height + 2 * padding);
+      bkg.attr("x", -padding).attr("y", -padding).attr("width", maxWidth + 2 * padding).attr("height", y2 + 2 * padding);
     }
-    return labelGroup.node();
+    return {
+      measurement: {
+        height: y2,
+        usedPretext,
+        width: maxWidth
+      },
+      node: labelGroup.node()
+    };
   }
   __name(createFormattedText, "createFormattedText");
   var createText = /* @__PURE__ */ __name((el, text2 = "", contents = [], {
@@ -42863,12 +46650,22 @@ a {
     useHtmlLabels = true,
     isNode: isNode2 = true,
     width: width2 = 300,
-    addSvgBackground = false
+    addSvgBackground = false,
+    fontFamily = DEFAULT_FONT_FAMILY,
+    fontSize = 16
   } = {}) => {
     log.info("createText", text2, JSON.stringify(contents, void 0, 2), style3, isTitle, classes2, useHtmlLabels, isNode2, addSvgBackground);
     if (!Array.isArray(contents) || contents.length == 0) return;
     const structuredBlocks = hastToLines(contents);
-    const svgLabel = createFormattedText(width2, el, structuredBlocks, addSvgBackground, txtColor);
+    const svgLabel = createFormattedText(
+      width2,
+      el,
+      structuredBlocks,
+      addSvgBackground,
+      txtColor,
+      fontSize,
+      fontFamily
+    );
     log.info("structuredBlocks ", JSON.stringify(structuredBlocks, void 0, 2));
     return svgLabel;
   }, "createText");
@@ -43090,16 +46887,19 @@ a {
     nodeElem.attr("class", (node2.class ? node2.class + " " : "") + "mindmap-node " + sectionClass + ` node-level-${node2.level}`);
     const bkgElem = nodeElem.append("g");
     const textElem = nodeElem.append("g");
+    const fontSize = theme_default.fontSize(node2.level);
     const description = node2.descr?.replace(/(<br\/*>)/g, "\n") ?? "";
     const contents = node2.contents;
-    const newEl = createText(
+    const textResult = createText(
       textElem,
       description,
       contents,
       {
         useHtmlLabels: htmlLabels,
         width: node2.width,
-        classes: "mindmap-node-label"
+        classes: "mindmap-node-label",
+        fontFamily: theme_default.defaultFontFamily,
+        fontSize
       }
     );
     const hasCodeTag = textElem.selectAll("code").size() > 0;
@@ -43109,14 +46909,13 @@ a {
     }
     if (hasCodeTag) {
     }
-    const fontSize = theme_default.fontSize(node2.level);
     log.debug("fffffffffffffontsize : ", fontSize);
     if (!htmlLabels) {
       textElem.attr("dy", "1em").attr("alignment-baseline", "middle").attr("dominant-baseline", "middle").attr("text-anchor", "middle");
     }
     let tt = textElem.selectAll("text");
     tt.attr("font-size", `${fontSize}px`);
-    const bbox = textElem.node().getBBox();
+    const bbox = textResult?.measurement ?? textElem.node().getBBox();
     if (hasImage) {
       node2.height = bbox.height;
       node2.width = bbox.width;