@vyaz/core 0.0.16 → 0.1.0

package/dist/cli/check.js

@@ -0,0 +1,4077 @@
+// @bun
+var __defProp = Object.defineProperty;
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: __exportSetter.bind(all, name)
+    });
+};
+var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
+var __require = import.meta.require;
+
+// ../../node_modules/.bun/@chenglou+pretext@0.0.8/node_modules/@chenglou/pretext/dist/generated/bidi-data.js
+var latin1BidiTypes, nonLatin1BidiRanges;
+var init_bidi_data = __esm(() => {
+  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"
+  ];
+  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"],
+    [118000, 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"],
+    [918000, 921599, "BN"],
+    [983038, 983039, "BN"],
+    [1048574, 1048575, "BN"],
+    [1114110, 1114111, "BN"]
+  ];
+});
+
+// ../../node_modules/.bun/@chenglou+pretext@0.0.8/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";
+}
+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 first = str.charCodeAt(i);
+    let codePoint = first;
+    let codeUnitLength = 1;
+    if (first >= 55296 && first <= 56319 && i + 1 < len) {
+      const second = str.charCodeAt(i + 1);
+      if (second >= 56320 && second <= 57343) {
+        codePoint = (first - 55296 << 10) + (second - 56320) + 65536;
+        codeUnitLength = 2;
+      }
+    }
+    const t = classifyCodePoint(codePoint);
+    if (t === "R" || t === "AL" || t === "AN")
+      sawBidi = true;
+    for (let j = 0;j < codeUnitLength; j++) {
+      types[i + j] = t;
+    }
+    i += codeUnitLength;
+  }
+  if (!sawBidi)
+    return null;
+  let startLevel = 0;
+  for (let i = 0;i < len; i++) {
+    const t = types[i];
+    if (t === "L") {
+      startLevel = 0;
+      break;
+    }
+    if (t === "R" || t === "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 t = types[i];
+    if (t === "EN")
+      types[i] = lastType === "AL" ? "AN" : "EN";
+    else if (t === "R" || t === "L" || t === "AL")
+      lastType = t;
+  }
+  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 t = types[i];
+    if (t === "WS" || t === "ES" || t === "ET" || t === "CS")
+      types[i] = "ON";
+  }
+  lastType = sor;
+  for (let i = 0;i < len; i++) {
+    const t = types[i];
+    if (t === "EN")
+      types[i] = lastType === "L" ? "L" : "EN";
+    else if (t === "R" || t === "L")
+      lastType = t;
+  }
+  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 t = types[i];
+    if ((levels[i] & 1) === 0) {
+      if (t === "R")
+        levels[i]++;
+      else if (t === "AN" || t === "EN")
+        levels[i] += 2;
+    } else if (t === "L" || t === "AN" || t === "EN") {
+      levels[i]++;
+    }
+  }
+  return levels;
+}
+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;
+}
+var init_bidi = __esm(() => {
+  init_bidi_data();
+});
+
+// ../../node_modules/.bun/@chenglou+pretext@0.0.8/node_modules/@chenglou/pretext/dist/analysis.js
+function getWhiteSpaceProfile(whiteSpace) {
+  const mode = whiteSpace ?? "normal";
+  return mode === "pre-wrap" ? { mode, preserveOrdinarySpaces: true, preserveHardBreaks: true } : { mode, preserveOrdinarySpaces: false, preserveHardBreaks: false };
+}
+function normalizeWhitespaceNormal(text) {
+  if (!needsWhitespaceNormalizationRe.test(text))
+    return text;
+  let normalized = text.replace(collapsibleWhitespaceRunRe, " ");
+  if (normalized.charCodeAt(0) === 32) {
+    normalized = normalized.slice(1);
+  }
+  if (normalized.length > 0 && normalized.charCodeAt(normalized.length - 1) === 32) {
+    normalized = normalized.slice(0, -1);
+  }
+  return normalized;
+}
+function normalizeWhitespacePreWrap(text) {
+  if (!/[\r\f]/.test(text))
+    return text;
+  return text.replace(/\r\n/g, `
+`).replace(/[\r\f]/g, `
+`);
+}
+function getSharedWordSegmenter() {
+  if (sharedWordSegmenter === null) {
+    sharedWordSegmenter = new Intl.Segmenter(segmenterLocale, { granularity: "word" });
+  }
+  return sharedWordSegmenter;
+}
+function clearAnalysisCaches() {
+  sharedWordSegmenter = null;
+}
+function setAnalysisLocale(locale) {
+  const nextLocale = locale && locale.length > 0 ? locale : undefined;
+  if (segmenterLocale === nextLocale)
+    return;
+  segmenterLocale = nextLocale;
+  sharedWordSegmenter = null;
+}
+function containsArabicScript(text) {
+  return arabicScriptRe.test(text);
+}
+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 >= 12592 && codePoint <= 12687 || codePoint >= 44032 && codePoint <= 55215 || codePoint >= 65280 && codePoint <= 65519;
+}
+function isCJK(s) {
+  for (let i = 0;i < s.length; i++) {
+    const first = s.charCodeAt(i);
+    if (first < 12288)
+      continue;
+    if (first >= 55296 && first <= 56319 && i + 1 < s.length) {
+      const second = s.charCodeAt(i + 1);
+      if (second >= 56320 && second <= 57343) {
+        const codePoint = (first - 55296 << 10) + (second - 56320) + 65536;
+        if (isCJKCodePoint(codePoint))
+          return true;
+        i++;
+        continue;
+      }
+    }
+    if (isCJKCodePoint(first))
+      return true;
+  }
+  return false;
+}
+function endsWithLineStartProhibitedText(text) {
+  const last = getLastCodePoint(text);
+  return last !== null && (kinsokuStart.has(last) || leftStickyPunctuation.has(last));
+}
+function endsWithKeepAllGlueText(text) {
+  const last = getLastCodePoint(text);
+  return last !== null && keepAllGlueChars.has(last);
+}
+function endsWithKeepAllDashBreakText(text) {
+  const last = getLastCodePoint(text);
+  return last !== null && keepAllDashBreakChars.has(last);
+}
+function canContinueKeepAllTextRun(previousText, breakAfterPunctuation) {
+  if (endsWithKeepAllGlueText(previousText))
+    return false;
+  if (!breakAfterPunctuation)
+    return true;
+  if (endsWithLineStartProhibitedText(previousText))
+    return false;
+  if (endsWithKeepAllDashBreakText(previousText))
+    return false;
+  return true;
+}
+function isLeftStickyPunctuationSegment(segment) {
+  if (isEscapedQuoteClusterSegment(segment))
+    return true;
+  let sawPunctuation = false;
+  for (const ch of segment) {
+    if (leftStickyPunctuation.has(ch) || isLineBreakNumericAffix(ch)) {
+      sawPunctuation = true;
+      continue;
+    }
+    if (sawPunctuation && combiningMarkRe.test(ch))
+      continue;
+    return false;
+  }
+  return sawPunctuation;
+}
+function isCJKLineStartProhibitedSegment(segment) {
+  for (const ch of segment) {
+    if (!kinsokuStart.has(ch) && !leftStickyPunctuation.has(ch))
+      return false;
+  }
+  return segment.length > 0;
+}
+function isForwardStickyClusterSegment(segment) {
+  if (isEscapedQuoteClusterSegment(segment))
+    return true;
+  for (const ch of segment) {
+    if (!kinsokuEnd.has(ch) && !forwardStickyGlue.has(ch) && !combiningMarkRe.test(ch) && !isLineBreakNumericAffix(ch)) {
+      return false;
+    }
+  }
+  return segment.length > 0;
+}
+function isEscapedQuoteClusterSegment(segment) {
+  let sawQuote = false;
+  for (const ch of segment) {
+    if (ch === "\\" || combiningMarkRe.test(ch))
+      continue;
+    if (kinsokuEnd.has(ch) || leftStickyPunctuation.has(ch) || forwardStickyGlue.has(ch)) {
+      sawQuote = true;
+      continue;
+    }
+    return false;
+  }
+  return sawQuote;
+}
+function previousCodePointStart(text, end) {
+  const last = end - 1;
+  if (last <= 0)
+    return Math.max(last, 0);
+  const lastCodeUnit = text.charCodeAt(last);
+  if (lastCodeUnit < 56320 || lastCodeUnit > 57343)
+    return last;
+  const maybeHigh = last - 1;
+  if (maybeHigh < 0)
+    return last;
+  const highCodeUnit = text.charCodeAt(maybeHigh);
+  return highCodeUnit >= 55296 && highCodeUnit <= 56319 ? maybeHigh : last;
+}
+function getLastCodePoint(text) {
+  if (text.length === 0)
+    return null;
+  const start = previousCodePointStart(text, text.length);
+  return text.slice(start);
+}
+function getFirstSignificantCodePoint(text) {
+  for (const ch of text) {
+    if (!combiningMarkRe.test(ch))
+      return ch;
+  }
+  return null;
+}
+function getLastSignificantCodePoint(text) {
+  for (let end = text.length;end > 0; ) {
+    const start = previousCodePointStart(text, end);
+    const ch = text.slice(start, end);
+    if (!combiningMarkRe.test(ch))
+      return ch;
+    end = start;
+  }
+  return null;
+}
+function isCodePointInRanges(codePoint, ranges) {
+  for (let i = 0;i < ranges.length; i += 2) {
+    if (codePoint >= ranges[i] && codePoint <= ranges[i + 1])
+      return true;
+  }
+  return false;
+}
+function isLineBreakNumericAffix(ch) {
+  const codePoint = ch.codePointAt(0);
+  return codePoint !== undefined && isCodePointInRanges(codePoint, lineBreakNumericAffixRanges);
+}
+function endsWithLineBreakNumericAffix(text) {
+  const last = getLastSignificantCodePoint(text);
+  return last !== null && isLineBreakNumericAffix(last);
+}
+function startsWithDecimalDigit(text) {
+  const first = getFirstSignificantCodePoint(text);
+  return first !== null && decimalDigitRe.test(first);
+}
+function splitTrailingForwardStickyCluster(text) {
+  const chars = Array.from(text);
+  let splitIndex = chars.length;
+  while (splitIndex > 0) {
+    const ch = chars[splitIndex - 1];
+    if (combiningMarkRe.test(ch)) {
+      splitIndex--;
+      continue;
+    }
+    if (kinsokuEnd.has(ch) || forwardStickyGlue.has(ch)) {
+      splitIndex--;
+      continue;
+    }
+    break;
+  }
+  if (splitIndex <= 0 || splitIndex === chars.length)
+    return null;
+  return {
+    head: chars.slice(0, splitIndex).join(""),
+    tail: chars.slice(splitIndex).join("")
+  };
+}
+function getRepeatableSingleCharRunChar(text, isWordLike, kind) {
+  return kind === "text" && !isWordLike && text.length === 1 && text !== "-" && text !== "\u2014" ? text : null;
+}
+function materializeDeferredSingleCharRun(texts, chars, lengths, index) {
+  const ch = chars[index];
+  const text = texts[index];
+  if (ch == null)
+    return text;
+  const length = lengths[index];
+  if (text.length === length)
+    return text;
+  const materialized = ch.repeat(length);
+  texts[index] = materialized;
+  return materialized;
+}
+function hasArabicNoSpacePunctuation(containsArabic, lastCodePoint) {
+  return containsArabic && lastCodePoint !== null && arabicNoSpaceTrailingPunctuation.has(lastCodePoint);
+}
+function endsWithMyanmarMedialGlue(segment) {
+  const lastCodePoint = getLastCodePoint(segment);
+  return lastCodePoint !== null && myanmarMedialGlue.has(lastCodePoint);
+}
+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;
+}
+function endsWithClosingQuote(text) {
+  let end = text.length;
+  while (end > 0) {
+    const start = previousCodePointStart(text, end);
+    const ch = text.slice(start, end);
+    if (closingQuoteChars.has(ch))
+      return true;
+    if (!leftStickyPunctuation.has(ch))
+      return false;
+    end = start;
+  }
+  return false;
+}
+function classifySegmentBreakChar(ch, whiteSpaceProfile) {
+  if (whiteSpaceProfile.preserveOrdinarySpaces || whiteSpaceProfile.preserveHardBreaks) {
+    if (ch === " ")
+      return "preserved-space";
+    if (ch === "\t")
+      return "tab";
+    if (whiteSpaceProfile.preserveHardBreaks && ch === `
+`)
+      return "hard-break";
+  }
+  if (ch === " ")
+    return "space";
+  if (ch === "\xA0" || ch === "\u202F" || ch === "\u2060" || ch === "\uFEFF") {
+    return "glue";
+  }
+  if (ch === "\u200B")
+    return "zero-width-break";
+  if (ch === "\xAD")
+    return "soft-hyphen";
+  return "text";
+}
+function joinTextParts(parts) {
+  return parts.length === 1 ? parts[0] : parts.join("");
+}
+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);
+}
+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;
+}
+function isTextRunBoundary(kind) {
+  return kind === "space" || kind === "preserved-space" || kind === "zero-width-break" || kind === "hard-break";
+}
+function isUrlLikeRunStart(segmentation, index) {
+  const text = segmentation.texts[index];
+  if (text.startsWith("www."))
+    return true;
+  return urlSchemeSegmentRe.test(text) && index + 1 < segmentation.len && segmentation.kinds[index + 1] === "text" && segmentation.texts[index + 1] === "//";
+}
+function isUrlQueryBoundarySegment(text) {
+  return text.includes("?") && (text.includes("://") || text.startsWith("www."));
+}
+function mergeUrlLikeRuns(segmentation) {
+  const texts = segmentation.texts.slice();
+  const isWordLike = segmentation.isWordLike.slice();
+  const kinds = segmentation.kinds.slice();
+  const starts = segmentation.starts.slice();
+  for (let 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 text = texts[read];
+    if (text.length === 0)
+      continue;
+    if (compactLen !== read) {
+      texts[compactLen] = text;
+      isWordLike[compactLen] = isWordLike[read];
+      kinds[compactLen] = kinds[read];
+      starts[compactLen] = starts[read];
+    }
+    compactLen++;
+  }
+  texts.length = compactLen;
+  isWordLike.length = compactLen;
+  kinds.length = compactLen;
+  starts.length = compactLen;
+  return {
+    len: compactLen,
+    texts,
+    isWordLike,
+    kinds,
+    starts
+  };
+}
+function mergeUrlQueryRuns(segmentation) {
+  const texts = [];
+  const isWordLike = [];
+  const kinds = [];
+  const starts = [];
+  for (let i = 0;i < segmentation.len; i++) {
+    const text = segmentation.texts[i];
+    texts.push(text);
+    isWordLike.push(segmentation.isWordLike[i]);
+    kinds.push(segmentation.kinds[i]);
+    starts.push(segmentation.starts[i]);
+    if (!isUrlQueryBoundarySegment(text))
+      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
+  };
+}
+function isAsciiWordInternalSymbolCode(code) {
+  return code >= 33 && code <= 47 && code !== 45 || code >= 58 && code <= 64 && code !== 63 || code >= 91 && code <= 96 || code >= 123 && code <= 126;
+}
+function isNoSpaceWordInternalSymbol(ch) {
+  const code = ch.charCodeAt(0);
+  if (code < 128)
+    return isAsciiWordInternalSymbolCode(code);
+  return !noSpaceWordBreakAfterChars.has(ch) && !emojiPresentationRe.test(ch) && wordInternalSymbolRe.test(ch);
+}
+function isNoSpaceWordInternalSymbolSegment(text) {
+  let sawSymbol = false;
+  for (const ch of text) {
+    if (combiningMarkRe.test(ch))
+      continue;
+    if (!isNoSpaceWordInternalSymbol(ch))
+      return false;
+    sawSymbol = true;
+  }
+  return sawSymbol;
+}
+function endsWithNoSpaceWordJoiner(text) {
+  for (let end = text.length;end > 0; ) {
+    const start = previousCodePointStart(text, end);
+    const ch = text.slice(start, end);
+    if (combiningMarkRe.test(ch)) {
+      end = start;
+      continue;
+    }
+    return isNoSpaceWordInternalSymbol(ch) || isLineBreakNumericAffix(ch);
+  }
+  return false;
+}
+function canJoinNoSpaceWordBoundary(leftText, leftWordLike, rightText, rightWordLike) {
+  const leftSymbol = !leftWordLike && isNoSpaceWordInternalSymbolSegment(leftText);
+  const rightSymbol = !rightWordLike && isNoSpaceWordInternalSymbolSegment(rightText);
+  const leftAffix = endsWithLineBreakNumericAffix(leftText);
+  const leftEndsJoiner = (leftWordLike || leftAffix) && endsWithNoSpaceWordJoiner(leftText);
+  if (!leftSymbol && !rightSymbol && !leftEndsJoiner)
+    return false;
+  if (isCJK(leftText) || isCJK(rightText))
+    return false;
+  return (leftWordLike || leftSymbol || leftAffix) && (rightWordLike || rightSymbol);
+}
+function segmentContainsDecimalDigit(text) {
+  for (const ch of text) {
+    if (decimalDigitRe.test(ch))
+      return true;
+  }
+  return false;
+}
+function isNumericRunSegment(text) {
+  if (text.length === 0)
+    return false;
+  for (const ch of text) {
+    if (decimalDigitRe.test(ch) || numericJoinerChars.has(ch))
+      continue;
+    return false;
+  }
+  return true;
+}
+function mergeNumericRuns(segmentation) {
+  const texts = [];
+  const isWordLike = [];
+  const kinds = [];
+  const starts = [];
+  for (let i = 0;i < segmentation.len; i++) {
+    const text = segmentation.texts[i];
+    const kind = segmentation.kinds[i];
+    if (kind === "text" && isNumericRunSegment(text) && segmentContainsDecimalDigit(text)) {
+      const mergedParts = [text];
+      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(text);
+    isWordLike.push(segmentation.isWordLike[i]);
+    kinds.push(kind);
+    starts.push(segmentation.starts[i]);
+  }
+  return {
+    len: texts.length,
+    texts,
+    isWordLike,
+    kinds,
+    starts
+  };
+}
+function mergeNoSpaceWordChains(segmentation) {
+  const texts = [];
+  const isWordLike = [];
+  const kinds = [];
+  const starts = [];
+  let i = 0;
+  while (i < segmentation.len) {
+    const text = segmentation.texts[i];
+    const kind = segmentation.kinds[i];
+    const wordLike = segmentation.isWordLike[i];
+    if (kind === "text") {
+      const mergedParts = [text];
+      let j = i + 1;
+      let mergedWordLike = wordLike;
+      while (j < segmentation.len && segmentation.kinds[j] === "text" && canJoinNoSpaceWordBoundary(segmentation.texts[j - 1], segmentation.isWordLike[j - 1], segmentation.texts[j], segmentation.isWordLike[j])) {
+        const nextText = segmentation.texts[j];
+        mergedParts.push(nextText);
+        mergedWordLike = mergedWordLike || segmentation.isWordLike[j];
+        j++;
+      }
+      if (j > i + 1) {
+        texts.push(joinTextParts(mergedParts));
+        isWordLike.push(mergedWordLike);
+        kinds.push("text");
+        starts.push(segmentation.starts[i]);
+        i = j;
+        continue;
+      }
+    }
+    texts.push(text);
+    isWordLike.push(wordLike);
+    kinds.push(kind);
+    starts.push(segmentation.starts[i]);
+    i++;
+  }
+  return {
+    len: texts.length,
+    texts,
+    isWordLike,
+    kinds,
+    starts
+  };
+}
+function splitHyphenatedNumericRuns(segmentation) {
+  const texts = [];
+  const isWordLike = [];
+  const kinds = [];
+  const starts = [];
+  for (let i = 0;i < segmentation.len; i++) {
+    const text = segmentation.texts[i];
+    if (segmentation.kinds[i] === "text" && text.includes("-")) {
+      const parts = text.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(text);
+    isWordLike.push(segmentation.isWordLike[i]);
+    kinds.push(segmentation.kinds[i]);
+    starts.push(segmentation.starts[i]);
+  }
+  return {
+    len: texts.length,
+    texts,
+    isWordLike,
+    kinds,
+    starts
+  };
+}
+function mergeGlueConnectedTextRuns(segmentation) {
+  const texts = [];
+  const isWordLike = [];
+  const kinds = [];
+  const starts = [];
+  let read = 0;
+  while (read < segmentation.len) {
+    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
+  };
+}
+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
+  };
+}
+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 appendPieceToPrevious = 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);
+      };
+      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]) {
+        appendPieceToPrevious();
+      } else if (isText && mergedLen > 0 && mergedKinds[prevIndex] === "text" && isCJKLineStartProhibitedSegment(piece.text) && mergedContainsCJK[prevIndex]) {
+        appendPieceToPrevious();
+      } else if (isText && mergedLen > 0 && mergedKinds[prevIndex] === "text" && mergedEndsWithMyanmarMedialGlue[prevIndex]) {
+        appendPieceToPrevious();
+      } else if (isText && mergedLen > 0 && mergedKinds[prevIndex] === "text" && piece.isWordLike && pieceContainsArabicScript && mergedHasArabicNoSpacePunctuation[prevIndex]) {
+        appendPieceToPrevious();
+        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" && !mergedContainsCJK[prevIndex] && (isLeftStickyPunctuationSegment(piece.text) || piece.text === "-" && mergedWordLike[prevIndex])) {
+        appendPieceToPrevious();
+      } 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" && !mergedContainsCJK[i - 1]) {
+      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 text = mergedTexts[i];
+    if (text.length === 0)
+      continue;
+    if (mergedKinds[i] === "text" && !mergedWordLike[i] && nextLiveIndex >= 0 && mergedKinds[nextLiveIndex] === "text" && (isForwardStickyClusterSegment(text) || text === "-" && startsWithDecimalDigit(mergedTexts[nextLiveIndex]))) {
+      const prefixParts = forwardStickyPrefixParts[nextLiveIndex] ?? [];
+      prefixParts.push(text);
+      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 text = mergedTexts[read];
+    if (text.length === 0)
+      continue;
+    if (compactLen !== read) {
+      mergedTexts[compactLen] = text;
+      mergedWordLike[compactLen] = mergedWordLike[read];
+      mergedKinds[compactLen] = mergedKinds[read];
+      mergedStarts[compactLen] = mergedStarts[read];
+    }
+    compactLen++;
+  }
+  mergedTexts.length = compactLen;
+  mergedWordLike.length = compactLen;
+  mergedKinds.length = compactLen;
+  mergedStarts.length = compactLen;
+  const compacted = mergeGlueConnectedTextRuns({
+    len: compactLen,
+    texts: mergedTexts,
+    isWordLike: mergedWordLike,
+    kinds: mergedKinds,
+    starts: mergedStarts
+  });
+  const withMergedUrls = carryTrailingForwardStickyAcrossCJKBoundary(mergeNoSpaceWordChains(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;
+}
+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;
+}
+function mergeKeepAllTextSegments(normalized, segmentation, breakAfterPunctuation) {
+  if (segmentation.len <= 1)
+    return segmentation;
+  const texts = [];
+  const isWordLike = [];
+  const kinds = [];
+  const starts = [];
+  let groupStart = -1;
+  let groupContainsCJK = false;
+  function pushOriginalText(index) {
+    texts.push(segmentation.texts[index]);
+    isWordLike.push(segmentation.isWordLike[index]);
+    kinds.push("text");
+    starts.push(segmentation.starts[index]);
+  }
+  function pushMergedText(start, end) {
+    let wordLike = false;
+    for (let i = start;i < end; i++) {
+      wordLike = wordLike || segmentation.isWordLike[i];
+    }
+    const sourceStart = segmentation.starts[start];
+    const sourceEnd = end < segmentation.len ? segmentation.starts[end] : normalized.length;
+    texts.push(normalized.slice(sourceStart, sourceEnd));
+    isWordLike.push(wordLike);
+    kinds.push("text");
+    starts.push(sourceStart);
+  }
+  function flushGroup(end) {
+    if (groupStart < 0)
+      return;
+    if (groupContainsCJK) {
+      if (groupStart + 1 === end) {
+        pushOriginalText(groupStart);
+      } else {
+        pushMergedText(groupStart, end);
+      }
+    } else {
+      for (let i = groupStart;i < end; i++)
+        pushOriginalText(i);
+    }
+    groupStart = -1;
+    groupContainsCJK = false;
+  }
+  for (let i = 0;i < segmentation.len; i++) {
+    const text = segmentation.texts[i];
+    const kind = segmentation.kinds[i];
+    if (kind === "text") {
+      if (groupStart >= 0 && !canContinueKeepAllTextRun(segmentation.texts[i - 1], breakAfterPunctuation)) {
+        flushGroup(i);
+      }
+      if (groupStart < 0)
+        groupStart = i;
+      groupContainsCJK = groupContainsCJK || isCJK(text);
+      continue;
+    }
+    flushGroup(i);
+    texts.push(text);
+    isWordLike.push(segmentation.isWordLike[i]);
+    kinds.push(kind);
+    starts.push(segmentation.starts[i]);
+  }
+  flushGroup(segmentation.len);
+  return {
+    len: texts.length,
+    texts,
+    isWordLike,
+    kinds,
+    starts
+  };
+}
+function analyzeText(text, profile, whiteSpace = "normal", wordBreak = "normal") {
+  const whiteSpaceProfile = getWhiteSpaceProfile(whiteSpace);
+  const normalized = whiteSpaceProfile.mode === "pre-wrap" ? normalizeWhitespacePreWrap(text) : normalizeWhitespaceNormal(text);
+  if (normalized.length === 0) {
+    return {
+      normalized,
+      chunks: [],
+      len: 0,
+      texts: [],
+      isWordLike: [],
+      kinds: [],
+      starts: []
+    };
+  }
+  const mergedSegmentation = buildMergedSegmentation(normalized, profile, whiteSpaceProfile);
+  const segmentation = wordBreak === "keep-all" ? mergeKeepAllTextSegments(normalized, mergedSegmentation, profile.breakKeepAllAfterPunctuation) : mergedSegmentation;
+  return {
+    normalized,
+    chunks: compileAnalysisChunks(segmentation, whiteSpaceProfile),
+    ...segmentation
+  };
+}
+var collapsibleWhitespaceRunRe, needsWhitespaceNormalizationRe, sharedWordSegmenter = null, segmenterLocale, arabicScriptRe, combiningMarkRe, decimalDigitRe, keepAllGlueChars, keepAllDashBreakChars, kinsokuStart, kinsokuEnd, forwardStickyGlue, leftStickyPunctuation, arabicNoSpaceTrailingPunctuation, myanmarMedialGlue, closingQuoteChars, lineBreakNumericAffixRanges, breakCharRe, urlSchemeSegmentRe, numericJoinerChars, wordInternalSymbolRe, emojiPresentationRe, noSpaceWordBreakAfterChars;
+var init_analysis = __esm(() => {
+  collapsibleWhitespaceRunRe = /[ \t\n\r\f]+/g;
+  needsWhitespaceNormalizationRe = /[\t\n\r\f]| {2,}|^ | $/;
+  arabicScriptRe = /\p{Script=Arabic}/u;
+  combiningMarkRe = /\p{M}/u;
+  decimalDigitRe = /\p{Nd}/u;
+  keepAllGlueChars = new Set([
+    "\xA0",
+    "\u202F",
+    "\u2060",
+    "\uFEFF"
+  ]);
+  keepAllDashBreakChars = new Set([
+    "-",
+    "\u2010",
+    "\u2013",
+    "\u2014"
+  ]);
+  kinsokuStart = new Set([
+    "\uFF0C",
+    "\uFF0E",
+    "\uFF01",
+    "\uFF1A",
+    "\uFF1B",
+    "\uFF1F",
+    "\u3001",
+    "\u3002",
+    "\u30FB",
+    "\uFF09",
+    "\u3015",
+    "\u3009",
+    "\u300B",
+    "\u300D",
+    "\u300F",
+    "\u3011",
+    "\u3017",
+    "\u3019",
+    "\u301B",
+    "\u30FC",
+    "\u3005",
+    "\u303B",
+    "\u309D",
+    "\u309E",
+    "\u30FD",
+    "\u30FE"
+  ]);
+  kinsokuEnd = new Set([
+    '"',
+    "(",
+    "[",
+    "{",
+    "\xA1",
+    "\xBF",
+    "\u201C",
+    "\u2018",
+    "\u201A",
+    "\u201E",
+    "\xAB",
+    "\u2039",
+    "\u2E18",
+    "\uFF08",
+    "\u3014",
+    "\u3008",
+    "\u300A",
+    "\u300C",
+    "\u300E",
+    "\u3010",
+    "\u3016",
+    "\u3018",
+    "\u301A"
+  ]);
+  forwardStickyGlue = new Set([
+    "'",
+    "\u2019"
+  ]);
+  leftStickyPunctuation = new Set([
+    ".",
+    ",",
+    "!",
+    "?",
+    ":",
+    ";",
+    "\u060C",
+    "\u061B",
+    "\u061F",
+    "\u0964",
+    "\u0965",
+    "\u104A",
+    "\u104B",
+    "\u104C",
+    "\u104D",
+    "\u104F",
+    ")",
+    "]",
+    "}",
+    "%",
+    '"',
+    "\u201D",
+    "\u2019",
+    "\xBB",
+    "\u203A",
+    "\u2026"
+  ]);
+  arabicNoSpaceTrailingPunctuation = new Set([
+    ":",
+    ".",
+    "\u060C",
+    "\u061B"
+  ]);
+  myanmarMedialGlue = new Set([
+    "\u104F"
+  ]);
+  closingQuoteChars = new Set([
+    "\u201D",
+    "\u2019",
+    "\xBB",
+    "\u203A",
+    "\u300D",
+    "\u300F",
+    "\u3011",
+    "\u300B",
+    "\u3009",
+    "\u3015",
+    "\uFF09"
+  ]);
+  lineBreakNumericAffixRanges = [
+    36,
+    37,
+    43,
+    43,
+    92,
+    92,
+    162,
+    165,
+    176,
+    177,
+    1423,
+    1423,
+    1545,
+    1547,
+    1642,
+    1642,
+    2046,
+    2047,
+    2546,
+    2547,
+    2553,
+    2555,
+    2801,
+    2801,
+    3065,
+    3065,
+    3449,
+    3449,
+    3647,
+    3647,
+    6107,
+    6107,
+    8240,
+    8247,
+    8279,
+    8279,
+    8352,
+    8399,
+    8451,
+    8451,
+    8457,
+    8457,
+    8470,
+    8470,
+    8722,
+    8723,
+    43064,
+    43064,
+    65020,
+    65020,
+    65129,
+    65130,
+    65284,
+    65285,
+    65504,
+    65505,
+    65509,
+    65510,
+    73693,
+    73696,
+    123647,
+    123647,
+    126124,
+    126124,
+    126128,
+    126128
+  ];
+  breakCharRe = /[\x20\t\n\xA0\xAD\u200B\u202F\u2060\uFEFF]/;
+  urlSchemeSegmentRe = /^[A-Za-z][A-Za-z0-9+.-]*:$/;
+  numericJoinerChars = new Set([
+    ":",
+    "-",
+    "/",
+    "\xD7",
+    ",",
+    ".",
+    "+",
+    "\u2013",
+    "\u2014"
+  ]);
+  wordInternalSymbolRe = /[\p{P}\p{S}\p{Co}]/u;
+  emojiPresentationRe = /\p{Emoji_Presentation}/u;
+  noSpaceWordBreakAfterChars = new Set([
+    "?",
+    "\u058A",
+    "-",
+    "\u2010",
+    "\u2012",
+    "\u2013",
+    "\u2014",
+    "\u2026",
+    "\u203C",
+    "\u203D",
+    "\u2049"
+  ]);
+});
+
+// ../../node_modules/.bun/@chenglou+pretext@0.0.8/node_modules/@chenglou/pretext/dist/measurement.js
+function getMeasureContext() {
+  if (measureContext !== null)
+    return measureContext;
+  if (typeof OffscreenCanvas !== "undefined") {
+    measureContext = new OffscreenCanvas(1, 1).getContext("2d");
+    return measureContext;
+  }
+  if (typeof document !== "undefined") {
+    measureContext = document.createElement("canvas").getContext("2d");
+    return measureContext;
+  }
+  throw new Error("Text measurement requires OffscreenCanvas or a DOM canvas context.");
+}
+function getSegmentMetricCache(font) {
+  let cache = segmentMetricCaches.get(font);
+  if (!cache) {
+    cache = new Map;
+    segmentMetricCaches.set(font, cache);
+  }
+  return cache;
+}
+function getSegmentMetrics(seg, cache) {
+  let metrics = cache.get(seg);
+  if (metrics === undefined) {
+    const ctx = getMeasureContext();
+    metrics = {
+      width: ctx.measureText(seg).width,
+      containsCJK: isCJK(seg)
+    };
+    cache.set(seg, metrics);
+  }
+  return metrics;
+}
+function getEngineProfile() {
+  if (cachedEngineProfile !== null)
+    return cachedEngineProfile;
+  if (typeof navigator === "undefined") {
+    cachedEngineProfile = {
+      lineFitEpsilon: 0.005,
+      carryCJKAfterClosingQuote: false,
+      breakKeepAllAfterPunctuation: true,
+      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 : 0.005,
+    carryCJKAfterClosingQuote: isChromium,
+    breakKeepAllAfterPunctuation: !isSafari,
+    preferPrefixWidthsForBreakableRuns: isSafari,
+    preferEarlySoftHyphenBreak: isSafari
+  };
+  return cachedEngineProfile;
+}
+function parseFontSize(font) {
+  const m = font.match(/(\d+(?:\.\d+)?)\s*px/);
+  return m ? parseFloat(m[1]) : 16;
+}
+function getSharedGraphemeSegmenter() {
+  if (sharedGraphemeSegmenter === null) {
+    sharedGraphemeSegmenter = new Intl.Segmenter(undefined, { granularity: "grapheme" });
+  }
+  return sharedGraphemeSegmenter;
+}
+function isEmojiGrapheme(g) {
+  return emojiPresentationRe2.test(g) || g.includes("\uFE0F");
+}
+function textMayContainEmoji(text) {
+  return maybeEmojiRe.test(text);
+}
+function getEmojiCorrection(font, fontSize) {
+  let correction = emojiCorrectionCache.get(font);
+  if (correction !== undefined)
+    return correction;
+  const ctx = getMeasureContext();
+  ctx.font = font;
+  const canvasW = ctx.measureText("\uD83D\uDE00").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 = "\uD83D\uDE00";
+    document.body.appendChild(span);
+    const domW = span.getBoundingClientRect().width;
+    document.body.removeChild(span);
+    if (canvasW - domW > 0.5) {
+      correction = canvasW - domW;
+    }
+  }
+  emojiCorrectionCache.set(font, correction);
+  return correction;
+}
+function countEmojiGraphemes(text) {
+  let count = 0;
+  const graphemeSegmenter = getSharedGraphemeSegmenter();
+  for (const g of graphemeSegmenter.segment(text)) {
+    if (isEmojiGrapheme(g.segment))
+      count++;
+  }
+  return count;
+}
+function getEmojiCount(seg, metrics) {
+  if (metrics.emojiCount === undefined) {
+    metrics.emojiCount = countEmojiGraphemes(seg);
+  }
+  return metrics.emojiCount;
+}
+function getCorrectedSegmentWidth(seg, metrics, emojiCorrection) {
+  if (emojiCorrection === 0)
+    return metrics.width;
+  return metrics.width - getEmojiCount(seg, metrics) * emojiCorrection;
+}
+function getSegmentBreakableFitAdvances(seg, metrics, cache, emojiCorrection, mode) {
+  if (metrics.breakableFitAdvances !== undefined && metrics.breakableFitMode === mode) {
+    return metrics.breakableFitAdvances;
+  }
+  metrics.breakableFitMode = mode;
+  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, cache);
+      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, cache);
+      const currentWidth = getCorrectedSegmentWidth(grapheme, graphemeMetrics, emojiCorrection);
+      if (previousGrapheme === null) {
+        advances2.push(currentWidth);
+      } else {
+        const pair = previousGrapheme + grapheme;
+        const pairMetrics = getSegmentMetrics(pair, cache);
+        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, cache);
+    const nextPrefixWidth = getCorrectedSegmentWidth(prefix, prefixMetrics, emojiCorrection);
+    advances.push(nextPrefixWidth - prefixWidth);
+    prefixWidth = nextPrefixWidth;
+  }
+  metrics.breakableFitAdvances = advances;
+  return metrics.breakableFitAdvances;
+}
+function getFontMeasurementState(font, needsEmojiCorrection) {
+  const ctx = getMeasureContext();
+  ctx.font = font;
+  const cache = getSegmentMetricCache(font);
+  const fontSize = parseFontSize(font);
+  const emojiCorrection = needsEmojiCorrection ? getEmojiCorrection(font, fontSize) : 0;
+  return { cache, fontSize, emojiCorrection };
+}
+function clearMeasurementCaches() {
+  segmentMetricCaches.clear();
+  emojiCorrectionCache.clear();
+  sharedGraphemeSegmenter = null;
+}
+var measureContext = null, segmentMetricCaches, cachedEngineProfile = null, MAX_PREFIX_FIT_GRAPHEMES = 96, emojiPresentationRe2, maybeEmojiRe, sharedGraphemeSegmenter = null, emojiCorrectionCache;
+var init_measurement = __esm(() => {
+  init_analysis();
+  segmentMetricCaches = new Map;
+  emojiPresentationRe2 = /\p{Emoji_Presentation}/u;
+  maybeEmojiRe = /[\p{Emoji_Presentation}\p{Extended_Pictographic}\p{Regional_Indicator}\uFE0F\u20E3]/u;
+  emojiCorrectionCache = new Map;
+});
+
+// ../../node_modules/.bun/@chenglou+pretext@0.0.8/node_modules/@chenglou/pretext/dist/line-break.js
+function consumesAtLineStart(kind) {
+  return kind === "space" || kind === "zero-width-break" || kind === "soft-hyphen";
+}
+function breaksAfter(kind) {
+  return kind === "space" || kind === "preserved-space" || kind === "tab" || kind === "zero-width-break" || kind === "soft-hyphen";
+}
+function normalizeLineStartSegmentIndex(prepared, segmentIndex, endSegmentIndex = prepared.widths.length) {
+  while (segmentIndex < endSegmentIndex) {
+    const kind = prepared.kinds[segmentIndex];
+    if (!consumesAtLineStart(kind))
+      break;
+    segmentIndex++;
+  }
+  return segmentIndex;
+}
+function getTabAdvance(lineWidth, tabStopAdvance) {
+  if (tabStopAdvance <= 0)
+    return 0;
+  const remainder = lineWidth % tabStopAdvance;
+  if (Math.abs(remainder) <= 0.000001)
+    return tabStopAdvance;
+  return tabStopAdvance - remainder;
+}
+function getLeadingLetterSpacing(prepared, hasContent, segmentIndex) {
+  return prepared.letterSpacing !== 0 && hasContent && prepared.spacingGraphemeCounts[segmentIndex] > 0 ? prepared.letterSpacing : 0;
+}
+function getLineEndContribution(leadingSpacing, segmentContribution) {
+  return segmentContribution === 0 ? 0 : leadingSpacing + segmentContribution;
+}
+function getTabTrailingLetterSpacing(prepared, segmentIndex) {
+  return prepared.letterSpacing !== 0 && prepared.spacingGraphemeCounts[segmentIndex] > 0 ? prepared.letterSpacing : 0;
+}
+function getWholeSegmentFitContribution(prepared, kind, segmentIndex, leadingSpacing, segmentWidth) {
+  const segmentContribution = kind === "tab" ? segmentWidth + getTabTrailingLetterSpacing(prepared, segmentIndex) : prepared.lineEndFitAdvances[segmentIndex];
+  return getLineEndContribution(leadingSpacing, segmentContribution);
+}
+function getBreakOpportunityFitContribution(prepared, kind, segmentIndex, leadingSpacing) {
+  const segmentContribution = kind === "tab" ? 0 : prepared.lineEndFitAdvances[segmentIndex];
+  return getLineEndContribution(leadingSpacing, segmentContribution);
+}
+function getLineEndPaintContribution(prepared, kind, segmentIndex, leadingSpacing, segmentWidth) {
+  const segmentContribution = kind === "tab" ? segmentWidth : prepared.lineEndPaintAdvances[segmentIndex];
+  return getLineEndContribution(leadingSpacing, segmentContribution);
+}
+function getBreakableGraphemeAdvance(prepared, hasContent, baseAdvance) {
+  return prepared.letterSpacing !== 0 && hasContent ? baseAdvance + prepared.letterSpacing : baseAdvance;
+}
+function getBreakableCandidateFitWidth(prepared, candidatePaintWidth) {
+  return prepared.letterSpacing === 0 ? candidatePaintWidth : candidatePaintWidth + prepared.letterSpacing;
+}
+function getNextPreferredBreakIndex(preferredBreaks, preferredBreakIndex, graphemeEnd) {
+  let index = preferredBreakIndex;
+  while (index < preferredBreaks.length && preferredBreaks[index] < graphemeEnd) {
+    index++;
+  }
+  return index;
+}
+function getTerminalLetterSpacing(prepared, startSegmentIndex, startGraphemeIndex, endSegmentIndex, endGraphemeIndex) {
+  if (prepared.letterSpacing === 0)
+    return 0;
+  if (endGraphemeIndex > 0) {
+    return prepared.spacingGraphemeCounts[endSegmentIndex] > 0 ? prepared.letterSpacing : 0;
+  }
+  for (let i = endSegmentIndex - 1;i >= startSegmentIndex; i--) {
+    const kind = prepared.kinds[i];
+    if (kind === "space" || kind === "zero-width-break" || kind === "hard-break")
+      continue;
+    if (kind === "soft-hyphen") {
+      if (i === endSegmentIndex - 1)
+        return 0;
+      continue;
+    }
+    if (i === startSegmentIndex && startGraphemeIndex > 0) {
+      return prepared.letterSpacing;
+    }
+    return prepared.spacingGraphemeCounts[i] > 0 ? prepared.letterSpacing : 0;
+  }
+  return 0;
+}
+function finalizeLinePaintWidth(prepared, width, startSegmentIndex, startGraphemeIndex, endSegmentIndex, endGraphemeIndex) {
+  return width + getTerminalLetterSpacing(prepared, startSegmentIndex, startGraphemeIndex, endSegmentIndex, endGraphemeIndex);
+}
+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;
+}
+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;
+  segmentIndex = normalizeLineStartSegmentIndex(prepared, segmentIndex, chunk.endSegmentIndex);
+  if (segmentIndex < chunk.endSegmentIndex) {
+    cursor.segmentIndex = segmentIndex;
+    cursor.graphemeIndex = 0;
+    return chunkIndex;
+  }
+  if (chunk.consumedEndSegmentIndex >= prepared.widths.length)
+    return -1;
+  cursor.segmentIndex = chunk.consumedEndSegmentIndex;
+  cursor.graphemeIndex = 0;
+  return chunkIndex + 1;
+}
+function normalizePreparedLineStart(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);
+}
+function normalizeLineStartChunkIndexFromHint(prepared, chunkIndex, cursor) {
+  if (cursor.segmentIndex >= prepared.widths.length)
+    return -1;
+  let nextChunkIndex = chunkIndex;
+  while (nextChunkIndex < prepared.chunks.length && cursor.segmentIndex >= prepared.chunks[nextChunkIndex].consumedEndSegmentIndex) {
+    nextChunkIndex++;
+  }
+  if (nextChunkIndex >= prepared.chunks.length)
+    return -1;
+  return normalizeLineStartInChunk(prepared, nextChunkIndex, cursor);
+}
+function countPreparedLines(prepared, maxWidth) {
+  return walkPreparedLinesRaw(prepared, maxWidth);
+}
+function walkPreparedLinesSimple(prepared, maxWidth, onLine) {
+  const { widths, kinds, breakableFitAdvances, breakablePreferredBreaks } = 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;
+  }
+  function emitCurrentLine(endSegmentIndex = lineEndSegmentIndex, endGraphemeIndex = lineEndGraphemeIndex, width = lineW) {
+    lineCount++;
+    onLine?.(width, lineStartSegmentIndex, lineStartGraphemeIndex, endSegmentIndex, endGraphemeIndex);
+    lineW = 0;
+    hasContent = false;
+    clearPendingBreak();
+  }
+  function startLineAtSegment(segmentIndex, width) {
+    hasContent = true;
+    lineStartSegmentIndex = segmentIndex;
+    lineStartGraphemeIndex = 0;
+    lineEndSegmentIndex = segmentIndex + 1;
+    lineEndGraphemeIndex = 0;
+    lineW = width;
+  }
+  function startLineAtGrapheme(segmentIndex, graphemeIndex, width) {
+    hasContent = true;
+    lineStartSegmentIndex = segmentIndex;
+    lineStartGraphemeIndex = graphemeIndex;
+    lineEndSegmentIndex = segmentIndex;
+    lineEndGraphemeIndex = graphemeIndex + 1;
+    lineW = width;
+  }
+  function appendWholeSegment(segmentIndex, width) {
+    if (!hasContent) {
+      startLineAtSegment(segmentIndex, width);
+      return;
+    }
+    lineW += width;
+    lineEndSegmentIndex = segmentIndex + 1;
+    lineEndGraphemeIndex = 0;
+  }
+  function appendBreakableSegmentFrom(segmentIndex, startGraphemeIndex) {
+    const fitAdvances = breakableFitAdvances[segmentIndex];
+    const preferredBreaks = breakablePreferredBreaks[segmentIndex] ?? null;
+    let preferredBreakIndex = preferredBreaks === null ? -1 : getNextPreferredBreakIndex(preferredBreaks, 0, startGraphemeIndex + 1);
+    let lastPreferredBreakEnd = -1;
+    let lastPreferredBreakWidth = 0;
+    let g = startGraphemeIndex;
+    while (g < fitAdvances.length) {
+      const gw = fitAdvances[g];
+      if (!hasContent) {
+        startLineAtGrapheme(segmentIndex, g, gw);
+      } else if (lineW + gw > fitLimit) {
+        if (preferredBreaks !== null && lastPreferredBreakEnd > startGraphemeIndex) {
+          emitCurrentLine(segmentIndex, lastPreferredBreakEnd, lastPreferredBreakWidth);
+          g = lastPreferredBreakEnd;
+          preferredBreakIndex = getNextPreferredBreakIndex(preferredBreaks, preferredBreakIndex, g + 1);
+          lastPreferredBreakEnd = -1;
+          lastPreferredBreakWidth = 0;
+          continue;
+        }
+        emitCurrentLine();
+        startLineAtGrapheme(segmentIndex, g, gw);
+      } else {
+        lineW += gw;
+        lineEndSegmentIndex = segmentIndex;
+        lineEndGraphemeIndex = g + 1;
+      }
+      const graphemeEnd = g + 1;
+      if (preferredBreaks !== null && preferredBreaks[preferredBreakIndex] === graphemeEnd) {
+        lastPreferredBreakEnd = graphemeEnd;
+        lastPreferredBreakWidth = lineW;
+        preferredBreakIndex++;
+      }
+      g++;
+    }
+    if (hasContent && lineEndSegmentIndex === segmentIndex && lineEndGraphemeIndex === fitAdvances.length) {
+      lineEndSegmentIndex = segmentIndex + 1;
+      lineEndGraphemeIndex = 0;
+    }
+  }
+  let i = 0;
+  while (i < widths.length) {
+    if (!hasContent) {
+      i = normalizeLineStartSegmentIndex(prepared, i);
+      if (i >= widths.length)
+        break;
+    }
+    const w = widths[i];
+    const kind = kinds[i];
+    const breakAfter = breaksAfter(kind);
+    if (!hasContent) {
+      if (w > fitLimit && 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 > fitLimit && 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;
+}
+function walkPreparedLinesRaw(prepared, maxWidth, onLine) {
+  if (prepared.simpleLineWalkFastPath) {
+    return walkPreparedLinesSimple(prepared, maxWidth, onLine);
+  }
+  const { widths, kinds, breakableFitAdvances, breakablePreferredBreaks, discretionaryHyphenWidth, 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;
+  }
+  function getCurrentLinePaintWidth() {
+    return pendingBreakKind === "soft-hyphen" && pendingBreakSegmentIndex === lineEndSegmentIndex && lineEndGraphemeIndex === 0 ? pendingBreakPaintWidth : lineW;
+  }
+  function emitCurrentLine(endSegmentIndex = lineEndSegmentIndex, endGraphemeIndex = lineEndGraphemeIndex, width) {
+    lineCount++;
+    if (onLine !== undefined) {
+      onLine(finalizeLinePaintWidth(prepared, width ?? getCurrentLinePaintWidth(), lineStartSegmentIndex, lineStartGraphemeIndex, endSegmentIndex, endGraphemeIndex), lineStartSegmentIndex, lineStartGraphemeIndex, endSegmentIndex, endGraphemeIndex);
+    }
+    lineW = 0;
+    hasContent = false;
+    clearPendingBreak();
+  }
+  function startLineAtSegment(segmentIndex, width) {
+    hasContent = true;
+    lineStartSegmentIndex = segmentIndex;
+    lineStartGraphemeIndex = 0;
+    lineEndSegmentIndex = segmentIndex + 1;
+    lineEndGraphemeIndex = 0;
+    lineW = width;
+  }
+  function startLineAtGrapheme(segmentIndex, graphemeIndex, width) {
+    hasContent = true;
+    lineStartSegmentIndex = segmentIndex;
+    lineStartGraphemeIndex = graphemeIndex;
+    lineEndSegmentIndex = segmentIndex;
+    lineEndGraphemeIndex = graphemeIndex + 1;
+    lineW = width;
+  }
+  function appendWholeSegment(segmentIndex, advance) {
+    if (!hasContent) {
+      startLineAtSegment(segmentIndex, advance);
+      return;
+    }
+    lineW += advance;
+    lineEndSegmentIndex = segmentIndex + 1;
+    lineEndGraphemeIndex = 0;
+  }
+  function updatePendingBreakForWholeSegment(kind, breakAfter, segmentIndex, segmentWidth, leadingSpacing, advance) {
+    if (!breakAfter)
+      return;
+    const fitAdvance = getBreakOpportunityFitContribution(prepared, kind, segmentIndex, leadingSpacing);
+    const paintAdvance = getLineEndPaintContribution(prepared, kind, segmentIndex, leadingSpacing, segmentWidth);
+    pendingBreakSegmentIndex = segmentIndex + 1;
+    pendingBreakFitWidth = lineW - advance + fitAdvance;
+    pendingBreakPaintWidth = lineW - advance + paintAdvance;
+    pendingBreakKind = kind;
+  }
+  function appendBreakableSegmentFrom(segmentIndex, startGraphemeIndex) {
+    const fitAdvances = breakableFitAdvances[segmentIndex];
+    const preferredBreaks = breakablePreferredBreaks[segmentIndex] ?? null;
+    let preferredBreakIndex = preferredBreaks === null ? -1 : getNextPreferredBreakIndex(preferredBreaks, 0, startGraphemeIndex + 1);
+    let lastPreferredBreakEnd = -1;
+    let lastPreferredBreakWidth = 0;
+    let g = startGraphemeIndex;
+    while (g < fitAdvances.length) {
+      const baseGw = fitAdvances[g];
+      if (!hasContent) {
+        startLineAtGrapheme(segmentIndex, g, baseGw);
+      } else {
+        const gw = getBreakableGraphemeAdvance(prepared, true, baseGw);
+        const candidatePaintWidth = lineW + gw;
+        if (getBreakableCandidateFitWidth(prepared, candidatePaintWidth) > fitLimit) {
+          if (preferredBreaks !== null && lastPreferredBreakEnd > startGraphemeIndex) {
+            emitCurrentLine(segmentIndex, lastPreferredBreakEnd, lastPreferredBreakWidth);
+            g = lastPreferredBreakEnd;
+            preferredBreakIndex = getNextPreferredBreakIndex(preferredBreaks, preferredBreakIndex, g + 1);
+            lastPreferredBreakEnd = -1;
+            lastPreferredBreakWidth = 0;
+            continue;
+          }
+          emitCurrentLine();
+          startLineAtGrapheme(segmentIndex, g, baseGw);
+        } else {
+          lineW = candidatePaintWidth;
+          lineEndSegmentIndex = segmentIndex;
+          lineEndGraphemeIndex = g + 1;
+        }
+      }
+      const graphemeEnd = g + 1;
+      if (preferredBreaks !== null && preferredBreaks[preferredBreakIndex] === graphemeEnd) {
+        lastPreferredBreakEnd = graphemeEnd;
+        lastPreferredBreakWidth = lineW;
+        preferredBreakIndex++;
+      }
+      g++;
+    }
+    if (hasContent && lineEndSegmentIndex === segmentIndex && lineEndGraphemeIndex === fitAdvances.length) {
+      lineEndSegmentIndex = segmentIndex + 1;
+      lineEndGraphemeIndex = 0;
+    }
+  }
+  function emitEmptyChunk(chunk) {
+    lineCount++;
+    onLine?.(0, chunk.startSegmentIndex, 0, chunk.consumedEndSegmentIndex, 0);
+    clearPendingBreak();
+  }
+  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) {
+      if (!hasContent) {
+        i = normalizeLineStartSegmentIndex(prepared, i, chunk.endSegmentIndex);
+        if (i >= chunk.endSegmentIndex)
+          break;
+      }
+      const kind = kinds[i];
+      const breakAfter = breaksAfter(kind);
+      const leadingSpacing = getLeadingLetterSpacing(prepared, hasContent, i);
+      const w = kind === "tab" ? getTabAdvance(lineW + leadingSpacing, prepared.tabStopAdvance) : widths[i];
+      const advance = leadingSpacing + w;
+      const fitAdvance = getWholeSegmentFitContribution(prepared, kind, i, leadingSpacing, w);
+      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 (fitAdvance > fitLimit && breakableFitAdvances[i] !== null) {
+          appendBreakableSegmentFrom(i, 0);
+        } else {
+          startLineAtSegment(i, w);
+        }
+        updatePendingBreakForWholeSegment(kind, breakAfter, i, w, leadingSpacing, advance);
+        i++;
+        continue;
+      }
+      const newFitW = lineW + fitAdvance;
+      if (newFitW > fitLimit) {
+        const currentBreakFitWidth = lineW + getBreakOpportunityFitContribution(prepared, kind, i, leadingSpacing);
+        const currentBreakPaintWidth = lineW + getLineEndPaintContribution(prepared, kind, i, leadingSpacing, w);
+        if (pendingBreakKind === "soft-hyphen" && engineProfile.preferEarlySoftHyphenBreak && pendingBreakFitWidth <= fitLimit) {
+          emitCurrentLine(pendingBreakSegmentIndex, 0, pendingBreakPaintWidth);
+          continue;
+        }
+        if (breakAfter && currentBreakFitWidth <= fitLimit) {
+          appendWholeSegment(i, advance);
+          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 (fitAdvance > fitLimit && breakableFitAdvances[i] !== null) {
+          emitCurrentLine();
+          appendBreakableSegmentFrom(i, 0);
+          i++;
+          continue;
+        }
+        emitCurrentLine();
+        continue;
+      }
+      appendWholeSegment(i, advance);
+      updatePendingBreakForWholeSegment(kind, breakAfter, i, w, leadingSpacing, advance);
+      i++;
+    }
+    if (hasContent) {
+      const finalPaintWidth = pendingBreakSegmentIndex === chunk.consumedEndSegmentIndex ? pendingBreakPaintWidth : lineW;
+      emitCurrentLine(chunk.consumedEndSegmentIndex, 0, finalPaintWidth);
+    }
+  }
+  return lineCount;
+}
+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, kinds, breakableFitAdvances, breakablePreferredBreaks, discretionaryHyphenWidth } = prepared;
+  const engineProfile = getEngineProfile();
+  const lineFitEpsilon = engineProfile.lineFitEpsilon;
+  const fitLimit = maxWidth + lineFitEpsilon;
+  const lineStartSegmentIndex = cursor.segmentIndex;
+  const lineStartGraphemeIndex = cursor.graphemeIndex;
+  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 getCurrentLinePaintWidth() {
+    return pendingBreakKind === "soft-hyphen" && pendingBreakSegmentIndex === lineEndSegmentIndex && lineEndGraphemeIndex === 0 ? pendingBreakPaintWidth : lineW;
+  }
+  function finishLine(endSegmentIndex = lineEndSegmentIndex, endGraphemeIndex = lineEndGraphemeIndex, width = getCurrentLinePaintWidth()) {
+    if (!hasContent)
+      return null;
+    cursor.segmentIndex = endSegmentIndex;
+    cursor.graphemeIndex = endGraphemeIndex;
+    return finalizeLinePaintWidth(prepared, width, lineStartSegmentIndex, lineStartGraphemeIndex, endSegmentIndex, endGraphemeIndex);
+  }
+  function startLineAtSegment(segmentIndex, width) {
+    hasContent = true;
+    lineEndSegmentIndex = segmentIndex + 1;
+    lineEndGraphemeIndex = 0;
+    lineW = width;
+  }
+  function startLineAtGrapheme(segmentIndex, graphemeIndex, width) {
+    hasContent = true;
+    lineEndSegmentIndex = segmentIndex;
+    lineEndGraphemeIndex = graphemeIndex + 1;
+    lineW = width;
+  }
+  function appendWholeSegment(segmentIndex, advance) {
+    if (!hasContent) {
+      startLineAtSegment(segmentIndex, advance);
+      return;
+    }
+    lineW += advance;
+    lineEndSegmentIndex = segmentIndex + 1;
+    lineEndGraphemeIndex = 0;
+  }
+  function updatePendingBreakForWholeSegment(kind, breakAfter, segmentIndex, segmentWidth, leadingSpacing, advance) {
+    if (!breakAfter)
+      return;
+    const fitAdvance = getBreakOpportunityFitContribution(prepared, kind, segmentIndex, leadingSpacing);
+    const paintAdvance = getLineEndPaintContribution(prepared, kind, segmentIndex, leadingSpacing, segmentWidth);
+    pendingBreakSegmentIndex = segmentIndex + 1;
+    pendingBreakFitWidth = lineW - advance + fitAdvance;
+    pendingBreakPaintWidth = lineW - advance + paintAdvance;
+    pendingBreakKind = kind;
+  }
+  function appendBreakableSegmentFrom(segmentIndex, startGraphemeIndex) {
+    const fitAdvances = breakableFitAdvances[segmentIndex];
+    const preferredBreaks = breakablePreferredBreaks[segmentIndex] ?? null;
+    let preferredBreakIndex = preferredBreaks === null ? -1 : getNextPreferredBreakIndex(preferredBreaks, 0, startGraphemeIndex + 1);
+    let lastPreferredBreakEnd = -1;
+    let lastPreferredBreakWidth = 0;
+    for (let g = startGraphemeIndex;g < fitAdvances.length; g++) {
+      const baseGw = fitAdvances[g];
+      if (!hasContent) {
+        startLineAtGrapheme(segmentIndex, g, baseGw);
+      } else {
+        const gw = getBreakableGraphemeAdvance(prepared, true, baseGw);
+        const candidatePaintWidth = lineW + gw;
+        if (getBreakableCandidateFitWidth(prepared, candidatePaintWidth) > fitLimit) {
+          if (preferredBreaks !== null && lastPreferredBreakEnd > startGraphemeIndex) {
+            return finishLine(segmentIndex, lastPreferredBreakEnd, lastPreferredBreakWidth);
+          }
+          return finishLine();
+        }
+        lineW = candidatePaintWidth;
+        lineEndSegmentIndex = segmentIndex;
+        lineEndGraphemeIndex = g + 1;
+      }
+      const graphemeEnd = g + 1;
+      if (preferredBreaks !== null && preferredBreaks[preferredBreakIndex] === graphemeEnd) {
+        lastPreferredBreakEnd = graphemeEnd;
+        lastPreferredBreakWidth = lineW;
+        preferredBreakIndex++;
+      }
+    }
+    if (hasContent && lineEndSegmentIndex === segmentIndex && lineEndGraphemeIndex === fitAdvances.length) {
+      lineEndSegmentIndex = segmentIndex + 1;
+      lineEndGraphemeIndex = 0;
+    }
+    return null;
+  }
+  function maybeFinishAtSoftHyphen() {
+    if (pendingBreakKind !== "soft-hyphen" || pendingBreakSegmentIndex < 0)
+      return null;
+    if (pendingBreakFitWidth <= fitLimit) {
+      return finishLine(pendingBreakSegmentIndex, 0, pendingBreakPaintWidth);
+    }
+    return null;
+  }
+  for (let i = cursor.segmentIndex;i < chunk.endSegmentIndex; i++) {
+    const kind = kinds[i];
+    const breakAfter = breaksAfter(kind);
+    const startGraphemeIndex = i === cursor.segmentIndex ? cursor.graphemeIndex : 0;
+    const leadingSpacing = getLeadingLetterSpacing(prepared, hasContent, i);
+    const w = kind === "tab" ? getTabAdvance(lineW + leadingSpacing, prepared.tabStopAdvance) : widths[i];
+    const advance = leadingSpacing + w;
+    const fitAdvance = getWholeSegmentFitContribution(prepared, kind, i, leadingSpacing, w);
+    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 line = appendBreakableSegmentFrom(i, startGraphemeIndex);
+        if (line !== null)
+          return line;
+      } else if (fitAdvance > fitLimit && breakableFitAdvances[i] !== null) {
+        const line = appendBreakableSegmentFrom(i, 0);
+        if (line !== null)
+          return line;
+      } else {
+        startLineAtSegment(i, w);
+      }
+      updatePendingBreakForWholeSegment(kind, breakAfter, i, w, leadingSpacing, advance);
+      continue;
+    }
+    const newFitW = lineW + fitAdvance;
+    if (newFitW > fitLimit) {
+      const currentBreakFitWidth = lineW + getBreakOpportunityFitContribution(prepared, kind, i, leadingSpacing);
+      const currentBreakPaintWidth = lineW + getLineEndPaintContribution(prepared, kind, i, leadingSpacing, w);
+      if (pendingBreakKind === "soft-hyphen" && engineProfile.preferEarlySoftHyphenBreak && pendingBreakFitWidth <= fitLimit) {
+        return finishLine(pendingBreakSegmentIndex, 0, pendingBreakPaintWidth);
+      }
+      const softBreakLine = maybeFinishAtSoftHyphen();
+      if (softBreakLine !== null)
+        return softBreakLine;
+      if (breakAfter && currentBreakFitWidth <= fitLimit) {
+        appendWholeSegment(i, advance);
+        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 (fitAdvance > fitLimit && breakableFitAdvances[i] !== null) {
+        const currentLine = finishLine();
+        if (currentLine !== null)
+          return currentLine;
+        const line = appendBreakableSegmentFrom(i, 0);
+        if (line !== null)
+          return line;
+      }
+      return finishLine();
+    }
+    appendWholeSegment(i, advance);
+    updatePendingBreakForWholeSegment(kind, breakAfter, i, w, leadingSpacing, advance);
+  }
+  if (pendingBreakSegmentIndex === chunk.consumedEndSegmentIndex && lineEndGraphemeIndex === 0) {
+    return finishLine(chunk.consumedEndSegmentIndex, 0, pendingBreakPaintWidth);
+  }
+  return finishLine(chunk.consumedEndSegmentIndex, 0, lineW);
+}
+function stepPreparedSimpleLineGeometry(prepared, cursor, maxWidth) {
+  const { widths, kinds, breakableFitAdvances, breakablePreferredBreaks } = 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 kind = kinds[i];
+    const breakAfter = breaksAfter(kind);
+    const startGraphemeIndex = i === cursor.segmentIndex ? cursor.graphemeIndex : 0;
+    const breakableFitAdvance = breakableFitAdvances[i];
+    const w = widths[i];
+    if (!hasContent) {
+      if (startGraphemeIndex > 0 || w > fitLimit && breakableFitAdvance !== null) {
+        const fitAdvances = breakableFitAdvance;
+        const preferredBreaks = breakablePreferredBreaks[i] ?? null;
+        let preferredBreakIndex = preferredBreaks === null ? -1 : getNextPreferredBreakIndex(preferredBreaks, 0, startGraphemeIndex + 1);
+        let lastPreferredBreakEnd = -1;
+        let lastPreferredBreakWidth = 0;
+        const firstGraphemeWidth = fitAdvances[startGraphemeIndex];
+        hasContent = true;
+        lineW = firstGraphemeWidth;
+        lineEndSegmentIndex = i;
+        lineEndGraphemeIndex = startGraphemeIndex + 1;
+        if (preferredBreaks !== null && preferredBreaks[preferredBreakIndex] === lineEndGraphemeIndex) {
+          lastPreferredBreakEnd = lineEndGraphemeIndex;
+          lastPreferredBreakWidth = lineW;
+          preferredBreakIndex++;
+        }
+        for (let g = startGraphemeIndex + 1;g < fitAdvances.length; g++) {
+          const gw = fitAdvances[g];
+          if (lineW + gw > fitLimit) {
+            if (preferredBreaks !== null && lastPreferredBreakEnd > startGraphemeIndex) {
+              cursor.segmentIndex = i;
+              cursor.graphemeIndex = lastPreferredBreakEnd;
+              return lastPreferredBreakWidth;
+            }
+            cursor.segmentIndex = lineEndSegmentIndex;
+            cursor.graphemeIndex = lineEndGraphemeIndex;
+            return lineW;
+          }
+          lineW += gw;
+          lineEndSegmentIndex = i;
+          lineEndGraphemeIndex = g + 1;
+          if (preferredBreaks !== null && preferredBreaks[preferredBreakIndex] === lineEndGraphemeIndex) {
+            lastPreferredBreakEnd = lineEndGraphemeIndex;
+            lastPreferredBreakWidth = lineW;
+            preferredBreakIndex++;
+          }
+        }
+        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;
+}
+function stepPreparedLineGeometryFromChunk(prepared, cursor, chunkIndex, maxWidth) {
+  if (prepared.simpleLineWalkFastPath) {
+    return stepPreparedSimpleLineGeometry(prepared, cursor, maxWidth);
+  }
+  return stepPreparedChunkLineGeometry(prepared, cursor, chunkIndex, maxWidth);
+}
+function stepPreparedLineGeometry(prepared, cursor, maxWidth) {
+  const chunkIndex = normalizePreparedLineStart(prepared, cursor);
+  if (chunkIndex < 0)
+    return null;
+  return stepPreparedLineGeometryFromChunk(prepared, cursor, chunkIndex, maxWidth);
+}
+function measurePreparedLineGeometry(prepared, maxWidth) {
+  if (prepared.widths.length === 0) {
+    return {
+      lineCount: 0,
+      maxLineWidth: 0
+    };
+  }
+  const cursor = {
+    segmentIndex: 0,
+    graphemeIndex: 0
+  };
+  let lineCount = 0;
+  let maxLineWidth = 0;
+  if (!prepared.simpleLineWalkFastPath) {
+    let chunkIndex = normalizePreparedLineStart(prepared, cursor);
+    while (chunkIndex >= 0) {
+      const lineWidth = stepPreparedChunkLineGeometry(prepared, cursor, chunkIndex, maxWidth);
+      if (lineWidth === null) {
+        return {
+          lineCount,
+          maxLineWidth
+        };
+      }
+      lineCount++;
+      if (lineWidth > maxLineWidth)
+        maxLineWidth = lineWidth;
+      chunkIndex = normalizeLineStartChunkIndexFromHint(prepared, chunkIndex, cursor);
+    }
+    return {
+      lineCount,
+      maxLineWidth
+    };
+  }
+  while (true) {
+    const lineWidth = stepPreparedLineGeometry(prepared, cursor, maxWidth);
+    if (lineWidth === null) {
+      return {
+        lineCount,
+        maxLineWidth
+      };
+    }
+    lineCount++;
+    if (lineWidth > maxLineWidth)
+      maxLineWidth = lineWidth;
+  }
+}
+var init_line_break = __esm(() => {
+  init_measurement();
+});
+
+// ../../node_modules/.bun/@chenglou+pretext@0.0.8/node_modules/@chenglou/pretext/dist/line-text.js
+function getSharedGraphemeSegmenter2() {
+  if (sharedGraphemeSegmenter2 === null) {
+    sharedGraphemeSegmenter2 = new Intl.Segmenter(undefined, { granularity: "grapheme" });
+  }
+  return sharedGraphemeSegmenter2;
+}
+function getSegmentGraphemes(segmentIndex, segments, cache) {
+  let graphemes = cache.get(segmentIndex);
+  if (graphemes !== undefined)
+    return graphemes;
+  graphemes = [];
+  const graphemeSegmenter = getSharedGraphemeSegmenter2();
+  for (const gs of graphemeSegmenter.segment(segments[segmentIndex])) {
+    graphemes.push(gs.segment);
+  }
+  cache.set(segmentIndex, graphemes);
+  return graphemes;
+}
+function lineHasDiscretionaryHyphen(kinds, startSegmentIndex, endSegmentIndex) {
+  return endSegmentIndex > startSegmentIndex && kinds[endSegmentIndex - 1] === "soft-hyphen";
+}
+function appendSegmentGraphemeRange(text, graphemes, startGraphemeIndex, endGraphemeIndex) {
+  for (let i = startGraphemeIndex;i < endGraphemeIndex; i++) {
+    text += graphemes[i];
+  }
+  return text;
+}
+function getLineTextCache(prepared) {
+  let cache = sharedLineTextCaches.get(prepared);
+  if (cache !== undefined)
+    return cache;
+  cache = new Map;
+  sharedLineTextCaches.set(prepared, cache);
+  return cache;
+}
+function buildLineTextFromRange(prepared, cache, startSegmentIndex, startGraphemeIndex, endSegmentIndex, endGraphemeIndex) {
+  let text = "";
+  const endsWithDiscretionaryHyphen = lineHasDiscretionaryHyphen(prepared.kinds, startSegmentIndex, endSegmentIndex);
+  for (let i = startSegmentIndex;i < endSegmentIndex; i++) {
+    if (prepared.kinds[i] === "soft-hyphen" || prepared.kinds[i] === "hard-break")
+      continue;
+    if (i === startSegmentIndex && startGraphemeIndex > 0) {
+      const graphemes = getSegmentGraphemes(i, prepared.segments, cache);
+      text = appendSegmentGraphemeRange(text, graphemes, startGraphemeIndex, graphemes.length);
+    } else {
+      text += prepared.segments[i];
+    }
+  }
+  if (endGraphemeIndex > 0) {
+    if (endsWithDiscretionaryHyphen)
+      text += "-";
+    const graphemes = getSegmentGraphemes(endSegmentIndex, prepared.segments, cache);
+    text = appendSegmentGraphemeRange(text, graphemes, startSegmentIndex === endSegmentIndex ? startGraphemeIndex : 0, endGraphemeIndex);
+  } else if (endsWithDiscretionaryHyphen) {
+    text += "-";
+  }
+  return text;
+}
+function clearLineTextCaches() {
+  sharedGraphemeSegmenter2 = null;
+  sharedLineTextCaches = new WeakMap;
+}
+var sharedGraphemeSegmenter2 = null, sharedLineTextCaches;
+var init_line_text = __esm(() => {
+  sharedLineTextCaches = new WeakMap;
+});
+
+// ../../node_modules/.bun/@chenglou+pretext@0.0.8/node_modules/@chenglou/pretext/dist/layout.js
+var exports_layout = {};
+__export(exports_layout, {
+  walkLineRanges: () => walkLineRanges,
+  setLocale: () => setLocale,
+  prepareWithSegments: () => prepareWithSegments,
+  prepare: () => prepare,
+  measureNaturalWidth: () => measureNaturalWidth,
+  measureLineStats: () => measureLineStats,
+  materializeLineRange: () => materializeLineRange,
+  layoutWithLines: () => layoutWithLines,
+  layoutNextLineRange: () => layoutNextLineRange,
+  layoutNextLine: () => layoutNextLine,
+  layout: () => layout,
+  clearCache: () => clearCache
+});
+function getSharedGraphemeSegmenter3() {
+  if (sharedGraphemeSegmenter3 === null) {
+    sharedGraphemeSegmenter3 = new Intl.Segmenter(undefined, { granularity: "grapheme" });
+  }
+  return sharedGraphemeSegmenter3;
+}
+function createEmptyPrepared(includeSegments) {
+  if (includeSegments) {
+    return {
+      widths: [],
+      lineEndFitAdvances: [],
+      lineEndPaintAdvances: [],
+      kinds: [],
+      simpleLineWalkFastPath: true,
+      segLevels: null,
+      breakableFitAdvances: [],
+      breakablePreferredBreaks: [],
+      letterSpacing: 0,
+      spacingGraphemeCounts: [],
+      discretionaryHyphenWidth: 0,
+      tabStopAdvance: 0,
+      chunks: [],
+      segments: []
+    };
+  }
+  return {
+    widths: [],
+    lineEndFitAdvances: [],
+    lineEndPaintAdvances: [],
+    kinds: [],
+    simpleLineWalkFastPath: true,
+    segLevels: null,
+    breakableFitAdvances: [],
+    breakablePreferredBreaks: [],
+    letterSpacing: 0,
+    spacingGraphemeCounts: [],
+    discretionaryHyphenWidth: 0,
+    tabStopAdvance: 0,
+    chunks: []
+  };
+}
+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;
+  }
+  function startUnit(grapheme, start, graphemeContainsCJK) {
+    unitParts = [grapheme];
+    unitStart = start;
+    unitContainsCJK = graphemeContainsCJK;
+    unitEndsWithClosingQuote = endsWithClosingQuote(grapheme);
+    unitIsSingleKinsokuEnd = kinsokuEnd.has(grapheme);
+  }
+  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;
+  }
+  for (const gs of getSharedGraphemeSegmenter3().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;
+}
+function mergeKeepAllTextUnits(segText, units, breakAfterPunctuation) {
+  if (units.length <= 1)
+    return units;
+  const merged = [];
+  let groupStart = -1;
+  let groupContainsCJK = false;
+  function pushMergedUnit(start, end) {
+    const sourceStart = units[start].start;
+    const sourceEnd = end < units.length ? units[end].start : segText.length;
+    merged.push({
+      text: segText.slice(sourceStart, sourceEnd),
+      start: sourceStart
+    });
+  }
+  function flushGroup(end) {
+    if (groupStart < 0)
+      return;
+    if (groupContainsCJK) {
+      if (groupStart + 1 === end) {
+        merged.push(units[groupStart]);
+      } else {
+        pushMergedUnit(groupStart, end);
+      }
+    } else {
+      for (let i = groupStart;i < end; i++)
+        merged.push(units[i]);
+    }
+    groupStart = -1;
+    groupContainsCJK = false;
+  }
+  for (let i = 0;i < units.length; i++) {
+    const unit = units[i];
+    if (groupStart >= 0 && !canContinueKeepAllTextRun(units[i - 1].text, breakAfterPunctuation)) {
+      flushGroup(i);
+    }
+    if (groupStart < 0)
+      groupStart = i;
+    groupContainsCJK = groupContainsCJK || isCJK(unit.text);
+  }
+  flushGroup(units.length);
+  return merged;
+}
+function countRenderedSpacingGraphemes(text, kind) {
+  if (kind === "zero-width-break" || kind === "soft-hyphen" || kind === "hard-break") {
+    return 0;
+  }
+  if (kind === "tab")
+    return 1;
+  let count = 0;
+  const graphemeSegmenter = getSharedGraphemeSegmenter3();
+  for (const _ of graphemeSegmenter.segment(text))
+    count++;
+  return count;
+}
+function isPreferredBreakGrapheme(grapheme) {
+  return grapheme === "-" || grapheme === "\u058A" || grapheme === "\u2010" || grapheme === "\u2012" || grapheme === "\u2013" || grapheme === "\u2014";
+}
+function getBreakablePreferredBreaks(text) {
+  if (!/[-\u058A\u2010\u2012\u2013\u2014]/u.test(text))
+    return null;
+  const breaks = [];
+  let graphemeIndex = 0;
+  for (const gs of getSharedGraphemeSegmenter3().segment(text)) {
+    graphemeIndex++;
+    if (isPreferredBreakGrapheme(gs.segment))
+      breaks.push(graphemeIndex);
+  }
+  return breaks.length === 0 ? null : breaks;
+}
+function addInternalLetterSpacing(width, graphemeCount, letterSpacing) {
+  return graphemeCount > 1 ? width + (graphemeCount - 1) * letterSpacing : width;
+}
+function measureAnalysis(analysis, font, includeSegments, wordBreak, letterSpacing) {
+  const engineProfile = getEngineProfile();
+  const { cache, emojiCorrection } = getFontMeasurementState(font, textMayContainEmoji(analysis.normalized));
+  const discretionaryHyphenWidth = getCorrectedSegmentWidth("-", getSegmentMetrics("-", cache), emojiCorrection) + (letterSpacing === 0 ? 0 : letterSpacing * 2);
+  const spaceWidth = getCorrectedSegmentWidth(" ", getSegmentMetrics(" ", cache), emojiCorrection);
+  const tabStopAdvance = spaceWidth * 8;
+  const hasLetterSpacing = letterSpacing !== 0;
+  if (analysis.len === 0)
+    return createEmptyPrepared(includeSegments);
+  const widths = [];
+  const lineEndFitAdvances = [];
+  const lineEndPaintAdvances = [];
+  const kinds = [];
+  let simpleLineWalkFastPath = analysis.chunks.length <= 1 && !hasLetterSpacing;
+  const segStarts = includeSegments ? [] : null;
+  const breakableFitAdvances = [];
+  const breakablePreferredBreaks = [];
+  const spacingGraphemeCounts = [];
+  const segments = includeSegments ? [] : null;
+  const preparedStartByAnalysisIndex = Array.from({ length: analysis.len });
+  function pushMeasuredSegment(text, width, lineEndFitAdvance, lineEndPaintAdvance, kind, start, breakableFitAdvance, breakablePreferredBreak, spacingGraphemeCount) {
+    if (kind !== "text" && kind !== "space" && kind !== "zero-width-break") {
+      simpleLineWalkFastPath = false;
+    }
+    widths.push(width);
+    lineEndFitAdvances.push(lineEndFitAdvance);
+    lineEndPaintAdvances.push(lineEndPaintAdvance);
+    kinds.push(kind);
+    segStarts?.push(start);
+    breakableFitAdvances.push(breakableFitAdvance);
+    breakablePreferredBreaks.push(breakablePreferredBreak);
+    if (hasLetterSpacing)
+      spacingGraphemeCounts.push(spacingGraphemeCount);
+    if (segments !== null)
+      segments.push(text);
+  }
+  function pushMeasuredTextSegment(text, kind, start, wordLike, allowOverflowBreaks) {
+    const textMetrics = getSegmentMetrics(text, cache);
+    const spacingGraphemeCount = hasLetterSpacing ? countRenderedSpacingGraphemes(text, kind) : 0;
+    const width = addInternalLetterSpacing(getCorrectedSegmentWidth(text, textMetrics, emojiCorrection), spacingGraphemeCount, letterSpacing);
+    const baseLineEndFitAdvance = kind === "space" || kind === "preserved-space" || kind === "zero-width-break" ? 0 : width;
+    const lineEndFitAdvance = baseLineEndFitAdvance === 0 ? 0 : baseLineEndFitAdvance + (spacingGraphemeCount > 0 ? letterSpacing : 0);
+    const lineEndPaintAdvance = kind === "space" || kind === "zero-width-break" ? 0 : width;
+    if (allowOverflowBreaks && wordLike && text.length > 1) {
+      let fitMode = "sum-graphemes";
+      if (letterSpacing !== 0) {
+        fitMode = "segment-prefixes";
+      } else if (isNumericRunSegment(text)) {
+        fitMode = "pair-context";
+      } else if (engineProfile.preferPrefixWidthsForBreakableRuns) {
+        fitMode = "segment-prefixes";
+      }
+      const fitAdvances = getSegmentBreakableFitAdvances(text, textMetrics, cache, emojiCorrection, fitMode);
+      const preferredBreaks = fitAdvances === null || wordBreak === "keep-all" ? null : getBreakablePreferredBreaks(text);
+      pushMeasuredSegment(text, width, lineEndFitAdvance, lineEndPaintAdvance, kind, start, fitAdvances, preferredBreaks, spacingGraphemeCount);
+      return;
+    }
+    pushMeasuredSegment(text, width, lineEndFitAdvance, lineEndPaintAdvance, kind, start, null, null, spacingGraphemeCount);
+  }
+  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, null, 0);
+      continue;
+    }
+    if (segKind === "hard-break") {
+      pushMeasuredSegment(segText, 0, 0, 0, segKind, segStart, null, null, 0);
+      continue;
+    }
+    if (segKind === "tab") {
+      pushMeasuredSegment(segText, 0, 0, 0, segKind, segStart, null, null, hasLetterSpacing ? countRenderedSpacingGraphemes(segText, segKind) : 0);
+      continue;
+    }
+    const segMetrics = getSegmentMetrics(segText, cache);
+    if (segKind === "text" && segMetrics.containsCJK) {
+      const baseUnits = buildBaseCjkUnits(segText, engineProfile);
+      const measuredUnits = wordBreak === "keep-all" ? mergeKeepAllTextUnits(segText, baseUnits, engineProfile.breakKeepAllAfterPunctuation) : 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,
+      breakablePreferredBreaks,
+      letterSpacing,
+      spacingGraphemeCounts,
+      discretionaryHyphenWidth,
+      tabStopAdvance,
+      chunks,
+      segments
+    };
+  }
+  return {
+    widths,
+    lineEndFitAdvances,
+    lineEndPaintAdvances,
+    kinds,
+    simpleLineWalkFastPath,
+    segLevels,
+    breakableFitAdvances,
+    breakablePreferredBreaks,
+    letterSpacing,
+    spacingGraphemeCounts,
+    discretionaryHyphenWidth,
+    tabStopAdvance,
+    chunks
+  };
+}
+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;
+}
+function prepareInternal(text, font, includeSegments, options) {
+  const wordBreak = options?.wordBreak ?? "normal";
+  const letterSpacing = options?.letterSpacing ?? 0;
+  const analysis = analyzeText(text, getEngineProfile(), options?.whiteSpace, wordBreak);
+  return measureAnalysis(analysis, font, includeSegments, wordBreak, letterSpacing);
+}
+function prepare(text, font, options) {
+  return prepareInternal(text, font, false, options);
+}
+function prepareWithSegments(text, font, options) {
+  return prepareInternal(text, font, true, options);
+}
+function getInternalPrepared(prepared) {
+  return prepared;
+}
+function layout(prepared, maxWidth, lineHeight) {
+  const lineCount = countPreparedLines(getInternalPrepared(prepared), maxWidth);
+  return { lineCount, height: lineCount * lineHeight };
+}
+function createLayoutLine(prepared, cache, width, startSegmentIndex, startGraphemeIndex, endSegmentIndex, endGraphemeIndex) {
+  return {
+    text: buildLineTextFromRange(prepared, cache, startSegmentIndex, startGraphemeIndex, endSegmentIndex, endGraphemeIndex),
+    width,
+    start: {
+      segmentIndex: startSegmentIndex,
+      graphemeIndex: startGraphemeIndex
+    },
+    end: {
+      segmentIndex: endSegmentIndex,
+      graphemeIndex: endGraphemeIndex
+    }
+  };
+}
+function createLayoutLineRange(width, startSegmentIndex, startGraphemeIndex, endSegmentIndex, endGraphemeIndex) {
+  return {
+    width,
+    start: {
+      segmentIndex: startSegmentIndex,
+      graphemeIndex: startGraphemeIndex
+    },
+    end: {
+      segmentIndex: endSegmentIndex,
+      graphemeIndex: endGraphemeIndex
+    }
+  };
+}
+function materializeLineRange(prepared, line) {
+  return createLayoutLine(prepared, getLineTextCache(prepared), line.width, line.start.segmentIndex, line.start.graphemeIndex, line.end.segmentIndex, line.end.graphemeIndex);
+}
+function walkLineRanges(prepared, maxWidth, onLine) {
+  if (prepared.widths.length === 0)
+    return 0;
+  return walkPreparedLinesRaw(getInternalPrepared(prepared), maxWidth, (width, startSegmentIndex, startGraphemeIndex, endSegmentIndex, endGraphemeIndex) => {
+    onLine(createLayoutLineRange(width, startSegmentIndex, startGraphemeIndex, endSegmentIndex, endGraphemeIndex));
+  });
+}
+function measureLineStats(prepared, maxWidth) {
+  return measurePreparedLineGeometry(getInternalPrepared(prepared), maxWidth);
+}
+function measureNaturalWidth(prepared) {
+  let maxWidth = 0;
+  walkPreparedLinesRaw(getInternalPrepared(prepared), Number.POSITIVE_INFINITY, (width) => {
+    if (width > maxWidth)
+      maxWidth = width;
+  });
+  return maxWidth;
+}
+function layoutNextLine(prepared, start, maxWidth) {
+  const internal = getInternalPrepared(prepared);
+  const end = {
+    segmentIndex: start.segmentIndex,
+    graphemeIndex: start.graphemeIndex
+  };
+  const chunkIndex = normalizePreparedLineStart(internal, end);
+  if (chunkIndex < 0)
+    return null;
+  const lineStartSegmentIndex = end.segmentIndex;
+  const lineStartGraphemeIndex = end.graphemeIndex;
+  const width = stepPreparedLineGeometryFromChunk(internal, end, chunkIndex, maxWidth);
+  if (width === null)
+    return null;
+  return createLayoutLine(prepared, getLineTextCache(prepared), width, lineStartSegmentIndex, lineStartGraphemeIndex, end.segmentIndex, end.graphemeIndex);
+}
+function layoutNextLineRange(prepared, start, maxWidth) {
+  const internal = getInternalPrepared(prepared);
+  const end = {
+    segmentIndex: start.segmentIndex,
+    graphemeIndex: start.graphemeIndex
+  };
+  const chunkIndex = normalizePreparedLineStart(internal, end);
+  if (chunkIndex < 0)
+    return null;
+  const lineStartSegmentIndex = end.segmentIndex;
+  const lineStartGraphemeIndex = end.graphemeIndex;
+  const width = stepPreparedLineGeometryFromChunk(internal, end, chunkIndex, maxWidth);
+  if (width === null)
+    return null;
+  return createLayoutLineRange(width, lineStartSegmentIndex, lineStartGraphemeIndex, end.segmentIndex, end.graphemeIndex);
+}
+function layoutWithLines(prepared, maxWidth, lineHeight) {
+  const lines = [];
+  if (prepared.widths.length === 0)
+    return { lineCount: 0, height: 0, lines };
+  const graphemeCache = getLineTextCache(prepared);
+  const lineCount = walkPreparedLinesRaw(getInternalPrepared(prepared), maxWidth, (width, startSegmentIndex, startGraphemeIndex, endSegmentIndex, endGraphemeIndex) => {
+    lines.push(createLayoutLine(prepared, graphemeCache, width, startSegmentIndex, startGraphemeIndex, endSegmentIndex, endGraphemeIndex));
+  });
+  return { lineCount, height: lineCount * lineHeight, lines };
+}
+function clearCache() {
+  clearAnalysisCaches();
+  sharedGraphemeSegmenter3 = null;
+  clearLineTextCaches();
+  clearMeasurementCaches();
+}
+function setLocale(locale) {
+  setAnalysisLocale(locale);
+  clearCache();
+}
+var sharedGraphemeSegmenter3 = null;
+var init_layout = __esm(() => {
+  init_bidi();
+  init_analysis();
+  init_measurement();
+  init_line_break();
+  init_line_text();
+});
+
+// src/cli/check.ts
+var _process = typeof globalThis !== "undefined" ? globalThis.process : undefined;
+var GREEN = "\x1B[32m";
+var RED = "\x1B[31m";
+var YELLOW = "\x1B[33m";
+var RESET = "\x1B[0m";
+var BOLD = "\x1B[1m";
+function ok(label, msg) {
+  console.log(`  ${GREEN}\u2713${RESET} ${label.padEnd(20)} ${msg}`);
+}
+function fail(label, msg) {
+  console.log(`  ${RED}\u2717${RESET} ${label.padEnd(20)} ${msg}`);
+}
+function skip(label, msg) {
+  console.log(`  ${YELLOW}\u2212${RESET} ${label.padEnd(20)} ${msg}`);
+}
+function _requireModule(name) {
+  let _require = null;
+  if (typeof _process?.getBuiltinModule === "function") {
+    const mb = _process.getBuiltinModule("module");
+    if (mb)
+      _require = mb.createRequire(import.meta.url);
+  }
+  if (!_require) {
+    const cjsRequire = globalThis["require"];
+    if (typeof cjsRequire === "function")
+      _require = cjsRequire;
+  }
+  if (!_require)
+    throw new Error("Cannot find require() \u2014 browser?");
+  return _require(name);
+}
+async function checkCanvasModule() {
+  try {
+    const canvas = _requireModule("@napi-rs/canvas");
+    if (typeof canvas.createCanvas !== "function") {
+      fail("@napi-rs/canvas", "createCanvas is not a function");
+      return false;
+    }
+    const c = canvas.createCanvas(10, 10);
+    const ctx = c.getContext("2d");
+    if (!ctx || typeof ctx.measureText !== "function") {
+      fail("@napi-rs/canvas", "getContext or measureText unavailable");
+      return false;
+    }
+    ok("@napi-rs/canvas", "createCanvas + measureText work");
+    return true;
+  } catch (err) {
+    fail("@napi-rs/canvas", `not available \u2014 ${err.message}`);
+    return false;
+  }
+}
+async function checkFontkitModule() {
+  try {
+    const fontkit = await import("fontkit");
+    const fk = fontkit.default || fontkit;
+    if (typeof fk.create !== "function") {
+      fail("fontkit", "create is not a function");
+      return false;
+    }
+    ok("fontkit", "fontkit.create() is available");
+    return true;
+  } catch (err) {
+    fail("fontkit", `not available \u2014 ${err.message}`);
+    return false;
+  }
+}
+async function checkPretextModule() {
+  try {
+    const pretext = await Promise.resolve().then(() => (init_layout(), exports_layout));
+    const pt = pretext.default || pretext;
+    if (typeof pt.prepare !== "function") {
+      fail("@chenglou/pretext", "prepare is not a function");
+      return false;
+    }
+    ok("@chenglou/pretext", "pretext.prepare() is available");
+    return true;
+  } catch (err) {
+    fail("@chenglou/pretext", `not available \u2014 ${err.message}`);
+    return false;
+  }
+}
+async function checkMeasureText() {
+  try {
+    const canvas = _requireModule("@napi-rs/canvas");
+    const c = canvas.createCanvas(200, 50);
+    const ctx = c.getContext("2d");
+    ctx.font = "16px serif";
+    const m = ctx.measureText("M");
+    if (m.width > 0) {
+      ok("measureText", `width = ${m.width} (> 0) \u2014 fontconfig OK`);
+      return true;
+    }
+    fail("measureText", `width = ${m.width} \u2014 fontconfig probably missing
+` + `        ${YELLOW}Solution: install fontconfig and run fc-cache -f${RESET}`);
+    return false;
+  } catch (err) {
+    fail("measureText", `error \u2014 ${err.message}`);
+    return false;
+  }
+}
+async function checkSystemFontsModule() {
+  try {
+    const mod = await import("get-system-fonts");
+    const getSystemFonts = mod.default || mod;
+    if (typeof getSystemFonts !== "function") {
+      skip("get-system-fonts", "not a function (browser build?)");
+      return true;
+    }
+    const paths = await getSystemFonts();
+    ok("get-system-fonts", `${paths.length} system fonts found`);
+    return true;
+  } catch (err) {
+    fail("get-system-fonts", `not available \u2014 ${err.message}`);
+    return false;
+  }
+}
+async function run() {
+  console.log(`${BOLD}vyaz environment check${RESET}
+`);
+  const results = await Promise.all([
+    checkCanvasModule(),
+    checkFontkitModule(),
+    checkPretextModule(),
+    checkMeasureText(),
+    checkSystemFontsModule()
+  ]);
+  const passed = results.filter(Boolean).length;
+  const total = results.length;
+  const allOk = passed === total;
+  console.log();
+  if (allOk) {
+    console.log(`  ${GREEN}${BOLD}\u2714 All ${total} checks passed${RESET}`);
+    _process?.exit(0);
+  } else {
+    console.log(`  ${RED}${BOLD}\u2718 ${passed}/${total} checks passed${RESET}
+`);
+    if (!results[3]) {
+      console.log(`  ${YELLOW}Hint: measureText returned 0 \u2014 fontconfig is likely missing.${RESET}
+  ${YELLOW}Install it with: apt-get install -y fontconfig && fc-cache -f${RESET}
+`);
+    }
+    _process?.exit(1);
+  }
+}
+export {
+  run
+};