@akairos/typeset-studio 0.2.1 → 0.2.3

package/dist/lib/index-6c43c7h4.js

@@ -0,0 +1,3880 @@
+// node_modules/@chenglou/pretext/dist/generated/bidi-data.js
+var latin1BidiTypes = [
+  "BN",
+  "BN",
+  "BN",
+  "BN",
+  "BN",
+  "BN",
+  "BN",
+  "BN",
+  "BN",
+  "S",
+  "B",
+  "S",
+  "WS",
+  "B",
+  "BN",
+  "BN",
+  "BN",
+  "BN",
+  "BN",
+  "BN",
+  "BN",
+  "BN",
+  "BN",
+  "BN",
+  "BN",
+  "BN",
+  "BN",
+  "BN",
+  "B",
+  "B",
+  "B",
+  "S",
+  "WS",
+  "ON",
+  "ON",
+  "ET",
+  "ET",
+  "ET",
+  "ON",
+  "ON",
+  "ON",
+  "ON",
+  "ON",
+  "ES",
+  "CS",
+  "ES",
+  "CS",
+  "CS",
+  "EN",
+  "EN",
+  "EN",
+  "EN",
+  "EN",
+  "EN",
+  "EN",
+  "EN",
+  "EN",
+  "EN",
+  "CS",
+  "ON",
+  "ON",
+  "ON",
+  "ON",
+  "ON",
+  "ON",
+  "L",
+  "L",
+  "L",
+  "L",
+  "L",
+  "L",
+  "L",
+  "L",
+  "L",
+  "L",
+  "L",
+  "L",
+  "L",
+  "L",
+  "L",
+  "L",
+  "L",
+  "L",
+  "L",
+  "L",
+  "L",
+  "L",
+  "L",
+  "L",
+  "L",
+  "L",
+  "ON",
+  "ON",
+  "ON",
+  "ON",
+  "ON",
+  "ON",
+  "L",
+  "L",
+  "L",
+  "L",
+  "L",
+  "L",
+  "L",
+  "L",
+  "L",
+  "L",
+  "L",
+  "L",
+  "L",
+  "L",
+  "L",
+  "L",
+  "L",
+  "L",
+  "L",
+  "L",
+  "L",
+  "L",
+  "L",
+  "L",
+  "L",
+  "L",
+  "ON",
+  "ON",
+  "ON",
+  "ON",
+  "BN",
+  "BN",
+  "BN",
+  "BN",
+  "BN",
+  "BN",
+  "B",
+  "BN",
+  "BN",
+  "BN",
+  "BN",
+  "BN",
+  "BN",
+  "BN",
+  "BN",
+  "BN",
+  "BN",
+  "BN",
+  "BN",
+  "BN",
+  "BN",
+  "BN",
+  "BN",
+  "BN",
+  "BN",
+  "BN",
+  "BN",
+  "BN",
+  "BN",
+  "BN",
+  "BN",
+  "BN",
+  "BN",
+  "CS",
+  "ON",
+  "ET",
+  "ET",
+  "ET",
+  "ET",
+  "ON",
+  "ON",
+  "ON",
+  "ON",
+  "L",
+  "ON",
+  "ON",
+  "BN",
+  "ON",
+  "ON",
+  "ET",
+  "ET",
+  "EN",
+  "EN",
+  "ON",
+  "L",
+  "ON",
+  "ON",
+  "ON",
+  "EN",
+  "L",
+  "ON",
+  "ON",
+  "ON",
+  "ON",
+  "ON",
+  "L",
+  "L",
+  "L",
+  "L",
+  "L",
+  "L",
+  "L",
+  "L",
+  "L",
+  "L",
+  "L",
+  "L",
+  "L",
+  "L",
+  "L",
+  "L",
+  "L",
+  "L",
+  "L",
+  "L",
+  "L",
+  "L",
+  "L",
+  "ON",
+  "L",
+  "L",
+  "L",
+  "L",
+  "L",
+  "L",
+  "L",
+  "L",
+  "L",
+  "L",
+  "L",
+  "L",
+  "L",
+  "L",
+  "L",
+  "L",
+  "L",
+  "L",
+  "L",
+  "L",
+  "L",
+  "L",
+  "L",
+  "L",
+  "L",
+  "L",
+  "L",
+  "L",
+  "L",
+  "L",
+  "L",
+  "ON",
+  "L",
+  "L",
+  "L",
+  "L",
+  "L",
+  "L",
+  "L",
+  "L"
+];
+var nonLatin1BidiRanges = [
+  [697, 698, "ON"],
+  [706, 719, "ON"],
+  [722, 735, "ON"],
+  [741, 749, "ON"],
+  [751, 767, "ON"],
+  [768, 879, "NSM"],
+  [884, 885, "ON"],
+  [894, 894, "ON"],
+  [900, 901, "ON"],
+  [903, 903, "ON"],
+  [1014, 1014, "ON"],
+  [1155, 1161, "NSM"],
+  [1418, 1418, "ON"],
+  [1421, 1422, "ON"],
+  [1423, 1423, "ET"],
+  [1424, 1424, "R"],
+  [1425, 1469, "NSM"],
+  [1470, 1470, "R"],
+  [1471, 1471, "NSM"],
+  [1472, 1472, "R"],
+  [1473, 1474, "NSM"],
+  [1475, 1475, "R"],
+  [1476, 1477, "NSM"],
+  [1478, 1478, "R"],
+  [1479, 1479, "NSM"],
+  [1480, 1535, "R"],
+  [1536, 1541, "AN"],
+  [1542, 1543, "ON"],
+  [1544, 1544, "AL"],
+  [1545, 1546, "ET"],
+  [1547, 1547, "AL"],
+  [1548, 1548, "CS"],
+  [1549, 1549, "AL"],
+  [1550, 1551, "ON"],
+  [1552, 1562, "NSM"],
+  [1563, 1610, "AL"],
+  [1611, 1631, "NSM"],
+  [1632, 1641, "AN"],
+  [1642, 1642, "ET"],
+  [1643, 1644, "AN"],
+  [1645, 1647, "AL"],
+  [1648, 1648, "NSM"],
+  [1649, 1749, "AL"],
+  [1750, 1756, "NSM"],
+  [1757, 1757, "AN"],
+  [1758, 1758, "ON"],
+  [1759, 1764, "NSM"],
+  [1765, 1766, "AL"],
+  [1767, 1768, "NSM"],
+  [1769, 1769, "ON"],
+  [1770, 1773, "NSM"],
+  [1774, 1775, "AL"],
+  [1776, 1785, "EN"],
+  [1786, 1808, "AL"],
+  [1809, 1809, "NSM"],
+  [1810, 1839, "AL"],
+  [1840, 1866, "NSM"],
+  [1867, 1957, "AL"],
+  [1958, 1968, "NSM"],
+  [1969, 1983, "AL"],
+  [1984, 2026, "R"],
+  [2027, 2035, "NSM"],
+  [2036, 2037, "R"],
+  [2038, 2041, "ON"],
+  [2042, 2044, "R"],
+  [2045, 2045, "NSM"],
+  [2046, 2069, "R"],
+  [2070, 2073, "NSM"],
+  [2074, 2074, "R"],
+  [2075, 2083, "NSM"],
+  [2084, 2084, "R"],
+  [2085, 2087, "NSM"],
+  [2088, 2088, "R"],
+  [2089, 2093, "NSM"],
+  [2094, 2136, "R"],
+  [2137, 2139, "NSM"],
+  [2140, 2143, "R"],
+  [2144, 2191, "AL"],
+  [2192, 2193, "AN"],
+  [2194, 2198, "AL"],
+  [2199, 2207, "NSM"],
+  [2208, 2249, "AL"],
+  [2250, 2273, "NSM"],
+  [2274, 2274, "AN"],
+  [2275, 2306, "NSM"],
+  [2362, 2362, "NSM"],
+  [2364, 2364, "NSM"],
+  [2369, 2376, "NSM"],
+  [2381, 2381, "NSM"],
+  [2385, 2391, "NSM"],
+  [2402, 2403, "NSM"],
+  [2433, 2433, "NSM"],
+  [2492, 2492, "NSM"],
+  [2497, 2500, "NSM"],
+  [2509, 2509, "NSM"],
+  [2530, 2531, "NSM"],
+  [2546, 2547, "ET"],
+  [2555, 2555, "ET"],
+  [2558, 2558, "NSM"],
+  [2561, 2562, "NSM"],
+  [2620, 2620, "NSM"],
+  [2625, 2626, "NSM"],
+  [2631, 2632, "NSM"],
+  [2635, 2637, "NSM"],
+  [2641, 2641, "NSM"],
+  [2672, 2673, "NSM"],
+  [2677, 2677, "NSM"],
+  [2689, 2690, "NSM"],
+  [2748, 2748, "NSM"],
+  [2753, 2757, "NSM"],
+  [2759, 2760, "NSM"],
+  [2765, 2765, "NSM"],
+  [2786, 2787, "NSM"],
+  [2801, 2801, "ET"],
+  [2810, 2815, "NSM"],
+  [2817, 2817, "NSM"],
+  [2876, 2876, "NSM"],
+  [2879, 2879, "NSM"],
+  [2881, 2884, "NSM"],
+  [2893, 2893, "NSM"],
+  [2901, 2902, "NSM"],
+  [2914, 2915, "NSM"],
+  [2946, 2946, "NSM"],
+  [3008, 3008, "NSM"],
+  [3021, 3021, "NSM"],
+  [3059, 3064, "ON"],
+  [3065, 3065, "ET"],
+  [3066, 3066, "ON"],
+  [3072, 3072, "NSM"],
+  [3076, 3076, "NSM"],
+  [3132, 3132, "NSM"],
+  [3134, 3136, "NSM"],
+  [3142, 3144, "NSM"],
+  [3146, 3149, "NSM"],
+  [3157, 3158, "NSM"],
+  [3170, 3171, "NSM"],
+  [3192, 3198, "ON"],
+  [3201, 3201, "NSM"],
+  [3260, 3260, "NSM"],
+  [3276, 3277, "NSM"],
+  [3298, 3299, "NSM"],
+  [3328, 3329, "NSM"],
+  [3387, 3388, "NSM"],
+  [3393, 3396, "NSM"],
+  [3405, 3405, "NSM"],
+  [3426, 3427, "NSM"],
+  [3457, 3457, "NSM"],
+  [3530, 3530, "NSM"],
+  [3538, 3540, "NSM"],
+  [3542, 3542, "NSM"],
+  [3633, 3633, "NSM"],
+  [3636, 3642, "NSM"],
+  [3647, 3647, "ET"],
+  [3655, 3662, "NSM"],
+  [3761, 3761, "NSM"],
+  [3764, 3772, "NSM"],
+  [3784, 3790, "NSM"],
+  [3864, 3865, "NSM"],
+  [3893, 3893, "NSM"],
+  [3895, 3895, "NSM"],
+  [3897, 3897, "NSM"],
+  [3898, 3901, "ON"],
+  [3953, 3966, "NSM"],
+  [3968, 3972, "NSM"],
+  [3974, 3975, "NSM"],
+  [3981, 3991, "NSM"],
+  [3993, 4028, "NSM"],
+  [4038, 4038, "NSM"],
+  [4141, 4144, "NSM"],
+  [4146, 4151, "NSM"],
+  [4153, 4154, "NSM"],
+  [4157, 4158, "NSM"],
+  [4184, 4185, "NSM"],
+  [4190, 4192, "NSM"],
+  [4209, 4212, "NSM"],
+  [4226, 4226, "NSM"],
+  [4229, 4230, "NSM"],
+  [4237, 4237, "NSM"],
+  [4253, 4253, "NSM"],
+  [4957, 4959, "NSM"],
+  [5008, 5017, "ON"],
+  [5120, 5120, "ON"],
+  [5760, 5760, "WS"],
+  [5787, 5788, "ON"],
+  [5906, 5908, "NSM"],
+  [5938, 5939, "NSM"],
+  [5970, 5971, "NSM"],
+  [6002, 6003, "NSM"],
+  [6068, 6069, "NSM"],
+  [6071, 6077, "NSM"],
+  [6086, 6086, "NSM"],
+  [6089, 6099, "NSM"],
+  [6107, 6107, "ET"],
+  [6109, 6109, "NSM"],
+  [6128, 6137, "ON"],
+  [6144, 6154, "ON"],
+  [6155, 6157, "NSM"],
+  [6158, 6158, "BN"],
+  [6159, 6159, "NSM"],
+  [6277, 6278, "NSM"],
+  [6313, 6313, "NSM"],
+  [6432, 6434, "NSM"],
+  [6439, 6440, "NSM"],
+  [6450, 6450, "NSM"],
+  [6457, 6459, "NSM"],
+  [6464, 6464, "ON"],
+  [6468, 6469, "ON"],
+  [6622, 6655, "ON"],
+  [6679, 6680, "NSM"],
+  [6683, 6683, "NSM"],
+  [6742, 6742, "NSM"],
+  [6744, 6750, "NSM"],
+  [6752, 6752, "NSM"],
+  [6754, 6754, "NSM"],
+  [6757, 6764, "NSM"],
+  [6771, 6780, "NSM"],
+  [6783, 6783, "NSM"],
+  [6832, 6877, "NSM"],
+  [6880, 6891, "NSM"],
+  [6912, 6915, "NSM"],
+  [6964, 6964, "NSM"],
+  [6966, 6970, "NSM"],
+  [6972, 6972, "NSM"],
+  [6978, 6978, "NSM"],
+  [7019, 7027, "NSM"],
+  [7040, 7041, "NSM"],
+  [7074, 7077, "NSM"],
+  [7080, 7081, "NSM"],
+  [7083, 7085, "NSM"],
+  [7142, 7142, "NSM"],
+  [7144, 7145, "NSM"],
+  [7149, 7149, "NSM"],
+  [7151, 7153, "NSM"],
+  [7212, 7219, "NSM"],
+  [7222, 7223, "NSM"],
+  [7376, 7378, "NSM"],
+  [7380, 7392, "NSM"],
+  [7394, 7400, "NSM"],
+  [7405, 7405, "NSM"],
+  [7412, 7412, "NSM"],
+  [7416, 7417, "NSM"],
+  [7616, 7679, "NSM"],
+  [8125, 8125, "ON"],
+  [8127, 8129, "ON"],
+  [8141, 8143, "ON"],
+  [8157, 8159, "ON"],
+  [8173, 8175, "ON"],
+  [8189, 8190, "ON"],
+  [8192, 8202, "WS"],
+  [8203, 8205, "BN"],
+  [8207, 8207, "R"],
+  [8208, 8231, "ON"],
+  [8232, 8232, "WS"],
+  [8233, 8233, "B"],
+  [8234, 8238, "BN"],
+  [8239, 8239, "CS"],
+  [8240, 8244, "ET"],
+  [8245, 8259, "ON"],
+  [8260, 8260, "CS"],
+  [8261, 8286, "ON"],
+  [8287, 8287, "WS"],
+  [8288, 8303, "BN"],
+  [8304, 8304, "EN"],
+  [8308, 8313, "EN"],
+  [8314, 8315, "ES"],
+  [8316, 8318, "ON"],
+  [8320, 8329, "EN"],
+  [8330, 8331, "ES"],
+  [8332, 8334, "ON"],
+  [8352, 8399, "ET"],
+  [8400, 8432, "NSM"],
+  [8448, 8449, "ON"],
+  [8451, 8454, "ON"],
+  [8456, 8457, "ON"],
+  [8468, 8468, "ON"],
+  [8470, 8472, "ON"],
+  [8478, 8483, "ON"],
+  [8485, 8485, "ON"],
+  [8487, 8487, "ON"],
+  [8489, 8489, "ON"],
+  [8494, 8494, "ET"],
+  [8506, 8507, "ON"],
+  [8512, 8516, "ON"],
+  [8522, 8525, "ON"],
+  [8528, 8543, "ON"],
+  [8585, 8587, "ON"],
+  [8592, 8721, "ON"],
+  [8722, 8722, "ES"],
+  [8723, 8723, "ET"],
+  [8724, 9013, "ON"],
+  [9083, 9108, "ON"],
+  [9110, 9257, "ON"],
+  [9280, 9290, "ON"],
+  [9312, 9351, "ON"],
+  [9352, 9371, "EN"],
+  [9450, 9899, "ON"],
+  [9901, 10239, "ON"],
+  [10496, 11123, "ON"],
+  [11126, 11263, "ON"],
+  [11493, 11498, "ON"],
+  [11503, 11505, "NSM"],
+  [11513, 11519, "ON"],
+  [11647, 11647, "NSM"],
+  [11744, 11775, "NSM"],
+  [11776, 11869, "ON"],
+  [11904, 11929, "ON"],
+  [11931, 12019, "ON"],
+  [12032, 12245, "ON"],
+  [12272, 12287, "ON"],
+  [12288, 12288, "WS"],
+  [12289, 12292, "ON"],
+  [12296, 12320, "ON"],
+  [12330, 12333, "NSM"],
+  [12336, 12336, "ON"],
+  [12342, 12343, "ON"],
+  [12349, 12351, "ON"],
+  [12441, 12442, "NSM"],
+  [12443, 12444, "ON"],
+  [12448, 12448, "ON"],
+  [12539, 12539, "ON"],
+  [12736, 12773, "ON"],
+  [12783, 12783, "ON"],
+  [12829, 12830, "ON"],
+  [12880, 12895, "ON"],
+  [12924, 12926, "ON"],
+  [12977, 12991, "ON"],
+  [13004, 13007, "ON"],
+  [13175, 13178, "ON"],
+  [13278, 13279, "ON"],
+  [13311, 13311, "ON"],
+  [19904, 19967, "ON"],
+  [42128, 42182, "ON"],
+  [42509, 42511, "ON"],
+  [42607, 42610, "NSM"],
+  [42611, 42611, "ON"],
+  [42612, 42621, "NSM"],
+  [42622, 42623, "ON"],
+  [42654, 42655, "NSM"],
+  [42736, 42737, "NSM"],
+  [42752, 42785, "ON"],
+  [42888, 42888, "ON"],
+  [43010, 43010, "NSM"],
+  [43014, 43014, "NSM"],
+  [43019, 43019, "NSM"],
+  [43045, 43046, "NSM"],
+  [43048, 43051, "ON"],
+  [43052, 43052, "NSM"],
+  [43064, 43065, "ET"],
+  [43124, 43127, "ON"],
+  [43204, 43205, "NSM"],
+  [43232, 43249, "NSM"],
+  [43263, 43263, "NSM"],
+  [43302, 43309, "NSM"],
+  [43335, 43345, "NSM"],
+  [43392, 43394, "NSM"],
+  [43443, 43443, "NSM"],
+  [43446, 43449, "NSM"],
+  [43452, 43453, "NSM"],
+  [43493, 43493, "NSM"],
+  [43561, 43566, "NSM"],
+  [43569, 43570, "NSM"],
+  [43573, 43574, "NSM"],
+  [43587, 43587, "NSM"],
+  [43596, 43596, "NSM"],
+  [43644, 43644, "NSM"],
+  [43696, 43696, "NSM"],
+  [43698, 43700, "NSM"],
+  [43703, 43704, "NSM"],
+  [43710, 43711, "NSM"],
+  [43713, 43713, "NSM"],
+  [43756, 43757, "NSM"],
+  [43766, 43766, "NSM"],
+  [43882, 43883, "ON"],
+  [44005, 44005, "NSM"],
+  [44008, 44008, "NSM"],
+  [44013, 44013, "NSM"],
+  [64285, 64285, "R"],
+  [64286, 64286, "NSM"],
+  [64287, 64296, "R"],
+  [64297, 64297, "ES"],
+  [64298, 64335, "R"],
+  [64336, 64450, "AL"],
+  [64451, 64466, "ON"],
+  [64467, 64829, "AL"],
+  [64830, 64847, "ON"],
+  [64848, 64911, "AL"],
+  [64912, 64913, "ON"],
+  [64914, 64967, "AL"],
+  [64968, 64975, "ON"],
+  [64976, 65007, "BN"],
+  [65008, 65020, "AL"],
+  [65021, 65023, "ON"],
+  [65024, 65039, "NSM"],
+  [65040, 65049, "ON"],
+  [65056, 65071, "NSM"],
+  [65072, 65103, "ON"],
+  [65104, 65104, "CS"],
+  [65105, 65105, "ON"],
+  [65106, 65106, "CS"],
+  [65108, 65108, "ON"],
+  [65109, 65109, "CS"],
+  [65110, 65118, "ON"],
+  [65119, 65119, "ET"],
+  [65120, 65121, "ON"],
+  [65122, 65123, "ES"],
+  [65124, 65126, "ON"],
+  [65128, 65128, "ON"],
+  [65129, 65130, "ET"],
+  [65131, 65131, "ON"],
+  [65136, 65278, "AL"],
+  [65279, 65279, "BN"],
+  [65281, 65282, "ON"],
+  [65283, 65285, "ET"],
+  [65286, 65290, "ON"],
+  [65291, 65291, "ES"],
+  [65292, 65292, "CS"],
+  [65293, 65293, "ES"],
+  [65294, 65295, "CS"],
+  [65296, 65305, "EN"],
+  [65306, 65306, "CS"],
+  [65307, 65312, "ON"],
+  [65339, 65344, "ON"],
+  [65371, 65381, "ON"],
+  [65504, 65505, "ET"],
+  [65506, 65508, "ON"],
+  [65509, 65510, "ET"],
+  [65512, 65518, "ON"],
+  [65520, 65528, "BN"],
+  [65529, 65533, "ON"],
+  [65534, 65535, "BN"],
+  [65793, 65793, "ON"],
+  [65856, 65932, "ON"],
+  [65936, 65948, "ON"],
+  [65952, 65952, "ON"],
+  [66045, 66045, "NSM"],
+  [66272, 66272, "NSM"],
+  [66273, 66299, "EN"],
+  [66422, 66426, "NSM"],
+  [67584, 67870, "R"],
+  [67871, 67871, "ON"],
+  [67872, 68096, "R"],
+  [68097, 68099, "NSM"],
+  [68100, 68100, "R"],
+  [68101, 68102, "NSM"],
+  [68103, 68107, "R"],
+  [68108, 68111, "NSM"],
+  [68112, 68151, "R"],
+  [68152, 68154, "NSM"],
+  [68155, 68158, "R"],
+  [68159, 68159, "NSM"],
+  [68160, 68324, "R"],
+  [68325, 68326, "NSM"],
+  [68327, 68408, "R"],
+  [68409, 68415, "ON"],
+  [68416, 68863, "R"],
+  [68864, 68899, "AL"],
+  [68900, 68903, "NSM"],
+  [68904, 68911, "AL"],
+  [68912, 68921, "AN"],
+  [68922, 68927, "AL"],
+  [68928, 68937, "AN"],
+  [68938, 68968, "R"],
+  [68969, 68973, "NSM"],
+  [68974, 68974, "ON"],
+  [68975, 69215, "R"],
+  [69216, 69246, "AN"],
+  [69247, 69290, "R"],
+  [69291, 69292, "NSM"],
+  [69293, 69311, "R"],
+  [69312, 69327, "AL"],
+  [69328, 69336, "ON"],
+  [69337, 69369, "AL"],
+  [69370, 69375, "NSM"],
+  [69376, 69423, "R"],
+  [69424, 69445, "AL"],
+  [69446, 69456, "NSM"],
+  [69457, 69487, "AL"],
+  [69488, 69505, "R"],
+  [69506, 69509, "NSM"],
+  [69510, 69631, "R"],
+  [69633, 69633, "NSM"],
+  [69688, 69702, "NSM"],
+  [69714, 69733, "ON"],
+  [69744, 69744, "NSM"],
+  [69747, 69748, "NSM"],
+  [69759, 69761, "NSM"],
+  [69811, 69814, "NSM"],
+  [69817, 69818, "NSM"],
+  [69826, 69826, "NSM"],
+  [69888, 69890, "NSM"],
+  [69927, 69931, "NSM"],
+  [69933, 69940, "NSM"],
+  [70003, 70003, "NSM"],
+  [70016, 70017, "NSM"],
+  [70070, 70078, "NSM"],
+  [70089, 70092, "NSM"],
+  [70095, 70095, "NSM"],
+  [70191, 70193, "NSM"],
+  [70196, 70196, "NSM"],
+  [70198, 70199, "NSM"],
+  [70206, 70206, "NSM"],
+  [70209, 70209, "NSM"],
+  [70367, 70367, "NSM"],
+  [70371, 70378, "NSM"],
+  [70400, 70401, "NSM"],
+  [70459, 70460, "NSM"],
+  [70464, 70464, "NSM"],
+  [70502, 70508, "NSM"],
+  [70512, 70516, "NSM"],
+  [70587, 70592, "NSM"],
+  [70606, 70606, "NSM"],
+  [70608, 70608, "NSM"],
+  [70610, 70610, "NSM"],
+  [70625, 70626, "NSM"],
+  [70712, 70719, "NSM"],
+  [70722, 70724, "NSM"],
+  [70726, 70726, "NSM"],
+  [70750, 70750, "NSM"],
+  [70835, 70840, "NSM"],
+  [70842, 70842, "NSM"],
+  [70847, 70848, "NSM"],
+  [70850, 70851, "NSM"],
+  [71090, 71093, "NSM"],
+  [71100, 71101, "NSM"],
+  [71103, 71104, "NSM"],
+  [71132, 71133, "NSM"],
+  [71219, 71226, "NSM"],
+  [71229, 71229, "NSM"],
+  [71231, 71232, "NSM"],
+  [71264, 71276, "ON"],
+  [71339, 71339, "NSM"],
+  [71341, 71341, "NSM"],
+  [71344, 71349, "NSM"],
+  [71351, 71351, "NSM"],
+  [71453, 71453, "NSM"],
+  [71455, 71455, "NSM"],
+  [71458, 71461, "NSM"],
+  [71463, 71467, "NSM"],
+  [71727, 71735, "NSM"],
+  [71737, 71738, "NSM"],
+  [71995, 71996, "NSM"],
+  [71998, 71998, "NSM"],
+  [72003, 72003, "NSM"],
+  [72148, 72151, "NSM"],
+  [72154, 72155, "NSM"],
+  [72160, 72160, "NSM"],
+  [72193, 72198, "NSM"],
+  [72201, 72202, "NSM"],
+  [72243, 72248, "NSM"],
+  [72251, 72254, "NSM"],
+  [72263, 72263, "NSM"],
+  [72273, 72278, "NSM"],
+  [72281, 72283, "NSM"],
+  [72330, 72342, "NSM"],
+  [72344, 72345, "NSM"],
+  [72544, 72544, "NSM"],
+  [72546, 72548, "NSM"],
+  [72550, 72550, "NSM"],
+  [72752, 72758, "NSM"],
+  [72760, 72765, "NSM"],
+  [72850, 72871, "NSM"],
+  [72874, 72880, "NSM"],
+  [72882, 72883, "NSM"],
+  [72885, 72886, "NSM"],
+  [73009, 73014, "NSM"],
+  [73018, 73018, "NSM"],
+  [73020, 73021, "NSM"],
+  [73023, 73029, "NSM"],
+  [73031, 73031, "NSM"],
+  [73104, 73105, "NSM"],
+  [73109, 73109, "NSM"],
+  [73111, 73111, "NSM"],
+  [73459, 73460, "NSM"],
+  [73472, 73473, "NSM"],
+  [73526, 73530, "NSM"],
+  [73536, 73536, "NSM"],
+  [73538, 73538, "NSM"],
+  [73562, 73562, "NSM"],
+  [73685, 73692, "ON"],
+  [73693, 73696, "ET"],
+  [73697, 73713, "ON"],
+  [78912, 78912, "NSM"],
+  [78919, 78933, "NSM"],
+  [90398, 90409, "NSM"],
+  [90413, 90415, "NSM"],
+  [92912, 92916, "NSM"],
+  [92976, 92982, "NSM"],
+  [94031, 94031, "NSM"],
+  [94095, 94098, "NSM"],
+  [94178, 94178, "ON"],
+  [94180, 94180, "NSM"],
+  [113821, 113822, "NSM"],
+  [113824, 113827, "BN"],
+  [117760, 117973, "ON"],
+  [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/@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;
+}
+
+// node_modules/@chenglou/pretext/dist/analysis.js
+var collapsibleWhitespaceRunRe = /[ \t\n\r\f]+/g;
+var needsWhitespaceNormalizationRe = /[\t\n\r\f]| {2,}|^ | $/;
+function getWhiteSpaceProfile(whiteSpace) {
+  const mode = whiteSpace ?? "normal";
+  return mode === "pre-wrap" ? { mode, preserveOrdinarySpaces: true, preserveHardBreaks: true } : { mode, preserveOrdinarySpaces: false, preserveHardBreaks: false };
+}
+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, `
+`);
+}
+var sharedWordSegmenter = null;
+var segmenterLocale;
+function getSharedWordSegmenter() {
+  if (sharedWordSegmenter === null) {
+    sharedWordSegmenter = new Intl.Segmenter(segmenterLocale, { granularity: "word" });
+  }
+  return sharedWordSegmenter;
+}
+function clearAnalysisCaches() {
+  sharedWordSegmenter = null;
+}
+var arabicScriptRe = /\p{Script=Arabic}/u;
+var combiningMarkRe = /\p{M}/u;
+var decimalDigitRe = /\p{Nd}/u;
+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));
+}
+var keepAllGlueChars = new Set([
+  " ",
+  " ",
+  "⁠",
+  "\uFEFF"
+]);
+var keepAllDashBreakChars = new Set([
+  "-",
+  "‐",
+  "–",
+  "—"
+]);
+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;
+}
+var kinsokuStart = new Set([
+  "，",
+  "．",
+  "！",
+  "：",
+  "；",
+  "？",
+  "、",
+  "。",
+  "・",
+  "）",
+  "〕",
+  "〉",
+  "》",
+  "」",
+  "』",
+  "】",
+  "〗",
+  "〙",
+  "〛",
+  "ー",
+  "々",
+  "〻",
+  "ゝ",
+  "ゞ",
+  "ヽ",
+  "ヾ"
+]);
+var kinsokuEnd = new Set([
+  '"',
+  "(",
+  "[",
+  "{",
+  "¡",
+  "¿",
+  "“",
+  "‘",
+  "‚",
+  "„",
+  "«",
+  "‹",
+  "⸘",
+  "（",
+  "〔",
+  "〈",
+  "《",
+  "「",
+  "『",
+  "【",
+  "〖",
+  "〘",
+  "〚"
+]);
+var forwardStickyGlue = new Set([
+  "'",
+  "’"
+]);
+var leftStickyPunctuation = new Set([
+  ".",
+  ",",
+  "!",
+  "?",
+  ":",
+  ";",
+  "،",
+  "؛",
+  "؟",
+  "।",
+  "॥",
+  "၊",
+  "။",
+  "၌",
+  "၍",
+  "၏",
+  ")",
+  "]",
+  "}",
+  "%",
+  '"',
+  "”",
+  "’",
+  "»",
+  "›",
+  "…"
+]);
+var arabicNoSpaceTrailingPunctuation = new Set([
+  ":",
+  ".",
+  "،",
+  "؛"
+]);
+var myanmarMedialGlue = new Set([
+  "၏"
+]);
+var closingQuoteChars = new Set([
+  "”",
+  "’",
+  "»",
+  "›",
+  "」",
+  "』",
+  "】",
+  "》",
+  "〉",
+  "〕",
+  "）"
+]);
+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;
+}
+var 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
+];
+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 !== "—" ? 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 === " " || ch === " " || ch === "⁠" || ch === "\uFEFF") {
+    return "glue";
+  }
+  if (ch === "​")
+    return "zero-width-break";
+  if (ch === "­")
+    return "soft-hyphen";
+  return "text";
+}
+var breakCharRe = /[\x20\t\n\xA0\xAD\u200B\u202F\u2060\uFEFF]/;
+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";
+}
+var urlSchemeSegmentRe = /^[A-Za-z][A-Za-z0-9+.-]*:$/;
+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
+  };
+}
+var numericJoinerChars = new Set([
+  ":",
+  "-",
+  "/",
+  "×",
+  ",",
+  ".",
+  "+",
+  "–",
+  "—"
+]);
+var wordInternalSymbolRe = /[\p{P}\p{S}\p{Co}]/u;
+var emojiPresentationRe = /\p{Emoji_Presentation}/u;
+var noSpaceWordBreakAfterChars = new Set([
+  "?",
+  "֊",
+  "-",
+  "‐",
+  "‒",
+  "–",
+  "—",
+  "…",
+  "‼",
+  "‽",
+  "⁉"
+]);
+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
+  };
+}
+
+// node_modules/@chenglou/pretext/dist/measurement.js
+var measureContext = null;
+var segmentMetricCaches = new Map;
+var cachedEngineProfile = null;
+var MAX_PREFIX_FIT_GRAPHEMES = 96;
+var emojiPresentationRe2 = /\p{Emoji_Presentation}/u;
+var maybeEmojiRe = /[\p{Emoji_Presentation}\p{Extended_Pictographic}\p{Regional_Indicator}\uFE0F\u20E3]/u;
+var sharedGraphemeSegmenter = null;
+var emojiCorrectionCache = new Map;
+function getMeasureContext() {
+  if (measureContext !== null)
+    return measureContext;
+  if (typeof OffscreenCanvas !== "undefined") {
+    measureContext = new OffscreenCanvas(1, 1).getContext("2d");
+    return measureContext;
+  }
+  if (typeof document !== "undefined") {
+    measureContext = document.createElement("canvas").getContext("2d");
+    return measureContext;
+  }
+  throw new Error("Text measurement requires OffscreenCanvas or a DOM canvas context.");
+}
+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("️");
+}
+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;
+}
+
+// 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 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);
+}
+
+// node_modules/@chenglou/pretext/dist/line-text.js
+var sharedGraphemeSegmenter2 = null;
+var sharedLineTextCaches = new WeakMap;
+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;
+}
+
+// node_modules/@chenglou/pretext/dist/layout.js
+var sharedGraphemeSegmenter3 = null;
+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 === "֊" || grapheme === "‐" || grapheme === "‒" || grapheme === "–" || grapheme === "—";
+}
+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 prepareWithSegments(text, font, options) {
+  return prepareInternal(text, font, true, options);
+}
+function getInternalPrepared(prepared) {
+  return prepared;
+}
+function measureNaturalWidth(prepared) {
+  let maxWidth = 0;
+  walkPreparedLinesRaw(getInternalPrepared(prepared), Number.POSITIVE_INFINITY, (width) => {
+    if (width > maxWidth)
+      maxWidth = width;
+  });
+  return maxWidth;
+}
+function clearCache() {
+  clearAnalysisCaches();
+  sharedGraphemeSegmenter3 = null;
+  clearLineTextCaches();
+  clearMeasurementCaches();
+}
+
+// src/core/font-loader.ts
+import { createRequire } from "node:module";
+import { existsSync, readdirSync, readFileSync, statSync } from "node:fs";
+import { basename, extname, join, resolve } from "node:path";
+function readFontFamilyName(filePath) {
+  try {
+    const buf = readFileSync(filePath);
+    if (buf.length < 12)
+      return null;
+    const numTables = buf.readUInt16BE(4);
+    let nameTableOffset = 0;
+    for (let i = 0;i < numTables; i++) {
+      const offset = 12 + i * 16;
+      if (offset + 16 > buf.length)
+        break;
+      const tag = buf.toString("utf8", offset, offset + 4);
+      if (tag === "name") {
+        nameTableOffset = buf.readUInt32BE(offset + 8);
+        break;
+      }
+    }
+    if (!nameTableOffset || nameTableOffset + 6 > buf.length)
+      return null;
+    const count = buf.readUInt16BE(nameTableOffset + 2);
+    const stringOffset = nameTableOffset + buf.readUInt16BE(nameTableOffset + 4);
+    let familyName = null;
+    let preferredFamily = null;
+    for (let i = 0;i < count; i++) {
+      const recOffset = nameTableOffset + 6 + i * 12;
+      if (recOffset + 12 > buf.length)
+        break;
+      const platformId = buf.readUInt16BE(recOffset);
+      const nameId = buf.readUInt16BE(recOffset + 6);
+      const length = buf.readUInt16BE(recOffset + 8);
+      const strOffset = stringOffset + buf.readUInt16BE(recOffset + 10);
+      if (strOffset + length > buf.length)
+        continue;
+      if (nameId === 1 || nameId === 16) {
+        let str = "";
+        if (platformId === 0 || platformId === 3) {
+          if (length % 2 !== 0)
+            continue;
+          str = Buffer.from(buf.subarray(strOffset, strOffset + length)).swap16().toString("utf16le").trim();
+        } else {
+          str = buf.toString("utf8", strOffset, strOffset + length).trim();
+        }
+        str = str.replace(/\0/g, "").trim();
+        if (str) {
+          if (nameId === 16)
+            preferredFamily = str;
+          if (nameId === 1 && !familyName)
+            familyName = str;
+        }
+      }
+    }
+    return preferredFamily || familyName || null;
+  } catch {
+    return null;
+  }
+}
+var SUPPORTED_EXTS = new Set([".ttf", ".otf", ".woff2", ".woff"]);
+var FORMAT_MAP = {
+  ".ttf": "truetype",
+  ".otf": "opentype",
+  ".woff2": "woff2",
+  ".woff": "woff"
+};
+var cachedFonts = null;
+var registeredServerFonts = false;
+function scanLocalFonts(options) {
+  if (cachedFonts && !options?.refresh) {
+    return cachedFonts;
+  }
+  const cwd = options?.cwd || process.cwd();
+  const searchDirs = [
+    join(cwd, "public", "fonts"),
+    join(cwd, "dist", "fonts"),
+    join(cwd, "fonts")
+  ];
+  const foundMap = new Map;
+  const seenFilenames = new Set;
+  for (const dir of searchDirs) {
+    if (!existsSync(dir))
+      continue;
+    let manifest = {};
+    const manifestPath = join(dir, "fonts.json");
+    if (existsSync(manifestPath)) {
+      try {
+        manifest = JSON.parse(readFileSync(manifestPath, "utf-8"));
+      } catch (err) {
+        console.warn(`[font-loader] Failed to parse manifest ${manifestPath}:`, err);
+      }
+    }
+    let files = [];
+    try {
+      files = readdirSync(dir);
+    } catch {
+      continue;
+    }
+    for (const filename of files) {
+      if (seenFilenames.has(filename))
+        continue;
+      const ext = extname(filename).toLowerCase();
+      if (!SUPPORTED_EXTS.has(ext))
+        continue;
+      const fullPath = resolve(dir, filename);
+      let fileStat;
+      try {
+        fileStat = statSync(fullPath);
+        if (!fileStat.isFile())
+          continue;
+      } catch {
+        continue;
+      }
+      seenFilenames.add(filename);
+      const rawBase = basename(filename, ext);
+      const customMeta = manifest[filename] || manifest[rawBase] || {};
+      const parsedFamily = ext === ".ttf" || ext === ".otf" ? readFontFamilyName(fullPath) : null;
+      const family = customMeta.family || parsedFamily || rawBase;
+      const label = customMeta.label || `${family} (本地字体)`;
+      if (!foundMap.has(family)) {
+        foundMap.set(family, {
+          family,
+          label,
+          filename,
+          path: fullPath,
+          url: `/fonts/${encodeURIComponent(filename)}`,
+          format: FORMAT_MAP[ext] || "truetype",
+          fileSizeBytes: fileStat.size
+        });
+      }
+    }
+  }
+  cachedFonts = Array.from(foundMap.values());
+  return cachedFonts;
+}
+function registerServerFonts(options) {
+  const fonts = scanLocalFonts({ refresh: options?.refresh });
+  if (registeredServerFonts && !options?.refresh) {
+    return fonts;
+  }
+  try {
+    const { GlobalFonts } = createRequire(import.meta.url)("@napi-rs/canvas");
+    if (GlobalFonts && typeof GlobalFonts.registerFromPath === "function") {
+      for (const font of fonts) {
+        try {
+          GlobalFonts.registerFromPath(font.path, font.family);
+          const rawBase = basename(font.filename, extname(font.filename));
+          if (rawBase !== font.family) {
+            GlobalFonts.registerFromPath(font.path, rawBase);
+          }
+        } catch (err) {
+          console.warn(`[font-loader] Failed to register font ${font.filename} in Skia:`, err);
+        }
+      }
+      registeredServerFonts = true;
+      clearCache();
+    }
+  } catch {}
+  return fonts;
+}
+
+export { stepPreparedLineGeometry, getLineTextCache, buildLineTextFromRange, prepareWithSegments, measureNaturalWidth, readFontFamilyName, scanLocalFonts, registerServerFonts };