@anlijiu/markmap 1.0.1 → 1.0.3

package/dist/markmap.core.mjs

@@ -7207,7 +7207,7 @@ function _unsupportedIterableToArray(r, 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({});
@@ -7285,7 +7285,7 @@ var promise = /* @__PURE__ */ __name(function promise2(obj) {
   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) {
@@ -39458,6 +39458,3757 @@ var updateLows = /* @__PURE__ */ __name((lowY, index, lastLows) => {
   };
 }, "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",
@@ -42270,99 +46021,6 @@ function closedDialog(node2) {
 }
 __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, ";");
@@ -42564,19 +46222,130 @@ var walkTree = /* @__PURE__ */ __name((tree, callback, key2 = "children", ...arg
 }, "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) => {
@@ -42590,6 +46359,17 @@ function updateTextContentAndStyles(tspan, wrappedLine) {
   });
 }
 __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);
@@ -42607,6 +46387,11 @@ function addImageObject(element5, node2, width2, y2) {
     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) {
@@ -42772,30 +46557,20 @@ var hastToLines = /* @__PURE__ */ __name((contents) => {
   });
   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,
@@ -42805,29 +46580,41 @@ function createFormattedText(width2, g, structuredBlocks, addBackground = false,
       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 = [], {
@@ -42838,12 +46625,22 @@ var createText = /* @__PURE__ */ __name((el, text2 = "", contents = [], {
   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");
@@ -43065,16 +46862,19 @@ var drawNode = /* @__PURE__ */ __name(function(elem, node2, opts, rootSection, i
   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;
@@ -43084,14 +46884,13 @@ var drawNode = /* @__PURE__ */ __name(function(elem, node2, opts, rootSection, i
   }
   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;
@@ -43266,7 +47065,16 @@ __name(partition, "partition");
 
 // src/markmap-renderer.ts
 cytoscape2.use(import_cytoscape_cose_bilkent.default);
+function assertMindmapNode(node2) {
+  if (!node2 || typeof node2 !== "object" || Array.isArray(node2)) {
+    throw new TypeError(
+      `Expected a MindmapNode object, received ${typeof node2}: ${JSON.stringify(node2)}`
+    );
+  }
+}
+__name(assertMindmapNode, "assertMindmapNode");
 function drawNodes(svg3, mindmap, opts, section, index = 0) {
+  assertMindmapNode(mindmap);
   drawNode(svg3, mindmap, opts, section, index);
   if (mindmap.children) {
     mindmap.children.forEach((child, index2) => {