@forevka/wordcanvas 0.7.1 → 0.7.3

package/dist-lib/recalcToc-BfXlXZik.js

@@ -0,0 +1,3985 @@
+import { C as kn, N as Dn, t as bn, s as Ln } from "./toc-D09f4PrI.js";
+import { e as On, f as ye } from "./lists-DpmgbDyt.js";
+import { a as ae, m as Pe, f as We } from "./metrics-bvGO8KDK.js";
+const yn = [
+  "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"
+], Mt = [
+  [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 In(e) {
+  if (e <= 255)
+    return yn[e];
+  let t = 0, n = Mt.length - 1;
+  for (; t <= n; ) {
+    const x = t + n >> 1, i = Mt[x];
+    if (e < i[0]) {
+      n = x - 1;
+      continue;
+    }
+    if (e > i[1]) {
+      t = x + 1;
+      continue;
+    }
+    return i[2];
+  }
+  return "L";
+}
+function wn(e) {
+  const t = e.length;
+  if (t === 0)
+    return null;
+  const n = new Array(t);
+  let x = !1;
+  for (let r = 0; r < t; ) {
+    const l = e.charCodeAt(r);
+    let f = l, h = 1;
+    if (l >= 55296 && l <= 56319 && r + 1 < t) {
+      const A = e.charCodeAt(r + 1);
+      A >= 56320 && A <= 57343 && (f = (l - 55296 << 10) + (A - 56320) + 65536, h = 2);
+    }
+    const g = In(f);
+    (g === "R" || g === "AL" || g === "AN") && (x = !0);
+    for (let A = 0; A < h; A++)
+      n[r + A] = g;
+    r += h;
+  }
+  if (!x)
+    return null;
+  let i = 0;
+  for (let r = 0; r < t; r++) {
+    const l = n[r];
+    if (l === "L") {
+      i = 0;
+      break;
+    }
+    if (l === "R" || l === "AL") {
+      i = 1;
+      break;
+    }
+  }
+  const s = new Int8Array(t);
+  for (let r = 0; r < t; r++)
+    s[r] = i;
+  const o = i & 1 ? "R" : "L", a = o;
+  let c = a;
+  for (let r = 0; r < t; r++)
+    n[r] === "NSM" ? n[r] = c : c = n[r];
+  c = a;
+  for (let r = 0; r < t; r++) {
+    const l = n[r];
+    l === "EN" ? n[r] = c === "AL" ? "AN" : "EN" : (l === "R" || l === "L" || l === "AL") && (c = l);
+  }
+  for (let r = 0; r < t; r++)
+    n[r] === "AL" && (n[r] = "R");
+  for (let r = 1; r < t - 1; r++)
+    n[r] === "ES" && n[r - 1] === "EN" && n[r + 1] === "EN" && (n[r] = "EN"), n[r] === "CS" && (n[r - 1] === "EN" || n[r - 1] === "AN") && n[r + 1] === n[r - 1] && (n[r] = n[r - 1]);
+  for (let r = 0; r < t; r++) {
+    if (n[r] !== "EN")
+      continue;
+    let l;
+    for (l = r - 1; l >= 0 && n[l] === "ET"; l--)
+      n[l] = "EN";
+    for (l = r + 1; l < t && n[l] === "ET"; l++)
+      n[l] = "EN";
+  }
+  for (let r = 0; r < t; r++) {
+    const l = n[r];
+    (l === "WS" || l === "ES" || l === "ET" || l === "CS") && (n[r] = "ON");
+  }
+  c = a;
+  for (let r = 0; r < t; r++) {
+    const l = n[r];
+    l === "EN" ? n[r] = c === "L" ? "L" : "EN" : (l === "R" || l === "L") && (c = l);
+  }
+  for (let r = 0; r < t; r++) {
+    if (n[r] !== "ON")
+      continue;
+    let l = r + 1;
+    for (; l < t && n[l] === "ON"; )
+      l++;
+    const f = r > 0 ? n[r - 1] : a, h = l < t ? n[l] : a, g = f !== "L" ? "R" : "L";
+    if (g === (h !== "L" ? "R" : "L"))
+      for (let m = r; m < l; m++)
+        n[m] = g;
+    r = l - 1;
+  }
+  for (let r = 0; r < t; r++)
+    n[r] === "ON" && (n[r] = o);
+  for (let r = 0; r < t; r++) {
+    const l = n[r];
+    (s[r] & 1) === 0 ? l === "R" ? s[r]++ : (l === "AN" || l === "EN") && (s[r] += 2) : (l === "L" || l === "AN" || l === "EN") && s[r]++;
+  }
+  return s;
+}
+function Pn(e, t) {
+  const n = wn(e);
+  if (n === null)
+    return null;
+  const x = new Int8Array(t.length);
+  for (let i = 0; i < t.length; i++)
+    x[i] = n[t[i]];
+  return x;
+}
+const Wn = /[ \t\n\r\f]+/g, vn = /[\t\n\r\f]| {2,}|^ | $/;
+function Rn(e) {
+  const t = e ?? "normal";
+  return t === "pre-wrap" ? { mode: t, preserveOrdinarySpaces: !0, preserveHardBreaks: !0 } : { mode: t, preserveOrdinarySpaces: !1, preserveHardBreaks: !1 };
+}
+function Tn(e) {
+  if (!vn.test(e))
+    return e;
+  let t = e.replace(Wn, " ");
+  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 Gn(e) {
+  return /[\r\f]/.test(e) ? e.replace(/\r\n/g, `
+`).replace(/[\r\f]/g, `
+`) : e;
+}
+let Ue = null, Hn;
+function _n() {
+  return Ue === null && (Ue = new Intl.Segmenter(Hn, { granularity: "word" })), Ue;
+}
+const zn = /\p{Script=Arabic}/u, ge = /\p{M}/u, st = /\p{Nd}/u;
+function Ct(e) {
+  return zn.test(e);
+}
+function kt(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 xe(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 x = e.charCodeAt(t + 1);
+        if (x >= 56320 && x <= 57343) {
+          const i = (n - 55296 << 10) + (x - 56320) + 65536;
+          if (kt(i))
+            return !0;
+          t++;
+          continue;
+        }
+      }
+      if (kt(n))
+        return !0;
+    }
+  }
+  return !1;
+}
+function jn(e) {
+  const t = ke(e);
+  return t !== null && (it.has(t) || Fe.has(t));
+}
+const Kn = /* @__PURE__ */ new Set([
+  " ",
+  " ",
+  "⁠",
+  "\uFEFF"
+]), Un = /* @__PURE__ */ new Set([
+  "-",
+  "‐",
+  "–",
+  "—"
+]);
+function Jn(e) {
+  const t = ke(e);
+  return t !== null && Kn.has(t);
+}
+function Qn(e) {
+  const t = ke(e);
+  return t !== null && Un.has(t);
+}
+function Jt(e, t) {
+  return Jn(e) ? !1 : t ? !(jn(e) || Qn(e)) : !0;
+}
+const it = /* @__PURE__ */ new Set([
+  "，",
+  "．",
+  "！",
+  "：",
+  "；",
+  "？",
+  "、",
+  "。",
+  "・",
+  "）",
+  "〕",
+  "〉",
+  "》",
+  "」",
+  "』",
+  "】",
+  "〗",
+  "〙",
+  "〛",
+  "ー",
+  "々",
+  "〻",
+  "ゝ",
+  "ゞ",
+  "ヽ",
+  "ヾ"
+]), Ge = /* @__PURE__ */ new Set([
+  '"',
+  "(",
+  "[",
+  "{",
+  "¡",
+  "¿",
+  "“",
+  "‘",
+  "‚",
+  "„",
+  "«",
+  "‹",
+  "⸘",
+  "（",
+  "〔",
+  "〈",
+  "《",
+  "「",
+  "『",
+  "【",
+  "〖",
+  "〘",
+  "〚"
+]), rt = /* @__PURE__ */ new Set([
+  "'",
+  "’"
+]), Fe = /* @__PURE__ */ new Set([
+  ".",
+  ",",
+  "!",
+  "?",
+  ":",
+  ";",
+  "،",
+  "؛",
+  "؟",
+  "।",
+  "॥",
+  "၊",
+  "။",
+  "၌",
+  "၍",
+  "၏",
+  ")",
+  "]",
+  "}",
+  "%",
+  '"',
+  "”",
+  "’",
+  "»",
+  "›",
+  "…"
+]), Yn = /* @__PURE__ */ new Set([
+  ":",
+  ".",
+  "،",
+  "؛"
+]), $n = /* @__PURE__ */ new Set([
+  "၏"
+]), Xn = /* @__PURE__ */ new Set([
+  "”",
+  "’",
+  "»",
+  "›",
+  "」",
+  "』",
+  "】",
+  "》",
+  "〉",
+  "〕",
+  "）"
+]);
+function Vn(e) {
+  if (xt(e))
+    return !0;
+  let t = !1;
+  for (const n of e) {
+    if (Fe.has(n) || _e(n)) {
+      t = !0;
+      continue;
+    }
+    if (!(t && ge.test(n)))
+      return !1;
+  }
+  return t;
+}
+function qn(e) {
+  for (const t of e)
+    if (!it.has(t) && !Fe.has(t))
+      return !1;
+  return e.length > 0;
+}
+function Zn(e) {
+  if (xt(e))
+    return !0;
+  for (const t of e)
+    if (!Ge.has(t) && !rt.has(t) && !ge.test(t) && !_e(t))
+      return !1;
+  return e.length > 0;
+}
+function xt(e) {
+  let t = !1;
+  for (const n of e)
+    if (!(n === "\\" || ge.test(n))) {
+      if (Ge.has(n) || Fe.has(n) || rt.has(n)) {
+        t = !0;
+        continue;
+      }
+      return !1;
+    }
+  return t;
+}
+function He(e, t) {
+  const n = t - 1;
+  if (n <= 0)
+    return Math.max(n, 0);
+  const x = e.charCodeAt(n);
+  if (x < 56320 || x > 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 ke(e) {
+  if (e.length === 0)
+    return null;
+  const t = He(e, e.length);
+  return e.slice(t);
+}
+function e0(e) {
+  for (const t of e)
+    if (!ge.test(t))
+      return t;
+  return null;
+}
+function t0(e) {
+  for (let t = e.length; t > 0; ) {
+    const n = He(e, t), x = e.slice(n, t);
+    if (!ge.test(x))
+      return x;
+    t = n;
+  }
+  return null;
+}
+const n0 = [
+  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 s0(e, t) {
+  for (let n = 0; n < t.length; n += 2)
+    if (e >= t[n] && e <= t[n + 1])
+      return !0;
+  return !1;
+}
+function _e(e) {
+  const t = e.codePointAt(0);
+  return t !== void 0 && s0(t, n0);
+}
+function i0(e) {
+  const t = t0(e);
+  return t !== null && _e(t);
+}
+function r0(e) {
+  const t = e0(e);
+  return t !== null && st.test(t);
+}
+function x0(e) {
+  const t = Array.from(e);
+  let n = t.length;
+  for (; n > 0; ) {
+    const x = t[n - 1];
+    if (ge.test(x)) {
+      n--;
+      continue;
+    }
+    if (Ge.has(x) || rt.has(x)) {
+      n--;
+      continue;
+    }
+    break;
+  }
+  return n <= 0 || n === t.length ? null : {
+    head: t.slice(0, n).join(""),
+    tail: t.slice(n).join("")
+  };
+}
+function o0(e, t, n) {
+  return n === "text" && !t && e.length === 1 && e !== "-" && e !== "—" ? e : null;
+}
+function Dt(e, t, n, x) {
+  const i = t[x], s = e[x];
+  if (i == null)
+    return s;
+  const o = n[x];
+  if (s.length === o)
+    return s;
+  const a = i.repeat(o);
+  return e[x] = a, a;
+}
+function bt(e, t) {
+  return e && t !== null && Yn.has(t);
+}
+function l0(e) {
+  const t = ke(e);
+  return t !== null && $n.has(t);
+}
+function c0(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 Ve(e) {
+  let t = e.length;
+  for (; t > 0; ) {
+    const n = He(e, t), x = e.slice(n, t);
+    if (Xn.has(x))
+      return !0;
+    if (!Fe.has(x))
+      return !1;
+    t = n;
+  }
+  return !1;
+}
+function a0(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 f0 = /[\x20\t\n\xA0\xAD\u200B\u202F\u2060\uFEFF]/;
+function re(e) {
+  return e.length === 1 ? e[0] : e.join("");
+}
+function u0(e, t) {
+  const n = [];
+  for (let x = e.length - 1; x >= 0; x--)
+    n.push(e[x]);
+  return n.push(t), re(n);
+}
+function h0(e, t, n, x) {
+  if (!f0.test(e))
+    return [{ text: e, isWordLike: t, kind: "text", start: n }];
+  const i = [];
+  let s = null, o = [], a = n, c = !1, r = 0;
+  for (const l of e) {
+    const f = a0(l, x), h = f === "text" && t;
+    if (s !== null && f === s && h === c) {
+      o.push(l), r += l.length;
+      continue;
+    }
+    s !== null && i.push({
+      text: re(o),
+      isWordLike: c,
+      kind: s,
+      start: a
+    }), s = f, o = [l], a = n + r, c = h, r += l.length;
+  }
+  return s !== null && i.push({
+    text: re(o),
+    isWordLike: c,
+    kind: s,
+    start: a
+  }), i;
+}
+function qe(e) {
+  return e === "space" || e === "preserved-space" || e === "zero-width-break" || e === "hard-break";
+}
+const d0 = /^[A-Za-z][A-Za-z0-9+.-]*:$/;
+function F0(e, t) {
+  const n = e.texts[t];
+  return n.startsWith("www.") ? !0 : d0.test(n) && t + 1 < e.len && e.kinds[t + 1] === "text" && e.texts[t + 1] === "//";
+}
+function g0(e) {
+  return e.includes("?") && (e.includes("://") || e.startsWith("www."));
+}
+function N0(e) {
+  const t = e.texts.slice(), n = e.isWordLike.slice(), x = e.kinds.slice(), i = e.starts.slice();
+  for (let o = 0; o < e.len; o++) {
+    if (x[o] !== "text" || !F0(e, o))
+      continue;
+    const a = [t[o]];
+    let c = o + 1;
+    for (; c < e.len && !qe(x[c]); ) {
+      a.push(t[c]), n[o] = !0;
+      const r = t[c].includes("?");
+      if (x[c] = "text", t[c] = "", c++, r)
+        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], x[s] = x[o], i[s] = i[o]), s++);
+  }
+  return t.length = s, n.length = s, x.length = s, i.length = s, {
+    len: s,
+    texts: t,
+    isWordLike: n,
+    kinds: x,
+    starts: i
+  };
+}
+function p0(e) {
+  const t = [], n = [], x = [], i = [];
+  for (let s = 0; s < e.len; s++) {
+    const o = e.texts[s];
+    if (t.push(o), n.push(e.isWordLike[s]), x.push(e.kinds[s]), i.push(e.starts[s]), !g0(o))
+      continue;
+    const a = s + 1;
+    if (a >= e.len || qe(e.kinds[a]))
+      continue;
+    const c = [], r = e.starts[a];
+    let l = a;
+    for (; l < e.len && !qe(e.kinds[l]); )
+      c.push(e.texts[l]), l++;
+    c.length > 0 && (t.push(re(c)), n.push(!0), x.push("text"), i.push(r), s = l - 1);
+  }
+  return {
+    len: t.length,
+    texts: t,
+    isWordLike: n,
+    kinds: x,
+    starts: i
+  };
+}
+const S0 = /* @__PURE__ */ new Set([
+  ":",
+  "-",
+  "/",
+  "×",
+  ",",
+  ".",
+  "+",
+  "–",
+  "—"
+]), m0 = /* @__PURE__ */ new Set([".", ",", ":", ";"]);
+function Lt(e) {
+  for (let t = e.length; t > 0; ) {
+    const n = He(e, t), x = e.slice(n, t);
+    if (ge.test(x)) {
+      t = n;
+      continue;
+    }
+    return m0.has(x) || _e(x);
+  }
+  return !1;
+}
+function A0(e, t) {
+  return t && !xe(e);
+}
+function Qt(e) {
+  for (const t of e)
+    if (st.test(t))
+      return !0;
+  return !1;
+}
+function ve(e) {
+  if (e.length === 0)
+    return !1;
+  for (const t of e)
+    if (!(st.test(t) || S0.has(t)))
+      return !1;
+  return !0;
+}
+function E0(e) {
+  const t = [], n = [], x = [], i = [];
+  for (let s = 0; s < e.len; s++) {
+    const o = e.texts[s], a = e.kinds[s];
+    if (a === "text" && ve(o) && Qt(o)) {
+      const c = [o];
+      let r = s + 1;
+      for (; r < e.len && e.kinds[r] === "text" && ve(e.texts[r]); )
+        c.push(e.texts[r]), r++;
+      t.push(re(c)), n.push(!0), x.push("text"), i.push(e.starts[s]), s = r - 1;
+      continue;
+    }
+    t.push(o), n.push(e.isWordLike[s]), x.push(a), i.push(e.starts[s]);
+  }
+  return {
+    len: t.length,
+    texts: t,
+    isWordLike: n,
+    kinds: x,
+    starts: i
+  };
+}
+function B0(e) {
+  const t = [], n = [], x = [], i = [];
+  for (let s = 0; s < e.len; s++) {
+    const o = e.texts[s], a = e.kinds[s], c = e.isWordLike[s];
+    if (a === "text" && Lt(o) && (c || i0(o)) && !xe(o)) {
+      const r = [o];
+      let l = !0, f = s + 1;
+      for (; l && f < e.len && e.kinds[f] === "text" && A0(e.texts[f], e.isWordLike[f]); ) {
+        const h = e.texts[f];
+        r.push(h), l = Lt(h), f++;
+      }
+      t.push(re(r)), n.push(!0), x.push("text"), i.push(e.starts[s]), s = f - 1;
+      continue;
+    }
+    t.push(o), n.push(c), x.push(a), i.push(e.starts[s]);
+  }
+  return {
+    len: t.length,
+    texts: t,
+    isWordLike: n,
+    kinds: x,
+    starts: i
+  };
+}
+function M0(e) {
+  const t = [], n = [], x = [], 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 c = a.length > 1;
+      for (let r = 0; r < a.length; r++) {
+        const l = a[r];
+        if (!c)
+          break;
+        (l.length === 0 || !Qt(l) || !ve(l)) && (c = !1);
+      }
+      if (c) {
+        let r = 0;
+        for (let l = 0; l < a.length; l++) {
+          const f = a[l], h = l < a.length - 1 ? `${f}-` : f;
+          t.push(h), n.push(!0), x.push("text"), i.push(e.starts[s] + r), r += h.length;
+        }
+        continue;
+      }
+    }
+    t.push(o), n.push(e.isWordLike[s]), x.push(e.kinds[s]), i.push(e.starts[s]);
+  }
+  return {
+    len: t.length,
+    texts: t,
+    isWordLike: n,
+    kinds: x,
+    starts: i
+  };
+}
+function C0(e) {
+  const t = [], n = [], x = [], i = [];
+  let s = 0;
+  for (; s < e.len; ) {
+    const o = [e.texts[s]];
+    let a = e.isWordLike[s], c = e.kinds[s], r = e.starts[s];
+    if (c === "glue") {
+      const l = [o[0]], f = r;
+      for (s++; s < e.len && e.kinds[s] === "glue"; )
+        l.push(e.texts[s]), s++;
+      const h = re(l);
+      if (s < e.len && e.kinds[s] === "text")
+        o[0] = h, o.push(e.texts[s]), a = e.isWordLike[s], c = "text", r = f, s++;
+      else {
+        t.push(h), n.push(!1), x.push("glue"), i.push(f);
+        continue;
+      }
+    } else
+      s++;
+    if (c === "text")
+      for (; s < e.len && e.kinds[s] === "glue"; ) {
+        const l = [];
+        for (; s < e.len && e.kinds[s] === "glue"; )
+          l.push(e.texts[s]), s++;
+        const f = re(l);
+        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), x.push(c), i.push(r);
+  }
+  return {
+    len: t.length,
+    texts: t,
+    isWordLike: n,
+    kinds: x,
+    starts: i
+  };
+}
+function k0(e) {
+  const t = e.texts.slice(), n = e.isWordLike.slice(), x = e.kinds.slice(), i = e.starts.slice();
+  for (let s = 0; s < t.length - 1; s++) {
+    if (x[s] !== "text" || x[s + 1] !== "text" || !xe(t[s]) || !xe(t[s + 1]))
+      continue;
+    const o = x0(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: x,
+    starts: i
+  };
+}
+function D0(e, t, n) {
+  const x = _n();
+  let i = 0;
+  const s = [], o = [], a = [], c = [], r = [], l = [], f = [], h = [], g = [], A = [], m = [], B = [];
+  for (const N of x.segment(e))
+    for (const D of h0(N.segment, N.isWordLike ?? !1, N.index, n)) {
+      let R = function() {
+        l[S] !== null && (o[S] = [
+          Dt(s, l, f, S)
+        ], l[S] = null), o[S].push(D.text), a[S] = a[S] || D.isWordLike, h[S] = h[S] || G, g[S] = g[S] || w, A[S] = z, m[S] = b, B[S] = bt(g[S], j);
+      };
+      const k = D.kind === "text", T = o0(D.text, D.isWordLike, D.kind), G = xe(D.text), w = Ct(D.text), j = ke(D.text), z = Ve(D.text), b = l0(D.text), S = i - 1;
+      t.carryCJKAfterClosingQuote && k && i > 0 && c[S] === "text" && G && h[S] && A[S] || k && i > 0 && c[S] === "text" && qn(D.text) && h[S] || k && i > 0 && c[S] === "text" && m[S] ? R() : k && i > 0 && c[S] === "text" && D.isWordLike && w && B[S] ? (R(), a[S] = !0) : T !== null && i > 0 && c[S] === "text" && l[S] === T ? f[S] = (f[S] ?? 1) + 1 : k && !D.isWordLike && i > 0 && c[S] === "text" && !h[S] && (Vn(D.text) || D.text === "-" && a[S]) ? R() : (s[i] = D.text, o[i] = [D.text], a[i] = D.isWordLike, c[i] = D.kind, r[i] = D.start, l[i] = T, f[i] = T === null ? 0 : 1, h[i] = G, g[i] = w, A[i] = z, m[i] = b, B[i] = bt(w, j), i++);
+    }
+  for (let N = 0; N < i; N++) {
+    if (l[N] !== null) {
+      s[N] = Dt(s, l, f, N);
+      continue;
+    }
+    s[N] = re(o[N]);
+  }
+  for (let N = 1; N < i; N++)
+    c[N] === "text" && !a[N] && xt(s[N]) && c[N - 1] === "text" && !h[N - 1] && (s[N - 1] += s[N], a[N - 1] = a[N - 1] || a[N], s[N] = "");
+  const C = Array.from({ length: i }, () => null);
+  let v = -1;
+  for (let N = i - 1; N >= 0; N--) {
+    const D = s[N];
+    if (D.length !== 0) {
+      if (c[N] === "text" && !a[N] && v >= 0 && c[v] === "text" && (Zn(D) || D === "-" && r0(s[v]))) {
+        const k = C[v] ?? [];
+        k.push(D), C[v] = k, r[v] = r[N], s[N] = "";
+        continue;
+      }
+      v = N;
+    }
+  }
+  for (let N = 0; N < i; N++) {
+    const D = C[N];
+    D != null && (s[N] = u0(D, s[N]));
+  }
+  let H = 0;
+  for (let N = 0; N < i; N++) {
+    const D = s[N];
+    D.length !== 0 && (H !== N && (s[H] = D, a[H] = a[N], c[H] = c[N], r[H] = r[N]), H++);
+  }
+  s.length = H, a.length = H, c.length = H, r.length = H;
+  const y = C0({
+    len: H,
+    texts: s,
+    isWordLike: a,
+    kinds: c,
+    starts: r
+  }), O = k0(B0(M0(E0(p0(N0(y))))));
+  for (let N = 0; N < O.len - 1; N++) {
+    const D = c0(O.texts[N]);
+    D !== null && (O.kinds[N] !== "space" && O.kinds[N] !== "preserved-space" || O.kinds[N + 1] !== "text" || !Ct(O.texts[N + 1]) || (O.texts[N] = D.space, O.isWordLike[N] = !1, O.kinds[N] = O.kinds[N] === "preserved-space" ? "preserved-space" : "space", O.texts[N + 1] = D.marks + O.texts[N + 1], O.starts[N + 1] = O.starts[N] + D.space.length));
+  }
+  return O;
+}
+function b0(e, t) {
+  if (e.len === 0)
+    return [];
+  if (!t.preserveHardBreaks)
+    return [{
+      startSegmentIndex: 0,
+      endSegmentIndex: e.len,
+      consumedEndSegmentIndex: e.len
+    }];
+  const n = [];
+  let x = 0;
+  for (let i = 0; i < e.len; i++)
+    e.kinds[i] === "hard-break" && (n.push({
+      startSegmentIndex: x,
+      endSegmentIndex: i,
+      consumedEndSegmentIndex: i + 1
+    }), x = i + 1);
+  return x < e.len && n.push({
+    startSegmentIndex: x,
+    endSegmentIndex: e.len,
+    consumedEndSegmentIndex: e.len
+  }), n;
+}
+function L0(e, t, n) {
+  if (t.len <= 1)
+    return t;
+  const x = [], i = [], s = [], o = [];
+  let a = -1, c = !1;
+  function r(h) {
+    x.push(t.texts[h]), i.push(t.isWordLike[h]), s.push("text"), o.push(t.starts[h]);
+  }
+  function l(h, g) {
+    let A = !1;
+    for (let C = h; C < g; C++)
+      A = A || t.isWordLike[C];
+    const m = t.starts[h], B = g < t.len ? t.starts[g] : e.length;
+    x.push(e.slice(m, B)), i.push(A), s.push("text"), o.push(m);
+  }
+  function f(h) {
+    if (!(a < 0)) {
+      if (c)
+        a + 1 === h ? r(a) : l(a, h);
+      else
+        for (let g = a; g < h; g++)
+          r(g);
+      a = -1, c = !1;
+    }
+  }
+  for (let h = 0; h < t.len; h++) {
+    const g = t.texts[h], A = t.kinds[h];
+    if (A === "text") {
+      a >= 0 && !Jt(t.texts[h - 1], n) && f(h), a < 0 && (a = h), c = c || xe(g);
+      continue;
+    }
+    f(h), x.push(g), i.push(t.isWordLike[h]), s.push(A), o.push(t.starts[h]);
+  }
+  return f(t.len), {
+    len: x.length,
+    texts: x,
+    isWordLike: i,
+    kinds: s,
+    starts: o
+  };
+}
+function O0(e, t, n = "normal", x = "normal") {
+  const i = Rn(n), s = i.mode === "pre-wrap" ? Gn(e) : Tn(e);
+  if (s.length === 0)
+    return {
+      normalized: s,
+      chunks: [],
+      len: 0,
+      texts: [],
+      isWordLike: [],
+      kinds: [],
+      starts: []
+    };
+  const o = D0(s, t, i), a = x === "keep-all" ? L0(s, o, t.breakKeepAllAfterPunctuation) : o;
+  return {
+    normalized: s,
+    chunks: b0(a, i),
+    ...a
+  };
+}
+let me = null;
+const Ot = /* @__PURE__ */ new Map();
+let Ae = null;
+const y0 = 96, I0 = /\p{Emoji_Presentation}/u, w0 = /[\p{Emoji_Presentation}\p{Extended_Pictographic}\p{Regional_Indicator}\uFE0F\u20E3]/u;
+let Je = null;
+const yt = /* @__PURE__ */ new Map();
+function ot() {
+  if (me !== null)
+    return me;
+  if (typeof OffscreenCanvas < "u")
+    return me = new OffscreenCanvas(1, 1).getContext("2d"), me;
+  if (typeof document < "u")
+    return me = document.createElement("canvas").getContext("2d"), me;
+  throw new Error("Text measurement requires OffscreenCanvas or a DOM canvas context.");
+}
+function P0(e) {
+  let t = Ot.get(e);
+  return t || (t = /* @__PURE__ */ new Map(), Ot.set(e, t)), t;
+}
+function ue(e, t) {
+  let n = t.get(e);
+  return n === void 0 && (n = {
+    width: ot().measureText(e).width,
+    containsCJK: xe(e)
+  }, t.set(e, n)), n;
+}
+function Ee() {
+  if (Ae !== null)
+    return Ae;
+  if (typeof navigator > "u")
+    return Ae = {
+      lineFitEpsilon: 5e-3,
+      carryCJKAfterClosingQuote: !1,
+      breakKeepAllAfterPunctuation: !0,
+      preferPrefixWidthsForBreakableRuns: !1,
+      preferEarlySoftHyphenBreak: !1
+    }, Ae;
+  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/"), x = e.includes("Chrome/") || e.includes("Chromium/") || e.includes("CriOS/") || e.includes("Edg/");
+  return Ae = {
+    lineFitEpsilon: n ? 1 / 64 : 5e-3,
+    carryCJKAfterClosingQuote: x,
+    breakKeepAllAfterPunctuation: !n,
+    preferPrefixWidthsForBreakableRuns: n,
+    preferEarlySoftHyphenBreak: n
+  }, Ae;
+}
+function W0(e) {
+  const t = e.match(/(\d+(?:\.\d+)?)\s*px/);
+  return t ? parseFloat(t[1]) : 16;
+}
+function Yt() {
+  return Je === null && (Je = new Intl.Segmenter(void 0, { granularity: "grapheme" })), Je;
+}
+function v0(e) {
+  return I0.test(e) || e.includes("️");
+}
+function R0(e) {
+  return w0.test(e);
+}
+function T0(e, t) {
+  let n = yt.get(e);
+  if (n !== void 0)
+    return n;
+  const x = ot();
+  x.font = e;
+  const i = x.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 yt.set(e, n), n;
+}
+function G0(e) {
+  let t = 0;
+  const n = Yt();
+  for (const x of n.segment(e))
+    v0(x.segment) && t++;
+  return t;
+}
+function H0(e, t) {
+  return t.emojiCount === void 0 && (t.emojiCount = G0(e)), t.emojiCount;
+}
+function de(e, t, n) {
+  return n === 0 ? t.width : t.width - H0(e, t) * n;
+}
+function _0(e, t, n, x, i) {
+  if (t.breakableFitAdvances !== void 0 && t.breakableFitMode === i)
+    return t.breakableFitAdvances;
+  t.breakableFitMode = i;
+  const s = Yt(), o = [];
+  for (const l of s.segment(e))
+    o.push(l.segment);
+  if (o.length <= 1)
+    return t.breakableFitAdvances = null, t.breakableFitAdvances;
+  if (i === "sum-graphemes") {
+    const l = [];
+    for (const f of o) {
+      const h = ue(f, n);
+      l.push(de(f, h, x));
+    }
+    return t.breakableFitAdvances = l, t.breakableFitAdvances;
+  }
+  if (i === "pair-context" || o.length > y0) {
+    const l = [];
+    let f = null, h = 0;
+    for (const g of o) {
+      const A = ue(g, n), m = de(g, A, x);
+      if (f === null)
+        l.push(m);
+      else {
+        const B = f + g, C = ue(B, n);
+        l.push(de(B, C, x) - h);
+      }
+      f = g, h = m;
+    }
+    return t.breakableFitAdvances = l, t.breakableFitAdvances;
+  }
+  const a = [];
+  let c = "", r = 0;
+  for (const l of o) {
+    c += l;
+    const f = ue(c, n), h = de(c, f, x);
+    a.push(h - r), r = h;
+  }
+  return t.breakableFitAdvances = a, t.breakableFitAdvances;
+}
+function z0(e, t) {
+  const n = ot();
+  n.font = e;
+  const x = P0(e), i = W0(e), s = t ? T0(e, i) : 0;
+  return { cache: x, fontSize: i, emojiCorrection: s };
+}
+function j0(e) {
+  return e === "space" || e === "zero-width-break" || e === "soft-hyphen";
+}
+function ze(e) {
+  return e === "space" || e === "preserved-space" || e === "tab" || e === "zero-width-break" || e === "soft-hyphen";
+}
+function lt(e, t, n = e.widths.length) {
+  for (; t < n; ) {
+    const x = e.kinds[t];
+    if (!j0(x))
+      break;
+    t++;
+  }
+  return t;
+}
+function $t(e, t) {
+  if (t <= 0)
+    return 0;
+  const n = e % t;
+  return Math.abs(n) <= 1e-6 ? t : t - n;
+}
+function Xt(e, t, n) {
+  return e.letterSpacing !== 0 && t && e.spacingGraphemeCounts[n] > 0 ? e.letterSpacing : 0;
+}
+function ct(e, t) {
+  return t === 0 ? 0 : e + t;
+}
+function K0(e, t) {
+  return e.letterSpacing !== 0 && e.spacingGraphemeCounts[t] > 0 ? e.letterSpacing : 0;
+}
+function Vt(e, t, n, x, i) {
+  const s = t === "tab" ? i + K0(e, n) : e.lineEndFitAdvances[n];
+  return ct(x, s);
+}
+function Re(e, t, n, x) {
+  const i = t === "tab" ? 0 : e.lineEndFitAdvances[n];
+  return ct(x, i);
+}
+function Te(e, t, n, x, i) {
+  const s = t === "tab" ? i : e.lineEndPaintAdvances[n];
+  return ct(x, s);
+}
+function qt(e, t, n) {
+  return e.letterSpacing !== 0 && t ? n + e.letterSpacing : n;
+}
+function Zt(e, t) {
+  return e.letterSpacing === 0 ? t : t + e.letterSpacing;
+}
+function U0(e, t, n, x, i) {
+  if (e.letterSpacing === 0)
+    return 0;
+  if (i > 0)
+    return e.spacingGraphemeCounts[x] > 0 ? e.letterSpacing : 0;
+  for (let s = x - 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 === x - 1)
+          return 0;
+        continue;
+      }
+      return s === t && n > 0 || e.spacingGraphemeCounts[s] > 0 ? e.letterSpacing : 0;
+    }
+  }
+  return 0;
+}
+function en(e, t, n, x, i, s) {
+  return t + U0(e, n, x, i, s);
+}
+function J0(e, t) {
+  let n = 0, x = e.chunks.length;
+  for (; n < x; ) {
+    const i = Math.floor((n + x) / 2);
+    t < e.chunks[i].consumedEndSegmentIndex ? x = i : n = i + 1;
+  }
+  return n < e.chunks.length ? n : -1;
+}
+function Q0(e, t, n) {
+  let x = n.segmentIndex;
+  if (n.graphemeIndex > 0)
+    return t;
+  const i = e.chunks[t];
+  return i.startSegmentIndex === i.endSegmentIndex && x === i.startSegmentIndex || (x < i.startSegmentIndex && (x = i.startSegmentIndex), x = lt(e, x, i.endSegmentIndex), x < i.endSegmentIndex) ? (n.segmentIndex = x, n.graphemeIndex = 0, t) : i.consumedEndSegmentIndex >= e.widths.length ? -1 : (n.segmentIndex = i.consumedEndSegmentIndex, n.graphemeIndex = 0, t + 1);
+}
+function Y0(e, t) {
+  if (t.segmentIndex >= e.widths.length)
+    return -1;
+  const n = J0(e, t.segmentIndex);
+  return n < 0 ? -1 : Q0(e, n, t);
+}
+function $0(e, t, n) {
+  const { widths: x, kinds: i, breakableFitAdvances: s } = e;
+  if (x.length === 0)
+    return 0;
+  const a = Ee().lineFitEpsilon, c = t + a;
+  let r = 0, l = 0, f = !1, h = 0, g = 0, A = 0, m = 0, B = -1, C = 0;
+  function v() {
+    B = -1, C = 0;
+  }
+  function H(T = A, G = m, w = l) {
+    r++, n?.(w, h, g, T, G), l = 0, f = !1, v();
+  }
+  function y(T, G) {
+    f = !0, h = T, g = 0, A = T + 1, m = 0, l = G;
+  }
+  function O(T, G, w) {
+    f = !0, h = T, g = G, A = T, m = G + 1, l = w;
+  }
+  function N(T, G) {
+    if (!f) {
+      y(T, G);
+      return;
+    }
+    l += G, A = T + 1, m = 0;
+  }
+  function D(T, G) {
+    const w = s[T];
+    for (let j = G; j < w.length; j++) {
+      const z = w[j];
+      f ? l + z > c ? (H(), O(T, j, z)) : (l += z, A = T, m = j + 1) : O(T, j, z);
+    }
+    f && A === T && m === w.length && (A = T + 1, m = 0);
+  }
+  let k = 0;
+  for (; k < x.length && !(!f && (k = lt(e, k), k >= x.length)); ) {
+    const T = x[k], G = i[k], w = ze(G);
+    if (!f) {
+      T > c && s[k] !== null ? D(k, 0) : y(k, T), w && (B = k + 1, C = l - T), k++;
+      continue;
+    }
+    if (l + T > c) {
+      if (w) {
+        N(k, T), H(k + 1, 0, l - T), k++;
+        continue;
+      }
+      if (B >= 0) {
+        if (A > B || A === B && m > 0) {
+          H();
+          continue;
+        }
+        H(B, 0, C);
+        continue;
+      }
+      if (T > c && s[k] !== null) {
+        H(), D(k, 0), k++;
+        continue;
+      }
+      H();
+      continue;
+    }
+    N(k, T), w && (B = k + 1, C = l - T), k++;
+  }
+  return f && H(), r;
+}
+function X0(e, t, n) {
+  if (e.simpleLineWalkFastPath)
+    return $0(e, t, n);
+  const { widths: x, kinds: i, breakableFitAdvances: s, discretionaryHyphenWidth: o, chunks: a } = e;
+  if (x.length === 0 || a.length === 0)
+    return 0;
+  const c = Ee(), r = c.lineFitEpsilon, l = t + r;
+  let f = 0, h = 0, g = !1, A = 0, m = 0, B = 0, C = 0, v = -1, H = 0, y = 0, O = null;
+  function N() {
+    v = -1, H = 0, y = 0, O = null;
+  }
+  function D() {
+    return O === "soft-hyphen" && v === B && C === 0 ? y : h;
+  }
+  function k(S = B, R = C, L) {
+    f++, n !== void 0 && n(en(e, L ?? D(), A, m, S, R), A, m, S, R), h = 0, g = !1, N();
+  }
+  function T(S, R) {
+    g = !0, A = S, m = 0, B = S + 1, C = 0, h = R;
+  }
+  function G(S, R, L) {
+    g = !0, A = S, m = R, B = S, C = R + 1, h = L;
+  }
+  function w(S, R) {
+    if (!g) {
+      T(S, R);
+      return;
+    }
+    h += R, B = S + 1, C = 0;
+  }
+  function j(S, R, L, P, W, J) {
+    if (!R)
+      return;
+    const X = Re(e, S, L, W), ne = Te(e, S, L, W, P);
+    v = L + 1, H = h - J + X, y = h - J + ne, O = S;
+  }
+  function z(S, R) {
+    const L = s[S];
+    for (let P = R; P < L.length; P++) {
+      const W = L[P];
+      if (!g)
+        G(S, P, W);
+      else {
+        const J = qt(e, !0, W), X = h + J;
+        Zt(e, X) > l ? (k(), G(S, P, W)) : (h = X, B = S, C = P + 1);
+      }
+    }
+    g && B === S && C === L.length && (B = S + 1, C = 0);
+  }
+  function b(S) {
+    f++, n?.(0, S.startSegmentIndex, 0, S.consumedEndSegmentIndex, 0), N();
+  }
+  for (let S = 0; S < a.length; S++) {
+    const R = a[S];
+    if (R.startSegmentIndex === R.endSegmentIndex) {
+      b(R);
+      continue;
+    }
+    g = !1, h = 0, A = R.startSegmentIndex, m = 0, B = R.startSegmentIndex, C = 0, N();
+    let L = R.startSegmentIndex;
+    for (; L < R.endSegmentIndex && !(!g && (L = lt(e, L, R.endSegmentIndex), L >= R.endSegmentIndex)); ) {
+      const P = i[L], W = ze(P), J = Xt(e, g, L), X = P === "tab" ? $t(h + J, e.tabStopAdvance) : x[L], ne = J + X, te = Vt(e, P, L, J, X);
+      if (P === "soft-hyphen") {
+        g && (B = L + 1, C = 0, v = L + 1, H = h + o, y = h + o, O = P), L++;
+        continue;
+      }
+      if (!g) {
+        te > l && s[L] !== null ? z(L, 0) : T(L, X), j(P, W, L, X, J, ne), L++;
+        continue;
+      }
+      if (h + te > l) {
+        const oe = h + Re(e, P, L, J), Z = h + Te(e, P, L, J, X);
+        if (O === "soft-hyphen" && c.preferEarlySoftHyphenBreak && H <= l) {
+          k(v, 0, y);
+          continue;
+        }
+        if (W && oe <= l) {
+          w(L, ne), k(L + 1, 0, Z), L++;
+          continue;
+        }
+        if (v >= 0 && H <= l) {
+          if (B > v || B === v && C > 0) {
+            k();
+            continue;
+          }
+          const le = v;
+          k(le, 0, y), L = le;
+          continue;
+        }
+        if (te > l && s[L] !== null) {
+          k(), z(L, 0), L++;
+          continue;
+        }
+        k();
+        continue;
+      }
+      w(L, ne), j(P, W, L, X, J, ne), L++;
+    }
+    if (g) {
+      const P = v === R.consumedEndSegmentIndex ? y : h;
+      k(R.consumedEndSegmentIndex, 0, P);
+    }
+  }
+  return f;
+}
+function V0(e, t, n, x) {
+  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: c } = e, r = Ee(), l = r.lineFitEpsilon, f = x + l, h = t.segmentIndex, g = t.graphemeIndex;
+  let A = 0, m = !1, B = t.segmentIndex, C = t.graphemeIndex, v = -1, H = 0, y = 0, O = null;
+  function N() {
+    return O === "soft-hyphen" && v === B && C === 0 ? y : A;
+  }
+  function D(b = B, S = C, R = N()) {
+    return m ? (t.segmentIndex = b, t.graphemeIndex = S, en(e, R, h, g, b, S)) : null;
+  }
+  function k(b, S) {
+    m = !0, B = b + 1, C = 0, A = S;
+  }
+  function T(b, S, R) {
+    m = !0, B = b, C = S + 1, A = R;
+  }
+  function G(b, S) {
+    if (!m) {
+      k(b, S);
+      return;
+    }
+    A += S, B = b + 1, C = 0;
+  }
+  function w(b, S, R, L, P, W) {
+    if (!S)
+      return;
+    const J = Re(e, b, R, P), X = Te(e, b, R, P, L);
+    v = R + 1, H = A - W + J, y = A - W + X, O = b;
+  }
+  function j(b, S) {
+    const R = a[b];
+    for (let L = S; L < R.length; L++) {
+      const P = R[L];
+      if (!m)
+        T(b, L, P);
+      else {
+        const W = qt(e, !0, P), J = A + W;
+        if (Zt(e, J) > f)
+          return D();
+        A = J, B = b, C = L + 1;
+      }
+    }
+    return m && B === b && C === R.length && (B = b + 1, C = 0), null;
+  }
+  function z() {
+    return O !== "soft-hyphen" || v < 0 ? null : H <= f ? D(v, 0, y) : null;
+  }
+  for (let b = t.segmentIndex; b < i.endSegmentIndex; b++) {
+    const S = o[b], R = ze(S), L = b === t.segmentIndex ? t.graphemeIndex : 0, P = Xt(e, m, b), W = S === "tab" ? $t(A + P, e.tabStopAdvance) : s[b], J = P + W, X = Vt(e, S, b, P, W);
+    if (S === "soft-hyphen" && L === 0) {
+      m && (B = b + 1, C = 0, v = b + 1, H = A + c, y = A + c, O = S);
+      continue;
+    }
+    if (!m) {
+      if (L > 0) {
+        const te = j(b, L);
+        if (te !== null)
+          return te;
+      } else if (X > f && a[b] !== null) {
+        const te = j(b, 0);
+        if (te !== null)
+          return te;
+      } else
+        k(b, W);
+      w(S, R, b, W, P, J);
+      continue;
+    }
+    if (A + X > f) {
+      const te = A + Re(e, S, b, P), De = A + Te(e, S, b, P, W);
+      if (O === "soft-hyphen" && r.preferEarlySoftHyphenBreak && H <= f)
+        return D(v, 0, y);
+      const oe = z();
+      if (oe !== null)
+        return oe;
+      if (R && te <= f)
+        return G(b, J), D(b + 1, 0, De);
+      if (v >= 0 && H <= f)
+        return B > v || B === v && C > 0 ? D() : D(v, 0, y);
+      if (X > f && a[b] !== null) {
+        const Z = D();
+        if (Z !== null)
+          return Z;
+        const le = j(b, 0);
+        if (le !== null)
+          return le;
+      }
+      return D();
+    }
+    G(b, J), w(S, R, b, W, P, J);
+  }
+  return v === i.consumedEndSegmentIndex && C === 0 ? D(i.consumedEndSegmentIndex, 0, y) : D(i.consumedEndSegmentIndex, 0, A);
+}
+function q0(e, t, n) {
+  const { widths: x, kinds: i, breakableFitAdvances: s } = e, a = Ee().lineFitEpsilon, c = n + a;
+  let r = 0, l = !1, f = t.segmentIndex, h = t.graphemeIndex, g = -1, A = 0;
+  for (let m = t.segmentIndex; m < x.length; m++) {
+    const B = i[m], C = ze(B), v = m === t.segmentIndex ? t.graphemeIndex : 0, H = s[m], y = x[m];
+    if (!l) {
+      if (v > 0 || y > c && H !== null) {
+        const O = H, N = O[v];
+        l = !0, r = N, f = m, h = v + 1;
+        for (let D = v + 1; D < O.length; D++) {
+          const k = O[D];
+          if (r + k > c)
+            return t.segmentIndex = f, t.graphemeIndex = h, r;
+          r += k, f = m, h = D + 1;
+        }
+        f === m && h === O.length && (f = m + 1, h = 0);
+      } else
+        l = !0, r = y, f = m + 1, h = 0;
+      C && (g = m + 1, A = r - y);
+      continue;
+    }
+    if (r + y > c)
+      return C ? (t.segmentIndex = m + 1, t.graphemeIndex = 0, r) : g >= 0 ? f > g || f === g && h > 0 ? (t.segmentIndex = f, t.graphemeIndex = h, r) : (t.segmentIndex = g, t.graphemeIndex = 0, A) : (t.segmentIndex = f, t.graphemeIndex = h, r);
+    r += y, f = m + 1, h = 0, C && (g = m + 1, A = r - y);
+  }
+  return l ? (t.segmentIndex = f, t.graphemeIndex = h, r) : null;
+}
+function Z0(e, t, n, x) {
+  return e.simpleLineWalkFastPath ? q0(e, t, x) : V0(e, t, n, x);
+}
+function Ze(e, t, n) {
+  const x = Y0(e, t);
+  return x < 0 ? null : Z0(e, t, x, n);
+}
+let Qe = null, It = /* @__PURE__ */ new WeakMap();
+function es() {
+  return Qe === null && (Qe = new Intl.Segmenter(void 0, { granularity: "grapheme" })), Qe;
+}
+function wt(e, t, n) {
+  let x = n.get(e);
+  if (x !== void 0)
+    return x;
+  x = [];
+  const i = es();
+  for (const s of i.segment(t[e]))
+    x.push(s.segment);
+  return n.set(e, x), x;
+}
+function ts(e, t, n) {
+  return n > t && e[n - 1] === "soft-hyphen";
+}
+function Pt(e, t, n, x) {
+  for (let i = n; i < x; i++)
+    e += t[i];
+  return e;
+}
+function ns(e) {
+  let t = It.get(e);
+  return t !== void 0 || (t = /* @__PURE__ */ new Map(), It.set(e, t)), t;
+}
+function ss(e, t, n, x, i, s) {
+  let o = "";
+  const a = ts(e.kinds, n, i);
+  for (let c = n; c < i; c++)
+    if (!(e.kinds[c] === "soft-hyphen" || e.kinds[c] === "hard-break"))
+      if (c === n && x > 0) {
+        const r = wt(c, e.segments, t);
+        o = Pt(o, r, x, r.length);
+      } else
+        o += e.segments[c];
+  if (s > 0) {
+    a && (o += "-");
+    const c = wt(i, e.segments, t);
+    o = Pt(o, c, n === i ? x : 0, s);
+  } else a && (o += "-");
+  return o;
+}
+let Ye = null;
+function tn() {
+  return Ye === null && (Ye = new Intl.Segmenter(void 0, { granularity: "grapheme" })), Ye;
+}
+function is(e) {
+  return {
+    widths: [],
+    lineEndFitAdvances: [],
+    lineEndPaintAdvances: [],
+    kinds: [],
+    simpleLineWalkFastPath: !0,
+    segLevels: null,
+    breakableFitAdvances: [],
+    letterSpacing: 0,
+    spacingGraphemeCounts: [],
+    discretionaryHyphenWidth: 0,
+    tabStopAdvance: 0,
+    chunks: [],
+    segments: []
+  };
+}
+function rs(e, t) {
+  const n = [];
+  let x = [], i = 0, s = !1, o = !1, a = !1;
+  function c() {
+    x.length !== 0 && (n.push({
+      text: x.length === 1 ? x[0] : x.join(""),
+      start: i
+    }), x = [], s = !1, o = !1, a = !1);
+  }
+  function r(f, h, g) {
+    x = [f], i = h, s = g, o = Ve(f), a = Ge.has(f);
+  }
+  function l(f, h) {
+    x.push(f), s = s || h;
+    const g = Ve(f);
+    f.length === 1 && Fe.has(f) ? o = o || g : o = g, a = !1;
+  }
+  for (const f of tn().segment(e)) {
+    const h = f.segment, g = xe(h);
+    if (x.length === 0) {
+      r(h, f.index, g);
+      continue;
+    }
+    if (a || it.has(h) || Fe.has(h) || t.carryCJKAfterClosingQuote && g && o) {
+      l(h, g);
+      continue;
+    }
+    if (!s && !g) {
+      l(h, g);
+      continue;
+    }
+    c(), r(h, f.index, g);
+  }
+  return c(), n;
+}
+function xs(e, t, n) {
+  if (t.length <= 1)
+    return t;
+  const x = [];
+  let i = -1, s = !1;
+  function o(c, r) {
+    const l = t[c].start, f = r < t.length ? t[r].start : e.length;
+    x.push({
+      text: e.slice(l, f),
+      start: l
+    });
+  }
+  function a(c) {
+    if (!(i < 0)) {
+      if (s)
+        i + 1 === c ? x.push(t[i]) : o(i, c);
+      else
+        for (let r = i; r < c; r++)
+          x.push(t[r]);
+      i = -1, s = !1;
+    }
+  }
+  for (let c = 0; c < t.length; c++) {
+    const r = t[c];
+    i >= 0 && !Jt(t[c - 1].text, n) && a(c), i < 0 && (i = c), s = s || xe(r.text);
+  }
+  return a(t.length), x;
+}
+function Wt(e, t) {
+  if (t === "zero-width-break" || t === "soft-hyphen" || t === "hard-break")
+    return 0;
+  if (t === "tab")
+    return 1;
+  let n = 0;
+  const x = tn();
+  for (const i of x.segment(e))
+    n++;
+  return n;
+}
+function os(e, t, n) {
+  return t > 1 ? e + (t - 1) * n : e;
+}
+function ls(e, t, n, x, i) {
+  const s = Ee(), { cache: o, emojiCorrection: a } = z0(t, R0(e.normalized)), c = de("-", ue("-", o), a) + (i === 0 ? 0 : i * 2), l = de(" ", ue(" ", o), a) * 8, f = i !== 0;
+  if (e.len === 0)
+    return is();
+  const h = [], g = [], A = [], m = [];
+  let B = e.chunks.length <= 1 && !f;
+  const C = n ? [] : null, v = [], H = [], y = n ? [] : null, O = Array.from({ length: e.len });
+  function N(G, w, j, z, b, S, R, L) {
+    b !== "text" && b !== "space" && b !== "zero-width-break" && (B = !1), h.push(w), g.push(j), A.push(z), m.push(b), C?.push(S), v.push(R), f && H.push(L), y !== null && y.push(G);
+  }
+  function D(G, w, j, z, b) {
+    const S = ue(G, o), R = f ? Wt(G, w) : 0, L = os(de(G, S, a), R, i), P = w === "space" || w === "preserved-space" || w === "zero-width-break" ? 0 : L, W = P === 0 ? 0 : P + (R > 0 ? i : 0), J = w === "space" || w === "zero-width-break" ? 0 : L;
+    if (b && z && G.length > 1) {
+      let X = "sum-graphemes";
+      i !== 0 ? X = "segment-prefixes" : ve(G) ? X = "pair-context" : s.preferPrefixWidthsForBreakableRuns && (X = "segment-prefixes");
+      const ne = _0(G, S, o, a, X);
+      N(G, L, W, J, w, j, ne, R);
+      return;
+    }
+    N(G, L, W, J, w, j, null, R);
+  }
+  for (let G = 0; G < e.len; G++) {
+    O[G] = h.length;
+    const w = e.texts[G], j = e.isWordLike[G], z = e.kinds[G], b = e.starts[G];
+    if (z === "soft-hyphen") {
+      N(w, 0, c, c, z, b, null, 0);
+      continue;
+    }
+    if (z === "hard-break") {
+      N(w, 0, 0, 0, z, b, null, 0);
+      continue;
+    }
+    if (z === "tab") {
+      N(w, 0, 0, 0, z, b, null, f ? Wt(w, z) : 0);
+      continue;
+    }
+    const S = ue(w, o);
+    if (z === "text" && S.containsCJK) {
+      const R = rs(w, s), L = x === "keep-all" ? xs(w, R, s.breakKeepAllAfterPunctuation) : R;
+      for (let P = 0; P < L.length; P++) {
+        const W = L[P];
+        D(W.text, "text", b + W.start, j, x === "keep-all" || !xe(W.text));
+      }
+      continue;
+    }
+    D(w, z, b, j, !0);
+  }
+  const k = cs(e.chunks, O, h.length), T = C === null ? null : Pn(e.normalized, C);
+  return y !== null ? {
+    widths: h,
+    lineEndFitAdvances: g,
+    lineEndPaintAdvances: A,
+    kinds: m,
+    simpleLineWalkFastPath: B,
+    segLevels: T,
+    breakableFitAdvances: v,
+    letterSpacing: i,
+    spacingGraphemeCounts: H,
+    discretionaryHyphenWidth: c,
+    tabStopAdvance: l,
+    chunks: k,
+    segments: y
+  } : {
+    widths: h,
+    lineEndFitAdvances: g,
+    lineEndPaintAdvances: A,
+    kinds: m,
+    simpleLineWalkFastPath: B,
+    segLevels: T,
+    breakableFitAdvances: v,
+    letterSpacing: i,
+    spacingGraphemeCounts: H,
+    discretionaryHyphenWidth: c,
+    tabStopAdvance: l,
+    chunks: k
+  };
+}
+function cs(e, t, n) {
+  const x = [];
+  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, c = s.consumedEndSegmentIndex < t.length ? t[s.consumedEndSegmentIndex] : n;
+    x.push({
+      startSegmentIndex: o,
+      endSegmentIndex: a,
+      consumedEndSegmentIndex: c
+    });
+  }
+  return x;
+}
+function as(e, t, n, x) {
+  const i = x?.wordBreak ?? "normal", s = x?.letterSpacing ?? 0, o = O0(e, Ee(), x?.whiteSpace, i);
+  return ls(o, t, n, i, s);
+}
+function et(e, t, n) {
+  return as(e, t, !0, n);
+}
+function vt(e) {
+  let t = 0;
+  return X0(e, Number.POSITIVE_INFINITY, (n) => {
+    n > t && (t = n);
+  }), t;
+}
+const fs = /[ \t\n\f\r]+/, Rt = /^[ \t\n\f\r]+/, Tt = /[ \t\n\f\r]+$/, Gt = { segmentIndex: 0, graphemeIndex: 0 }, us = {
+  itemIndex: 0,
+  segmentIndex: 0,
+  graphemeIndex: 0
+};
+function $e(e) {
+  return {
+    segmentIndex: e.segmentIndex,
+    graphemeIndex: e.graphemeIndex
+  };
+}
+function Ht(e) {
+  return e.segmentIndex === 0 && e.graphemeIndex === 0;
+}
+function Ie(e, t, n) {
+  const x = `${e}\0${t}`, i = n.get(x);
+  if (i !== void 0)
+    return i;
+  const s = t === 0 ? void 0 : { letterSpacing: t }, o = vt(et("A A", e, s)), a = vt(et("AA", e, s)), c = Math.max(0, o - a);
+  return n.set(x, c), c;
+}
+function hs(e) {
+  const t = { segmentIndex: 0, graphemeIndex: 0 }, n = Ze(e, t, Number.POSITIVE_INFINITY);
+  return n === null ? null : {
+    endGraphemeIndex: t.graphemeIndex,
+    endSegmentIndex: t.segmentIndex,
+    width: n
+  };
+}
+function ds(e, t) {
+  return e === 0 && t > 0;
+}
+function nn(e) {
+  const t = [], n = Array.from({ length: e.length }), x = /* @__PURE__ */ new Map();
+  let i = 0;
+  for (let s = 0; s < e.length; s++) {
+    const o = e[s], a = o.letterSpacing ?? 0, c = Rt.test(o.text), r = Tt.test(o.text), l = o.text.replace(Rt, "").replace(Tt, "");
+    if (l.length === 0) {
+      fs.test(o.text) && i === 0 && (i = Ie(o.font, a, x));
+      continue;
+    }
+    const f = i > 0 ? i : c ? Ie(o.font, a, x) : 0, h = et(l, o.font, a === 0 ? void 0 : { letterSpacing: a }), g = hs(h);
+    if (g === null) {
+      i = r ? Ie(o.font, a, x) : 0;
+      continue;
+    }
+    const A = {
+      break: o.break ?? "normal",
+      endGraphemeIndex: g.endGraphemeIndex,
+      endSegmentIndex: g.endSegmentIndex,
+      extraWidth: o.extraWidth ?? 0,
+      gapBefore: f,
+      naturalWidth: g.width,
+      prepared: h,
+      sourceItemIndex: s
+    };
+    t.push(A), n[s] = A, i = r ? Ie(o.font, a, x) : 0;
+  }
+  return {
+    items: t,
+    itemsBySourceItemIndex: n
+  };
+}
+function Fs(e, t, n, x) {
+  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 c = e.items[a];
+    if (!Ht(n) && n.segmentIndex === c.endSegmentIndex && n.graphemeIndex === c.endGraphemeIndex) {
+      a++, n.segmentIndex = 0, n.graphemeIndex = 0;
+      continue;
+    }
+    const r = s === 0 ? 0 : c.gapBefore, l = Ht(n);
+    if (c.break === "never") {
+      if (!l) {
+        a++, n.segmentIndex = 0, n.graphemeIndex = 0;
+        continue;
+      }
+      const C = c.naturalWidth + c.extraWidth, v = r + C;
+      if (s > 0 && v > o)
+        break e;
+      x?.(c, r, C, $e(Gt), {
+        segmentIndex: c.endSegmentIndex,
+        graphemeIndex: c.endGraphemeIndex
+      }), s += v, o = Math.max(0, i - s), a++, n.segmentIndex = 0, n.graphemeIndex = 0;
+      continue;
+    }
+    const f = r + c.extraWidth;
+    if (s > 0 && f >= o)
+      break e;
+    if (l) {
+      const C = f + c.naturalWidth;
+      if (C <= o) {
+        x?.(c, r, c.naturalWidth + c.extraWidth, $e(Gt), {
+          segmentIndex: c.endSegmentIndex,
+          graphemeIndex: c.endGraphemeIndex
+        }), s += C, o = Math.max(0, i - s), a++, n.segmentIndex = 0, n.graphemeIndex = 0;
+        continue;
+      }
+    }
+    const h = Math.max(1, o - f), g = {
+      segmentIndex: n.segmentIndex,
+      graphemeIndex: n.graphemeIndex
+    }, A = Ze(c.prepared, g, h);
+    if (A === 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 m = A + c.extraWidth, B = r + m;
+    if (s > 0 && l && B > o)
+      break e;
+    if (s > 0 && l && r > 0 && ds(g.segmentIndex, g.graphemeIndex)) {
+      const C = { segmentIndex: 0, graphemeIndex: 0 };
+      if (Ze(c.prepared, C, Math.max(1, i - c.extraWidth)) !== null && (C.segmentIndex > g.segmentIndex || C.segmentIndex === g.segmentIndex && C.graphemeIndex > g.graphemeIndex))
+        break e;
+    }
+    if (x?.(c, r, m, $e(n), {
+      segmentIndex: g.segmentIndex,
+      graphemeIndex: g.graphemeIndex
+    }), s += B, o = Math.max(0, i - s), g.segmentIndex === c.endSegmentIndex && g.graphemeIndex === c.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 gs(e, t, n = us) {
+  const x = e, i = {
+    itemIndex: n.itemIndex,
+    segmentIndex: n.segmentIndex,
+    graphemeIndex: n.graphemeIndex
+  }, s = [], o = Fs(x, t, i, (a, c, r, l, f) => {
+    s.push({
+      itemIndex: a.sourceItemIndex,
+      gapBefore: c,
+      occupiedWidth: r,
+      start: l,
+      end: f
+    });
+  });
+  return o === null ? null : {
+    fragments: s,
+    width: o,
+    end: i
+  };
+}
+function Ns(e, t) {
+  return ss(e.prepared, ns(e.prepared), t.start.segmentIndex, t.start.graphemeIndex, t.end.segmentIndex, t.end.graphemeIndex);
+}
+function ps(e, t) {
+  const n = e, x = [];
+  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");
+    x.push({
+      itemIndex: s.itemIndex,
+      text: Ns(o, s),
+      gapBefore: s.gapBefore,
+      occupiedWidth: s.occupiedWidth,
+      start: s.start,
+      end: s.end
+    });
+  }
+  return {
+    fragments: x,
+    width: t.width,
+    end: t.end
+  };
+}
+function Ss(e) {
+  const t = [];
+  let n = [], x = 0, i = 0;
+  for (const s of e) {
+    let o = 0;
+    for (; ; ) {
+      const c = s.text.indexOf("\v", o);
+      if (c < 0) break;
+      const r = s.text.slice(o, c);
+      r.length > 0 && n.push({ text: r, style: s.style }), i += c - o, t.push({ runs: n, startOffset: x }), i += 1, x = i, n = [], o = c + 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: x }), t;
+}
+function sn(e) {
+  return e.map((t) => {
+    const n = { text: t.style.hidden ? "" : t.text, font: ae(t.style) };
+    return !t.style.hidden && t.style.letterSpacingPx !== void 0 && (n.letterSpacing = t.style.letterSpacingPx), n;
+  });
+}
+function ms(e) {
+  return nn(sn(e));
+}
+class tt {
+  map = /* @__PURE__ */ new Map();
+  get(t) {
+    const n = this.map.get(t.id);
+    if (n && n.revision === t.revision) return n.segments;
+    const x = Ss(t.runs).map((i) => ({
+      prepared: nn(sn(i.runs)),
+      runs: i.runs,
+      startOffset: i.startOffset
+    }));
+    return this.map.set(t.id, { revision: t.revision, segments: x }), x;
+  }
+  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 Xe = 48;
+function As() {
+  const e = new tt(), t = /* @__PURE__ */ new Map();
+  let n = null;
+  const x = (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 = ln(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 c = Os(i, x, (r) => (n?.add(r.id), e.get(r)), a);
+        if (n) {
+          for (const r of t.keys()) n.has(r) || t.delete(r);
+          e.retainOnly(n);
+        }
+        return c;
+      } finally {
+        n = null;
+      }
+    },
+    evict(i) {
+      e.evict(i), t.delete(i);
+    },
+    reset() {
+      e.clear(), t.clear();
+    }
+  };
+}
+function Es(e) {
+  let t = 0;
+  for (let n = 0; n < e.length; n++) e.charCodeAt(n) === 32 && t++;
+  return t;
+}
+const Bs = (e) => e === " " || e === "	" || e === `
+` || e === "\r";
+function Ms(e, t, n) {
+  const x = e.indexOf(n, t);
+  if (x >= 0) return { start: x, end: x + 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 (Bs(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 at(e, t) {
+  const n = [];
+  let x = t;
+  for (const i of e)
+    n.push(x), x += i.text.length;
+  return n;
+}
+function Cs(e) {
+  return kn(e) && !e.style.sectionBreak && !e.style.pageBreakBefore;
+}
+function rn(e) {
+  const t = e.runs[0]?.style, n = t?.fontSizePx ?? 16, x = t ? We(ae(t)) : { ascent: n * 0.8, descent: n * 0.2 }, i = x.ascent + x.descent, s = Math.max(i, e.style.lineHeight * n);
+  return { height: s, ascent: (s - i) / 2 + x.ascent };
+}
+function ft(e, t, n, x, i, s) {
+  const o = gs(t.prepared, n, x);
+  if (o === null) return null;
+  const a = ps(t.prepared, o), c = [];
+  let r = 0, l = 0, f = 0, h = 0;
+  for (const B of a.fragments) {
+    r += B.gapBefore;
+    const C = t.runs[B.itemIndex], v = We(ae(C.style));
+    if (l = Math.max(l, v.ascent), f = Math.max(f, v.descent), h = Math.max(h, C.style.fontSizePx), B.text.length > 0) {
+      const H = Ms(C.text, s[B.itemIndex], B.text);
+      s[B.itemIndex] = H.end;
+      const y = {
+        blockId: e.id,
+        startOffset: i[B.itemIndex] + H.start,
+        endOffset: i[B.itemIndex] + H.end,
+        text: B.text,
+        style: C.style,
+        x: r,
+        width: B.occupiedWidth
+      };
+      H.map && (y.offsetMap = H.map), c.push({ frag: y, hadGap: B.gapBefore > 0, spaces: Es(B.text) });
+    }
+    r += B.occupiedWidth;
+  }
+  if (h === 0) {
+    const B = e.runs[0]?.style;
+    if (B) {
+      const C = We(ae(B));
+      l = C.ascent, f = C.descent, h = B.fontSizePx;
+    }
+  }
+  const g = l + f, A = Math.max(g, e.style.lineHeight * h), m = (A - g) / 2;
+  return { frags: c, width: a.width, height: A, ascent: m + l, end: a.end };
+}
+function ks(e, t, n) {
+  for (const i of t) if (i.posPx > e + 0.5) return i;
+  let x = (Math.floor(e / Xe) + 1) * Xe;
+  return x <= e && (x = e + Xe), { posPx: Math.min(x, Math.max(e + 1, n)), align: "left", leader: "none" };
+}
+function Ds(e) {
+  const t = e.map((i) => i.text).join(""), n = ae(e[0]?.style ?? xn);
+  let x = t.indexOf(".");
+  return x < 0 && (x = t.indexOf(",")), Pe(x < 0 ? t : t.slice(0, x + 1), n);
+}
+const xn = { fontFamily: "Georgia, serif", fontSizePx: 16 };
+function bs(e, t, n, x, i) {
+  const s = [];
+  let o = [], a = n, c = n;
+  for (const y of t) {
+    let O = 0;
+    for (; ; ) {
+      const D = y.text.indexOf("	", O);
+      if (D < 0) break;
+      const k = y.text.slice(O, D);
+      k.length > 0 && o.push({ text: k, style: y.style }), c += D - O, s.push({ runs: o, start: a }), c += 1, a = c, o = [], O = D + 1;
+    }
+    const N = y.text.slice(O);
+    N.length > 0 && o.push({ text: N, style: y.style }), c += N.length;
+  }
+  s.push({ runs: o, start: a });
+  const r = (e.style.tabStops ?? []).slice().sort((y, O) => y.posPx - O.posPx), l = t.find((y) => y.text.length > 0)?.style ?? e.runs[0]?.style, f = [];
+  let h = [], g = [], A = [], m = i, B = 0, C = 0, v = !1;
+  const H = (y) => {
+    if (B === 0 && l) {
+      const O = We(ae(l));
+      B = Math.max(O.ascent + O.descent, e.style.lineHeight * l.fontSizePx), C = (B - (O.ascent + O.descent)) / 2 + O.ascent;
+    }
+    f.push({
+      frags: h,
+      width: m,
+      indent: 0,
+      // fragment x is already absolute (tab/indent baked in)
+      lineMaxWidth: x,
+      height: B,
+      ascent: C,
+      // 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: y || v,
+      ...g.length > 0 ? { leaders: g } : {},
+      ...A.length > 0 ? { tabArrows: A } : {}
+    }), h = [], g = [], A = [], m = 0, B = 0, C = 0, v = !1;
+  };
+  return s.forEach((y, O) => {
+    if (O > 0) {
+      const w = ks(m, r, x), j = w.align ?? "left", z = Pe(y.runs.map((R) => R.text).join(""), ae(y.runs[0]?.style ?? l ?? xn)), b = m + z <= x;
+      let S = w.posPx;
+      b && j === "right" ? S = w.posPx - z : b && j === "center" ? S = w.posPx - z / 2 : b && j === "decimal" && (S = w.posPx - Ds(y.runs)), S < m && (S = m), (w.leader ?? "none") !== "none" && S > m + 1 && l && g.push({ x1: m, x2: S, kind: w.leader ?? "none", color: l.color, fontSizePx: l.fontSizePx }), A.push({ x1: m, x2: Math.max(S, m) }), m = S, v = !0;
+    }
+    if (y.runs.length === 0) return;
+    const N = { prepared: ms(y.runs), runs: y.runs, startOffset: y.start }, D = at(y.runs, y.start), k = y.runs.map(() => 0);
+    let T, G = !0;
+    for (; ; ) {
+      const w = Math.max(24, x - (G ? m : 0)), j = ft(e, N, w, T, D, k);
+      if (j === null) break;
+      G || H(!1);
+      const z = G ? m : 0;
+      for (const b of j.frags)
+        b.frag.x += z, h.push(b);
+      m = z + j.width, B = Math.max(B, j.height), C = Math.max(C, j.ascent), T = j.end, G = !1;
+    }
+  }), H(!0), f;
+}
+function on(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 x = t / n;
+  let i = 0;
+  for (const s of e)
+    s.hadGap && (i += x), s.frag.x += i, s.spaces > 0 && (s.frag.wordSpacingPx = x, s.frag.width += s.spaces * x, i += s.spaces * x);
+}
+function ln(e, t, n) {
+  const x = n.get(e), i = [], s = [];
+  let o = !0;
+  const a = [];
+  for (let r = 0; r < x.length; r++) {
+    const l = x[r];
+    if (l.runs.some((m) => m.text.includes("	"))) {
+      s.push(...bs(e, l.runs, l.startOffset, t, o ? e.style.indentFirstLinePx : 0)), o = !1, a[r] = s.length - 1;
+      continue;
+    }
+    const f = at(l.runs, l.startOffset), h = l.runs.map(() => 0);
+    let g, A = !1;
+    for (; ; ) {
+      const m = o ? e.style.indentFirstLinePx : 0, B = t - m, C = ft(e, l, B, g, f, h);
+      if (C === null) break;
+      s.push({
+        frags: C.frags,
+        width: C.width,
+        indent: m,
+        lineMaxWidth: B,
+        height: C.height,
+        ascent: C.ascent,
+        lastOfSegment: !1
+      }), g = C.end, o = !1, A = !0;
+    }
+    if (A)
+      s[s.length - 1].lastOfSegment = !0;
+    else {
+      const m = rn(e);
+      s.push({
+        frags: [],
+        width: 0,
+        indent: 0,
+        lineMaxWidth: t,
+        height: m.height,
+        ascent: m.ascent,
+        lastOfSegment: !0,
+        emptyOffset: l.startOffset
+      }), o = !1;
+    }
+    a[r] = s.length - 1;
+  }
+  for (let r = 0; r < a.length; r++) {
+    const l = a[r];
+    l !== void 0 && (r === x.length - 1 ? s[l].paragraphEnd = !0 : s[l].lineBreak = !0);
+  }
+  let c = 0;
+  for (const r of s) {
+    const l = r.lineMaxWidth - r.width;
+    let f = r.indent;
+    e.style.align === "center" ? f += l / 2 : e.style.align === "right" ? f += l : e.style.align === "justify" && !r.lastOfSegment && on(r.frags, l);
+    for (const g of r.frags) g.frag.x += f;
+    const h = { y: c, height: r.height, ascent: r.ascent, fragments: r.frags.map((g) => g.frag) };
+    r.emptyOffset !== void 0 && (h.emptyOffset = r.emptyOffset), r.leaders && r.leaders.length > 0 && (h.leaders = r.leaders.map((g) => ({ ...g, x1: g.x1 + f, x2: g.x2 + f }))), r.tabArrows && r.tabArrows.length > 0 && (h.tabArrows = r.tabArrows.map((g) => ({ x1: g.x1 + f, x2: g.x2 + f }))), r.paragraphEnd && (h.paragraphEnd = !0), r.lineBreak && (h.lineBreak = !0), i.push(h), c += r.height;
+  }
+  return i;
+}
+const _t = 2, zt = 2, Ls = 48, cn = ["header", "footer", "headerFirst", "headerEven", "footerFirst", "footerEven"];
+function an(e, t) {
+  const n = {
+    pageWidthPx: t.pageWidthPx ?? e.pageWidthPx,
+    pageHeightPx: t.pageHeightPx ?? e.pageHeightPx,
+    marginPx: t.marginPx ?? e.marginPx
+  }, x = t.columns === void 0 ? e.columns : t.columns ?? void 0;
+  x && (n.columns = x), 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);
+  const o = t.pageColorHex ?? e.pageColorHex;
+  o !== void 0 && (n.pageColorHex = o);
+  const a = t.pageBorders ?? e.pageBorders;
+  a !== void 0 && (n.pageBorders = a);
+  for (const c of cn) {
+    const r = t[c] ?? e[c];
+    r && (n[c] = r);
+  }
+  return n;
+}
+function jt(e, t) {
+  return e.headerDistancePx !== void 0 ? e.headerDistancePx : Math.max(8, (e.marginPx.top - t) / 2);
+}
+function Kt(e, t) {
+  return e.footerDistancePx !== void 0 ? e.pageHeightPx - e.footerDistancePx - t : e.pageHeightPx - Math.max(8, (e.marginPx.bottom - t) / 2) - t;
+}
+function fn(e) {
+  const t = [];
+  for (let n = 0; n < e.blocks.length; n++) {
+    const x = e.blocks[n];
+    x.kind === "paragraph" && x.style.sectionBreak && t.push({ props: an(e.section, x.style.sectionBreak.props), endBlock: n });
+  }
+  return t.push({ props: e.section, endBlock: e.blocks.length - 1 }), t;
+}
+function Os(e, t, n, x) {
+  const s = /* @__PURE__ */ new Map();
+  let o = null;
+  const a = (u) => {
+    const F = s.get(u);
+    if (F) return F;
+    let d = u.marginPx.top, p = u.pageHeightPx - u.marginPx.bottom;
+    const M = [u.header, u.headerFirst, u.headerEven].filter((_) => !!_), E = [u.footer, u.footerFirst, u.footerEven].filter((_) => !!_);
+    if (M.length > 0 || E.length > 0) {
+      o ??= new tt();
+      const _ = u.pageWidthPx - u.marginPx.left - u.marginPx.right, K = u.marginPx.left, Y = (q) => we(q, _, K, 999, 999, o, !1).height, U = (q) => {
+        const ee = we(q, _, K, 999, 999, o, !1);
+        for (const $ of ee.placed)
+          if (!!$.table || !!$.image || $.lines.some((Be) => Be.fragments.some((fe) => fe.text.trim().length > 0))) return ee.height - $.y;
+        return 0;
+      }, Q = M.reduce((q, ee) => Math.max(q, Y(ee)), 0);
+      if (Q > 0) {
+        const q = jt(u, Q);
+        d = Math.max(d, q + Q + 6);
+      }
+      const V = E.reduce((q, ee) => Math.max(q, Y(ee)), 0);
+      if (V > 0)
+        if (u.footerDistancePx !== void 0) {
+          const q = u.pageHeightPx - u.footerDistancePx, ee = E.reduce(($, Se) => Math.max($, U(Se)), 0);
+          p = Math.min(p, q - ee);
+        } else
+          p = Math.min(p, Kt(u, V) - 6);
+      p = Math.max(p, d + 24);
+    }
+    const I = { top: d, bottom: p };
+    return s.set(u, I), I;
+  }, c = fn(e);
+  let r = c[0].props, l = 0, f = 0, h = 0, g = 0, A = 1, m = 0, B = [], C = [];
+  const v = (u) => {
+    r = u;
+    const F = a(r);
+    l = r.marginPx.left, f = F.top, h = F.bottom, g = r.pageWidthPx - r.marginPx.left - r.marginPx.right, A = Math.max(1, r.columns?.count ?? 1);
+    const d = r.columns?.gapPx ?? 24, p = r.columns?.cols;
+    if (A > 1 && p && p.length === A) {
+      let M = l;
+      B = p.map((E, I) => {
+        const _ = { x: M, width: E.widthPx };
+        return M += E.widthPx + (I < A - 1 ? E.spaceAfterPx : 0), _;
+      }), m = Math.min(...p.map((E) => E.widthPx));
+    } else A > 1 ? (m = (g - (A - 1) * d) / A, B = Array.from({ length: A }, (M, E) => ({
+      x: l + E * (m + d),
+      width: m
+    }))) : (m = g, B = [{ x: l, width: g }]);
+    C = r.columns?.sep ? B.slice(0, -1).map((M, E) => (M.x + M.width + B[E + 1].x) / 2) : [];
+  };
+  v(r);
+  const H = e.lists ?? {}, y = (u) => {
+    const F = u.style.list;
+    if (!F) return null;
+    const d = H[F.listId];
+    return d ? d.levels[Math.min(F.level, d.levels.length - 1)] ?? null : null;
+  }, O = (u) => u.style.indentLeftPx + (y(u)?.indentLeftPx ?? 0), N = (u) => u.style.indentRightPx ?? 0, D = (u) => y(u)?.indentLeftPx ?? 0, k = /* @__PURE__ */ new Map(), T = /* @__PURE__ */ new Map(), G = (u) => {
+    const F = u.style.list, d = y(u);
+    if (!F || !d) return;
+    const p = H[F.listId], M = k.get(F.listId) ?? [];
+    M[F.level] = (M[F.level] ?? d.start - 1) + 1, M.length = F.level + 1, k.set(F.listId, M);
+    const E = On(p, F.level, M);
+    if (E.length === 0) return;
+    const I = u.runs[0]?.style;
+    I && T.set(u.id, {
+      text: E,
+      style: { ...I, ...d.markerStyle ?? {} },
+      hangingPx: d.hangingPx
+    });
+  }, w = (u) => {
+    for (const F of u)
+      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 j = { indentOf: D, markers: T }, z = [];
+  let b = 0;
+  for (let u = 0; u < e.blocks.length; u++) {
+    for (; u > c[b].endBlock; ) v(c[++b].props);
+    const F = e.blocks[u];
+    if (F.kind === "paragraph") {
+      if (Cs(F)) continue;
+      const d = F.style.tocEntry ? Ls : 0;
+      z.push({
+        kind: "para",
+        block: F,
+        lines: t(F, m - O(F) - N(F) - d)
+      });
+    } else if (F.kind === "image")
+      z.push({ kind: "image", block: F, height: F.anchor ? 0 : F.heightPx });
+    else {
+      const d = ut(F, m, t, j);
+      z.push({ kind: "table", block: F, ...d });
+    }
+  }
+  b = 0, v(c[0].props);
+  const S = [], R = () => {
+    S.push(r);
+    const u = {
+      index: S.length - 1,
+      number: S.length,
+      // provisional; the post-pass sets the real value
+      blocks: [],
+      widthPx: r.pageWidthPx,
+      heightPx: r.pageHeightPx,
+      marginPx: r.marginPx,
+      contentTopPx: f,
+      contentBottomPx: h
+    };
+    return r.pageColorHex !== void 0 && (u.pageColorHex = r.pageColorHex), r.pageBorders !== void 0 && (u.pageBorders = r.pageBorders), C.length && (u.columnSeparatorsX = C.slice()), u;
+  }, L = [R()];
+  let P = L[0], W = f;
+  const J = /* @__PURE__ */ new Map(), X = 14, ne = 18, te = e.footnotes ?? {}, De = Object.keys(te).length > 0;
+  let oe = 0;
+  const Z = () => h - oe, le = /* @__PURE__ */ new Set(), be = [[]], je = [0], Ft = /* @__PURE__ */ new Map(), gt = (u) => {
+    const F = te[u];
+    if (!F || F.length === 0) return null;
+    const d = Math.max(40, g - ne);
+    let p = 0;
+    return { paras: F.map((E) => {
+      const I = t(E, d);
+      return p += E.style.spaceBeforePx + pe(I) + E.style.spaceAfterPx, { p: E, lines: I };
+    }), height: p };
+  }, dn = (u, F, d) => {
+    const p = [];
+    for (let M = F; M < F + d; M++)
+      for (const E of u[M].fragments) {
+        const I = E.style.footnoteRef;
+        I && te[I] && !le.has(I) && !p.some(([_]) => _ === I) && p.push([I, E.text]);
+      }
+    return p;
+  };
+  let Ne = 0, Le = 0;
+  const ce = () => B[Ne]?.x ?? l, se = () => P.blocks.length > Le, Ke = () => {
+    Ne = 0, Le = 0, P = R(), L.push(P), be.push([]), je.push(0), oe = 0, W = f, he = [];
+  }, ie = () => {
+    Ne + 1 < A ? (Ne++, Le = P.blocks.length, W = f, he = []) : Ke();
+  }, Fn = () => {
+    P.blocks.length === 0 ? (P.widthPx = r.pageWidthPx, P.heightPx = r.pageHeightPx, P.marginPx = r.marginPx, P.contentTopPx = f, P.contentBottomPx = h, r.pageColorHex !== void 0 ? P.pageColorHex = r.pageColorHex : delete P.pageColorHex, r.pageBorders !== void 0 ? P.pageBorders = r.pageBorders : delete P.pageBorders, C.length ? P.columnSeparatorsX = C.slice() : delete P.columnSeparatorsX, S[P.index] = r, Ne = 0, Le = 0, W = f, he = []) : Ke();
+  }, gn = (u, F, d, p) => {
+    const M = {
+      blockId: u.id,
+      x: ce() + O(u),
+      y: W,
+      firstLineIndex: d,
+      lines: []
+    }, E = d === 0 ? T.get(u.id) : void 0;
+    E && (M.marker = { text: E.text, style: E.style, x: M.x - E.hangingPx }), u.style.tocEntry && J.set(u.id, { chunk: M, rightEdge: ce() + m, para: u }), P.blocks.push(M);
+    for (let I = d; I < d + p; I++) {
+      const _ = F[I];
+      M.lines.push({ ..._, y: W - M.y }), W += _.height;
+    }
+  }, Nn = (u, F) => {
+    let d = 0, p = W;
+    for (; F + d < u.length && p + u[F + d].height <= Z(); )
+      p += u[F + d].height, d++;
+    return d;
+  }, Nt = (u) => {
+    let F = be[P.index].length === 0 ? X : 0;
+    const d = [];
+    for (const [p, M] of u) {
+      const E = gt(p);
+      E && (F += E.height, d.push([p, M, E]));
+    }
+    return { H: F, measures: d };
+  }, pt = (u, F) => {
+    for (const [d, p] of u)
+      le.add(d), be[P.index].push(d), Ft.set(d, p);
+    oe += F, je[P.index] = oe;
+  }, pn = (u) => {
+    const F = [], d = (p) => {
+      for (const M of p)
+        if (M.kind === "paragraph") {
+          let E = 0;
+          for (const I of M.runs) {
+            const _ = I.style.footnoteRef;
+            _ && te[_] && !le.has(_) && !F.some(([K]) => K === _) && F.push([_, I.text]), E += I.text.length;
+          }
+        } else if (M.kind === "table")
+          for (const E of M.rows) for (const I of E.cells) d(I.blocks);
+    };
+    for (const p of u) for (const M of p.cells) d(M.blocks);
+    return F;
+  }, Sn = (u, F, d) => {
+    for (; ; ) {
+      if (d <= 0) return d;
+      const p = dn(u, F, d);
+      if (p.length === 0) return d;
+      const { H: M, measures: E } = Nt(p);
+      if (E.length === 0) return d;
+      let I = 0;
+      for (let K = F; K < F + d; K++) I += u[K].height;
+      if (W + I + M <= Z() || d === 1 && !se())
+        return pt(E, M), d;
+      d--;
+    }
+  }, mn = (u, F) => {
+    if (u.style.keepLinesTogether === !0 && se()) {
+      const p = pe(F);
+      W + p > Z() && p <= h - f && ie();
+    }
+    let d = 0;
+    for (; d < F.length; ) {
+      const p = F.length - d, M = Nn(F, d);
+      let E;
+      if (M >= p ? E = p : (E = M, p - E === 1 && (E -= zt - 1), d === 0 && E > 0 && E < _t && (E = 0), E <= 0 && (E = se() ? 0 : Math.max(1, M))), E > 0 && De && (E = Sn(F, d, E)), E > 0 && (gn(u, F, d, E), d += E), d >= F.length) return;
+      ie();
+    }
+  }, pe = (u) => {
+    let F = 0;
+    for (const d of u) F += d.height;
+    return F;
+  };
+  let he = [];
+  const St = 10, An = (u) => {
+    let F = ce(), d = ce() + m;
+    for (const p of he)
+      u >= p.bottom || (p.side === "left" ? F = Math.max(F, p.right + St) : d = Math.min(d, p.left - St));
+    return { x0: F, width: Math.max(40, d - F) };
+  }, En = (u) => he.some((F) => F.bottom > u), Bn = (u) => {
+    const F = u.anchor;
+    let d;
+    switch (F.relFromH) {
+      case "page":
+      case "leftMargin":
+        d = 0;
+        break;
+      case "rightMargin":
+        d = r.pageWidthPx - r.marginPx.right;
+        break;
+      case "column":
+        d = ce();
+        break;
+      default:
+        d = r.marginPx.left;
+        break;
+    }
+    let p;
+    switch (F.relFromV) {
+      case "page":
+      case "topMargin":
+        p = 0;
+        break;
+      case "bottomMargin":
+        p = r.pageHeightPx - r.marginPx.bottom;
+        break;
+      case "paragraph":
+      case "line":
+        p = W;
+        break;
+      // current flow position
+      default:
+        p = r.marginPx.top;
+        break;
+    }
+    const M = { src: u.src, width: u.widthPx, height: u.heightPx, z: F.z ?? 0 };
+    F.behind ? M.behind = !0 : M.front = !0, P.blocks.push({
+      blockId: u.id,
+      x: d + F.offsetXPx,
+      y: p + F.offsetYPx,
+      firstLineIndex: 0,
+      lines: [],
+      image: M
+    });
+  }, mt = (u) => {
+    if (u.anchor) {
+      Bn(u);
+      return;
+    }
+    W + u.heightPx > Z() && se() && ie();
+    const F = u.wrap === "square" && u.align !== "center", d = m - u.widthPx, p = ce() + (u.align === "center" ? d / 2 : u.align === "right" ? d : 0);
+    P.blocks.push({
+      blockId: u.id,
+      x: p,
+      y: W,
+      firstLineIndex: 0,
+      lines: [],
+      image: { src: u.src, width: u.widthPx, height: u.heightPx }
+    }), F ? he.push({ left: p, right: p + u.widthPx, bottom: W + u.heightPx, side: u.align === "right" ? "right" : "left" }) : W += u.heightPx;
+  }, Mn = (u) => {
+    const F = n(u);
+    let d = !0, p = 0, M = null;
+    const E = (I, _, K, Y) => {
+      if (M === null) {
+        M = { blockId: u.id, x: ce() + O(u), y: W, firstLineIndex: p, lines: [] };
+        const Q = p === 0 ? T.get(u.id) : void 0;
+        if (Q) {
+          const V = I[0]?.frag.x ?? 0;
+          M.marker = { text: Q.text, style: Q.style, x: M.x + V - Q.hangingPx };
+        }
+        P.blocks.push(M);
+      }
+      const U = { y: W - M.y, height: _, ascent: K, fragments: I.map((Q) => Q.frag) };
+      Y !== void 0 && (U.emptyOffset = Y), M.lines.push(U), W += _, p++;
+    };
+    for (const I of F) {
+      const _ = at(I.runs, I.startOffset), K = I.runs.map(() => 0);
+      let Y, U = !1, Q = null;
+      for (; ; ) {
+        const V = K.slice(), q = An(W), ee = d ? u.style.indentFirstLinePx : 0, $ = ft(
+          u,
+          I,
+          Math.max(24, q.width - O(u) - ee - N(u)),
+          Y,
+          _,
+          K
+        );
+        if ($ === null) break;
+        if (W + $.height > Z() && se()) {
+          for (let fe = 0; fe < K.length; fe++) K[fe] = V[fe];
+          ie(), M = null;
+          continue;
+        }
+        const Se = q.width - ee - N(u) - $.width;
+        let Be = q.x0 - ce() + ee;
+        u.style.align === "center" ? Be += Se / 2 : u.style.align === "right" && (Be += Se);
+        for (const fe of $.frags) fe.frag.x += Be;
+        u.style.align === "justify" && (Q && on(Q.frags, Q.slack), Q = { frags: $.frags, slack: Se }), E($.frags, $.height, $.ascent), Y = $.end, d = !1, U = !0;
+      }
+      if (!U) {
+        const V = rn(u);
+        W + V.height > Z() && se() && (ie(), M = null), E([], V.height, V.ascent, I.startOffset), d = !1;
+      }
+    }
+  }, Cn = (u) => {
+    u.block.rows.some((p) => p.cells.some((M) => (M.rowSpan ?? 1) > 1)) && se() && W + u.height > Z() && u.height <= h - f && ie();
+    let d = 0;
+    for (; d < u.rows.length; ) {
+      let p = 0, M = W;
+      for (; d + p < u.rows.length && M + u.rows[d + p].height <= Z(); )
+        M += u.rows[d + p].height, p++;
+      if (p === 0) {
+        if (se()) {
+          ie();
+          continue;
+        }
+        p = 1;
+      }
+      let E = [], I = 0;
+      for (; ; ) {
+        const K = pn(u.block.rows.slice(d, d + p));
+        if (K.length === 0) break;
+        const { H: Y, measures: U } = Nt(K);
+        if (U.length === 0) break;
+        let Q = 0;
+        for (let V = d; V < d + p; V++) Q += u.rows[V].height;
+        if (W + Q + Y <= Z() || p === 1 && !se()) {
+          E = U, I = Y;
+          break;
+        }
+        if (p--, p === 0) break;
+      }
+      if (p === 0) {
+        ie();
+        continue;
+      }
+      E.length > 0 && pt(E, I);
+      const _ = u.rows.slice(d, d + p);
+      P.blocks.push(dt(u.block, _, u.colWidths, ce(), W, m, d, j)), W += _.reduce((K, Y) => K + Y.height, 0), d += p, d < u.rows.length && ie();
+    }
+  };
+  for (let u = 0; u < z.length; u++) {
+    if (u > c[b].endBlock) {
+      for (; u > c[b].endBlock; ) v(c[++b].props);
+      Fn();
+    }
+    const F = z[u], d = (_) => _?.kind === "table" || _?.kind === "image" && _.block.anchor === void 0, p = d(z[u - 1]), M = d(z[u + 1]);
+    if (F.kind === "image") {
+      if (F.block.anchor) {
+        mt(F.block);
+        continue;
+      }
+      p || (W += Me), mt(F.block), !M && (F.block.wrap !== "square" || F.block.align === "center") && (W += Me);
+      continue;
+    }
+    if (F.kind === "table") {
+      p || (W += Me);
+      for (const _ of he) _.bottom > W && (W = _.bottom);
+      Cn(F), M || (W += Me);
+      continue;
+    }
+    const { block: E, lines: I } = F;
+    if (E.style.pageBreakBefore === !0 && (P.blocks.length > 0 || Ne > 0) ? Ke() : E.style.columnBreakBefore === !0 && se() && ie(), W += E.style.spaceBeforePx, W >= Z() && se() && ie(), En(W)) {
+      Mn(E), W += E.style.spaceAfterPx;
+      continue;
+    }
+    if (E.style.keepWithNext === !0 && z[u + 1] !== void 0 && se()) {
+      let _ = W + pe(I) + E.style.spaceAfterPx, K = _ <= Z();
+      for (let Y = u + 1; K; Y++) {
+        const U = z[Y];
+        if (U === void 0) break;
+        if (U.kind !== "para") {
+          const $ = U.kind === "table" ? U.rows[0]?.height ?? U.height : U.height;
+          _ + Me + $ > Z() && (K = !1);
+          break;
+        }
+        _ += U.block.style.spaceBeforePx;
+        const Q = U.block.style.keepWithNext === !0 && z[Y + 1] !== void 0;
+        if (Q || U.block.style.keepLinesTogether === !0) {
+          const $ = pe(U.lines);
+          if (_ + $ > Z()) {
+            K = !1;
+            break;
+          }
+          if (_ += $ + U.block.style.spaceAfterPx, !Q) break;
+          continue;
+        }
+        if (z[Y + 1] !== void 0 && U.block.runs.every(($) => $.text.trim().length === 0)) {
+          const $ = pe(U.lines);
+          if (_ + $ > Z()) {
+            K = !1;
+            break;
+          }
+          _ += $ + U.block.style.spaceAfterPx;
+          continue;
+        }
+        let V = 0, q = _;
+        for (; V < U.lines.length && q + U.lines[V].height <= Z(); )
+          q += U.lines[V].height, V++;
+        let ee = V;
+        V < U.lines.length && (U.lines.length - ee === 1 && (ee -= zt - 1), ee < _t && (ee = 0)), ee <= 0 && (K = !1);
+        break;
+      }
+      K || ie();
+    }
+    mn(E, I), W += E.style.spaceAfterPx;
+  }
+  for (const u of L) {
+    const F = be[u.index];
+    if (!F || F.length === 0) continue;
+    const d = S[u.index];
+    v(d);
+    let p = h - je[u.index];
+    u.footnoteRuleY = p + 4, p += X;
+    const M = d.marginPx.left;
+    for (const E of F) {
+      const I = gt(E);
+      if (!I) continue;
+      let _ = !0;
+      for (const K of I.paras) {
+        p += K.p.style.spaceBeforePx;
+        const Y = {
+          blockId: K.p.id,
+          x: M + ne,
+          y: p,
+          firstLineIndex: 0,
+          lines: K.lines
+        };
+        _ && K.p.runs[0] && (Y.marker = { text: `${Ft.get(E) ?? "•"}.`, style: K.p.runs[0].style, x: M }, _ = !1), u.blocks.push(Y), p += pe(K.lines) + K.p.style.spaceAfterPx;
+      }
+    }
+  }
+  const At = (u) => {
+    for (const d of u)
+      if (d.table) for (const p of d.table.rows) for (const M of p.cells) M.blocks = At(M.blocks);
+    if (!u.some((d) => d.image?.behind || d.image?.front)) return u;
+    const F = (d) => d.image?.behind ? 0 : d.image?.front ? 2 : 1;
+    return u.map((d, p) => ({ b: d, i: p })).sort((d, p) => {
+      const M = F(d.b) - F(p.b);
+      if (M !== 0) return M;
+      if (F(d.b) !== 1) {
+        const E = (d.b.image.z ?? 0) - (p.b.image.z ?? 0);
+        if (E !== 0) return E;
+      }
+      return d.i - p.i;
+    }).map((d) => d.b);
+  };
+  for (const u of L) u.blocks = At(u.blocks);
+  const Oe = [];
+  {
+    let u = 0;
+    for (let F = 0; F < L.length; F++) {
+      const d = S[F];
+      (F === 0 || S[F - 1] !== d) && d.pageNumberStart !== void 0 ? u = d.pageNumberStart : u++, Oe.push(u), L[F].number = u;
+    }
+  }
+  const Et = e.fields;
+  if (Et) {
+    const u = (p) => {
+      if (p === void 0) return !1;
+      const M = Et[p], E = M && M.kind === "builtin" ? M.spec?.type : void 0;
+      return E === "PAGE" || E === "NUMPAGES";
+    }, F = (p, M) => {
+      let E = 0;
+      for (const I of p.fragments) {
+        if (E !== 0 && (I.x += E), !u(I.style.fieldId)) continue;
+        const _ = un(I.text, M, L.length);
+        if (_ === I.text) continue;
+        const K = I.endOffset - I.startOffset, Y = I.width;
+        I.text = _, I.width = Pe(_, ae(I.style)), I.offsetMap = Array.from({ length: _.length + 1 }, (U, Q) => Q === _.length ? K : 0), E += I.width - Y;
+      }
+    }, d = (p, M) => {
+      for (const E of p.lines) F(E, M);
+      if (p.table) for (const E of p.table.rows) for (const I of E.cells) for (const _ of I.blocks) d(_, M);
+    };
+    for (const p of L) for (const M of p.blocks) d(M, Oe[p.index]);
+  }
+  if (J.size > 0) {
+    const u = /* @__PURE__ */ new Map(), F = (d, p) => {
+      for (const M of d)
+        if (u.has(M.blockId) || u.set(M.blockId, p), M.table) for (const E of M.table.rows) for (const I of E.cells) F(I.blocks, p);
+    };
+    for (const d of L) F(d.blocks, Oe[d.index]);
+    for (const d of J.values()) {
+      const p = d.para.style.tocEntry.targetId, M = u.get(p);
+      if (M === void 0) continue;
+      const E = d.para.runs[0]?.style;
+      if (!E || d.chunk.lines.length === 0) continue;
+      const I = String(M);
+      d.chunk.toc = {
+        numText: I,
+        numX: d.rightEdge - Pe(I, ae(E)),
+        lineIndex: d.chunk.lines.length - 1,
+        style: E,
+        targetId: p
+      };
+    }
+  }
+  const Bt = (u, F, d, p) => {
+    const M = F === "header" ? u.headerFirst : u.footerFirst, E = F === "header" ? u.headerEven : u.footerEven;
+    if (d && M) return { blocks: M, source: F === "header" ? "headerFirst" : "footerFirst" };
+    if (p && E) return { blocks: E, source: F === "header" ? "headerEven" : "footerEven" };
+    const I = u[F];
+    return I ? { blocks: I, source: F } : null;
+  };
+  if (S.some((u) => cn.some((F) => u[F]))) {
+    const u = new tt();
+    for (const F of L) {
+      const d = S[F.index], p = d.pageWidthPx - d.marginPx.left - d.marginPx.right, M = d.marginPx.left, E = F.index === 0 || S[F.index - 1] !== d, I = Oe[F.index], _ = I % 2 === 0, K = Bt(d, "header", E, _);
+      if (K) {
+        const U = x === "header", Q = we(K.blocks, p, M, I, L.length, u, U), V = jt(d, Q.height);
+        F.header = Q.placed.map((q) => nt(q, V)), F.headerSource = K.source;
+      }
+      const Y = Bt(d, "footer", E, _);
+      if (Y) {
+        const U = x === "footer", Q = we(Y.blocks, p, M, I, L.length, u, U), V = Kt(d, Q.height);
+        F.footer = Q.placed.map((q) => nt(q, V)), F.footerSource = Y.source;
+      }
+    }
+  }
+  return {
+    pages: L,
+    pageWidthPx: e.section.pageWidthPx,
+    pageHeightPx: e.section.pageHeightPx,
+    marginPx: e.section.marginPx
+  };
+}
+function ys(e, t) {
+  switch (t) {
+    case "roman":
+      return ye(e, "lowerRoman");
+    case "Roman":
+      return ye(e, "upperRoman");
+    case "alpha":
+      return ye(e, "lowerLetter");
+    case "Alpha":
+      return ye(e, "upperLetter");
+    default:
+      return String(e);
+  }
+}
+function un(e, t, n) {
+  return e.replace(/\{page(?::(roman|Roman|alpha|Alpha))?\}/g, (x, i) => ys(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 Is(e, t, n) {
+  const x = (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: un(s.text, t, n) }))
+  } : i;
+  return e.kind === "paragraph" ? x(e) : e.kind === "table" ? {
+    ...e,
+    rows: e.rows.map((i) => ({
+      cells: i.cells.map((s) => ({
+        ...s,
+        blocks: s.blocks.map((o) => o.kind === "paragraph" ? x(o) : o)
+      }))
+    }))
+  } : e;
+}
+function we(e, t, n, x, i, s, o) {
+  const a = (l, f) => ln(l, f, s), c = [];
+  let r = 0;
+  for (const l of e) {
+    const f = o ? l : Is(l, x, i);
+    if (f.kind === "paragraph") {
+      r += f.style.spaceBeforePx;
+      const h = a(f, t);
+      c.push({ blockId: f.id, x: n + f.style.indentLeftPx, y: r, firstLineIndex: 0, lines: h }), r += ht(h) + f.style.spaceAfterPx;
+    } else if (f.kind === "image") {
+      const h = t - f.widthPx, g = n + (f.align === "center" ? h / 2 : f.align === "right" ? h : 0);
+      c.push({
+        blockId: f.id,
+        x: g,
+        y: r,
+        firstLineIndex: 0,
+        lines: [],
+        image: { src: f.src, width: f.widthPx, height: f.heightPx }
+      }), r += f.heightPx;
+    } else {
+      const h = ut(f, t, a, Ut);
+      c.push(dt(f, h.rows, h.colWidths, n, r, t, 0, Ut)), r += h.height;
+    }
+  }
+  return { placed: c, height: r };
+}
+function nt(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((x) => ({
+      ...x,
+      y: x.y + t,
+      cells: x.cells.map((i) => ({
+        ...i,
+        y: i.y + t,
+        blocks: i.blocks.map((s) => nt(s, t))
+      }))
+    }))
+  }), n;
+}
+const Me = 12, ws = { top: 0, right: 7.2, bottom: 0, left: 7.2 }, hn = (e) => e.margin ?? ws, Ce = 4, Ut = { indentOf: () => 0, markers: /* @__PURE__ */ new Map() };
+function ut(e, t, n, x) {
+  const s = Dn(e).map((l) => l * t), o = s.length, a = new Array(o).fill(0), c = e.rows.map((l) => {
+    let f = 0;
+    const h = l.cells.map((g) => {
+      for (; f < o && a[f] > 0; ) f++;
+      const A = Math.max(1, g.colSpan ?? 1), m = Math.max(1, g.rowSpan ?? 1), B = f;
+      let C = 0;
+      for (let N = 0; N < A; N++) C += s[f + N] ?? s[o - 1] ?? 40;
+      if (m > 1) for (let N = 0; N < A && f + N < o; N++) a[f + N] = m;
+      f += A;
+      const v = hn(g), H = Math.max(8, C - v.left - v.right);
+      let y = 0;
+      const O = g.blocks.map((N) => {
+        if (N.kind === "paragraph") {
+          const k = H - N.style.indentLeftPx - x.indentOf(N) - (N.style.indentRightPx ?? 0), T = n(N, Math.max(8, k));
+          return y += N.style.spaceBeforePx + ht(T) + N.style.spaceAfterPx, { kind: "para", block: N, lines: T };
+        }
+        if (N.kind === "image") {
+          if (N.anchor) return { kind: "image", block: N, width: N.widthPx, height: N.heightPx };
+          const k = Math.min(1, H / Math.max(1, N.widthPx)), T = N.widthPx * k, G = N.heightPx * k;
+          return y += G + Ce, { kind: "image", block: N, width: T, height: G };
+        }
+        const D = ut(N, H, n, x);
+        return y += D.height + Ce, { kind: "table", block: N, ...D };
+      });
+      return { cell: g, items: O, height: y + v.top + v.bottom, width: C, colStart: B, rowSpan: m };
+    });
+    for (let g = 0; g < o; g++) a[g] > 0 && a[g]--;
+    return { cells: h, height: 0 };
+  }), r = c.map((l) => Math.max(0, ...l.cells.filter((f) => f.rowSpan === 1).map((f) => f.height)));
+  return c.forEach((l, f) => {
+    for (const h of l.cells) {
+      if (h.rowSpan <= 1) continue;
+      const g = Math.min(c.length - 1, f + h.rowSpan - 1);
+      let A = 0;
+      for (let m = f; m <= g; m++) A += r[m];
+      h.height > A && (r[g] += h.height - A);
+    }
+  }), c.forEach((l, f) => l.height = r[f]), { rows: c, colWidths: s, height: r.reduce((l, f) => l + f, 0) };
+}
+function ht(e) {
+  let t = 0;
+  for (const n of e) t += n.height;
+  return t;
+}
+function dt(e, t, n, x, i, s, o, a) {
+  const c = [0];
+  for (const h of n) c.push(c[c.length - 1] + h);
+  const r = [i];
+  for (const h of t) r.push(r[r.length - 1] + h.height);
+  const l = [];
+  for (let h = 0; h < t.length; h++) {
+    const g = t[h], A = r[h], m = [];
+    for (const B of g.cells) {
+      const C = x + (c[B.colStart] ?? c[c.length - 1]), v = Math.min(t.length - 1, h + B.rowSpan - 1), H = r[v + 1] - A, y = [], O = hn(B.cell), N = B.width - O.left - O.right;
+      let D = A + O.top;
+      for (const k of B.items)
+        if (k.kind === "para") {
+          D += k.block.style.spaceBeforePx;
+          const T = C + O.left + k.block.style.indentLeftPx + a.indentOf(k.block), G = {
+            blockId: k.block.id,
+            x: T,
+            y: D,
+            firstLineIndex: 0,
+            lines: k.lines
+            // line.y is already block-relative; coords stay consistent
+          }, w = a.markers.get(k.block.id);
+          w && (G.marker = { text: w.text, style: w.style, x: Math.max(C + 1, T - w.hangingPx) }), y.push(G), D += ht(k.lines) + k.block.style.spaceAfterPx;
+        } else if (k.kind === "image") {
+          const T = k.block.anchor;
+          if (T) {
+            const w = {
+              src: k.block.src,
+              width: k.block.widthPx,
+              height: k.block.heightPx,
+              z: T.z ?? 0
+            };
+            T.behind ? w.behind = !0 : w.front = !0, y.push({
+              blockId: k.block.id,
+              x: C + O.left + T.offsetXPx,
+              y: A + O.top + T.offsetYPx,
+              firstLineIndex: 0,
+              lines: [],
+              image: w
+            });
+            continue;
+          }
+          const G = H - O.top - O.bottom;
+          if (B.items.length === 1 && G > k.height + 8) {
+            const w = Math.max(N / k.block.widthPx, G / k.block.heightPx), j = k.block.widthPx * w, z = k.block.heightPx * w, b = C + O.left, S = A + O.top;
+            y.push({
+              blockId: k.block.id,
+              x: b + (N - j) / 2,
+              y: S + (G - z) / 2,
+              firstLineIndex: 0,
+              lines: [],
+              image: { src: k.block.src, width: j, height: z, clip: { x: b, y: S, width: N, height: G } }
+            }), D += k.height + Ce;
+          } else {
+            const w = N - k.width, j = C + O.left + (k.block.align === "center" ? w / 2 : k.block.align === "right" ? w : 0);
+            y.push({
+              blockId: k.block.id,
+              x: j,
+              y: D,
+              firstLineIndex: 0,
+              lines: [],
+              image: { src: k.block.src, width: k.width, height: k.height }
+            }), D += k.height + Ce;
+          }
+        } else
+          y.push(dt(k.block, k.rows, k.colWidths, C + O.left, D, N, 0, a)), D += k.height + Ce;
+      m.push({
+        x: C,
+        y: A,
+        width: B.width,
+        height: H,
+        originRow: o + h,
+        originCol: B.colStart,
+        blocks: y,
+        ...B.cell.shading !== void 0 ? { shading: B.cell.shading } : {},
+        ...B.cell.borders !== void 0 ? { borders: B.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: C + O.left, y: A, width: N, height: H }
+      });
+    }
+    l.push({ y: A, height: g.height, cells: m });
+  }
+  const f = t.reduce((h, g) => h + g.height, 0);
+  return {
+    blockId: e.id,
+    x,
+    y: i,
+    firstLineIndex: o,
+    // for tables this is the chunk's first ROW index
+    lines: [],
+    table: { x, y: i, width: s, height: f, rows: l, colWidths: n }
+  };
+}
+const Ts = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  createLayoutEngine: As,
+  effectiveSection: an,
+  resolveSections: fn
+}, Symbol.toStringTag, { value: "Module" }));
+function Ps(e) {
+  const t = /* @__PURE__ */ new Map(), n = (x, i) => {
+    for (const s of x)
+      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 x of e.pages) n(x.blocks, x.number);
+  return t;
+}
+function Gs(e, t) {
+  const n = Ps(t), x = [];
+  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 c = bn(i.runs), r = c.match(/\t(\d+)(\s*)$/);
+    if (!r || r[1] === String(a)) continue;
+    const l = c.length - r[2].length - r[1].length;
+    x.push({
+      blockId: i.id,
+      start: l,
+      end: l + r[1].length,
+      text: String(a),
+      style: Ln(i.runs, l) ?? i.runs[0]?.style
+    });
+  }
+  return x;
+}
+export {
+  Gs as a,
+  As as c,
+  Ts as e,
+  Ps as p
+};