@forevka/wordcanvas 0.7.0 → 0.7.1

package/dist-lib/recalcToc-g1hFKSNs.js

@@ -0,0 +1,3935 @@
+import { r as Mn, F as Cn, t as kn, f as Dn } from "./browser-DkKxreJM.js";
+import { e as Ln, f as Oe } from "./lists-Sc5I40JO.js";
+import { m as ce, q as Pe, t as we } from "./metrics-CkAo4zh8.js";
+const bn = [
+  "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"
+], Et = [
+  [697, 698, "ON"],
+  [706, 719, "ON"],
+  [722, 735, "ON"],
+  [741, 749, "ON"],
+  [751, 767, "ON"],
+  [768, 879, "NSM"],
+  [884, 885, "ON"],
+  [894, 894, "ON"],
+  [900, 901, "ON"],
+  [903, 903, "ON"],
+  [1014, 1014, "ON"],
+  [1155, 1161, "NSM"],
+  [1418, 1418, "ON"],
+  [1421, 1422, "ON"],
+  [1423, 1423, "ET"],
+  [1424, 1424, "R"],
+  [1425, 1469, "NSM"],
+  [1470, 1470, "R"],
+  [1471, 1471, "NSM"],
+  [1472, 1472, "R"],
+  [1473, 1474, "NSM"],
+  [1475, 1475, "R"],
+  [1476, 1477, "NSM"],
+  [1478, 1478, "R"],
+  [1479, 1479, "NSM"],
+  [1480, 1535, "R"],
+  [1536, 1541, "AN"],
+  [1542, 1543, "ON"],
+  [1544, 1544, "AL"],
+  [1545, 1546, "ET"],
+  [1547, 1547, "AL"],
+  [1548, 1548, "CS"],
+  [1549, 1549, "AL"],
+  [1550, 1551, "ON"],
+  [1552, 1562, "NSM"],
+  [1563, 1610, "AL"],
+  [1611, 1631, "NSM"],
+  [1632, 1641, "AN"],
+  [1642, 1642, "ET"],
+  [1643, 1644, "AN"],
+  [1645, 1647, "AL"],
+  [1648, 1648, "NSM"],
+  [1649, 1749, "AL"],
+  [1750, 1756, "NSM"],
+  [1757, 1757, "AN"],
+  [1758, 1758, "ON"],
+  [1759, 1764, "NSM"],
+  [1765, 1766, "AL"],
+  [1767, 1768, "NSM"],
+  [1769, 1769, "ON"],
+  [1770, 1773, "NSM"],
+  [1774, 1775, "AL"],
+  [1776, 1785, "EN"],
+  [1786, 1808, "AL"],
+  [1809, 1809, "NSM"],
+  [1810, 1839, "AL"],
+  [1840, 1866, "NSM"],
+  [1867, 1957, "AL"],
+  [1958, 1968, "NSM"],
+  [1969, 1983, "AL"],
+  [1984, 2026, "R"],
+  [2027, 2035, "NSM"],
+  [2036, 2037, "R"],
+  [2038, 2041, "ON"],
+  [2042, 2044, "R"],
+  [2045, 2045, "NSM"],
+  [2046, 2069, "R"],
+  [2070, 2073, "NSM"],
+  [2074, 2074, "R"],
+  [2075, 2083, "NSM"],
+  [2084, 2084, "R"],
+  [2085, 2087, "NSM"],
+  [2088, 2088, "R"],
+  [2089, 2093, "NSM"],
+  [2094, 2136, "R"],
+  [2137, 2139, "NSM"],
+  [2140, 2143, "R"],
+  [2144, 2191, "AL"],
+  [2192, 2193, "AN"],
+  [2194, 2198, "AL"],
+  [2199, 2207, "NSM"],
+  [2208, 2249, "AL"],
+  [2250, 2273, "NSM"],
+  [2274, 2274, "AN"],
+  [2275, 2306, "NSM"],
+  [2362, 2362, "NSM"],
+  [2364, 2364, "NSM"],
+  [2369, 2376, "NSM"],
+  [2381, 2381, "NSM"],
+  [2385, 2391, "NSM"],
+  [2402, 2403, "NSM"],
+  [2433, 2433, "NSM"],
+  [2492, 2492, "NSM"],
+  [2497, 2500, "NSM"],
+  [2509, 2509, "NSM"],
+  [2530, 2531, "NSM"],
+  [2546, 2547, "ET"],
+  [2555, 2555, "ET"],
+  [2558, 2558, "NSM"],
+  [2561, 2562, "NSM"],
+  [2620, 2620, "NSM"],
+  [2625, 2626, "NSM"],
+  [2631, 2632, "NSM"],
+  [2635, 2637, "NSM"],
+  [2641, 2641, "NSM"],
+  [2672, 2673, "NSM"],
+  [2677, 2677, "NSM"],
+  [2689, 2690, "NSM"],
+  [2748, 2748, "NSM"],
+  [2753, 2757, "NSM"],
+  [2759, 2760, "NSM"],
+  [2765, 2765, "NSM"],
+  [2786, 2787, "NSM"],
+  [2801, 2801, "ET"],
+  [2810, 2815, "NSM"],
+  [2817, 2817, "NSM"],
+  [2876, 2876, "NSM"],
+  [2879, 2879, "NSM"],
+  [2881, 2884, "NSM"],
+  [2893, 2893, "NSM"],
+  [2901, 2902, "NSM"],
+  [2914, 2915, "NSM"],
+  [2946, 2946, "NSM"],
+  [3008, 3008, "NSM"],
+  [3021, 3021, "NSM"],
+  [3059, 3064, "ON"],
+  [3065, 3065, "ET"],
+  [3066, 3066, "ON"],
+  [3072, 3072, "NSM"],
+  [3076, 3076, "NSM"],
+  [3132, 3132, "NSM"],
+  [3134, 3136, "NSM"],
+  [3142, 3144, "NSM"],
+  [3146, 3149, "NSM"],
+  [3157, 3158, "NSM"],
+  [3170, 3171, "NSM"],
+  [3192, 3198, "ON"],
+  [3201, 3201, "NSM"],
+  [3260, 3260, "NSM"],
+  [3276, 3277, "NSM"],
+  [3298, 3299, "NSM"],
+  [3328, 3329, "NSM"],
+  [3387, 3388, "NSM"],
+  [3393, 3396, "NSM"],
+  [3405, 3405, "NSM"],
+  [3426, 3427, "NSM"],
+  [3457, 3457, "NSM"],
+  [3530, 3530, "NSM"],
+  [3538, 3540, "NSM"],
+  [3542, 3542, "NSM"],
+  [3633, 3633, "NSM"],
+  [3636, 3642, "NSM"],
+  [3647, 3647, "ET"],
+  [3655, 3662, "NSM"],
+  [3761, 3761, "NSM"],
+  [3764, 3772, "NSM"],
+  [3784, 3790, "NSM"],
+  [3864, 3865, "NSM"],
+  [3893, 3893, "NSM"],
+  [3895, 3895, "NSM"],
+  [3897, 3897, "NSM"],
+  [3898, 3901, "ON"],
+  [3953, 3966, "NSM"],
+  [3968, 3972, "NSM"],
+  [3974, 3975, "NSM"],
+  [3981, 3991, "NSM"],
+  [3993, 4028, "NSM"],
+  [4038, 4038, "NSM"],
+  [4141, 4144, "NSM"],
+  [4146, 4151, "NSM"],
+  [4153, 4154, "NSM"],
+  [4157, 4158, "NSM"],
+  [4184, 4185, "NSM"],
+  [4190, 4192, "NSM"],
+  [4209, 4212, "NSM"],
+  [4226, 4226, "NSM"],
+  [4229, 4230, "NSM"],
+  [4237, 4237, "NSM"],
+  [4253, 4253, "NSM"],
+  [4957, 4959, "NSM"],
+  [5008, 5017, "ON"],
+  [5120, 5120, "ON"],
+  [5760, 5760, "WS"],
+  [5787, 5788, "ON"],
+  [5906, 5908, "NSM"],
+  [5938, 5939, "NSM"],
+  [5970, 5971, "NSM"],
+  [6002, 6003, "NSM"],
+  [6068, 6069, "NSM"],
+  [6071, 6077, "NSM"],
+  [6086, 6086, "NSM"],
+  [6089, 6099, "NSM"],
+  [6107, 6107, "ET"],
+  [6109, 6109, "NSM"],
+  [6128, 6137, "ON"],
+  [6144, 6154, "ON"],
+  [6155, 6157, "NSM"],
+  [6158, 6158, "BN"],
+  [6159, 6159, "NSM"],
+  [6277, 6278, "NSM"],
+  [6313, 6313, "NSM"],
+  [6432, 6434, "NSM"],
+  [6439, 6440, "NSM"],
+  [6450, 6450, "NSM"],
+  [6457, 6459, "NSM"],
+  [6464, 6464, "ON"],
+  [6468, 6469, "ON"],
+  [6622, 6655, "ON"],
+  [6679, 6680, "NSM"],
+  [6683, 6683, "NSM"],
+  [6742, 6742, "NSM"],
+  [6744, 6750, "NSM"],
+  [6752, 6752, "NSM"],
+  [6754, 6754, "NSM"],
+  [6757, 6764, "NSM"],
+  [6771, 6780, "NSM"],
+  [6783, 6783, "NSM"],
+  [6832, 6877, "NSM"],
+  [6880, 6891, "NSM"],
+  [6912, 6915, "NSM"],
+  [6964, 6964, "NSM"],
+  [6966, 6970, "NSM"],
+  [6972, 6972, "NSM"],
+  [6978, 6978, "NSM"],
+  [7019, 7027, "NSM"],
+  [7040, 7041, "NSM"],
+  [7074, 7077, "NSM"],
+  [7080, 7081, "NSM"],
+  [7083, 7085, "NSM"],
+  [7142, 7142, "NSM"],
+  [7144, 7145, "NSM"],
+  [7149, 7149, "NSM"],
+  [7151, 7153, "NSM"],
+  [7212, 7219, "NSM"],
+  [7222, 7223, "NSM"],
+  [7376, 7378, "NSM"],
+  [7380, 7392, "NSM"],
+  [7394, 7400, "NSM"],
+  [7405, 7405, "NSM"],
+  [7412, 7412, "NSM"],
+  [7416, 7417, "NSM"],
+  [7616, 7679, "NSM"],
+  [8125, 8125, "ON"],
+  [8127, 8129, "ON"],
+  [8141, 8143, "ON"],
+  [8157, 8159, "ON"],
+  [8173, 8175, "ON"],
+  [8189, 8190, "ON"],
+  [8192, 8202, "WS"],
+  [8203, 8205, "BN"],
+  [8207, 8207, "R"],
+  [8208, 8231, "ON"],
+  [8232, 8232, "WS"],
+  [8233, 8233, "B"],
+  [8234, 8238, "BN"],
+  [8239, 8239, "CS"],
+  [8240, 8244, "ET"],
+  [8245, 8259, "ON"],
+  [8260, 8260, "CS"],
+  [8261, 8286, "ON"],
+  [8287, 8287, "WS"],
+  [8288, 8303, "BN"],
+  [8304, 8304, "EN"],
+  [8308, 8313, "EN"],
+  [8314, 8315, "ES"],
+  [8316, 8318, "ON"],
+  [8320, 8329, "EN"],
+  [8330, 8331, "ES"],
+  [8332, 8334, "ON"],
+  [8352, 8399, "ET"],
+  [8400, 8432, "NSM"],
+  [8448, 8449, "ON"],
+  [8451, 8454, "ON"],
+  [8456, 8457, "ON"],
+  [8468, 8468, "ON"],
+  [8470, 8472, "ON"],
+  [8478, 8483, "ON"],
+  [8485, 8485, "ON"],
+  [8487, 8487, "ON"],
+  [8489, 8489, "ON"],
+  [8494, 8494, "ET"],
+  [8506, 8507, "ON"],
+  [8512, 8516, "ON"],
+  [8522, 8525, "ON"],
+  [8528, 8543, "ON"],
+  [8585, 8587, "ON"],
+  [8592, 8721, "ON"],
+  [8722, 8722, "ES"],
+  [8723, 8723, "ET"],
+  [8724, 9013, "ON"],
+  [9083, 9108, "ON"],
+  [9110, 9257, "ON"],
+  [9280, 9290, "ON"],
+  [9312, 9351, "ON"],
+  [9352, 9371, "EN"],
+  [9450, 9899, "ON"],
+  [9901, 10239, "ON"],
+  [10496, 11123, "ON"],
+  [11126, 11263, "ON"],
+  [11493, 11498, "ON"],
+  [11503, 11505, "NSM"],
+  [11513, 11519, "ON"],
+  [11647, 11647, "NSM"],
+  [11744, 11775, "NSM"],
+  [11776, 11869, "ON"],
+  [11904, 11929, "ON"],
+  [11931, 12019, "ON"],
+  [12032, 12245, "ON"],
+  [12272, 12287, "ON"],
+  [12288, 12288, "WS"],
+  [12289, 12292, "ON"],
+  [12296, 12320, "ON"],
+  [12330, 12333, "NSM"],
+  [12336, 12336, "ON"],
+  [12342, 12343, "ON"],
+  [12349, 12351, "ON"],
+  [12441, 12442, "NSM"],
+  [12443, 12444, "ON"],
+  [12448, 12448, "ON"],
+  [12539, 12539, "ON"],
+  [12736, 12773, "ON"],
+  [12783, 12783, "ON"],
+  [12829, 12830, "ON"],
+  [12880, 12895, "ON"],
+  [12924, 12926, "ON"],
+  [12977, 12991, "ON"],
+  [13004, 13007, "ON"],
+  [13175, 13178, "ON"],
+  [13278, 13279, "ON"],
+  [13311, 13311, "ON"],
+  [19904, 19967, "ON"],
+  [42128, 42182, "ON"],
+  [42509, 42511, "ON"],
+  [42607, 42610, "NSM"],
+  [42611, 42611, "ON"],
+  [42612, 42621, "NSM"],
+  [42622, 42623, "ON"],
+  [42654, 42655, "NSM"],
+  [42736, 42737, "NSM"],
+  [42752, 42785, "ON"],
+  [42888, 42888, "ON"],
+  [43010, 43010, "NSM"],
+  [43014, 43014, "NSM"],
+  [43019, 43019, "NSM"],
+  [43045, 43046, "NSM"],
+  [43048, 43051, "ON"],
+  [43052, 43052, "NSM"],
+  [43064, 43065, "ET"],
+  [43124, 43127, "ON"],
+  [43204, 43205, "NSM"],
+  [43232, 43249, "NSM"],
+  [43263, 43263, "NSM"],
+  [43302, 43309, "NSM"],
+  [43335, 43345, "NSM"],
+  [43392, 43394, "NSM"],
+  [43443, 43443, "NSM"],
+  [43446, 43449, "NSM"],
+  [43452, 43453, "NSM"],
+  [43493, 43493, "NSM"],
+  [43561, 43566, "NSM"],
+  [43569, 43570, "NSM"],
+  [43573, 43574, "NSM"],
+  [43587, 43587, "NSM"],
+  [43596, 43596, "NSM"],
+  [43644, 43644, "NSM"],
+  [43696, 43696, "NSM"],
+  [43698, 43700, "NSM"],
+  [43703, 43704, "NSM"],
+  [43710, 43711, "NSM"],
+  [43713, 43713, "NSM"],
+  [43756, 43757, "NSM"],
+  [43766, 43766, "NSM"],
+  [43882, 43883, "ON"],
+  [44005, 44005, "NSM"],
+  [44008, 44008, "NSM"],
+  [44013, 44013, "NSM"],
+  [64285, 64285, "R"],
+  [64286, 64286, "NSM"],
+  [64287, 64296, "R"],
+  [64297, 64297, "ES"],
+  [64298, 64335, "R"],
+  [64336, 64450, "AL"],
+  [64451, 64466, "ON"],
+  [64467, 64829, "AL"],
+  [64830, 64847, "ON"],
+  [64848, 64911, "AL"],
+  [64912, 64913, "ON"],
+  [64914, 64967, "AL"],
+  [64968, 64975, "ON"],
+  [64976, 65007, "BN"],
+  [65008, 65020, "AL"],
+  [65021, 65023, "ON"],
+  [65024, 65039, "NSM"],
+  [65040, 65049, "ON"],
+  [65056, 65071, "NSM"],
+  [65072, 65103, "ON"],
+  [65104, 65104, "CS"],
+  [65105, 65105, "ON"],
+  [65106, 65106, "CS"],
+  [65108, 65108, "ON"],
+  [65109, 65109, "CS"],
+  [65110, 65118, "ON"],
+  [65119, 65119, "ET"],
+  [65120, 65121, "ON"],
+  [65122, 65123, "ES"],
+  [65124, 65126, "ON"],
+  [65128, 65128, "ON"],
+  [65129, 65130, "ET"],
+  [65131, 65131, "ON"],
+  [65136, 65278, "AL"],
+  [65279, 65279, "BN"],
+  [65281, 65282, "ON"],
+  [65283, 65285, "ET"],
+  [65286, 65290, "ON"],
+  [65291, 65291, "ES"],
+  [65292, 65292, "CS"],
+  [65293, 65293, "ES"],
+  [65294, 65295, "CS"],
+  [65296, 65305, "EN"],
+  [65306, 65306, "CS"],
+  [65307, 65312, "ON"],
+  [65339, 65344, "ON"],
+  [65371, 65381, "ON"],
+  [65504, 65505, "ET"],
+  [65506, 65508, "ON"],
+  [65509, 65510, "ET"],
+  [65512, 65518, "ON"],
+  [65520, 65528, "BN"],
+  [65529, 65533, "ON"],
+  [65534, 65535, "BN"],
+  [65793, 65793, "ON"],
+  [65856, 65932, "ON"],
+  [65936, 65948, "ON"],
+  [65952, 65952, "ON"],
+  [66045, 66045, "NSM"],
+  [66272, 66272, "NSM"],
+  [66273, 66299, "EN"],
+  [66422, 66426, "NSM"],
+  [67584, 67870, "R"],
+  [67871, 67871, "ON"],
+  [67872, 68096, "R"],
+  [68097, 68099, "NSM"],
+  [68100, 68100, "R"],
+  [68101, 68102, "NSM"],
+  [68103, 68107, "R"],
+  [68108, 68111, "NSM"],
+  [68112, 68151, "R"],
+  [68152, 68154, "NSM"],
+  [68155, 68158, "R"],
+  [68159, 68159, "NSM"],
+  [68160, 68324, "R"],
+  [68325, 68326, "NSM"],
+  [68327, 68408, "R"],
+  [68409, 68415, "ON"],
+  [68416, 68863, "R"],
+  [68864, 68899, "AL"],
+  [68900, 68903, "NSM"],
+  [68904, 68911, "AL"],
+  [68912, 68921, "AN"],
+  [68922, 68927, "AL"],
+  [68928, 68937, "AN"],
+  [68938, 68968, "R"],
+  [68969, 68973, "NSM"],
+  [68974, 68974, "ON"],
+  [68975, 69215, "R"],
+  [69216, 69246, "AN"],
+  [69247, 69290, "R"],
+  [69291, 69292, "NSM"],
+  [69293, 69311, "R"],
+  [69312, 69327, "AL"],
+  [69328, 69336, "ON"],
+  [69337, 69369, "AL"],
+  [69370, 69375, "NSM"],
+  [69376, 69423, "R"],
+  [69424, 69445, "AL"],
+  [69446, 69456, "NSM"],
+  [69457, 69487, "AL"],
+  [69488, 69505, "R"],
+  [69506, 69509, "NSM"],
+  [69510, 69631, "R"],
+  [69633, 69633, "NSM"],
+  [69688, 69702, "NSM"],
+  [69714, 69733, "ON"],
+  [69744, 69744, "NSM"],
+  [69747, 69748, "NSM"],
+  [69759, 69761, "NSM"],
+  [69811, 69814, "NSM"],
+  [69817, 69818, "NSM"],
+  [69826, 69826, "NSM"],
+  [69888, 69890, "NSM"],
+  [69927, 69931, "NSM"],
+  [69933, 69940, "NSM"],
+  [70003, 70003, "NSM"],
+  [70016, 70017, "NSM"],
+  [70070, 70078, "NSM"],
+  [70089, 70092, "NSM"],
+  [70095, 70095, "NSM"],
+  [70191, 70193, "NSM"],
+  [70196, 70196, "NSM"],
+  [70198, 70199, "NSM"],
+  [70206, 70206, "NSM"],
+  [70209, 70209, "NSM"],
+  [70367, 70367, "NSM"],
+  [70371, 70378, "NSM"],
+  [70400, 70401, "NSM"],
+  [70459, 70460, "NSM"],
+  [70464, 70464, "NSM"],
+  [70502, 70508, "NSM"],
+  [70512, 70516, "NSM"],
+  [70587, 70592, "NSM"],
+  [70606, 70606, "NSM"],
+  [70608, 70608, "NSM"],
+  [70610, 70610, "NSM"],
+  [70625, 70626, "NSM"],
+  [70712, 70719, "NSM"],
+  [70722, 70724, "NSM"],
+  [70726, 70726, "NSM"],
+  [70750, 70750, "NSM"],
+  [70835, 70840, "NSM"],
+  [70842, 70842, "NSM"],
+  [70847, 70848, "NSM"],
+  [70850, 70851, "NSM"],
+  [71090, 71093, "NSM"],
+  [71100, 71101, "NSM"],
+  [71103, 71104, "NSM"],
+  [71132, 71133, "NSM"],
+  [71219, 71226, "NSM"],
+  [71229, 71229, "NSM"],
+  [71231, 71232, "NSM"],
+  [71264, 71276, "ON"],
+  [71339, 71339, "NSM"],
+  [71341, 71341, "NSM"],
+  [71344, 71349, "NSM"],
+  [71351, 71351, "NSM"],
+  [71453, 71453, "NSM"],
+  [71455, 71455, "NSM"],
+  [71458, 71461, "NSM"],
+  [71463, 71467, "NSM"],
+  [71727, 71735, "NSM"],
+  [71737, 71738, "NSM"],
+  [71995, 71996, "NSM"],
+  [71998, 71998, "NSM"],
+  [72003, 72003, "NSM"],
+  [72148, 72151, "NSM"],
+  [72154, 72155, "NSM"],
+  [72160, 72160, "NSM"],
+  [72193, 72198, "NSM"],
+  [72201, 72202, "NSM"],
+  [72243, 72248, "NSM"],
+  [72251, 72254, "NSM"],
+  [72263, 72263, "NSM"],
+  [72273, 72278, "NSM"],
+  [72281, 72283, "NSM"],
+  [72330, 72342, "NSM"],
+  [72344, 72345, "NSM"],
+  [72544, 72544, "NSM"],
+  [72546, 72548, "NSM"],
+  [72550, 72550, "NSM"],
+  [72752, 72758, "NSM"],
+  [72760, 72765, "NSM"],
+  [72850, 72871, "NSM"],
+  [72874, 72880, "NSM"],
+  [72882, 72883, "NSM"],
+  [72885, 72886, "NSM"],
+  [73009, 73014, "NSM"],
+  [73018, 73018, "NSM"],
+  [73020, 73021, "NSM"],
+  [73023, 73029, "NSM"],
+  [73031, 73031, "NSM"],
+  [73104, 73105, "NSM"],
+  [73109, 73109, "NSM"],
+  [73111, 73111, "NSM"],
+  [73459, 73460, "NSM"],
+  [73472, 73473, "NSM"],
+  [73526, 73530, "NSM"],
+  [73536, 73536, "NSM"],
+  [73538, 73538, "NSM"],
+  [73562, 73562, "NSM"],
+  [73685, 73692, "ON"],
+  [73693, 73696, "ET"],
+  [73697, 73713, "ON"],
+  [78912, 78912, "NSM"],
+  [78919, 78933, "NSM"],
+  [90398, 90409, "NSM"],
+  [90413, 90415, "NSM"],
+  [92912, 92916, "NSM"],
+  [92976, 92982, "NSM"],
+  [94031, 94031, "NSM"],
+  [94095, 94098, "NSM"],
+  [94178, 94178, "ON"],
+  [94180, 94180, "NSM"],
+  [113821, 113822, "NSM"],
+  [113824, 113827, "BN"],
+  [117760, 117973, "ON"],
+  [118e3, 118009, "EN"],
+  [118010, 118012, "ON"],
+  [118016, 118451, "ON"],
+  [118458, 118480, "ON"],
+  [118496, 118512, "ON"],
+  [118528, 118573, "NSM"],
+  [118576, 118598, "NSM"],
+  [119143, 119145, "NSM"],
+  [119155, 119162, "BN"],
+  [119163, 119170, "NSM"],
+  [119173, 119179, "NSM"],
+  [119210, 119213, "NSM"],
+  [119273, 119274, "ON"],
+  [119296, 119361, "ON"],
+  [119362, 119364, "NSM"],
+  [119365, 119365, "ON"],
+  [119552, 119638, "ON"],
+  [120513, 120513, "ON"],
+  [120539, 120539, "ON"],
+  [120571, 120571, "ON"],
+  [120597, 120597, "ON"],
+  [120629, 120629, "ON"],
+  [120655, 120655, "ON"],
+  [120687, 120687, "ON"],
+  [120713, 120713, "ON"],
+  [120745, 120745, "ON"],
+  [120771, 120771, "ON"],
+  [120782, 120831, "EN"],
+  [121344, 121398, "NSM"],
+  [121403, 121452, "NSM"],
+  [121461, 121461, "NSM"],
+  [121476, 121476, "NSM"],
+  [121499, 121503, "NSM"],
+  [121505, 121519, "NSM"],
+  [122880, 122886, "NSM"],
+  [122888, 122904, "NSM"],
+  [122907, 122913, "NSM"],
+  [122915, 122916, "NSM"],
+  [122918, 122922, "NSM"],
+  [123023, 123023, "NSM"],
+  [123184, 123190, "NSM"],
+  [123566, 123566, "NSM"],
+  [123628, 123631, "NSM"],
+  [123647, 123647, "ET"],
+  [124140, 124143, "NSM"],
+  [124398, 124399, "NSM"],
+  [124643, 124643, "NSM"],
+  [124646, 124646, "NSM"],
+  [124654, 124655, "NSM"],
+  [124661, 124661, "NSM"],
+  [124928, 125135, "R"],
+  [125136, 125142, "NSM"],
+  [125143, 125251, "R"],
+  [125252, 125258, "NSM"],
+  [125259, 126063, "R"],
+  [126064, 126143, "AL"],
+  [126144, 126207, "R"],
+  [126208, 126287, "AL"],
+  [126288, 126463, "R"],
+  [126464, 126703, "AL"],
+  [126704, 126705, "ON"],
+  [126706, 126719, "AL"],
+  [126720, 126975, "R"],
+  [126976, 127019, "ON"],
+  [127024, 127123, "ON"],
+  [127136, 127150, "ON"],
+  [127153, 127167, "ON"],
+  [127169, 127183, "ON"],
+  [127185, 127221, "ON"],
+  [127232, 127242, "EN"],
+  [127243, 127247, "ON"],
+  [127279, 127279, "ON"],
+  [127338, 127343, "ON"],
+  [127405, 127405, "ON"],
+  [127584, 127589, "ON"],
+  [127744, 128728, "ON"],
+  [128732, 128748, "ON"],
+  [128752, 128764, "ON"],
+  [128768, 128985, "ON"],
+  [128992, 129003, "ON"],
+  [129008, 129008, "ON"],
+  [129024, 129035, "ON"],
+  [129040, 129095, "ON"],
+  [129104, 129113, "ON"],
+  [129120, 129159, "ON"],
+  [129168, 129197, "ON"],
+  [129200, 129211, "ON"],
+  [129216, 129217, "ON"],
+  [129232, 129240, "ON"],
+  [129280, 129623, "ON"],
+  [129632, 129645, "ON"],
+  [129648, 129660, "ON"],
+  [129664, 129674, "ON"],
+  [129678, 129734, "ON"],
+  [129736, 129736, "ON"],
+  [129741, 129756, "ON"],
+  [129759, 129770, "ON"],
+  [129775, 129784, "ON"],
+  [129792, 129938, "ON"],
+  [129940, 130031, "ON"],
+  [130032, 130041, "EN"],
+  [130042, 130042, "ON"],
+  [131070, 131071, "BN"],
+  [196606, 196607, "BN"],
+  [262142, 262143, "BN"],
+  [327678, 327679, "BN"],
+  [393214, 393215, "BN"],
+  [458750, 458751, "BN"],
+  [524286, 524287, "BN"],
+  [589822, 589823, "BN"],
+  [655358, 655359, "BN"],
+  [720894, 720895, "BN"],
+  [786430, 786431, "BN"],
+  [851966, 851967, "BN"],
+  [917502, 917759, "BN"],
+  [917760, 917999, "NSM"],
+  [918e3, 921599, "BN"],
+  [983038, 983039, "BN"],
+  [1048574, 1048575, "BN"],
+  [1114110, 1114111, "BN"]
+];
+function On(e) {
+  if (e <= 255)
+    return bn[e];
+  let t = 0, n = Et.length - 1;
+  for (; t <= n; ) {
+    const r = t + n >> 1, i = Et[r];
+    if (e < i[0]) {
+      n = r - 1;
+      continue;
+    }
+    if (e > i[1]) {
+      t = r + 1;
+      continue;
+    }
+    return i[2];
+  }
+  return "L";
+}
+function yn(e) {
+  const t = e.length;
+  if (t === 0)
+    return null;
+  const n = new Array(t);
+  let r = !1;
+  for (let x = 0; x < t; ) {
+    const c = e.charCodeAt(x);
+    let f = c, u = 1;
+    if (c >= 55296 && c <= 56319 && x + 1 < t) {
+      const S = e.charCodeAt(x + 1);
+      S >= 56320 && S <= 57343 && (f = (c - 55296 << 10) + (S - 56320) + 65536, u = 2);
+    }
+    const g = On(f);
+    (g === "R" || g === "AL" || g === "AN") && (r = !0);
+    for (let S = 0; S < u; S++)
+      n[x + S] = g;
+    x += u;
+  }
+  if (!r)
+    return null;
+  let i = 0;
+  for (let x = 0; x < t; x++) {
+    const c = n[x];
+    if (c === "L") {
+      i = 0;
+      break;
+    }
+    if (c === "R" || c === "AL") {
+      i = 1;
+      break;
+    }
+  }
+  const s = new Int8Array(t);
+  for (let x = 0; x < t; x++)
+    s[x] = i;
+  const o = i & 1 ? "R" : "L", a = o;
+  let l = a;
+  for (let x = 0; x < t; x++)
+    n[x] === "NSM" ? n[x] = l : l = n[x];
+  l = a;
+  for (let x = 0; x < t; x++) {
+    const c = n[x];
+    c === "EN" ? n[x] = l === "AL" ? "AN" : "EN" : (c === "R" || c === "L" || c === "AL") && (l = c);
+  }
+  for (let x = 0; x < t; x++)
+    n[x] === "AL" && (n[x] = "R");
+  for (let x = 1; x < t - 1; x++)
+    n[x] === "ES" && n[x - 1] === "EN" && n[x + 1] === "EN" && (n[x] = "EN"), n[x] === "CS" && (n[x - 1] === "EN" || n[x - 1] === "AN") && n[x + 1] === n[x - 1] && (n[x] = n[x - 1]);
+  for (let x = 0; x < t; x++) {
+    if (n[x] !== "EN")
+      continue;
+    let c;
+    for (c = x - 1; c >= 0 && n[c] === "ET"; c--)
+      n[c] = "EN";
+    for (c = x + 1; c < t && n[c] === "ET"; c++)
+      n[c] = "EN";
+  }
+  for (let x = 0; x < t; x++) {
+    const c = n[x];
+    (c === "WS" || c === "ES" || c === "ET" || c === "CS") && (n[x] = "ON");
+  }
+  l = a;
+  for (let x = 0; x < t; x++) {
+    const c = n[x];
+    c === "EN" ? n[x] = l === "L" ? "L" : "EN" : (c === "R" || c === "L") && (l = c);
+  }
+  for (let x = 0; x < t; x++) {
+    if (n[x] !== "ON")
+      continue;
+    let c = x + 1;
+    for (; c < t && n[c] === "ON"; )
+      c++;
+    const f = x > 0 ? n[x - 1] : a, u = c < t ? n[c] : a, g = f !== "L" ? "R" : "L";
+    if (g === (u !== "L" ? "R" : "L"))
+      for (let E = x; E < c; E++)
+        n[E] = g;
+    x = c - 1;
+  }
+  for (let x = 0; x < t; x++)
+    n[x] === "ON" && (n[x] = o);
+  for (let x = 0; x < t; x++) {
+    const c = n[x];
+    (s[x] & 1) === 0 ? c === "R" ? s[x]++ : (c === "AN" || c === "EN") && (s[x] += 2) : (c === "L" || c === "AN" || c === "EN") && s[x]++;
+  }
+  return s;
+}
+function In(e, t) {
+  const n = yn(e);
+  if (n === null)
+    return null;
+  const r = new Int8Array(t.length);
+  for (let i = 0; i < t.length; i++)
+    r[i] = n[t[i]];
+  return r;
+}
+const Pn = /[ \t\n\r\f]+/g, wn = /[\t\n\r\f]| {2,}|^ | $/;
+function Wn(e) {
+  const t = e ?? "normal";
+  return t === "pre-wrap" ? { mode: t, preserveOrdinarySpaces: !0, preserveHardBreaks: !0 } : { mode: t, preserveOrdinarySpaces: !1, preserveHardBreaks: !1 };
+}
+function vn(e) {
+  if (!wn.test(e))
+    return e;
+  let t = e.replace(Pn, " ");
+  return t.charCodeAt(0) === 32 && (t = t.slice(1)), t.length > 0 && t.charCodeAt(t.length - 1) === 32 && (t = t.slice(0, -1)), t;
+}
+function Rn(e) {
+  return /[\r\f]/.test(e) ? e.replace(/\r\n/g, `
+`).replace(/[\r\f]/g, `
+`) : e;
+}
+let Ke = null, Tn;
+function Gn() {
+  return Ke === null && (Ke = new Intl.Segmenter(Tn, { granularity: "word" })), Ke;
+}
+const Hn = /\p{Script=Arabic}/u, Ne = /\p{M}/u, nt = /\p{Nd}/u;
+function Bt(e) {
+  return Hn.test(e);
+}
+function Mt(e) {
+  return e >= 19968 && e <= 40959 || e >= 13312 && e <= 19903 || e >= 131072 && e <= 173791 || e >= 173824 && e <= 177983 || e >= 177984 && e <= 178207 || e >= 178208 && e <= 183983 || e >= 183984 && e <= 191471 || e >= 191472 && e <= 192093 || e >= 194560 && e <= 195103 || e >= 196608 && e <= 201551 || e >= 201552 && e <= 205743 || e >= 205744 && e <= 210041 || e >= 63744 && e <= 64255 || e >= 12288 && e <= 12351 || e >= 12352 && e <= 12447 || e >= 12448 && e <= 12543 || e >= 12592 && e <= 12687 || e >= 44032 && e <= 55215 || e >= 65280 && e <= 65519;
+}
+function oe(e) {
+  for (let t = 0; t < e.length; t++) {
+    const n = e.charCodeAt(t);
+    if (!(n < 12288)) {
+      if (n >= 55296 && n <= 56319 && t + 1 < e.length) {
+        const r = e.charCodeAt(t + 1);
+        if (r >= 56320 && r <= 57343) {
+          const i = (n - 55296 << 10) + (r - 56320) + 65536;
+          if (Mt(i))
+            return !0;
+          t++;
+          continue;
+        }
+      }
+      if (Mt(n))
+        return !0;
+    }
+  }
+  return !1;
+}
+function _n(e) {
+  const t = De(e);
+  return t !== null && (st.has(t) || ge.has(t));
+}
+const zn = /* @__PURE__ */ new Set([
+  " ",
+  " ",
+  "⁠",
+  "\uFEFF"
+]), jn = /* @__PURE__ */ new Set([
+  "-",
+  "‐",
+  "–",
+  "—"
+]);
+function Kn(e) {
+  const t = De(e);
+  return t !== null && zn.has(t);
+}
+function Un(e) {
+  const t = De(e);
+  return t !== null && jn.has(t);
+}
+function Kt(e, t) {
+  return Kn(e) ? !1 : t ? !(_n(e) || Un(e)) : !0;
+}
+const st = /* @__PURE__ */ new Set([
+  "，",
+  "．",
+  "！",
+  "：",
+  "；",
+  "？",
+  "、",
+  "。",
+  "・",
+  "）",
+  "〕",
+  "〉",
+  "》",
+  "」",
+  "』",
+  "】",
+  "〗",
+  "〙",
+  "〛",
+  "ー",
+  "々",
+  "〻",
+  "ゝ",
+  "ゞ",
+  "ヽ",
+  "ヾ"
+]), Te = /* @__PURE__ */ new Set([
+  '"',
+  "(",
+  "[",
+  "{",
+  "¡",
+  "¿",
+  "“",
+  "‘",
+  "‚",
+  "„",
+  "«",
+  "‹",
+  "⸘",
+  "（",
+  "〔",
+  "〈",
+  "《",
+  "「",
+  "『",
+  "【",
+  "〖",
+  "〘",
+  "〚"
+]), it = /* @__PURE__ */ new Set([
+  "'",
+  "’"
+]), ge = /* @__PURE__ */ new Set([
+  ".",
+  ",",
+  "!",
+  "?",
+  ":",
+  ";",
+  "،",
+  "؛",
+  "؟",
+  "।",
+  "॥",
+  "၊",
+  "။",
+  "၌",
+  "၍",
+  "၏",
+  ")",
+  "]",
+  "}",
+  "%",
+  '"',
+  "”",
+  "’",
+  "»",
+  "›",
+  "…"
+]), Jn = /* @__PURE__ */ new Set([
+  ":",
+  ".",
+  "،",
+  "؛"
+]), Qn = /* @__PURE__ */ new Set([
+  "၏"
+]), $n = /* @__PURE__ */ new Set([
+  "”",
+  "’",
+  "»",
+  "›",
+  "」",
+  "』",
+  "】",
+  "》",
+  "〉",
+  "〕",
+  "）"
+]);
+function Yn(e) {
+  if (rt(e))
+    return !0;
+  let t = !1;
+  for (const n of e) {
+    if (ge.has(n) || He(n)) {
+      t = !0;
+      continue;
+    }
+    if (!(t && Ne.test(n)))
+      return !1;
+  }
+  return t;
+}
+function Xn(e) {
+  for (const t of e)
+    if (!st.has(t) && !ge.has(t))
+      return !1;
+  return e.length > 0;
+}
+function qn(e) {
+  if (rt(e))
+    return !0;
+  for (const t of e)
+    if (!Te.has(t) && !it.has(t) && !Ne.test(t) && !He(t))
+      return !1;
+  return e.length > 0;
+}
+function rt(e) {
+  let t = !1;
+  for (const n of e)
+    if (!(n === "\\" || Ne.test(n))) {
+      if (Te.has(n) || ge.has(n) || it.has(n)) {
+        t = !0;
+        continue;
+      }
+      return !1;
+    }
+  return t;
+}
+function Ge(e, t) {
+  const n = t - 1;
+  if (n <= 0)
+    return Math.max(n, 0);
+  const r = e.charCodeAt(n);
+  if (r < 56320 || r > 57343)
+    return n;
+  const i = n - 1;
+  if (i < 0)
+    return n;
+  const s = e.charCodeAt(i);
+  return s >= 55296 && s <= 56319 ? i : n;
+}
+function De(e) {
+  if (e.length === 0)
+    return null;
+  const t = Ge(e, e.length);
+  return e.slice(t);
+}
+function Vn(e) {
+  for (const t of e)
+    if (!Ne.test(t))
+      return t;
+  return null;
+}
+function Zn(e) {
+  for (let t = e.length; t > 0; ) {
+    const n = Ge(e, t), r = e.slice(n, t);
+    if (!Ne.test(r))
+      return r;
+    t = n;
+  }
+  return null;
+}
+const e0 = [
+  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 t0(e, t) {
+  for (let n = 0; n < t.length; n += 2)
+    if (e >= t[n] && e <= t[n + 1])
+      return !0;
+  return !1;
+}
+function He(e) {
+  const t = e.codePointAt(0);
+  return t !== void 0 && t0(t, e0);
+}
+function n0(e) {
+  const t = Zn(e);
+  return t !== null && He(t);
+}
+function s0(e) {
+  const t = Vn(e);
+  return t !== null && nt.test(t);
+}
+function i0(e) {
+  const t = Array.from(e);
+  let n = t.length;
+  for (; n > 0; ) {
+    const r = t[n - 1];
+    if (Ne.test(r)) {
+      n--;
+      continue;
+    }
+    if (Te.has(r) || it.has(r)) {
+      n--;
+      continue;
+    }
+    break;
+  }
+  return n <= 0 || n === t.length ? null : {
+    head: t.slice(0, n).join(""),
+    tail: t.slice(n).join("")
+  };
+}
+function r0(e, t, n) {
+  return n === "text" && !t && e.length === 1 && e !== "-" && e !== "—" ? e : null;
+}
+function Ct(e, t, n, r) {
+  const i = t[r], s = e[r];
+  if (i == null)
+    return s;
+  const o = n[r];
+  if (s.length === o)
+    return s;
+  const a = i.repeat(o);
+  return e[r] = a, a;
+}
+function kt(e, t) {
+  return e && t !== null && Jn.has(t);
+}
+function x0(e) {
+  const t = De(e);
+  return t !== null && Qn.has(t);
+}
+function o0(e) {
+  if (e.length < 2 || e[0] !== " ")
+    return null;
+  const t = e.slice(1);
+  return /^\p{M}+$/u.test(t) ? { space: " ", marks: t } : null;
+}
+function Xe(e) {
+  let t = e.length;
+  for (; t > 0; ) {
+    const n = Ge(e, t), r = e.slice(n, t);
+    if ($n.has(r))
+      return !0;
+    if (!ge.has(r))
+      return !1;
+    t = n;
+  }
+  return !1;
+}
+function l0(e, t) {
+  if (t.preserveOrdinarySpaces || t.preserveHardBreaks) {
+    if (e === " ")
+      return "preserved-space";
+    if (e === "	")
+      return "tab";
+    if (t.preserveHardBreaks && e === `
+`)
+      return "hard-break";
+  }
+  return e === " " ? "space" : e === " " || e === " " || e === "⁠" || e === "\uFEFF" ? "glue" : e === "​" ? "zero-width-break" : e === "­" ? "soft-hyphen" : "text";
+}
+const c0 = /[\x20\t\n\xA0\xAD\u200B\u202F\u2060\uFEFF]/;
+function re(e) {
+  return e.length === 1 ? e[0] : e.join("");
+}
+function a0(e, t) {
+  const n = [];
+  for (let r = e.length - 1; r >= 0; r--)
+    n.push(e[r]);
+  return n.push(t), re(n);
+}
+function f0(e, t, n, r) {
+  if (!c0.test(e))
+    return [{ text: e, isWordLike: t, kind: "text", start: n }];
+  const i = [];
+  let s = null, o = [], a = n, l = !1, x = 0;
+  for (const c of e) {
+    const f = l0(c, r), u = f === "text" && t;
+    if (s !== null && f === s && u === l) {
+      o.push(c), x += c.length;
+      continue;
+    }
+    s !== null && i.push({
+      text: re(o),
+      isWordLike: l,
+      kind: s,
+      start: a
+    }), s = f, o = [c], a = n + x, l = u, x += c.length;
+  }
+  return s !== null && i.push({
+    text: re(o),
+    isWordLike: l,
+    kind: s,
+    start: a
+  }), i;
+}
+function qe(e) {
+  return e === "space" || e === "preserved-space" || e === "zero-width-break" || e === "hard-break";
+}
+const u0 = /^[A-Za-z][A-Za-z0-9+.-]*:$/;
+function h0(e, t) {
+  const n = e.texts[t];
+  return n.startsWith("www.") ? !0 : u0.test(n) && t + 1 < e.len && e.kinds[t + 1] === "text" && e.texts[t + 1] === "//";
+}
+function d0(e) {
+  return e.includes("?") && (e.includes("://") || e.startsWith("www."));
+}
+function F0(e) {
+  const t = e.texts.slice(), n = e.isWordLike.slice(), r = e.kinds.slice(), i = e.starts.slice();
+  for (let o = 0; o < e.len; o++) {
+    if (r[o] !== "text" || !h0(e, o))
+      continue;
+    const a = [t[o]];
+    let l = o + 1;
+    for (; l < e.len && !qe(r[l]); ) {
+      a.push(t[l]), n[o] = !0;
+      const x = t[l].includes("?");
+      if (r[l] = "text", t[l] = "", l++, x)
+        break;
+    }
+    t[o] = re(a);
+  }
+  let s = 0;
+  for (let o = 0; o < t.length; o++) {
+    const a = t[o];
+    a.length !== 0 && (s !== o && (t[s] = a, n[s] = n[o], r[s] = r[o], i[s] = i[o]), s++);
+  }
+  return t.length = s, n.length = s, r.length = s, i.length = s, {
+    len: s,
+    texts: t,
+    isWordLike: n,
+    kinds: r,
+    starts: i
+  };
+}
+function g0(e) {
+  const t = [], n = [], r = [], i = [];
+  for (let s = 0; s < e.len; s++) {
+    const o = e.texts[s];
+    if (t.push(o), n.push(e.isWordLike[s]), r.push(e.kinds[s]), i.push(e.starts[s]), !d0(o))
+      continue;
+    const a = s + 1;
+    if (a >= e.len || qe(e.kinds[a]))
+      continue;
+    const l = [], x = e.starts[a];
+    let c = a;
+    for (; c < e.len && !qe(e.kinds[c]); )
+      l.push(e.texts[c]), c++;
+    l.length > 0 && (t.push(re(l)), n.push(!0), r.push("text"), i.push(x), s = c - 1);
+  }
+  return {
+    len: t.length,
+    texts: t,
+    isWordLike: n,
+    kinds: r,
+    starts: i
+  };
+}
+const N0 = /* @__PURE__ */ new Set([
+  ":",
+  "-",
+  "/",
+  "×",
+  ",",
+  ".",
+  "+",
+  "–",
+  "—"
+]), p0 = /* @__PURE__ */ new Set([".", ",", ":", ";"]);
+function Dt(e) {
+  for (let t = e.length; t > 0; ) {
+    const n = Ge(e, t), r = e.slice(n, t);
+    if (Ne.test(r)) {
+      t = n;
+      continue;
+    }
+    return p0.has(r) || He(r);
+  }
+  return !1;
+}
+function S0(e, t) {
+  return t && !oe(e);
+}
+function Ut(e) {
+  for (const t of e)
+    if (nt.test(t))
+      return !0;
+  return !1;
+}
+function We(e) {
+  if (e.length === 0)
+    return !1;
+  for (const t of e)
+    if (!(nt.test(t) || N0.has(t)))
+      return !1;
+  return !0;
+}
+function m0(e) {
+  const t = [], n = [], r = [], i = [];
+  for (let s = 0; s < e.len; s++) {
+    const o = e.texts[s], a = e.kinds[s];
+    if (a === "text" && We(o) && Ut(o)) {
+      const l = [o];
+      let x = s + 1;
+      for (; x < e.len && e.kinds[x] === "text" && We(e.texts[x]); )
+        l.push(e.texts[x]), x++;
+      t.push(re(l)), n.push(!0), r.push("text"), i.push(e.starts[s]), s = x - 1;
+      continue;
+    }
+    t.push(o), n.push(e.isWordLike[s]), r.push(a), i.push(e.starts[s]);
+  }
+  return {
+    len: t.length,
+    texts: t,
+    isWordLike: n,
+    kinds: r,
+    starts: i
+  };
+}
+function A0(e) {
+  const t = [], n = [], r = [], i = [];
+  for (let s = 0; s < e.len; s++) {
+    const o = e.texts[s], a = e.kinds[s], l = e.isWordLike[s];
+    if (a === "text" && Dt(o) && (l || n0(o)) && !oe(o)) {
+      const x = [o];
+      let c = !0, f = s + 1;
+      for (; c && f < e.len && e.kinds[f] === "text" && S0(e.texts[f], e.isWordLike[f]); ) {
+        const u = e.texts[f];
+        x.push(u), c = Dt(u), f++;
+      }
+      t.push(re(x)), n.push(!0), r.push("text"), i.push(e.starts[s]), s = f - 1;
+      continue;
+    }
+    t.push(o), n.push(l), r.push(a), i.push(e.starts[s]);
+  }
+  return {
+    len: t.length,
+    texts: t,
+    isWordLike: n,
+    kinds: r,
+    starts: i
+  };
+}
+function E0(e) {
+  const t = [], n = [], r = [], i = [];
+  for (let s = 0; s < e.len; s++) {
+    const o = e.texts[s];
+    if (e.kinds[s] === "text" && o.includes("-")) {
+      const a = o.split("-");
+      let l = a.length > 1;
+      for (let x = 0; x < a.length; x++) {
+        const c = a[x];
+        if (!l)
+          break;
+        (c.length === 0 || !Ut(c) || !We(c)) && (l = !1);
+      }
+      if (l) {
+        let x = 0;
+        for (let c = 0; c < a.length; c++) {
+          const f = a[c], u = c < a.length - 1 ? `${f}-` : f;
+          t.push(u), n.push(!0), r.push("text"), i.push(e.starts[s] + x), x += u.length;
+        }
+        continue;
+      }
+    }
+    t.push(o), n.push(e.isWordLike[s]), r.push(e.kinds[s]), i.push(e.starts[s]);
+  }
+  return {
+    len: t.length,
+    texts: t,
+    isWordLike: n,
+    kinds: r,
+    starts: i
+  };
+}
+function B0(e) {
+  const t = [], n = [], r = [], i = [];
+  let s = 0;
+  for (; s < e.len; ) {
+    const o = [e.texts[s]];
+    let a = e.isWordLike[s], l = e.kinds[s], x = e.starts[s];
+    if (l === "glue") {
+      const c = [o[0]], f = x;
+      for (s++; s < e.len && e.kinds[s] === "glue"; )
+        c.push(e.texts[s]), s++;
+      const u = re(c);
+      if (s < e.len && e.kinds[s] === "text")
+        o[0] = u, o.push(e.texts[s]), a = e.isWordLike[s], l = "text", x = f, s++;
+      else {
+        t.push(u), n.push(!1), r.push("glue"), i.push(f);
+        continue;
+      }
+    } else
+      s++;
+    if (l === "text")
+      for (; s < e.len && e.kinds[s] === "glue"; ) {
+        const c = [];
+        for (; s < e.len && e.kinds[s] === "glue"; )
+          c.push(e.texts[s]), s++;
+        const f = re(c);
+        if (s < e.len && e.kinds[s] === "text") {
+          o.push(f, e.texts[s]), a = a || e.isWordLike[s], s++;
+          continue;
+        }
+        o.push(f);
+      }
+    t.push(re(o)), n.push(a), r.push(l), i.push(x);
+  }
+  return {
+    len: t.length,
+    texts: t,
+    isWordLike: n,
+    kinds: r,
+    starts: i
+  };
+}
+function M0(e) {
+  const t = e.texts.slice(), n = e.isWordLike.slice(), r = e.kinds.slice(), i = e.starts.slice();
+  for (let s = 0; s < t.length - 1; s++) {
+    if (r[s] !== "text" || r[s + 1] !== "text" || !oe(t[s]) || !oe(t[s + 1]))
+      continue;
+    const o = i0(t[s]);
+    o !== null && (t[s] = o.head, t[s + 1] = o.tail + t[s + 1], i[s + 1] = i[s] + o.head.length);
+  }
+  return {
+    len: t.length,
+    texts: t,
+    isWordLike: n,
+    kinds: r,
+    starts: i
+  };
+}
+function C0(e, t, n) {
+  const r = Gn();
+  let i = 0;
+  const s = [], o = [], a = [], l = [], x = [], c = [], f = [], u = [], g = [], S = [], E = [], m = [];
+  for (const N of r.segment(e))
+    for (const b of f0(N.segment, N.isWordLike ?? !1, N.index, n)) {
+      let I = function() {
+        c[A] !== null && (o[A] = [
+          Ct(s, c, f, A)
+        ], c[A] = null), o[A].push(b.text), a[A] = a[A] || b.isWordLike, u[A] = u[A] || W, g[A] = g[A] || v, S[A] = z, E[A] = D, m[A] = kt(g[A], _);
+      };
+      const M = b.kind === "text", G = r0(b.text, b.isWordLike, b.kind), W = oe(b.text), v = Bt(b.text), _ = De(b.text), z = Xe(b.text), D = x0(b.text), A = i - 1;
+      t.carryCJKAfterClosingQuote && M && i > 0 && l[A] === "text" && W && u[A] && S[A] || M && i > 0 && l[A] === "text" && Xn(b.text) && u[A] || M && i > 0 && l[A] === "text" && E[A] ? I() : M && i > 0 && l[A] === "text" && b.isWordLike && v && m[A] ? (I(), a[A] = !0) : G !== null && i > 0 && l[A] === "text" && c[A] === G ? f[A] = (f[A] ?? 1) + 1 : M && !b.isWordLike && i > 0 && l[A] === "text" && !u[A] && (Yn(b.text) || b.text === "-" && a[A]) ? I() : (s[i] = b.text, o[i] = [b.text], a[i] = b.isWordLike, l[i] = b.kind, x[i] = b.start, c[i] = G, f[i] = G === null ? 0 : 1, u[i] = W, g[i] = v, S[i] = z, E[i] = D, m[i] = kt(v, _), i++);
+    }
+  for (let N = 0; N < i; N++) {
+    if (c[N] !== null) {
+      s[N] = Ct(s, c, f, N);
+      continue;
+    }
+    s[N] = re(o[N]);
+  }
+  for (let N = 1; N < i; N++)
+    l[N] === "text" && !a[N] && rt(s[N]) && l[N - 1] === "text" && !u[N - 1] && (s[N - 1] += s[N], a[N - 1] = a[N - 1] || a[N], s[N] = "");
+  const k = Array.from({ length: i }, () => null);
+  let T = -1;
+  for (let N = i - 1; N >= 0; N--) {
+    const b = s[N];
+    if (b.length !== 0) {
+      if (l[N] === "text" && !a[N] && T >= 0 && l[T] === "text" && (qn(b) || b === "-" && s0(s[T]))) {
+        const M = k[T] ?? [];
+        M.push(b), k[T] = M, x[T] = x[N], s[N] = "";
+        continue;
+      }
+      T = N;
+    }
+  }
+  for (let N = 0; N < i; N++) {
+    const b = k[N];
+    b != null && (s[N] = a0(b, s[N]));
+  }
+  let O = 0;
+  for (let N = 0; N < i; N++) {
+    const b = s[N];
+    b.length !== 0 && (O !== N && (s[O] = b, a[O] = a[N], l[O] = l[N], x[O] = x[N]), O++);
+  }
+  s.length = O, a.length = O, l.length = O, x.length = O;
+  const w = B0({
+    len: O,
+    texts: s,
+    isWordLike: a,
+    kinds: l,
+    starts: x
+  }), R = M0(A0(E0(m0(g0(F0(w))))));
+  for (let N = 0; N < R.len - 1; N++) {
+    const b = o0(R.texts[N]);
+    b !== null && (R.kinds[N] !== "space" && R.kinds[N] !== "preserved-space" || R.kinds[N + 1] !== "text" || !Bt(R.texts[N + 1]) || (R.texts[N] = b.space, R.isWordLike[N] = !1, R.kinds[N] = R.kinds[N] === "preserved-space" ? "preserved-space" : "space", R.texts[N + 1] = b.marks + R.texts[N + 1], R.starts[N + 1] = R.starts[N] + b.space.length));
+  }
+  return R;
+}
+function k0(e, t) {
+  if (e.len === 0)
+    return [];
+  if (!t.preserveHardBreaks)
+    return [{
+      startSegmentIndex: 0,
+      endSegmentIndex: e.len,
+      consumedEndSegmentIndex: e.len
+    }];
+  const n = [];
+  let r = 0;
+  for (let i = 0; i < e.len; i++)
+    e.kinds[i] === "hard-break" && (n.push({
+      startSegmentIndex: r,
+      endSegmentIndex: i,
+      consumedEndSegmentIndex: i + 1
+    }), r = i + 1);
+  return r < e.len && n.push({
+    startSegmentIndex: r,
+    endSegmentIndex: e.len,
+    consumedEndSegmentIndex: e.len
+  }), n;
+}
+function D0(e, t, n) {
+  if (t.len <= 1)
+    return t;
+  const r = [], i = [], s = [], o = [];
+  let a = -1, l = !1;
+  function x(u) {
+    r.push(t.texts[u]), i.push(t.isWordLike[u]), s.push("text"), o.push(t.starts[u]);
+  }
+  function c(u, g) {
+    let S = !1;
+    for (let k = u; k < g; k++)
+      S = S || t.isWordLike[k];
+    const E = t.starts[u], m = g < t.len ? t.starts[g] : e.length;
+    r.push(e.slice(E, m)), i.push(S), s.push("text"), o.push(E);
+  }
+  function f(u) {
+    if (!(a < 0)) {
+      if (l)
+        a + 1 === u ? x(a) : c(a, u);
+      else
+        for (let g = a; g < u; g++)
+          x(g);
+      a = -1, l = !1;
+    }
+  }
+  for (let u = 0; u < t.len; u++) {
+    const g = t.texts[u], S = t.kinds[u];
+    if (S === "text") {
+      a >= 0 && !Kt(t.texts[u - 1], n) && f(u), a < 0 && (a = u), l = l || oe(g);
+      continue;
+    }
+    f(u), r.push(g), i.push(t.isWordLike[u]), s.push(S), o.push(t.starts[u]);
+  }
+  return f(t.len), {
+    len: r.length,
+    texts: r,
+    isWordLike: i,
+    kinds: s,
+    starts: o
+  };
+}
+function L0(e, t, n = "normal", r = "normal") {
+  const i = Wn(n), s = i.mode === "pre-wrap" ? Rn(e) : vn(e);
+  if (s.length === 0)
+    return {
+      normalized: s,
+      chunks: [],
+      len: 0,
+      texts: [],
+      isWordLike: [],
+      kinds: [],
+      starts: []
+    };
+  const o = C0(s, t, i), a = r === "keep-all" ? D0(s, o, t.breakKeepAllAfterPunctuation) : o;
+  return {
+    normalized: s,
+    chunks: k0(a, i),
+    ...a
+  };
+}
+let Ae = null;
+const Lt = /* @__PURE__ */ new Map();
+let Ee = null;
+const b0 = 96, O0 = /\p{Emoji_Presentation}/u, y0 = /[\p{Emoji_Presentation}\p{Extended_Pictographic}\p{Regional_Indicator}\uFE0F\u20E3]/u;
+let Ue = null;
+const bt = /* @__PURE__ */ new Map();
+function xt() {
+  if (Ae !== null)
+    return Ae;
+  if (typeof OffscreenCanvas < "u")
+    return Ae = new OffscreenCanvas(1, 1).getContext("2d"), Ae;
+  if (typeof document < "u")
+    return Ae = document.createElement("canvas").getContext("2d"), Ae;
+  throw new Error("Text measurement requires OffscreenCanvas or a DOM canvas context.");
+}
+function I0(e) {
+  let t = Lt.get(e);
+  return t || (t = /* @__PURE__ */ new Map(), Lt.set(e, t)), t;
+}
+function ue(e, t) {
+  let n = t.get(e);
+  return n === void 0 && (n = {
+    width: xt().measureText(e).width,
+    containsCJK: oe(e)
+  }, t.set(e, n)), n;
+}
+function Be() {
+  if (Ee !== null)
+    return Ee;
+  if (typeof navigator > "u")
+    return Ee = {
+      lineFitEpsilon: 5e-3,
+      carryCJKAfterClosingQuote: !1,
+      breakKeepAllAfterPunctuation: !0,
+      preferPrefixWidthsForBreakableRuns: !1,
+      preferEarlySoftHyphenBreak: !1
+    }, Ee;
+  const e = navigator.userAgent, n = navigator.vendor === "Apple Computer, Inc." && e.includes("Safari/") && !e.includes("Chrome/") && !e.includes("Chromium/") && !e.includes("CriOS/") && !e.includes("FxiOS/") && !e.includes("EdgiOS/"), r = e.includes("Chrome/") || e.includes("Chromium/") || e.includes("CriOS/") || e.includes("Edg/");
+  return Ee = {
+    lineFitEpsilon: n ? 1 / 64 : 5e-3,
+    carryCJKAfterClosingQuote: r,
+    breakKeepAllAfterPunctuation: !n,
+    preferPrefixWidthsForBreakableRuns: n,
+    preferEarlySoftHyphenBreak: n
+  }, Ee;
+}
+function P0(e) {
+  const t = e.match(/(\d+(?:\.\d+)?)\s*px/);
+  return t ? parseFloat(t[1]) : 16;
+}
+function Jt() {
+  return Ue === null && (Ue = new Intl.Segmenter(void 0, { granularity: "grapheme" })), Ue;
+}
+function w0(e) {
+  return O0.test(e) || e.includes("️");
+}
+function W0(e) {
+  return y0.test(e);
+}
+function v0(e, t) {
+  let n = bt.get(e);
+  if (n !== void 0)
+    return n;
+  const r = xt();
+  r.font = e;
+  const i = r.measureText("😀").width;
+  if (n = 0, i > t + 0.5 && typeof document < "u" && document.body !== null) {
+    const s = document.createElement("span");
+    s.style.font = e, s.style.display = "inline-block", s.style.visibility = "hidden", s.style.position = "absolute", s.textContent = "😀", document.body.appendChild(s);
+    const o = s.getBoundingClientRect().width;
+    document.body.removeChild(s), i - o > 0.5 && (n = i - o);
+  }
+  return bt.set(e, n), n;
+}
+function R0(e) {
+  let t = 0;
+  const n = Jt();
+  for (const r of n.segment(e))
+    w0(r.segment) && t++;
+  return t;
+}
+function T0(e, t) {
+  return t.emojiCount === void 0 && (t.emojiCount = R0(e)), t.emojiCount;
+}
+function Fe(e, t, n) {
+  return n === 0 ? t.width : t.width - T0(e, t) * n;
+}
+function G0(e, t, n, r, i) {
+  if (t.breakableFitAdvances !== void 0 && t.breakableFitMode === i)
+    return t.breakableFitAdvances;
+  t.breakableFitMode = i;
+  const s = Jt(), o = [];
+  for (const c of s.segment(e))
+    o.push(c.segment);
+  if (o.length <= 1)
+    return t.breakableFitAdvances = null, t.breakableFitAdvances;
+  if (i === "sum-graphemes") {
+    const c = [];
+    for (const f of o) {
+      const u = ue(f, n);
+      c.push(Fe(f, u, r));
+    }
+    return t.breakableFitAdvances = c, t.breakableFitAdvances;
+  }
+  if (i === "pair-context" || o.length > b0) {
+    const c = [];
+    let f = null, u = 0;
+    for (const g of o) {
+      const S = ue(g, n), E = Fe(g, S, r);
+      if (f === null)
+        c.push(E);
+      else {
+        const m = f + g, k = ue(m, n);
+        c.push(Fe(m, k, r) - u);
+      }
+      f = g, u = E;
+    }
+    return t.breakableFitAdvances = c, t.breakableFitAdvances;
+  }
+  const a = [];
+  let l = "", x = 0;
+  for (const c of o) {
+    l += c;
+    const f = ue(l, n), u = Fe(l, f, r);
+    a.push(u - x), x = u;
+  }
+  return t.breakableFitAdvances = a, t.breakableFitAdvances;
+}
+function H0(e, t) {
+  const n = xt();
+  n.font = e;
+  const r = I0(e), i = P0(e), s = t ? v0(e, i) : 0;
+  return { cache: r, fontSize: i, emojiCorrection: s };
+}
+function _0(e) {
+  return e === "space" || e === "zero-width-break" || e === "soft-hyphen";
+}
+function _e(e) {
+  return e === "space" || e === "preserved-space" || e === "tab" || e === "zero-width-break" || e === "soft-hyphen";
+}
+function ot(e, t, n = e.widths.length) {
+  for (; t < n; ) {
+    const r = e.kinds[t];
+    if (!_0(r))
+      break;
+    t++;
+  }
+  return t;
+}
+function Qt(e, t) {
+  if (t <= 0)
+    return 0;
+  const n = e % t;
+  return Math.abs(n) <= 1e-6 ? t : t - n;
+}
+function $t(e, t, n) {
+  return e.letterSpacing !== 0 && t && e.spacingGraphemeCounts[n] > 0 ? e.letterSpacing : 0;
+}
+function lt(e, t) {
+  return t === 0 ? 0 : e + t;
+}
+function z0(e, t) {
+  return e.letterSpacing !== 0 && e.spacingGraphemeCounts[t] > 0 ? e.letterSpacing : 0;
+}
+function Yt(e, t, n, r, i) {
+  const s = t === "tab" ? i + z0(e, n) : e.lineEndFitAdvances[n];
+  return lt(r, s);
+}
+function ve(e, t, n, r) {
+  const i = t === "tab" ? 0 : e.lineEndFitAdvances[n];
+  return lt(r, i);
+}
+function Re(e, t, n, r, i) {
+  const s = t === "tab" ? i : e.lineEndPaintAdvances[n];
+  return lt(r, s);
+}
+function Xt(e, t, n) {
+  return e.letterSpacing !== 0 && t ? n + e.letterSpacing : n;
+}
+function qt(e, t) {
+  return e.letterSpacing === 0 ? t : t + e.letterSpacing;
+}
+function j0(e, t, n, r, i) {
+  if (e.letterSpacing === 0)
+    return 0;
+  if (i > 0)
+    return e.spacingGraphemeCounts[r] > 0 ? e.letterSpacing : 0;
+  for (let s = r - 1; s >= t; s--) {
+    const o = e.kinds[s];
+    if (!(o === "space" || o === "zero-width-break" || o === "hard-break")) {
+      if (o === "soft-hyphen") {
+        if (s === r - 1)
+          return 0;
+        continue;
+      }
+      return s === t && n > 0 || e.spacingGraphemeCounts[s] > 0 ? e.letterSpacing : 0;
+    }
+  }
+  return 0;
+}
+function Vt(e, t, n, r, i, s) {
+  return t + j0(e, n, r, i, s);
+}
+function K0(e, t) {
+  let n = 0, r = e.chunks.length;
+  for (; n < r; ) {
+    const i = Math.floor((n + r) / 2);
+    t < e.chunks[i].consumedEndSegmentIndex ? r = i : n = i + 1;
+  }
+  return n < e.chunks.length ? n : -1;
+}
+function U0(e, t, n) {
+  let r = n.segmentIndex;
+  if (n.graphemeIndex > 0)
+    return t;
+  const i = e.chunks[t];
+  return i.startSegmentIndex === i.endSegmentIndex && r === i.startSegmentIndex || (r < i.startSegmentIndex && (r = i.startSegmentIndex), r = ot(e, r, i.endSegmentIndex), r < i.endSegmentIndex) ? (n.segmentIndex = r, n.graphemeIndex = 0, t) : i.consumedEndSegmentIndex >= e.widths.length ? -1 : (n.segmentIndex = i.consumedEndSegmentIndex, n.graphemeIndex = 0, t + 1);
+}
+function J0(e, t) {
+  if (t.segmentIndex >= e.widths.length)
+    return -1;
+  const n = K0(e, t.segmentIndex);
+  return n < 0 ? -1 : U0(e, n, t);
+}
+function Q0(e, t, n) {
+  const { widths: r, kinds: i, breakableFitAdvances: s } = e;
+  if (r.length === 0)
+    return 0;
+  const a = Be().lineFitEpsilon, l = t + a;
+  let x = 0, c = 0, f = !1, u = 0, g = 0, S = 0, E = 0, m = -1, k = 0;
+  function T() {
+    m = -1, k = 0;
+  }
+  function O(G = S, W = E, v = c) {
+    x++, n?.(v, u, g, G, W), c = 0, f = !1, T();
+  }
+  function w(G, W) {
+    f = !0, u = G, g = 0, S = G + 1, E = 0, c = W;
+  }
+  function R(G, W, v) {
+    f = !0, u = G, g = W, S = G, E = W + 1, c = v;
+  }
+  function N(G, W) {
+    if (!f) {
+      w(G, W);
+      return;
+    }
+    c += W, S = G + 1, E = 0;
+  }
+  function b(G, W) {
+    const v = s[G];
+    for (let _ = W; _ < v.length; _++) {
+      const z = v[_];
+      f ? c + z > l ? (O(), R(G, _, z)) : (c += z, S = G, E = _ + 1) : R(G, _, z);
+    }
+    f && S === G && E === v.length && (S = G + 1, E = 0);
+  }
+  let M = 0;
+  for (; M < r.length && !(!f && (M = ot(e, M), M >= r.length)); ) {
+    const G = r[M], W = i[M], v = _e(W);
+    if (!f) {
+      G > l && s[M] !== null ? b(M, 0) : w(M, G), v && (m = M + 1, k = c - G), M++;
+      continue;
+    }
+    if (c + G > l) {
+      if (v) {
+        N(M, G), O(M + 1, 0, c - G), M++;
+        continue;
+      }
+      if (m >= 0) {
+        if (S > m || S === m && E > 0) {
+          O();
+          continue;
+        }
+        O(m, 0, k);
+        continue;
+      }
+      if (G > l && s[M] !== null) {
+        O(), b(M, 0), M++;
+        continue;
+      }
+      O();
+      continue;
+    }
+    N(M, G), v && (m = M + 1, k = c - G), M++;
+  }
+  return f && O(), x;
+}
+function $0(e, t, n) {
+  if (e.simpleLineWalkFastPath)
+    return Q0(e, t, n);
+  const { widths: r, kinds: i, breakableFitAdvances: s, discretionaryHyphenWidth: o, chunks: a } = e;
+  if (r.length === 0 || a.length === 0)
+    return 0;
+  const l = Be(), x = l.lineFitEpsilon, c = t + x;
+  let f = 0, u = 0, g = !1, S = 0, E = 0, m = 0, k = 0, T = -1, O = 0, w = 0, R = null;
+  function N() {
+    T = -1, O = 0, w = 0, R = null;
+  }
+  function b() {
+    return R === "soft-hyphen" && T === m && k === 0 ? w : u;
+  }
+  function M(A = m, I = k, L) {
+    f++, n !== void 0 && n(Vt(e, L ?? b(), S, E, A, I), S, E, A, I), u = 0, g = !1, N();
+  }
+  function G(A, I) {
+    g = !0, S = A, E = 0, m = A + 1, k = 0, u = I;
+  }
+  function W(A, I, L) {
+    g = !0, S = A, E = I, m = A, k = I + 1, u = L;
+  }
+  function v(A, I) {
+    if (!g) {
+      G(A, I);
+      return;
+    }
+    u += I, m = A + 1, k = 0;
+  }
+  function _(A, I, L, y, U, Q) {
+    if (!I)
+      return;
+    const X = ve(e, A, L, U), te = Re(e, A, L, U, y);
+    T = L + 1, O = u - Q + X, w = u - Q + te, R = A;
+  }
+  function z(A, I) {
+    const L = s[A];
+    for (let y = I; y < L.length; y++) {
+      const U = L[y];
+      if (!g)
+        W(A, y, U);
+      else {
+        const Q = Xt(e, !0, U), X = u + Q;
+        qt(e, X) > c ? (M(), W(A, y, U)) : (u = X, m = A, k = y + 1);
+      }
+    }
+    g && m === A && k === L.length && (m = A + 1, k = 0);
+  }
+  function D(A) {
+    f++, n?.(0, A.startSegmentIndex, 0, A.consumedEndSegmentIndex, 0), N();
+  }
+  for (let A = 0; A < a.length; A++) {
+    const I = a[A];
+    if (I.startSegmentIndex === I.endSegmentIndex) {
+      D(I);
+      continue;
+    }
+    g = !1, u = 0, S = I.startSegmentIndex, E = 0, m = I.startSegmentIndex, k = 0, N();
+    let L = I.startSegmentIndex;
+    for (; L < I.endSegmentIndex && !(!g && (L = ot(e, L, I.endSegmentIndex), L >= I.endSegmentIndex)); ) {
+      const y = i[L], U = _e(y), Q = $t(e, g, L), X = y === "tab" ? Qt(u + Q, e.tabStopAdvance) : r[L], te = Q + X, ne = Yt(e, y, L, Q, X);
+      if (y === "soft-hyphen") {
+        g && (m = L + 1, k = 0, T = L + 1, O = u + o, w = u + o, R = y), L++;
+        continue;
+      }
+      if (!g) {
+        ne > c && s[L] !== null ? z(L, 0) : G(L, X), _(y, U, L, X, Q, te), L++;
+        continue;
+      }
+      if (u + ne > c) {
+        const Z = u + ve(e, y, L, Q), ae = u + Re(e, y, L, Q, X);
+        if (R === "soft-hyphen" && l.preferEarlySoftHyphenBreak && O <= c) {
+          M(T, 0, w);
+          continue;
+        }
+        if (U && Z <= c) {
+          v(L, te), M(L + 1, 0, ae), L++;
+          continue;
+        }
+        if (T >= 0 && O <= c) {
+          if (m > T || m === T && k > 0) {
+            M();
+            continue;
+          }
+          const xe = T;
+          M(xe, 0, w), L = xe;
+          continue;
+        }
+        if (ne > c && s[L] !== null) {
+          M(), z(L, 0), L++;
+          continue;
+        }
+        M();
+        continue;
+      }
+      v(L, te), _(y, U, L, X, Q, te), L++;
+    }
+    if (g) {
+      const y = T === I.consumedEndSegmentIndex ? w : u;
+      M(I.consumedEndSegmentIndex, 0, y);
+    }
+  }
+  return f;
+}
+function Y0(e, t, n, r) {
+  const i = e.chunks[n];
+  if (i.startSegmentIndex === i.endSegmentIndex)
+    return t.segmentIndex = i.consumedEndSegmentIndex, t.graphemeIndex = 0, 0;
+  const { widths: s, kinds: o, breakableFitAdvances: a, discretionaryHyphenWidth: l } = e, x = Be(), c = x.lineFitEpsilon, f = r + c, u = t.segmentIndex, g = t.graphemeIndex;
+  let S = 0, E = !1, m = t.segmentIndex, k = t.graphemeIndex, T = -1, O = 0, w = 0, R = null;
+  function N() {
+    return R === "soft-hyphen" && T === m && k === 0 ? w : S;
+  }
+  function b(D = m, A = k, I = N()) {
+    return E ? (t.segmentIndex = D, t.graphemeIndex = A, Vt(e, I, u, g, D, A)) : null;
+  }
+  function M(D, A) {
+    E = !0, m = D + 1, k = 0, S = A;
+  }
+  function G(D, A, I) {
+    E = !0, m = D, k = A + 1, S = I;
+  }
+  function W(D, A) {
+    if (!E) {
+      M(D, A);
+      return;
+    }
+    S += A, m = D + 1, k = 0;
+  }
+  function v(D, A, I, L, y, U) {
+    if (!A)
+      return;
+    const Q = ve(e, D, I, y), X = Re(e, D, I, y, L);
+    T = I + 1, O = S - U + Q, w = S - U + X, R = D;
+  }
+  function _(D, A) {
+    const I = a[D];
+    for (let L = A; L < I.length; L++) {
+      const y = I[L];
+      if (!E)
+        G(D, L, y);
+      else {
+        const U = Xt(e, !0, y), Q = S + U;
+        if (qt(e, Q) > f)
+          return b();
+        S = Q, m = D, k = L + 1;
+      }
+    }
+    return E && m === D && k === I.length && (m = D + 1, k = 0), null;
+  }
+  function z() {
+    return R !== "soft-hyphen" || T < 0 ? null : O <= f ? b(T, 0, w) : null;
+  }
+  for (let D = t.segmentIndex; D < i.endSegmentIndex; D++) {
+    const A = o[D], I = _e(A), L = D === t.segmentIndex ? t.graphemeIndex : 0, y = $t(e, E, D), U = A === "tab" ? Qt(S + y, e.tabStopAdvance) : s[D], Q = y + U, X = Yt(e, A, D, y, U);
+    if (A === "soft-hyphen" && L === 0) {
+      E && (m = D + 1, k = 0, T = D + 1, O = S + l, w = S + l, R = A);
+      continue;
+    }
+    if (!E) {
+      if (L > 0) {
+        const ne = _(D, L);
+        if (ne !== null)
+          return ne;
+      } else if (X > f && a[D] !== null) {
+        const ne = _(D, 0);
+        if (ne !== null)
+          return ne;
+      } else
+        M(D, U);
+      v(A, I, D, U, y, Q);
+      continue;
+    }
+    if (S + X > f) {
+      const ne = S + ve(e, A, D, y), he = S + Re(e, A, D, y, U);
+      if (R === "soft-hyphen" && x.preferEarlySoftHyphenBreak && O <= f)
+        return b(T, 0, w);
+      const Z = z();
+      if (Z !== null)
+        return Z;
+      if (I && ne <= f)
+        return W(D, Q), b(D + 1, 0, he);
+      if (T >= 0 && O <= f)
+        return m > T || m === T && k > 0 ? b() : b(T, 0, w);
+      if (X > f && a[D] !== null) {
+        const ae = b();
+        if (ae !== null)
+          return ae;
+        const xe = _(D, 0);
+        if (xe !== null)
+          return xe;
+      }
+      return b();
+    }
+    W(D, Q), v(A, I, D, U, y, Q);
+  }
+  return T === i.consumedEndSegmentIndex && k === 0 ? b(i.consumedEndSegmentIndex, 0, w) : b(i.consumedEndSegmentIndex, 0, S);
+}
+function X0(e, t, n) {
+  const { widths: r, kinds: i, breakableFitAdvances: s } = e, a = Be().lineFitEpsilon, l = n + a;
+  let x = 0, c = !1, f = t.segmentIndex, u = t.graphemeIndex, g = -1, S = 0;
+  for (let E = t.segmentIndex; E < r.length; E++) {
+    const m = i[E], k = _e(m), T = E === t.segmentIndex ? t.graphemeIndex : 0, O = s[E], w = r[E];
+    if (!c) {
+      if (T > 0 || w > l && O !== null) {
+        const R = O, N = R[T];
+        c = !0, x = N, f = E, u = T + 1;
+        for (let b = T + 1; b < R.length; b++) {
+          const M = R[b];
+          if (x + M > l)
+            return t.segmentIndex = f, t.graphemeIndex = u, x;
+          x += M, f = E, u = b + 1;
+        }
+        f === E && u === R.length && (f = E + 1, u = 0);
+      } else
+        c = !0, x = w, f = E + 1, u = 0;
+      k && (g = E + 1, S = x - w);
+      continue;
+    }
+    if (x + w > l)
+      return k ? (t.segmentIndex = E + 1, t.graphemeIndex = 0, x) : g >= 0 ? f > g || f === g && u > 0 ? (t.segmentIndex = f, t.graphemeIndex = u, x) : (t.segmentIndex = g, t.graphemeIndex = 0, S) : (t.segmentIndex = f, t.graphemeIndex = u, x);
+    x += w, f = E + 1, u = 0, k && (g = E + 1, S = x - w);
+  }
+  return c ? (t.segmentIndex = f, t.graphemeIndex = u, x) : null;
+}
+function q0(e, t, n, r) {
+  return e.simpleLineWalkFastPath ? X0(e, t, r) : Y0(e, t, n, r);
+}
+function Ve(e, t, n) {
+  const r = J0(e, t);
+  return r < 0 ? null : q0(e, t, r, n);
+}
+let Je = null, Ot = /* @__PURE__ */ new WeakMap();
+function V0() {
+  return Je === null && (Je = new Intl.Segmenter(void 0, { granularity: "grapheme" })), Je;
+}
+function yt(e, t, n) {
+  let r = n.get(e);
+  if (r !== void 0)
+    return r;
+  r = [];
+  const i = V0();
+  for (const s of i.segment(t[e]))
+    r.push(s.segment);
+  return n.set(e, r), r;
+}
+function Z0(e, t, n) {
+  return n > t && e[n - 1] === "soft-hyphen";
+}
+function It(e, t, n, r) {
+  for (let i = n; i < r; i++)
+    e += t[i];
+  return e;
+}
+function es(e) {
+  let t = Ot.get(e);
+  return t !== void 0 || (t = /* @__PURE__ */ new Map(), Ot.set(e, t)), t;
+}
+function ts(e, t, n, r, i, s) {
+  let o = "";
+  const a = Z0(e.kinds, n, i);
+  for (let l = n; l < i; l++)
+    if (!(e.kinds[l] === "soft-hyphen" || e.kinds[l] === "hard-break"))
+      if (l === n && r > 0) {
+        const x = yt(l, e.segments, t);
+        o = It(o, x, r, x.length);
+      } else
+        o += e.segments[l];
+  if (s > 0) {
+    a && (o += "-");
+    const l = yt(i, e.segments, t);
+    o = It(o, l, n === i ? r : 0, s);
+  } else a && (o += "-");
+  return o;
+}
+let Qe = null;
+function Zt() {
+  return Qe === null && (Qe = new Intl.Segmenter(void 0, { granularity: "grapheme" })), Qe;
+}
+function ns(e) {
+  return {
+    widths: [],
+    lineEndFitAdvances: [],
+    lineEndPaintAdvances: [],
+    kinds: [],
+    simpleLineWalkFastPath: !0,
+    segLevels: null,
+    breakableFitAdvances: [],
+    letterSpacing: 0,
+    spacingGraphemeCounts: [],
+    discretionaryHyphenWidth: 0,
+    tabStopAdvance: 0,
+    chunks: [],
+    segments: []
+  };
+}
+function ss(e, t) {
+  const n = [];
+  let r = [], i = 0, s = !1, o = !1, a = !1;
+  function l() {
+    r.length !== 0 && (n.push({
+      text: r.length === 1 ? r[0] : r.join(""),
+      start: i
+    }), r = [], s = !1, o = !1, a = !1);
+  }
+  function x(f, u, g) {
+    r = [f], i = u, s = g, o = Xe(f), a = Te.has(f);
+  }
+  function c(f, u) {
+    r.push(f), s = s || u;
+    const g = Xe(f);
+    f.length === 1 && ge.has(f) ? o = o || g : o = g, a = !1;
+  }
+  for (const f of Zt().segment(e)) {
+    const u = f.segment, g = oe(u);
+    if (r.length === 0) {
+      x(u, f.index, g);
+      continue;
+    }
+    if (a || st.has(u) || ge.has(u) || t.carryCJKAfterClosingQuote && g && o) {
+      c(u, g);
+      continue;
+    }
+    if (!s && !g) {
+      c(u, g);
+      continue;
+    }
+    l(), x(u, f.index, g);
+  }
+  return l(), n;
+}
+function is(e, t, n) {
+  if (t.length <= 1)
+    return t;
+  const r = [];
+  let i = -1, s = !1;
+  function o(l, x) {
+    const c = t[l].start, f = x < t.length ? t[x].start : e.length;
+    r.push({
+      text: e.slice(c, f),
+      start: c
+    });
+  }
+  function a(l) {
+    if (!(i < 0)) {
+      if (s)
+        i + 1 === l ? r.push(t[i]) : o(i, l);
+      else
+        for (let x = i; x < l; x++)
+          r.push(t[x]);
+      i = -1, s = !1;
+    }
+  }
+  for (let l = 0; l < t.length; l++) {
+    const x = t[l];
+    i >= 0 && !Kt(t[l - 1].text, n) && a(l), i < 0 && (i = l), s = s || oe(x.text);
+  }
+  return a(t.length), r;
+}
+function Pt(e, t) {
+  if (t === "zero-width-break" || t === "soft-hyphen" || t === "hard-break")
+    return 0;
+  if (t === "tab")
+    return 1;
+  let n = 0;
+  const r = Zt();
+  for (const i of r.segment(e))
+    n++;
+  return n;
+}
+function rs(e, t, n) {
+  return t > 1 ? e + (t - 1) * n : e;
+}
+function xs(e, t, n, r, i) {
+  const s = Be(), { cache: o, emojiCorrection: a } = H0(t, W0(e.normalized)), l = Fe("-", ue("-", o), a) + (i === 0 ? 0 : i * 2), c = Fe(" ", ue(" ", o), a) * 8, f = i !== 0;
+  if (e.len === 0)
+    return ns();
+  const u = [], g = [], S = [], E = [];
+  let m = e.chunks.length <= 1 && !f;
+  const k = n ? [] : null, T = [], O = [], w = n ? [] : null, R = Array.from({ length: e.len });
+  function N(W, v, _, z, D, A, I, L) {
+    D !== "text" && D !== "space" && D !== "zero-width-break" && (m = !1), u.push(v), g.push(_), S.push(z), E.push(D), k?.push(A), T.push(I), f && O.push(L), w !== null && w.push(W);
+  }
+  function b(W, v, _, z, D) {
+    const A = ue(W, o), I = f ? Pt(W, v) : 0, L = rs(Fe(W, A, a), I, i), y = v === "space" || v === "preserved-space" || v === "zero-width-break" ? 0 : L, U = y === 0 ? 0 : y + (I > 0 ? i : 0), Q = v === "space" || v === "zero-width-break" ? 0 : L;
+    if (D && z && W.length > 1) {
+      let X = "sum-graphemes";
+      i !== 0 ? X = "segment-prefixes" : We(W) ? X = "pair-context" : s.preferPrefixWidthsForBreakableRuns && (X = "segment-prefixes");
+      const te = G0(W, A, o, a, X);
+      N(W, L, U, Q, v, _, te, I);
+      return;
+    }
+    N(W, L, U, Q, v, _, null, I);
+  }
+  for (let W = 0; W < e.len; W++) {
+    R[W] = u.length;
+    const v = e.texts[W], _ = e.isWordLike[W], z = e.kinds[W], D = e.starts[W];
+    if (z === "soft-hyphen") {
+      N(v, 0, l, l, z, D, null, 0);
+      continue;
+    }
+    if (z === "hard-break") {
+      N(v, 0, 0, 0, z, D, null, 0);
+      continue;
+    }
+    if (z === "tab") {
+      N(v, 0, 0, 0, z, D, null, f ? Pt(v, z) : 0);
+      continue;
+    }
+    const A = ue(v, o);
+    if (z === "text" && A.containsCJK) {
+      const I = ss(v, s), L = r === "keep-all" ? is(v, I, s.breakKeepAllAfterPunctuation) : I;
+      for (let y = 0; y < L.length; y++) {
+        const U = L[y];
+        b(U.text, "text", D + U.start, _, r === "keep-all" || !oe(U.text));
+      }
+      continue;
+    }
+    b(v, z, D, _, !0);
+  }
+  const M = os(e.chunks, R, u.length), G = k === null ? null : In(e.normalized, k);
+  return w !== null ? {
+    widths: u,
+    lineEndFitAdvances: g,
+    lineEndPaintAdvances: S,
+    kinds: E,
+    simpleLineWalkFastPath: m,
+    segLevels: G,
+    breakableFitAdvances: T,
+    letterSpacing: i,
+    spacingGraphemeCounts: O,
+    discretionaryHyphenWidth: l,
+    tabStopAdvance: c,
+    chunks: M,
+    segments: w
+  } : {
+    widths: u,
+    lineEndFitAdvances: g,
+    lineEndPaintAdvances: S,
+    kinds: E,
+    simpleLineWalkFastPath: m,
+    segLevels: G,
+    breakableFitAdvances: T,
+    letterSpacing: i,
+    spacingGraphemeCounts: O,
+    discretionaryHyphenWidth: l,
+    tabStopAdvance: c,
+    chunks: M
+  };
+}
+function os(e, t, n) {
+  const r = [];
+  for (let i = 0; i < e.length; i++) {
+    const s = e[i], o = s.startSegmentIndex < t.length ? t[s.startSegmentIndex] : n, a = s.endSegmentIndex < t.length ? t[s.endSegmentIndex] : n, l = s.consumedEndSegmentIndex < t.length ? t[s.consumedEndSegmentIndex] : n;
+    r.push({
+      startSegmentIndex: o,
+      endSegmentIndex: a,
+      consumedEndSegmentIndex: l
+    });
+  }
+  return r;
+}
+function ls(e, t, n, r) {
+  const i = r?.wordBreak ?? "normal", s = r?.letterSpacing ?? 0, o = L0(e, Be(), r?.whiteSpace, i);
+  return xs(o, t, n, i, s);
+}
+function Ze(e, t, n) {
+  return ls(e, t, !0, n);
+}
+function wt(e) {
+  let t = 0;
+  return $0(e, Number.POSITIVE_INFINITY, (n) => {
+    n > t && (t = n);
+  }), t;
+}
+const cs = /[ \t\n\f\r]+/, Wt = /^[ \t\n\f\r]+/, vt = /[ \t\n\f\r]+$/, Rt = { segmentIndex: 0, graphemeIndex: 0 }, as = {
+  itemIndex: 0,
+  segmentIndex: 0,
+  graphemeIndex: 0
+};
+function $e(e) {
+  return {
+    segmentIndex: e.segmentIndex,
+    graphemeIndex: e.graphemeIndex
+  };
+}
+function Tt(e) {
+  return e.segmentIndex === 0 && e.graphemeIndex === 0;
+}
+function ye(e, t, n) {
+  const r = `${e}\0${t}`, i = n.get(r);
+  if (i !== void 0)
+    return i;
+  const s = t === 0 ? void 0 : { letterSpacing: t }, o = wt(Ze("A A", e, s)), a = wt(Ze("AA", e, s)), l = Math.max(0, o - a);
+  return n.set(r, l), l;
+}
+function fs(e) {
+  const t = { segmentIndex: 0, graphemeIndex: 0 }, n = Ve(e, t, Number.POSITIVE_INFINITY);
+  return n === null ? null : {
+    endGraphemeIndex: t.graphemeIndex,
+    endSegmentIndex: t.segmentIndex,
+    width: n
+  };
+}
+function us(e, t) {
+  return e === 0 && t > 0;
+}
+function en(e) {
+  const t = [], n = Array.from({ length: e.length }), r = /* @__PURE__ */ new Map();
+  let i = 0;
+  for (let s = 0; s < e.length; s++) {
+    const o = e[s], a = o.letterSpacing ?? 0, l = Wt.test(o.text), x = vt.test(o.text), c = o.text.replace(Wt, "").replace(vt, "");
+    if (c.length === 0) {
+      cs.test(o.text) && i === 0 && (i = ye(o.font, a, r));
+      continue;
+    }
+    const f = i > 0 ? i : l ? ye(o.font, a, r) : 0, u = Ze(c, o.font, a === 0 ? void 0 : { letterSpacing: a }), g = fs(u);
+    if (g === null) {
+      i = x ? ye(o.font, a, r) : 0;
+      continue;
+    }
+    const S = {
+      break: o.break ?? "normal",
+      endGraphemeIndex: g.endGraphemeIndex,
+      endSegmentIndex: g.endSegmentIndex,
+      extraWidth: o.extraWidth ?? 0,
+      gapBefore: f,
+      naturalWidth: g.width,
+      prepared: u,
+      sourceItemIndex: s
+    };
+    t.push(S), n[s] = S, i = x ? ye(o.font, a, r) : 0;
+  }
+  return {
+    items: t,
+    itemsBySourceItemIndex: n
+  };
+}
+function hs(e, t, n, r) {
+  if (e.items.length === 0 || n.itemIndex >= e.items.length)
+    return null;
+  const i = Math.max(1, t);
+  let s = 0, o = i, a = n.itemIndex;
+  e: for (; a < e.items.length; ) {
+    const l = e.items[a];
+    if (!Tt(n) && n.segmentIndex === l.endSegmentIndex && n.graphemeIndex === l.endGraphemeIndex) {
+      a++, n.segmentIndex = 0, n.graphemeIndex = 0;
+      continue;
+    }
+    const x = s === 0 ? 0 : l.gapBefore, c = Tt(n);
+    if (l.break === "never") {
+      if (!c) {
+        a++, n.segmentIndex = 0, n.graphemeIndex = 0;
+        continue;
+      }
+      const k = l.naturalWidth + l.extraWidth, T = x + k;
+      if (s > 0 && T > o)
+        break e;
+      r?.(l, x, k, $e(Rt), {
+        segmentIndex: l.endSegmentIndex,
+        graphemeIndex: l.endGraphemeIndex
+      }), s += T, o = Math.max(0, i - s), a++, n.segmentIndex = 0, n.graphemeIndex = 0;
+      continue;
+    }
+    const f = x + l.extraWidth;
+    if (s > 0 && f >= o)
+      break e;
+    if (c) {
+      const k = f + l.naturalWidth;
+      if (k <= o) {
+        r?.(l, x, l.naturalWidth + l.extraWidth, $e(Rt), {
+          segmentIndex: l.endSegmentIndex,
+          graphemeIndex: l.endGraphemeIndex
+        }), s += k, o = Math.max(0, i - s), a++, n.segmentIndex = 0, n.graphemeIndex = 0;
+        continue;
+      }
+    }
+    const u = Math.max(1, o - f), g = {
+      segmentIndex: n.segmentIndex,
+      graphemeIndex: n.graphemeIndex
+    }, S = Ve(l.prepared, g, u);
+    if (S === null) {
+      a++, n.segmentIndex = 0, n.graphemeIndex = 0;
+      continue;
+    }
+    if (n.segmentIndex === g.segmentIndex && n.graphemeIndex === g.graphemeIndex) {
+      a++, n.segmentIndex = 0, n.graphemeIndex = 0;
+      continue;
+    }
+    const E = S + l.extraWidth, m = x + E;
+    if (s > 0 && c && m > o)
+      break e;
+    if (s > 0 && c && x > 0 && us(g.segmentIndex, g.graphemeIndex)) {
+      const k = { segmentIndex: 0, graphemeIndex: 0 };
+      if (Ve(l.prepared, k, Math.max(1, i - l.extraWidth)) !== null && (k.segmentIndex > g.segmentIndex || k.segmentIndex === g.segmentIndex && k.graphemeIndex > g.graphemeIndex))
+        break e;
+    }
+    if (r?.(l, x, E, $e(n), {
+      segmentIndex: g.segmentIndex,
+      graphemeIndex: g.graphemeIndex
+    }), s += m, o = Math.max(0, i - s), g.segmentIndex === l.endSegmentIndex && g.graphemeIndex === l.endGraphemeIndex) {
+      a++, n.segmentIndex = 0, n.graphemeIndex = 0;
+      continue;
+    }
+    n.segmentIndex = g.segmentIndex, n.graphemeIndex = g.graphemeIndex;
+    break;
+  }
+  return s === 0 ? null : (n.itemIndex = a, s);
+}
+function ds(e, t, n = as) {
+  const r = e, i = {
+    itemIndex: n.itemIndex,
+    segmentIndex: n.segmentIndex,
+    graphemeIndex: n.graphemeIndex
+  }, s = [], o = hs(r, t, i, (a, l, x, c, f) => {
+    s.push({
+      itemIndex: a.sourceItemIndex,
+      gapBefore: l,
+      occupiedWidth: x,
+      start: c,
+      end: f
+    });
+  });
+  return o === null ? null : {
+    fragments: s,
+    width: o,
+    end: i
+  };
+}
+function Fs(e, t) {
+  return ts(e.prepared, es(e.prepared), t.start.segmentIndex, t.start.graphemeIndex, t.end.segmentIndex, t.end.graphemeIndex);
+}
+function gs(e, t) {
+  const n = e, r = [];
+  for (let i = 0; i < t.fragments.length; i++) {
+    const s = t.fragments[i], o = n.itemsBySourceItemIndex[s.itemIndex];
+    if (o === void 0)
+      throw new Error("Missing rich-text inline item for fragment");
+    r.push({
+      itemIndex: s.itemIndex,
+      text: Fs(o, s),
+      gapBefore: s.gapBefore,
+      occupiedWidth: s.occupiedWidth,
+      start: s.start,
+      end: s.end
+    });
+  }
+  return {
+    fragments: r,
+    width: t.width,
+    end: t.end
+  };
+}
+function Ns(e) {
+  const t = [];
+  let n = [], r = 0, i = 0;
+  for (const s of e) {
+    let o = 0;
+    for (; ; ) {
+      const l = s.text.indexOf("\v", o);
+      if (l < 0) break;
+      const x = s.text.slice(o, l);
+      x.length > 0 && n.push({ text: x, style: s.style }), i += l - o, t.push({ runs: n, startOffset: r }), i += 1, r = i, n = [], o = l + 1;
+    }
+    const a = s.text.slice(o);
+    a.length > 0 && n.push({ text: a, style: s.style }), i += a.length;
+  }
+  return t.push({ runs: n, startOffset: r }), t;
+}
+function tn(e) {
+  return e.map((t) => {
+    const n = { text: t.style.hidden ? "" : t.text, font: ce(t.style) };
+    return !t.style.hidden && t.style.letterSpacingPx !== void 0 && (n.letterSpacing = t.style.letterSpacingPx), n;
+  });
+}
+function ps(e) {
+  return en(tn(e));
+}
+class et {
+  map = /* @__PURE__ */ new Map();
+  get(t) {
+    const n = this.map.get(t.id);
+    if (n && n.revision === t.revision) return n.segments;
+    const r = Ns(t.runs).map((i) => ({
+      prepared: en(tn(i.runs)),
+      runs: i.runs,
+      startOffset: i.startOffset
+    }));
+    return this.map.set(t.id, { revision: t.revision, segments: r }), r;
+  }
+  evict(t) {
+    this.map.delete(t);
+  }
+  /** Drop every entry — used when the whole document is replaced (the importer
+   *  re-mints block ids from i0, so a stale entry at the same id+revision would
+   *  otherwise leak the previous document's prepared text into the new one). */
+  clear() {
+    this.map.clear();
+  }
+  /** Drop every entry whose id is NOT in `keep` (paragraphs no longer in the
+   *  document). Called after a full layout to bound the cache to live blocks. */
+  retainOnly(t) {
+    for (const n of this.map.keys()) t.has(n) || this.map.delete(n);
+  }
+}
+const Ye = 48;
+function Ss() {
+  const e = new et(), t = /* @__PURE__ */ new Map();
+  let n = null;
+  const r = (i, s) => {
+    n?.add(i.id);
+    const o = t.get(i.id);
+    if (o && o.revision === i.revision && o.width === s) return o.lines;
+    const a = xn(i, s, e);
+    return t.set(i.id, { revision: i.revision, width: s, lines: a }), a;
+  };
+  return {
+    layout(i, s, o) {
+      const a = o?.rawBand ?? null;
+      n = a === null ? /* @__PURE__ */ new Set() : null;
+      try {
+        const l = Ls(i, r, (x) => (n?.add(x.id), e.get(x)), a);
+        if (n) {
+          for (const x of t.keys()) n.has(x) || t.delete(x);
+          e.retainOnly(n);
+        }
+        return l;
+      } finally {
+        n = null;
+      }
+    },
+    evict(i) {
+      e.evict(i), t.delete(i);
+    },
+    reset() {
+      e.clear(), t.clear();
+    }
+  };
+}
+function ms(e) {
+  let t = 0;
+  for (let n = 0; n < e.length; n++) e.charCodeAt(n) === 32 && t++;
+  return t;
+}
+const As = (e) => e === " " || e === "	" || e === `
+` || e === "\r";
+function Es(e, t, n) {
+  const r = e.indexOf(n, t);
+  if (r >= 0) return { start: r, end: r + n.length };
+  const i = [];
+  let s = t, o = 0, a = -1;
+  for (; o < n.length && s < e.length; ) {
+    if (e[s] === n[o]) {
+      a < 0 && (a = s), i.push(s - a), s++, o++;
+      continue;
+    }
+    if (As(e[s])) {
+      s++;
+      continue;
+    }
+    a = -1;
+    break;
+  }
+  return a >= 0 && o === n.length ? (i.push(s - a), s - a === n.length ? { start: a, end: s } : { start: a, end: s, map: i }) : { start: t, end: t + n.length };
+}
+function ct(e, t) {
+  const n = [];
+  let r = t;
+  for (const i of e)
+    n.push(r), r += i.text.length;
+  return n;
+}
+function Bs(e) {
+  return Mn(e) && !e.style.sectionBreak && !e.style.pageBreakBefore;
+}
+function nn(e) {
+  const t = e.runs[0]?.style, n = t?.fontSizePx ?? 16, r = t ? we(ce(t)) : { ascent: n * 0.8, descent: n * 0.2 }, i = r.ascent + r.descent, s = Math.max(i, e.style.lineHeight * n);
+  return { height: s, ascent: (s - i) / 2 + r.ascent };
+}
+function at(e, t, n, r, i, s) {
+  const o = ds(t.prepared, n, r);
+  if (o === null) return null;
+  const a = gs(t.prepared, o), l = [];
+  let x = 0, c = 0, f = 0, u = 0;
+  for (const m of a.fragments) {
+    x += m.gapBefore;
+    const k = t.runs[m.itemIndex], T = we(ce(k.style));
+    if (c = Math.max(c, T.ascent), f = Math.max(f, T.descent), u = Math.max(u, k.style.fontSizePx), m.text.length > 0) {
+      const O = Es(k.text, s[m.itemIndex], m.text);
+      s[m.itemIndex] = O.end;
+      const w = {
+        blockId: e.id,
+        startOffset: i[m.itemIndex] + O.start,
+        endOffset: i[m.itemIndex] + O.end,
+        text: m.text,
+        style: k.style,
+        x,
+        width: m.occupiedWidth
+      };
+      O.map && (w.offsetMap = O.map), l.push({ frag: w, hadGap: m.gapBefore > 0, spaces: ms(m.text) });
+    }
+    x += m.occupiedWidth;
+  }
+  if (u === 0) {
+    const m = e.runs[0]?.style;
+    if (m) {
+      const k = we(ce(m));
+      c = k.ascent, f = k.descent, u = m.fontSizePx;
+    }
+  }
+  const g = c + f, S = Math.max(g, e.style.lineHeight * u), E = (S - g) / 2;
+  return { frags: l, width: a.width, height: S, ascent: E + c, end: a.end };
+}
+function Ms(e, t, n) {
+  for (const i of t) if (i.posPx > e + 0.5) return i;
+  let r = (Math.floor(e / Ye) + 1) * Ye;
+  return r <= e && (r = e + Ye), { posPx: Math.min(r, Math.max(e + 1, n)), align: "left", leader: "none" };
+}
+function Cs(e) {
+  const t = e.map((i) => i.text).join(""), n = ce(e[0]?.style ?? sn);
+  let r = t.indexOf(".");
+  return r < 0 && (r = t.indexOf(",")), Pe(r < 0 ? t : t.slice(0, r + 1), n);
+}
+const sn = { fontFamily: "Georgia, serif", fontSizePx: 16 };
+function ks(e, t, n, r, i) {
+  const s = [];
+  let o = [], a = n, l = n;
+  for (const O of t) {
+    let w = 0;
+    for (; ; ) {
+      const N = O.text.indexOf("	", w);
+      if (N < 0) break;
+      const b = O.text.slice(w, N);
+      b.length > 0 && o.push({ text: b, style: O.style }), l += N - w, s.push({ runs: o, start: a }), l += 1, a = l, o = [], w = N + 1;
+    }
+    const R = O.text.slice(w);
+    R.length > 0 && o.push({ text: R, style: O.style }), l += R.length;
+  }
+  s.push({ runs: o, start: a });
+  const x = (e.style.tabStops ?? []).slice().sort((O, w) => O.posPx - w.posPx), c = t.find((O) => O.text.length > 0)?.style ?? e.runs[0]?.style, f = [];
+  let u = [], g = [], S = i, E = 0, m = 0, k = !1;
+  const T = (O) => {
+    if (E === 0 && c) {
+      const w = we(ce(c));
+      E = Math.max(w.ascent + w.descent, e.style.lineHeight * c.fontSizePx), m = (E - (w.ascent + w.descent)) / 2 + w.ascent;
+    }
+    f.push({
+      frags: u,
+      width: S,
+      indent: 0,
+      // fragment x is already absolute (tab/indent baked in)
+      lineMaxWidth: r,
+      height: E,
+      ascent: m,
+      // A tab-positioned line stays ragged (its manual x must not be re-justified);
+      // pure wrapped continuation lines justify normally when the paragraph does.
+      lastOfSegment: O || k,
+      ...g.length > 0 ? { leaders: g } : {}
+    }), u = [], g = [], S = 0, E = 0, m = 0, k = !1;
+  };
+  return s.forEach((O, w) => {
+    if (w > 0) {
+      const W = Ms(S, x, r), v = W.align ?? "left", _ = Pe(O.runs.map((A) => A.text).join(""), ce(O.runs[0]?.style ?? c ?? sn)), z = S + _ <= r;
+      let D = W.posPx;
+      z && v === "right" ? D = W.posPx - _ : z && v === "center" ? D = W.posPx - _ / 2 : z && v === "decimal" && (D = W.posPx - Cs(O.runs)), D < S && (D = S), (W.leader ?? "none") !== "none" && D > S + 1 && c && g.push({ x1: S, x2: D, kind: W.leader ?? "none", color: c.color, fontSizePx: c.fontSizePx }), S = D, k = !0;
+    }
+    if (O.runs.length === 0) return;
+    const R = { prepared: ps(O.runs), runs: O.runs, startOffset: O.start }, N = ct(O.runs, O.start), b = O.runs.map(() => 0);
+    let M, G = !0;
+    for (; ; ) {
+      const W = Math.max(24, r - (G ? S : 0)), v = at(e, R, W, M, N, b);
+      if (v === null) break;
+      G || T(!1);
+      const _ = G ? S : 0;
+      for (const z of v.frags)
+        z.frag.x += _, u.push(z);
+      S = _ + v.width, E = Math.max(E, v.height), m = Math.max(m, v.ascent), M = v.end, G = !1;
+    }
+  }), T(!0), f;
+}
+function rn(e, t) {
+  if (t <= 0) return;
+  const n = e.reduce((s, o) => s + o.spaces + (o.hadGap ? 1 : 0), 0);
+  if (n <= 0) return;
+  const r = t / n;
+  let i = 0;
+  for (const s of e)
+    s.hadGap && (i += r), s.frag.x += i, s.spaces > 0 && (s.frag.wordSpacingPx = r, s.frag.width += s.spaces * r, i += s.spaces * r);
+}
+function xn(e, t, n) {
+  const r = n.get(e), i = [], s = [];
+  let o = !0;
+  for (const l of r) {
+    if (l.runs.some((g) => g.text.includes("	"))) {
+      s.push(...ks(e, l.runs, l.startOffset, t, o ? e.style.indentFirstLinePx : 0)), o = !1;
+      continue;
+    }
+    const x = ct(l.runs, l.startOffset), c = l.runs.map(() => 0);
+    let f, u = !1;
+    for (; ; ) {
+      const g = o ? e.style.indentFirstLinePx : 0, S = t - g, E = at(e, l, S, f, x, c);
+      if (E === null) break;
+      s.push({
+        frags: E.frags,
+        width: E.width,
+        indent: g,
+        lineMaxWidth: S,
+        height: E.height,
+        ascent: E.ascent,
+        lastOfSegment: !1
+      }), f = E.end, o = !1, u = !0;
+    }
+    if (u)
+      s[s.length - 1].lastOfSegment = !0;
+    else {
+      const g = nn(e);
+      s.push({
+        frags: [],
+        width: 0,
+        indent: 0,
+        lineMaxWidth: t,
+        height: g.height,
+        ascent: g.ascent,
+        lastOfSegment: !0,
+        emptyOffset: l.startOffset
+      }), o = !1;
+    }
+  }
+  let a = 0;
+  for (const l of s) {
+    const x = l.lineMaxWidth - l.width;
+    let c = l.indent;
+    e.style.align === "center" ? c += x / 2 : e.style.align === "right" ? c += x : e.style.align === "justify" && !l.lastOfSegment && rn(l.frags, x);
+    for (const u of l.frags) u.frag.x += c;
+    const f = { y: a, height: l.height, ascent: l.ascent, fragments: l.frags.map((u) => u.frag) };
+    l.emptyOffset !== void 0 && (f.emptyOffset = l.emptyOffset), l.leaders && l.leaders.length > 0 && (f.leaders = l.leaders.map((u) => ({ ...u, x1: u.x1 + c, x2: u.x2 + c }))), i.push(f), a += l.height;
+  }
+  return i;
+}
+const Gt = 2, Ht = 2, Ds = 48, on = ["header", "footer", "headerFirst", "headerEven", "footerFirst", "footerEven"];
+function ln(e, t) {
+  const n = {
+    pageWidthPx: t.pageWidthPx ?? e.pageWidthPx,
+    pageHeightPx: t.pageHeightPx ?? e.pageHeightPx,
+    marginPx: t.marginPx ?? e.marginPx
+  }, r = t.columns === void 0 ? e.columns : t.columns ?? void 0;
+  r && (n.columns = r), t.pageNumberStart !== void 0 && (n.pageNumberStart = t.pageNumberStart);
+  const i = t.headerDistancePx ?? e.headerDistancePx;
+  i !== void 0 && (n.headerDistancePx = i);
+  const s = t.footerDistancePx ?? e.footerDistancePx;
+  s !== void 0 && (n.footerDistancePx = s);
+  for (const o of on) {
+    const a = t[o] ?? e[o];
+    a && (n[o] = a);
+  }
+  return n;
+}
+function _t(e, t) {
+  return e.headerDistancePx !== void 0 ? e.headerDistancePx : Math.max(8, (e.marginPx.top - t) / 2);
+}
+function zt(e, t) {
+  return e.footerDistancePx !== void 0 ? e.pageHeightPx - e.footerDistancePx - t : e.pageHeightPx - Math.max(8, (e.marginPx.bottom - t) / 2) - t;
+}
+function cn(e) {
+  const t = [];
+  for (let n = 0; n < e.blocks.length; n++) {
+    const r = e.blocks[n];
+    r.kind === "paragraph" && r.style.sectionBreak && t.push({ props: ln(e.section, r.style.sectionBreak.props), endBlock: n });
+  }
+  return t.push({ props: e.section, endBlock: e.blocks.length - 1 }), t;
+}
+function Ls(e, t, n, r) {
+  const s = /* @__PURE__ */ new Map();
+  let o = null;
+  const a = (h) => {
+    const F = s.get(h);
+    if (F) return F;
+    let d = h.marginPx.top, p = h.pageHeightPx - h.marginPx.bottom;
+    const C = [h.header, h.headerFirst, h.headerEven].filter((H) => !!H), B = [h.footer, h.footerFirst, h.footerEven].filter((H) => !!H);
+    if (C.length > 0 || B.length > 0) {
+      o ??= new et();
+      const H = h.pageWidthPx - h.marginPx.left - h.marginPx.right, j = h.marginPx.left, $ = (V) => Ie(V, H, j, 999, 999, o, !1).height, K = (V) => {
+        const ee = Ie(V, H, j, 999, 999, o, !1);
+        for (const Y of ee.placed)
+          if (!!Y.table || !!Y.image || Y.lines.some((Me) => Me.fragments.some((fe) => fe.text.trim().length > 0))) return ee.height - Y.y;
+        return 0;
+      }, J = C.reduce((V, ee) => Math.max(V, $(ee)), 0);
+      if (J > 0) {
+        const V = _t(h, J);
+        d = Math.max(d, V + J + 6);
+      }
+      const q = B.reduce((V, ee) => Math.max(V, $(ee)), 0);
+      if (q > 0)
+        if (h.footerDistancePx !== void 0) {
+          const V = h.pageHeightPx - h.footerDistancePx, ee = B.reduce((Y, me) => Math.max(Y, K(me)), 0);
+          p = Math.min(p, V - ee);
+        } else
+          p = Math.min(p, zt(h, q) - 6);
+      p = Math.max(p, d + 24);
+    }
+    const P = { top: d, bottom: p };
+    return s.set(h, P), P;
+  }, l = cn(e);
+  let x = l[0].props, c = 0, f = 0, u = 0, g = 0, S = 1, E = 0, m = 0;
+  const k = (h) => {
+    x = h;
+    const F = a(x);
+    c = x.marginPx.left, f = F.top, u = F.bottom, g = x.pageWidthPx - x.marginPx.left - x.marginPx.right, S = Math.max(1, x.columns?.count ?? 1), E = x.columns?.gapPx ?? 24, m = S > 1 ? (g - (S - 1) * E) / S : g;
+  };
+  k(x);
+  const T = e.lists ?? {}, O = (h) => {
+    const F = h.style.list;
+    if (!F) return null;
+    const d = T[F.listId];
+    return d ? d.levels[Math.min(F.level, d.levels.length - 1)] ?? null : null;
+  }, w = (h) => h.style.indentLeftPx + (O(h)?.indentLeftPx ?? 0), R = (h) => h.style.indentRightPx ?? 0, N = (h) => O(h)?.indentLeftPx ?? 0, b = /* @__PURE__ */ new Map(), M = /* @__PURE__ */ new Map(), G = (h) => {
+    const F = h.style.list, d = O(h);
+    if (!F || !d) return;
+    const p = T[F.listId], C = b.get(F.listId) ?? [];
+    C[F.level] = (C[F.level] ?? d.start - 1) + 1, C.length = F.level + 1, b.set(F.listId, C);
+    const B = Ln(p, F.level, C);
+    if (B.length === 0) return;
+    const P = h.runs[0]?.style;
+    P && M.set(h.id, {
+      text: B,
+      style: { ...P, ...d.markerStyle ?? {} },
+      hangingPx: d.hangingPx
+    });
+  }, W = (h) => {
+    for (const F of h)
+      if (F.kind === "paragraph") G(F);
+      else if (F.kind === "table") for (const d of F.rows) for (const p of d.cells) W(p.blocks);
+  };
+  W(e.blocks);
+  const v = { indentOf: N, markers: M }, _ = [];
+  let z = 0;
+  for (let h = 0; h < e.blocks.length; h++) {
+    for (; h > l[z].endBlock; ) k(l[++z].props);
+    const F = e.blocks[h];
+    if (F.kind === "paragraph") {
+      if (Bs(F)) continue;
+      const d = F.style.tocEntry ? Ds : 0;
+      _.push({
+        kind: "para",
+        block: F,
+        lines: t(F, m - w(F) - R(F) - d)
+      });
+    } else if (F.kind === "image")
+      _.push({ kind: "image", block: F, height: F.anchor ? 0 : F.heightPx });
+    else {
+      const d = ft(F, m, t, v);
+      _.push({ kind: "table", block: F, ...d });
+    }
+  }
+  z = 0, k(l[0].props);
+  const D = [], A = () => (D.push(x), {
+    index: D.length - 1,
+    number: D.length,
+    // provisional; the post-pass sets the real value
+    blocks: [],
+    widthPx: x.pageWidthPx,
+    heightPx: x.pageHeightPx,
+    marginPx: x.marginPx,
+    contentTopPx: f,
+    contentBottomPx: u
+  }), I = [A()];
+  let L = I[0], y = f;
+  const U = /* @__PURE__ */ new Map(), Q = 14, X = 18, te = e.footnotes ?? {}, ne = Object.keys(te).length > 0;
+  let he = 0;
+  const Z = () => u - he, ae = /* @__PURE__ */ new Set(), xe = [[]], ze = [0], dt = /* @__PURE__ */ new Map(), Ft = (h) => {
+    const F = te[h];
+    if (!F || F.length === 0) return null;
+    const d = Math.max(40, g - X);
+    let p = 0;
+    return { paras: F.map((B) => {
+      const P = t(B, d);
+      return p += B.style.spaceBeforePx + Se(P) + B.style.spaceAfterPx, { p: B, lines: P };
+    }), height: p };
+  }, un = (h, F, d) => {
+    const p = [];
+    for (let C = F; C < F + d; C++)
+      for (const B of h[C].fragments) {
+        const P = B.style.footnoteRef;
+        P && te[P] && !ae.has(P) && !p.some(([H]) => H === P) && p.push([P, B.text]);
+      }
+    return p;
+  };
+  let pe = 0, Le = 0;
+  const le = () => c + pe * (m + E), se = () => L.blocks.length > Le, je = () => {
+    pe = 0, Le = 0, L = A(), I.push(L), xe.push([]), ze.push(0), he = 0, y = f, de = [];
+  }, ie = () => {
+    pe + 1 < S ? (pe++, Le = L.blocks.length, y = f, de = []) : je();
+  }, hn = () => {
+    L.blocks.length === 0 ? (L.widthPx = x.pageWidthPx, L.heightPx = x.pageHeightPx, L.marginPx = x.marginPx, L.contentTopPx = f, L.contentBottomPx = u, D[L.index] = x, pe = 0, Le = 0, y = f, de = []) : je();
+  }, dn = (h, F, d, p) => {
+    const C = {
+      blockId: h.id,
+      x: le() + w(h),
+      y,
+      firstLineIndex: d,
+      lines: []
+    }, B = d === 0 ? M.get(h.id) : void 0;
+    B && (C.marker = { text: B.text, style: B.style, x: C.x - B.hangingPx }), h.style.tocEntry && U.set(h.id, { chunk: C, rightEdge: le() + m, para: h }), L.blocks.push(C);
+    for (let P = d; P < d + p; P++) {
+      const H = F[P];
+      C.lines.push({ ...H, y: y - C.y }), y += H.height;
+    }
+  }, Fn = (h, F) => {
+    let d = 0, p = y;
+    for (; F + d < h.length && p + h[F + d].height <= Z(); )
+      p += h[F + d].height, d++;
+    return d;
+  }, gt = (h) => {
+    let F = xe[L.index].length === 0 ? Q : 0;
+    const d = [];
+    for (const [p, C] of h) {
+      const B = Ft(p);
+      B && (F += B.height, d.push([p, C, B]));
+    }
+    return { H: F, measures: d };
+  }, Nt = (h, F) => {
+    for (const [d, p] of h)
+      ae.add(d), xe[L.index].push(d), dt.set(d, p);
+    he += F, ze[L.index] = he;
+  }, gn = (h) => {
+    const F = [], d = (p) => {
+      for (const C of p)
+        if (C.kind === "paragraph") {
+          let B = 0;
+          for (const P of C.runs) {
+            const H = P.style.footnoteRef;
+            H && te[H] && !ae.has(H) && !F.some(([j]) => j === H) && F.push([H, P.text]), B += P.text.length;
+          }
+        } else if (C.kind === "table")
+          for (const B of C.rows) for (const P of B.cells) d(P.blocks);
+    };
+    for (const p of h) for (const C of p.cells) d(C.blocks);
+    return F;
+  }, Nn = (h, F, d) => {
+    for (; ; ) {
+      if (d <= 0) return d;
+      const p = un(h, F, d);
+      if (p.length === 0) return d;
+      const { H: C, measures: B } = gt(p);
+      if (B.length === 0) return d;
+      let P = 0;
+      for (let j = F; j < F + d; j++) P += h[j].height;
+      if (y + P + C <= Z() || d === 1 && !se())
+        return Nt(B, C), d;
+      d--;
+    }
+  }, pn = (h, F) => {
+    if (h.style.keepLinesTogether === !0 && se()) {
+      const p = Se(F);
+      y + p > Z() && p <= u - f && ie();
+    }
+    let d = 0;
+    for (; d < F.length; ) {
+      const p = F.length - d, C = Fn(F, d);
+      let B;
+      if (C >= p ? B = p : (B = C, p - B === 1 && (B -= Ht - 1), d === 0 && B > 0 && B < Gt && (B = 0), B <= 0 && (B = se() ? 0 : Math.max(1, C))), B > 0 && ne && (B = Nn(F, d, B)), B > 0 && (dn(h, F, d, B), d += B), d >= F.length) return;
+      ie();
+    }
+  }, Se = (h) => {
+    let F = 0;
+    for (const d of h) F += d.height;
+    return F;
+  };
+  let de = [];
+  const pt = 10, Sn = (h) => {
+    let F = le(), d = le() + m;
+    for (const p of de)
+      h >= p.bottom || (p.side === "left" ? F = Math.max(F, p.right + pt) : d = Math.min(d, p.left - pt));
+    return { x0: F, width: Math.max(40, d - F) };
+  }, mn = (h) => de.some((F) => F.bottom > h), An = (h) => {
+    const F = h.anchor;
+    let d;
+    switch (F.relFromH) {
+      case "page":
+      case "leftMargin":
+        d = 0;
+        break;
+      case "rightMargin":
+        d = x.pageWidthPx - x.marginPx.right;
+        break;
+      case "column":
+        d = le();
+        break;
+      default:
+        d = x.marginPx.left;
+        break;
+    }
+    let p;
+    switch (F.relFromV) {
+      case "page":
+      case "topMargin":
+        p = 0;
+        break;
+      case "bottomMargin":
+        p = x.pageHeightPx - x.marginPx.bottom;
+        break;
+      case "paragraph":
+      case "line":
+        p = y;
+        break;
+      // current flow position
+      default:
+        p = x.marginPx.top;
+        break;
+    }
+    const C = { src: h.src, width: h.widthPx, height: h.heightPx, z: F.z ?? 0 };
+    F.behind ? C.behind = !0 : C.front = !0, L.blocks.push({
+      blockId: h.id,
+      x: d + F.offsetXPx,
+      y: p + F.offsetYPx,
+      firstLineIndex: 0,
+      lines: [],
+      image: C
+    });
+  }, St = (h) => {
+    if (h.anchor) {
+      An(h);
+      return;
+    }
+    y + h.heightPx > Z() && se() && ie();
+    const F = h.wrap === "square" && h.align !== "center", d = m - h.widthPx, p = le() + (h.align === "center" ? d / 2 : h.align === "right" ? d : 0);
+    L.blocks.push({
+      blockId: h.id,
+      x: p,
+      y,
+      firstLineIndex: 0,
+      lines: [],
+      image: { src: h.src, width: h.widthPx, height: h.heightPx }
+    }), F ? de.push({ left: p, right: p + h.widthPx, bottom: y + h.heightPx, side: h.align === "right" ? "right" : "left" }) : y += h.heightPx;
+  }, En = (h) => {
+    const F = n(h);
+    let d = !0, p = 0, C = null;
+    const B = (P, H, j, $) => {
+      if (C === null) {
+        C = { blockId: h.id, x: le() + w(h), y, firstLineIndex: p, lines: [] };
+        const J = p === 0 ? M.get(h.id) : void 0;
+        if (J) {
+          const q = P[0]?.frag.x ?? 0;
+          C.marker = { text: J.text, style: J.style, x: C.x + q - J.hangingPx };
+        }
+        L.blocks.push(C);
+      }
+      const K = { y: y - C.y, height: H, ascent: j, fragments: P.map((J) => J.frag) };
+      $ !== void 0 && (K.emptyOffset = $), C.lines.push(K), y += H, p++;
+    };
+    for (const P of F) {
+      const H = ct(P.runs, P.startOffset), j = P.runs.map(() => 0);
+      let $, K = !1, J = null;
+      for (; ; ) {
+        const q = j.slice(), V = Sn(y), ee = d ? h.style.indentFirstLinePx : 0, Y = at(
+          h,
+          P,
+          Math.max(24, V.width - w(h) - ee - R(h)),
+          $,
+          H,
+          j
+        );
+        if (Y === null) break;
+        if (y + Y.height > Z() && se()) {
+          for (let fe = 0; fe < j.length; fe++) j[fe] = q[fe];
+          ie(), C = null;
+          continue;
+        }
+        const me = V.width - ee - R(h) - Y.width;
+        let Me = V.x0 - le() + ee;
+        h.style.align === "center" ? Me += me / 2 : h.style.align === "right" && (Me += me);
+        for (const fe of Y.frags) fe.frag.x += Me;
+        h.style.align === "justify" && (J && rn(J.frags, J.slack), J = { frags: Y.frags, slack: me }), B(Y.frags, Y.height, Y.ascent), $ = Y.end, d = !1, K = !0;
+      }
+      if (!K) {
+        const q = nn(h);
+        y + q.height > Z() && se() && (ie(), C = null), B([], q.height, q.ascent, P.startOffset), d = !1;
+      }
+    }
+  }, Bn = (h) => {
+    h.block.rows.some((p) => p.cells.some((C) => (C.rowSpan ?? 1) > 1)) && se() && y + h.height > Z() && h.height <= u - f && ie();
+    let d = 0;
+    for (; d < h.rows.length; ) {
+      let p = 0, C = y;
+      for (; d + p < h.rows.length && C + h.rows[d + p].height <= Z(); )
+        C += h.rows[d + p].height, p++;
+      if (p === 0) {
+        if (se()) {
+          ie();
+          continue;
+        }
+        p = 1;
+      }
+      let B = [], P = 0;
+      for (; ; ) {
+        const j = gn(h.block.rows.slice(d, d + p));
+        if (j.length === 0) break;
+        const { H: $, measures: K } = gt(j);
+        if (K.length === 0) break;
+        let J = 0;
+        for (let q = d; q < d + p; q++) J += h.rows[q].height;
+        if (y + J + $ <= Z() || p === 1 && !se()) {
+          B = K, P = $;
+          break;
+        }
+        if (p--, p === 0) break;
+      }
+      if (p === 0) {
+        ie();
+        continue;
+      }
+      B.length > 0 && Nt(B, P);
+      const H = h.rows.slice(d, d + p);
+      L.blocks.push(ht(h.block, H, h.colWidths, le(), y, m, d, v)), y += H.reduce((j, $) => j + $.height, 0), d += p, d < h.rows.length && ie();
+    }
+  };
+  for (let h = 0; h < _.length; h++) {
+    if (h > l[z].endBlock) {
+      for (; h > l[z].endBlock; ) k(l[++z].props);
+      hn();
+    }
+    const F = _[h], d = (H) => H?.kind === "table" || H?.kind === "image" && H.block.anchor === void 0, p = d(_[h - 1]), C = d(_[h + 1]);
+    if (F.kind === "image") {
+      if (F.block.anchor) {
+        St(F.block);
+        continue;
+      }
+      p || (y += Ce), St(F.block), !C && (F.block.wrap !== "square" || F.block.align === "center") && (y += Ce);
+      continue;
+    }
+    if (F.kind === "table") {
+      p || (y += Ce);
+      for (const H of de) H.bottom > y && (y = H.bottom);
+      Bn(F), C || (y += Ce);
+      continue;
+    }
+    const { block: B, lines: P } = F;
+    if (B.style.pageBreakBefore === !0 && (L.blocks.length > 0 || pe > 0) ? je() : B.style.columnBreakBefore === !0 && se() && ie(), y += B.style.spaceBeforePx, y >= Z() && se() && ie(), mn(y)) {
+      En(B), y += B.style.spaceAfterPx;
+      continue;
+    }
+    if (B.style.keepWithNext === !0 && _[h + 1] !== void 0 && se()) {
+      let H = y + Se(P) + B.style.spaceAfterPx, j = H <= Z();
+      for (let $ = h + 1; j; $++) {
+        const K = _[$];
+        if (K === void 0) break;
+        if (K.kind !== "para") {
+          const Y = K.kind === "table" ? K.rows[0]?.height ?? K.height : K.height;
+          H + Ce + Y > Z() && (j = !1);
+          break;
+        }
+        H += K.block.style.spaceBeforePx;
+        const J = K.block.style.keepWithNext === !0 && _[$ + 1] !== void 0;
+        if (J || K.block.style.keepLinesTogether === !0) {
+          const Y = Se(K.lines);
+          if (H + Y > Z()) {
+            j = !1;
+            break;
+          }
+          if (H += Y + K.block.style.spaceAfterPx, !J) break;
+          continue;
+        }
+        if (_[$ + 1] !== void 0 && K.block.runs.every((Y) => Y.text.trim().length === 0)) {
+          const Y = Se(K.lines);
+          if (H + Y > Z()) {
+            j = !1;
+            break;
+          }
+          H += Y + K.block.style.spaceAfterPx;
+          continue;
+        }
+        let q = 0, V = H;
+        for (; q < K.lines.length && V + K.lines[q].height <= Z(); )
+          V += K.lines[q].height, q++;
+        let ee = q;
+        q < K.lines.length && (K.lines.length - ee === 1 && (ee -= Ht - 1), ee < Gt && (ee = 0)), ee <= 0 && (j = !1);
+        break;
+      }
+      j || ie();
+    }
+    pn(B, P), y += B.style.spaceAfterPx;
+  }
+  for (const h of I) {
+    const F = xe[h.index];
+    if (!F || F.length === 0) continue;
+    const d = D[h.index];
+    k(d);
+    let p = u - ze[h.index];
+    h.footnoteRuleY = p + 4, p += Q;
+    const C = d.marginPx.left;
+    for (const B of F) {
+      const P = Ft(B);
+      if (!P) continue;
+      let H = !0;
+      for (const j of P.paras) {
+        p += j.p.style.spaceBeforePx;
+        const $ = {
+          blockId: j.p.id,
+          x: C + X,
+          y: p,
+          firstLineIndex: 0,
+          lines: j.lines
+        };
+        H && j.p.runs[0] && ($.marker = { text: `${dt.get(B) ?? "•"}.`, style: j.p.runs[0].style, x: C }, H = !1), h.blocks.push($), p += Se(j.lines) + j.p.style.spaceAfterPx;
+      }
+    }
+  }
+  for (const h of I) {
+    if (!h.blocks.some((d) => d.image?.behind || d.image?.front)) continue;
+    const F = (d) => d.image?.behind ? 0 : d.image?.front ? 2 : 1;
+    h.blocks = h.blocks.map((d, p) => ({ b: d, i: p })).sort((d, p) => {
+      const C = F(d.b) - F(p.b);
+      if (C !== 0) return C;
+      if (F(d.b) !== 1) {
+        const B = (d.b.image.z ?? 0) - (p.b.image.z ?? 0);
+        if (B !== 0) return B;
+      }
+      return d.i - p.i;
+    }).map((d) => d.b);
+  }
+  const be = [];
+  {
+    let h = 0;
+    for (let F = 0; F < I.length; F++) {
+      const d = D[F];
+      (F === 0 || D[F - 1] !== d) && d.pageNumberStart !== void 0 ? h = d.pageNumberStart : h++, be.push(h), I[F].number = h;
+    }
+  }
+  const mt = e.fields;
+  if (mt) {
+    const h = (p) => {
+      if (p === void 0) return !1;
+      const C = mt[p], B = C && C.kind === "builtin" ? C.spec?.type : void 0;
+      return B === "PAGE" || B === "NUMPAGES";
+    }, F = (p, C) => {
+      let B = 0;
+      for (const P of p.fragments) {
+        if (B !== 0 && (P.x += B), !h(P.style.fieldId)) continue;
+        const H = an(P.text, C, I.length);
+        if (H === P.text) continue;
+        const j = P.endOffset - P.startOffset, $ = P.width;
+        P.text = H, P.width = Pe(H, ce(P.style)), P.offsetMap = Array.from({ length: H.length + 1 }, (K, J) => J === H.length ? j : 0), B += P.width - $;
+      }
+    }, d = (p, C) => {
+      for (const B of p.lines) F(B, C);
+      if (p.table) for (const B of p.table.rows) for (const P of B.cells) for (const H of P.blocks) d(H, C);
+    };
+    for (const p of I) for (const C of p.blocks) d(C, be[p.index]);
+  }
+  if (U.size > 0) {
+    const h = /* @__PURE__ */ new Map(), F = (d, p) => {
+      for (const C of d)
+        if (h.has(C.blockId) || h.set(C.blockId, p), C.table) for (const B of C.table.rows) for (const P of B.cells) F(P.blocks, p);
+    };
+    for (const d of I) F(d.blocks, be[d.index]);
+    for (const d of U.values()) {
+      const p = d.para.style.tocEntry.targetId, C = h.get(p);
+      if (C === void 0) continue;
+      const B = d.para.runs[0]?.style;
+      if (!B || d.chunk.lines.length === 0) continue;
+      const P = String(C);
+      d.chunk.toc = {
+        numText: P,
+        numX: d.rightEdge - Pe(P, ce(B)),
+        lineIndex: d.chunk.lines.length - 1,
+        style: B,
+        targetId: p
+      };
+    }
+  }
+  const At = (h, F, d, p) => {
+    const C = F === "header" ? h.headerFirst : h.footerFirst, B = F === "header" ? h.headerEven : h.footerEven;
+    if (d && C) return { blocks: C, source: F === "header" ? "headerFirst" : "footerFirst" };
+    if (p && B) return { blocks: B, source: F === "header" ? "headerEven" : "footerEven" };
+    const P = h[F];
+    return P ? { blocks: P, source: F } : null;
+  };
+  if (D.some((h) => on.some((F) => h[F]))) {
+    const h = new et();
+    for (const F of I) {
+      const d = D[F.index], p = d.pageWidthPx - d.marginPx.left - d.marginPx.right, C = d.marginPx.left, B = F.index === 0 || D[F.index - 1] !== d, P = be[F.index], H = P % 2 === 0, j = At(d, "header", B, H);
+      if (j) {
+        const K = r === "header", J = Ie(j.blocks, p, C, P, I.length, h, K), q = _t(d, J.height);
+        F.header = J.placed.map((V) => tt(V, q)), F.headerSource = j.source;
+      }
+      const $ = At(d, "footer", B, H);
+      if ($) {
+        const K = r === "footer", J = Ie($.blocks, p, C, P, I.length, h, K), q = zt(d, J.height);
+        F.footer = J.placed.map((V) => tt(V, q)), F.footerSource = $.source;
+      }
+    }
+  }
+  return {
+    pages: I,
+    pageWidthPx: e.section.pageWidthPx,
+    pageHeightPx: e.section.pageHeightPx,
+    marginPx: e.section.marginPx
+  };
+}
+function bs(e, t) {
+  switch (t) {
+    case "roman":
+      return Oe(e, "lowerRoman");
+    case "Roman":
+      return Oe(e, "upperRoman");
+    case "alpha":
+      return Oe(e, "lowerLetter");
+    case "Alpha":
+      return Oe(e, "upperLetter");
+    default:
+      return String(e);
+  }
+}
+function an(e, t, n) {
+  return e.replace(/\{page(?::(roman|Roman|alpha|Alpha))?\}/g, (r, i) => bs(t, i)).replace(/\{pages\}/g, String(n)).replace(/\{date\}/g, () => (/* @__PURE__ */ new Date()).toLocaleDateString()).replace(/\{time\}/g, () => (/* @__PURE__ */ new Date()).toLocaleTimeString([], { hour: "2-digit", minute: "2-digit" }));
+}
+function Os(e, t, n) {
+  const r = (i) => i.runs.some((s) => s.text.includes("{")) ? {
+    ...i,
+    id: `${i.id}@p${t}`,
+    // per-page identity keeps the band prepare-cache honest
+    runs: i.runs.map((s) => ({ ...s, text: an(s.text, t, n) }))
+  } : i;
+  return e.kind === "paragraph" ? r(e) : e.kind === "table" ? {
+    ...e,
+    rows: e.rows.map((i) => ({
+      cells: i.cells.map((s) => ({
+        ...s,
+        blocks: s.blocks.map((o) => o.kind === "paragraph" ? r(o) : o)
+      }))
+    }))
+  } : e;
+}
+function Ie(e, t, n, r, i, s, o) {
+  const a = (c, f) => xn(c, f, s), l = [];
+  let x = 0;
+  for (const c of e) {
+    const f = o ? c : Os(c, r, i);
+    if (f.kind === "paragraph") {
+      x += f.style.spaceBeforePx;
+      const u = a(f, t);
+      l.push({ blockId: f.id, x: n + f.style.indentLeftPx, y: x, firstLineIndex: 0, lines: u }), x += ut(u) + f.style.spaceAfterPx;
+    } else if (f.kind === "image") {
+      const u = t - f.widthPx, g = n + (f.align === "center" ? u / 2 : f.align === "right" ? u : 0);
+      l.push({
+        blockId: f.id,
+        x: g,
+        y: x,
+        firstLineIndex: 0,
+        lines: [],
+        image: { src: f.src, width: f.widthPx, height: f.heightPx }
+      }), x += f.heightPx;
+    } else {
+      const u = ft(f, t, a, jt);
+      l.push(ht(f, u.rows, u.colWidths, n, x, t, 0, jt)), x += u.height;
+    }
+  }
+  return { placed: l, height: x };
+}
+function tt(e, t) {
+  const n = { ...e, y: e.y + t };
+  return e.table && (n.table = {
+    ...e.table,
+    y: e.table.y + t,
+    rows: e.table.rows.map((r) => ({
+      ...r,
+      y: r.y + t,
+      cells: r.cells.map((i) => ({
+        ...i,
+        y: i.y + t,
+        blocks: i.blocks.map((s) => tt(s, t))
+      }))
+    }))
+  }), n;
+}
+const Ce = 12, ys = { top: 0, right: 7.2, bottom: 0, left: 7.2 }, fn = (e) => e.margin ?? ys, ke = 4, jt = { indentOf: () => 0, markers: /* @__PURE__ */ new Map() };
+function ft(e, t, n, r) {
+  const s = Cn(e).map((c) => c * t), o = s.length, a = new Array(o).fill(0), l = e.rows.map((c) => {
+    let f = 0;
+    const u = c.cells.map((g) => {
+      for (; f < o && a[f] > 0; ) f++;
+      const S = Math.max(1, g.colSpan ?? 1), E = Math.max(1, g.rowSpan ?? 1), m = f;
+      let k = 0;
+      for (let N = 0; N < S; N++) k += s[f + N] ?? s[o - 1] ?? 40;
+      if (E > 1) for (let N = 0; N < S && f + N < o; N++) a[f + N] = E;
+      f += S;
+      const T = fn(g), O = Math.max(8, k - T.left - T.right);
+      let w = 0;
+      const R = g.blocks.map((N) => {
+        if (N.kind === "paragraph") {
+          const M = O - N.style.indentLeftPx - r.indentOf(N) - (N.style.indentRightPx ?? 0), G = n(N, Math.max(8, M));
+          return w += N.style.spaceBeforePx + ut(G) + N.style.spaceAfterPx, { kind: "para", block: N, lines: G };
+        }
+        if (N.kind === "image") {
+          const M = Math.min(1, O / Math.max(1, N.widthPx)), G = N.widthPx * M, W = N.heightPx * M;
+          return w += W + ke, { kind: "image", block: N, width: G, height: W };
+        }
+        const b = ft(N, O, n, r);
+        return w += b.height + ke, { kind: "table", block: N, ...b };
+      });
+      return { cell: g, items: R, height: w + T.top + T.bottom, width: k, colStart: m, rowSpan: E };
+    });
+    for (let g = 0; g < o; g++) a[g] > 0 && a[g]--;
+    return { cells: u, height: 0 };
+  }), x = l.map((c) => Math.max(0, ...c.cells.filter((f) => f.rowSpan === 1).map((f) => f.height)));
+  return l.forEach((c, f) => {
+    for (const u of c.cells) {
+      if (u.rowSpan <= 1) continue;
+      const g = Math.min(l.length - 1, f + u.rowSpan - 1);
+      let S = 0;
+      for (let E = f; E <= g; E++) S += x[E];
+      u.height > S && (x[g] += u.height - S);
+    }
+  }), l.forEach((c, f) => c.height = x[f]), { rows: l, colWidths: s, height: x.reduce((c, f) => c + f, 0) };
+}
+function ut(e) {
+  let t = 0;
+  for (const n of e) t += n.height;
+  return t;
+}
+function ht(e, t, n, r, i, s, o, a) {
+  const l = [0];
+  for (const u of n) l.push(l[l.length - 1] + u);
+  const x = [i];
+  for (const u of t) x.push(x[x.length - 1] + u.height);
+  const c = [];
+  for (let u = 0; u < t.length; u++) {
+    const g = t[u], S = x[u], E = [];
+    for (const m of g.cells) {
+      const k = r + (l[m.colStart] ?? l[l.length - 1]), T = Math.min(t.length - 1, u + m.rowSpan - 1), O = x[T + 1] - S, w = [], R = fn(m.cell), N = m.width - R.left - R.right;
+      let b = S + R.top;
+      for (const M of m.items)
+        if (M.kind === "para") {
+          b += M.block.style.spaceBeforePx;
+          const G = k + R.left + M.block.style.indentLeftPx + a.indentOf(M.block), W = {
+            blockId: M.block.id,
+            x: G,
+            y: b,
+            firstLineIndex: 0,
+            lines: M.lines
+            // line.y is already block-relative; coords stay consistent
+          }, v = a.markers.get(M.block.id);
+          v && (W.marker = { text: v.text, style: v.style, x: Math.max(k + 1, G - v.hangingPx) }), w.push(W), b += ut(M.lines) + M.block.style.spaceAfterPx;
+        } else if (M.kind === "image") {
+          const G = O - R.top - R.bottom;
+          if (m.items.length === 1 && G > M.height + 8) {
+            const W = Math.max(N / M.block.widthPx, G / M.block.heightPx), v = M.block.widthPx * W, _ = M.block.heightPx * W, z = k + R.left, D = S + R.top;
+            w.push({
+              blockId: M.block.id,
+              x: z + (N - v) / 2,
+              y: D + (G - _) / 2,
+              firstLineIndex: 0,
+              lines: [],
+              image: { src: M.block.src, width: v, height: _, clip: { x: z, y: D, width: N, height: G } }
+            }), b += M.height + ke;
+          } else {
+            const W = N - M.width, v = k + R.left + (M.block.align === "center" ? W / 2 : M.block.align === "right" ? W : 0);
+            w.push({
+              blockId: M.block.id,
+              x: v,
+              y: b,
+              firstLineIndex: 0,
+              lines: [],
+              image: { src: M.block.src, width: M.width, height: M.height }
+            }), b += M.height + ke;
+          }
+        } else
+          w.push(ht(M.block, M.rows, M.colWidths, k + R.left, b, N, 0, a)), b += M.height + ke;
+      E.push({
+        x: k,
+        y: S,
+        width: m.width,
+        height: O,
+        originRow: o + u,
+        originCol: m.colStart,
+        blocks: w,
+        ...m.cell.shading !== void 0 ? { shading: m.cell.shading } : {},
+        ...m.cell.borders !== void 0 ? { borders: m.cell.borders } : {},
+        // Horizontal content band (full cell height): clips over-wide text to the
+        // inner box so it never paints onto the border or into the next column.
+        contentClip: { x: k + R.left, y: S, width: N, height: O }
+      });
+    }
+    c.push({ y: S, height: g.height, cells: E });
+  }
+  const f = t.reduce((u, g) => u + g.height, 0);
+  return {
+    blockId: e.id,
+    x: r,
+    y: i,
+    firstLineIndex: o,
+    // for tables this is the chunk's first ROW index
+    lines: [],
+    table: { x: r, y: i, width: s, height: f, rows: c, colWidths: n }
+  };
+}
+const vs = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  createLayoutEngine: Ss,
+  effectiveSection: ln,
+  resolveSections: cn
+}, Symbol.toStringTag, { value: "Module" }));
+function Is(e) {
+  const t = /* @__PURE__ */ new Map(), n = (r, i) => {
+    for (const s of r)
+      if (t.has(s.blockId) || t.set(s.blockId, i), s.table) for (const o of s.table.rows) for (const a of o.cells) n(a.blocks, i);
+  };
+  for (const r of e.pages) n(r.blocks, r.number);
+  return t;
+}
+function Rs(e, t) {
+  const n = Is(t), r = [];
+  for (const i of e.blocks) {
+    if (i.kind !== "paragraph") continue;
+    const s = i.runs.find((f) => f.style.link?.startsWith("#"))?.style.link?.slice(1);
+    if (!s) continue;
+    const o = e.bookmarks?.[s]?.start.blockId;
+    if (!o) continue;
+    const a = n.get(o);
+    if (a === void 0) continue;
+    const l = kn(i.runs), x = l.match(/\t(\d+)(\s*)$/);
+    if (!x || x[1] === String(a)) continue;
+    const c = l.length - x[2].length - x[1].length;
+    r.push({
+      blockId: i.id,
+      start: c,
+      end: c + x[1].length,
+      text: String(a),
+      style: Dn(i.runs, c) ?? i.runs[0]?.style
+    });
+  }
+  return r;
+}
+export {
+  Rs as a,
+  Ss as c,
+  vs as e,
+  Is as p
+};