{"mappings":"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","names":["baseTypes","arabicTypes","classifyChar","charCode","computeBidiLevels","str","len","types","numBidi","t","startLevel","levels","e","sor","lastType","j","end","before","after","bDir","computeSegmentLevels","normalized","segStarts","bidiLevels","segLevels","i","collapsibleWhitespaceRunRe","needsWhitespaceNormalizationRe","getWhiteSpaceProfile","whiteSpace","mode","normalizeWhitespaceNormal","text","normalized","normalizeWhitespacePreWrap","sharedWordSegmenter","segmenterLocale","getSharedWordSegmenter","clearAnalysisCaches","setAnalysisLocale","locale","nextLocale","arabicScriptRe","combiningMarkRe","decimalDigitRe","containsArabicScript","isCJK","s","ch","c","kinsokuStart","kinsokuEnd","forwardStickyGlue","leftStickyPunctuation","arabicNoSpaceTrailingPunctuation","myanmarMedialGlue","closingQuoteChars","isLeftStickyPunctuationSegment","segment","isEscapedQuoteClusterSegment","sawPunctuation","isCJKLineStartProhibitedSegment","isForwardStickyClusterSegment","sawQuote","splitTrailingForwardStickyCluster","chars","splitIndex","isRepeatedSingleCharRun","part","endsWithArabicNoSpacePunctuation","endsWithMyanmarMedialGlue","splitLeadingSpaceAndMarks","marks","endsWithClosingQuote","i","classifySegmentBreakChar","whiteSpaceProfile","splitSegmentByBreakKind","isWordLike","start","pieces","currentKind","currentText","currentStart","currentWordLike","offset","kind","wordLike","isTextRunBoundary","urlSchemeSegmentRe","isUrlLikeRunStart","segmentation","index","isUrlQueryBoundarySegment","mergeUrlLikeRuns","texts","kinds","starts","j","endsQueryPrefix","compactLen","read","mergeUrlQueryRuns","nextIndex","queryText","queryStart","numericJoinerChars","asciiPunctuationChainSegmentRe","asciiPunctuationChainTrailingJoinersRe","segmentContainsDecimalDigit","isNumericRunSegment","mergeNumericRuns","mergedText","mergeAsciiPunctuationChains","splitHyphenatedNumericRuns","parts","shouldSplit","splitText","mergeGlueConnectedTextRuns","glueText","glueStart","carryTrailingForwardStickyAcrossCJKBoundary","split","buildMergedSegmentation","profile","wordSegmenter","mergedLen","mergedTexts","mergedWordLike","mergedKinds","mergedStarts","piece","isText","compacted","withMergedUrls","compileAnalysisChunks","chunks","startSegmentIndex","analyzeText","measureContext","segmentMetricCaches","cachedEngineProfile","emojiPresentationRe","maybeEmojiRe","sharedGraphemeSegmenter","emojiCorrectionCache","getMeasureContext","getSegmentMetricCache","font","cache","getSegmentMetrics","seg","metrics","isCJK","getEngineProfile","ua","isSafari","isChromium","parseFontSize","m","getSharedGraphemeSegmenter","isEmojiGrapheme","g","textMayContainEmoji","text","getEmojiCorrection","fontSize","correction","ctx","canvasW","span","domW","countEmojiGraphemes","count","graphemeSegmenter","getEmojiCount","getCorrectedSegmentWidth","emojiCorrection","getSegmentGraphemeWidths","widths","gs","graphemeMetrics","getSegmentGraphemePrefixWidths","prefixWidths","prefix","prefixMetrics","getFontMeasurementState","needsEmojiCorrection","clearMeasurementCaches","canBreakAfter","kind","isSimpleCollapsibleSpace","getTabAdvance","lineWidth","tabStopAdvance","remainder","getBreakableAdvance","graphemeWidths","graphemePrefixWidths","graphemeIndex","preferPrefixWidths","fitSoftHyphenBreak","initialWidth","maxWidth","lineFitEpsilon","discretionaryHyphenWidth","cumulativeWidths","fitCount","fittedWidth","nextWidth","findChunkIndexForStart","prepared","segmentIndex","i","chunk","normalizeLineStart","start","chunkIndex","countPreparedLines","countPreparedLinesSimple","walkPreparedLines","widths","kinds","breakableWidths","breakablePrefixWidths","engineProfile","getEngineProfile","lineCount","lineW","hasContent","placeOnFreshLine","w","gWidths","gPrefixWidths","g","gw","newW","walkPreparedLinesSimple","onLine","lineStartSegmentIndex","lineStartGraphemeIndex","lineEndSegmentIndex","lineEndGraphemeIndex","pendingBreakSegmentIndex","pendingBreakPaintWidth","clearPendingBreak","emitCurrentLine","endSegmentIndex","endGraphemeIndex","width","startLineAtSegment","startLineAtGrapheme","appendWholeSegment","updatePendingBreak","segmentWidth","appendBreakableSegment","appendBreakableSegmentFrom","startGraphemeIndex","lineEndFitAdvances","lineEndPaintAdvances","chunks","pendingBreakFitWidth","pendingBreakKind","updatePendingBreakForWholeSegment","fitAdvance","paintAdvance","continueSoftHyphenBreakableSegment","fitWidths","usesPrefixWidths","emitEmptyChunk","currentBreakFitWidth","currentBreakPaintWidth","finalPaintWidth","layoutNextLineRange","normalizedStart","layoutNextLineRangeSimple","finishLine","maybeFinishAtSoftHyphen","line","softBreakLine","currentLine","sharedGraphemeSegmenter","sharedLineTextCaches","getSharedGraphemeSegmenter","createEmptyPrepared","includeSegments","measureAnalysis","analysis","font","graphemeSegmenter","engineProfile","getEngineProfile","cache","emojiCorrection","getFontMeasurementState","textMayContainEmoji","discretionaryHyphenWidth","getCorrectedSegmentWidth","getSegmentMetrics","tabStopAdvance","widths","lineEndFitAdvances","lineEndPaintAdvances","kinds","simpleLineWalkFastPath","segStarts","breakableWidths","breakablePrefixWidths","segments","preparedStartByAnalysisIndex","preparedEndByAnalysisIndex","pushMeasuredSegment","text","width","lineEndFitAdvance","lineEndPaintAdvance","kind","start","breakable","breakablePrefix","mi","segText","segWordLike","segKind","segStart","segMetrics","unitText","unitStart","gs","grapheme","kinsokuEnd","kinsokuStart","leftStickyPunctuation","isCJK","endsWithClosingQuote","unitMetrics","w","graphemeWidths","getSegmentGraphemeWidths","graphemePrefixWidths","getSegmentGraphemePrefixWidths","chunks","mapAnalysisChunksToPreparedChunks","segLevels","computeSegmentLevels","preparedChunks","i","chunk","startSegmentIndex","endSegmentIndex","consumedEndSegmentIndex","prepareInternal","options","analyzeText","profilePrepare","t0","t1","prepared","t2","breakableSegments","prepare","prepareWithSegments","layout","prepared","maxWidth","lineHeight","lineCount","countPreparedLines","getSegmentGraphemes","segmentIndex","segments","cache","graphemes","graphemeSegmenter","getSharedGraphemeSegmenter","gs","getLineTextCache","sharedLineTextCaches","lineHasDiscretionaryHyphen","kinds","startSegmentIndex","startGraphemeIndex","endSegmentIndex","buildLineTextFromRange","endGraphemeIndex","text","endsWithDiscretionaryHyphen","createLayoutLine","width","materializeLayoutLine","line","toLayoutLineRange","stepLineRange","start","layoutNextLineRange","materializeLine","walkLineRanges","onLine","walkPreparedLines","layoutNextLine","layoutWithLines","lines","graphemeCache","clearCache","clearAnalysisCaches","sharedGraphemeSegmenter","clearMeasurementCaches","setLocale","locale","setAnalysisLocale"],"sources":["../esm/npm/@chenglou/pretext@0.0.3/node_modules/@chenglou/pretext/dist/bidi.js","../esm/npm/@chenglou/pretext@0.0.3/node_modules/@chenglou/pretext/dist/analysis.js","../esm/npm/@chenglou/pretext@0.0.3/node_modules/@chenglou/pretext/dist/measurement.js","../esm/npm/@chenglou/pretext@0.0.3/node_modules/@chenglou/pretext/dist/line-break.js","../esm/npm/@chenglou/pretext@0.0.3/node_modules/@chenglou/pretext/dist/layout.js"],"sourcesContent":["// Simplified bidi metadata helper for the rich prepareWithSegments() path,\n// forked from pdf.js via Sebastian's text-layout. It classifies characters\n// into bidi types, computes embedding levels, and maps them onto prepared\n// segments for custom rendering. The line-breaking engine does not consume\n// these levels.\nconst baseTypes = [\n    'BN', 'BN', 'BN', 'BN', 'BN', 'BN', 'BN', 'BN', 'BN', 'S', 'B', 'S', 'WS',\n    'B', 'BN', 'BN', 'BN', 'BN', 'BN', 'BN', 'BN', 'BN', 'BN', 'BN', 'BN', 'BN',\n    'BN', 'BN', 'B', 'B', 'B', 'S', 'WS', 'ON', 'ON', 'ET', 'ET', 'ET', 'ON',\n    'ON', 'ON', 'ON', 'ON', 'ON', 'CS', 'ON', 'CS', 'ON', 'EN', 'EN', 'EN',\n    'EN', 'EN', 'EN', 'EN', 'EN', 'EN', 'EN', 'ON', 'ON', 'ON', 'ON', 'ON',\n    'ON', 'ON', 'L', 'L', 'L', 'L', 'L', 'L', 'L', 'L', 'L', 'L', 'L', 'L', 'L',\n    'L', 'L', 'L', 'L', 'L', 'L', 'L', 'L', 'L', 'L', 'L', 'L', 'L', 'ON', 'ON',\n    'ON', 'ON', 'ON', 'ON', 'L', 'L', 'L', 'L', 'L', 'L', 'L', 'L', 'L', 'L',\n    'L', 'L', 'L', 'L', 'L', 'L', 'L', 'L', 'L', 'L', 'L', 'L', 'L', 'L', 'L',\n    'L', 'ON', 'ON', 'ON', 'ON', 'BN', 'BN', 'BN', 'BN', 'BN', 'BN', 'B', 'BN',\n    'BN', 'BN', 'BN', 'BN', 'BN', 'BN', 'BN', 'BN', 'BN', 'BN', 'BN', 'BN',\n    'BN', 'BN', 'BN', 'BN', 'BN', 'BN', 'BN', 'BN', 'BN', 'BN', 'BN', 'BN',\n    'BN', 'CS', 'ON', 'ET', 'ET', 'ET', 'ET', 'ON', 'ON', 'ON', 'ON', 'L', 'ON',\n    'ON', 'ON', 'ON', 'ON', 'ET', 'ET', 'EN', 'EN', 'ON', 'L', 'ON', 'ON', 'ON',\n    'EN', 'L', 'ON', 'ON', 'ON', 'ON', 'ON', 'L', 'L', 'L', 'L', 'L', 'L', 'L',\n    'L', 'L', 'L', 'L', 'L', 'L', 'L', 'L', 'L', 'L', 'L', 'L', 'L', 'L', 'L',\n    'L', 'ON', 'L', 'L', 'L', 'L', 'L', 'L', 'L', 'L', 'L', 'L', 'L', 'L', 'L',\n    'L', 'L', 'L', 'L', 'L', 'L', 'L', 'L', 'L', 'L', 'L', 'L', 'L', 'L', 'L',\n    'L', 'L', 'L', 'ON', 'L', 'L', 'L', 'L', 'L', 'L', 'L', 'L'\n];\nconst arabicTypes = [\n    'AL', 'AL', 'AL', 'AL', 'AL', 'AL', 'AL', 'AL', 'AL', 'AL', 'AL', 'AL',\n    'CS', 'AL', 'ON', 'ON', 'NSM', 'NSM', 'NSM', 'NSM', 'NSM', 'NSM', 'AL',\n    'AL', 'AL', 'AL', 'AL', 'AL', 'AL', 'AL', 'AL', 'AL', 'AL', 'AL', 'AL',\n    'AL', 'AL', 'AL', 'AL', 'AL', 'AL', 'AL', 'AL', 'AL', 'AL', 'AL', 'AL',\n    'AL', 'AL', 'AL', 'AL', 'AL', 'AL', 'AL', 'AL', 'AL', 'AL', 'AL', 'AL',\n    'AL', 'AL', 'AL', 'AL', 'AL', 'AL', 'AL', 'AL', 'AL', 'AL', 'AL', 'AL',\n    'AL', 'AL', 'AL', 'AL', 'NSM', 'NSM', 'NSM', 'NSM', 'NSM', 'NSM', 'NSM',\n    'NSM', 'NSM', 'NSM', 'NSM', 'NSM', 'NSM', 'NSM', 'AL', 'AL', 'AL', 'AL',\n    'AL', 'AL', 'AL', 'AN', 'AN', 'AN', 'AN', 'AN', 'AN', 'AN', 'AN', 'AN',\n    'AN', 'ET', 'AN', 'AN', 'AL', 'AL', 'AL', 'NSM', 'AL', 'AL', 'AL', 'AL',\n    'AL', 'AL', 'AL', 'AL', 'AL', 'AL', 'AL', 'AL', 'AL', 'AL', 'AL', 'AL',\n    'AL', 'AL', 'AL', 'AL', 'AL', 'AL', 'AL', 'AL', 'AL', 'AL', 'AL', 'AL',\n    'AL', 'AL', 'AL', 'AL', 'AL', 'AL', 'AL', 'AL', 'AL', 'AL', 'AL', 'AL',\n    'AL', 'AL', 'AL', 'AL', 'AL', 'AL', 'AL', 'AL', 'AL', 'AL', 'AL', 'AL',\n    'AL', 'AL', 'AL', 'AL', 'AL', 'AL', 'AL', 'AL', 'AL', 'AL', 'AL', 'AL',\n    'AL', 'AL', 'AL', 'AL', 'AL', 'AL', 'AL', 'AL', 'AL', 'AL', 'AL', 'AL',\n    'AL', 'AL', 'AL', 'AL', 'AL', 'AL', 'AL', 'AL', 'AL', 'AL', 'AL', 'AL',\n    'AL', 'AL', 'AL', 'AL', 'AL', 'AL', 'AL', 'AL', 'AL', 'AL', 'AL', 'AL',\n    'AL', 'NSM', 'NSM', 'NSM', 'NSM', 'NSM', 'NSM', 'NSM', 'NSM', 'NSM', 'NSM',\n    'NSM', 'NSM', 'NSM', 'NSM', 'NSM', 'NSM', 'NSM', 'NSM', 'NSM', 'ON', 'NSM',\n    'NSM', 'NSM', 'NSM', 'AL', 'AL', 'AL', 'AL', 'AL', 'AL', 'AL', 'AL', 'AL',\n    'AL', 'AL', 'AL', 'AL', 'AL', 'AL', 'AL', 'AL', 'AL'\n];\nfunction classifyChar(charCode) {\n    if (charCode \u003c= 0x00ff)\n        return baseTypes[charCode];\n    if (0x0590 \u003c= charCode \u0026\u0026 charCode \u003c= 0x05f4)\n        return 'R';\n    if (0x0600 \u003c= charCode \u0026\u0026 charCode \u003c= 0x06ff)\n        return arabicTypes[charCode \u0026 0xff];\n    if (0x0700 \u003c= charCode \u0026\u0026 charCode \u003c= 0x08AC)\n        return 'AL';\n    return 'L';\n}\nfunction computeBidiLevels(str) {\n    const len = str.length;\n    if (len === 0)\n        return null;\n    // eslint-disable-next-line unicorn/no-new-array\n    const types = new Array(len);\n    let numBidi = 0;\n    for (let i = 0; i \u003c len; i++) {\n        const t = classifyChar(str.charCodeAt(i));\n        if (t === 'R' || t === 'AL' || t === 'AN')\n            numBidi++;\n        types[i] = t;\n    }\n    if (numBidi === 0)\n        return null;\n    const startLevel = (len / numBidi) \u003c 0.3 ? 0 : 1;\n    const levels = new Int8Array(len);\n    for (let i = 0; i \u003c len; i++)\n        levels[i] = startLevel;\n    const e = (startLevel \u0026 1) ? 'R' : 'L';\n    const sor = e;\n    // W1-W7\n    let lastType = sor;\n    for (let i = 0; i \u003c len; i++) {\n        if (types[i] === 'NSM')\n            types[i] = lastType;\n        else\n            lastType = types[i];\n    }\n    lastType = sor;\n    for (let i = 0; i \u003c len; i++) {\n        const t = types[i];\n        if (t === 'EN')\n            types[i] = lastType === 'AL' ? 'AN' : 'EN';\n        else if (t === 'R' || t === 'L' || t === 'AL')\n            lastType = t;\n    }\n    for (let i = 0; i \u003c len; i++) {\n        if (types[i] === 'AL')\n            types[i] = 'R';\n    }\n    for (let i = 1; i \u003c len - 1; i++) {\n        if (types[i] === 'ES' \u0026\u0026 types[i - 1] === 'EN' \u0026\u0026 types[i + 1] === 'EN') {\n            types[i] = 'EN';\n        }\n        if (types[i] === 'CS' \u0026\u0026\n            (types[i - 1] === 'EN' || types[i - 1] === 'AN') \u0026\u0026\n            types[i + 1] === types[i - 1]) {\n            types[i] = types[i - 1];\n        }\n    }\n    for (let i = 0; i \u003c len; i++) {\n        if (types[i] !== 'EN')\n            continue;\n        let j;\n        for (j = i - 1; j \u003e= 0 \u0026\u0026 types[j] === 'ET'; j--)\n            types[j] = 'EN';\n        for (j = i + 1; j \u003c len \u0026\u0026 types[j] === 'ET'; j++)\n            types[j] = 'EN';\n    }\n    for (let i = 0; i \u003c len; i++) {\n        const t = types[i];\n        if (t === 'WS' || t === 'ES' || t === 'ET' || t === 'CS')\n            types[i] = 'ON';\n    }\n    lastType = sor;\n    for (let i = 0; i \u003c len; i++) {\n        const t = types[i];\n        if (t === 'EN')\n            types[i] = lastType === 'L' ? 'L' : 'EN';\n        else if (t === 'R' || t === 'L')\n            lastType = t;\n    }\n    // N1-N2\n    for (let i = 0; i \u003c len; i++) {\n        if (types[i] !== 'ON')\n            continue;\n        let end = i + 1;\n        while (end \u003c len \u0026\u0026 types[end] === 'ON')\n            end++;\n        const before = i \u003e 0 ? types[i - 1] : sor;\n        const after = end \u003c len ? types[end] : sor;\n        const bDir = before !== 'L' ? 'R' : 'L';\n        const aDir = after !== 'L' ? 'R' : 'L';\n        if (bDir === aDir) {\n            for (let j = i; j \u003c end; j++)\n                types[j] = bDir;\n        }\n        i = end - 1;\n    }\n    for (let i = 0; i \u003c len; i++) {\n        if (types[i] === 'ON')\n            types[i] = e;\n    }\n    // I1-I2\n    for (let i = 0; i \u003c len; i++) {\n        const t = types[i];\n        if ((levels[i] \u0026 1) === 0) {\n            if (t === 'R')\n                levels[i]++;\n            else if (t === 'AN' || t === 'EN')\n                levels[i] += 2;\n        }\n        else if (t === 'L' || t === 'AN' || t === 'EN') {\n            levels[i]++;\n        }\n    }\n    return levels;\n}\nexport function computeSegmentLevels(normalized, segStarts) {\n    const bidiLevels = computeBidiLevels(normalized);\n    if (bidiLevels === null)\n        return null;\n    const segLevels = new Int8Array(segStarts.length);\n    for (let i = 0; i \u003c segStarts.length; i++) {\n        segLevels[i] = bidiLevels[segStarts[i]];\n    }\n    return segLevels;\n}\n","const collapsibleWhitespaceRunRe = /[ \\t\\n\\r\\f]+/g;\nconst needsWhitespaceNormalizationRe = /[\\t\\n\\r\\f]| {2,}|^ | $/;\nfunction getWhiteSpaceProfile(whiteSpace) {\n    const mode = whiteSpace ?? 'normal';\n    return mode === 'pre-wrap'\n        ? { mode, preserveOrdinarySpaces: true, preserveHardBreaks: true }\n        : { mode, preserveOrdinarySpaces: false, preserveHardBreaks: false };\n}\nexport function normalizeWhitespaceNormal(text) {\n    if (!needsWhitespaceNormalizationRe.test(text))\n        return text;\n    let normalized = text.replace(collapsibleWhitespaceRunRe, ' ');\n    if (normalized.charCodeAt(0) === 0x20) {\n        normalized = normalized.slice(1);\n    }\n    if (normalized.length \u003e 0 \u0026\u0026 normalized.charCodeAt(normalized.length - 1) === 0x20) {\n        normalized = normalized.slice(0, -1);\n    }\n    return normalized;\n}\nfunction normalizeWhitespacePreWrap(text) {\n    if (!/[\\r\\f]/.test(text))\n        return text.replace(/\\r\\n/g, '\\n');\n    return text\n        .replace(/\\r\\n/g, '\\n')\n        .replace(/[\\r\\f]/g, '\\n');\n}\nlet sharedWordSegmenter = null;\nlet segmenterLocale;\nfunction getSharedWordSegmenter() {\n    if (sharedWordSegmenter === null) {\n        sharedWordSegmenter = new Intl.Segmenter(segmenterLocale, { granularity: 'word' });\n    }\n    return sharedWordSegmenter;\n}\nexport function clearAnalysisCaches() {\n    sharedWordSegmenter = null;\n}\nexport function setAnalysisLocale(locale) {\n    const nextLocale = locale \u0026\u0026 locale.length \u003e 0 ? locale : undefined;\n    if (segmenterLocale === nextLocale)\n        return;\n    segmenterLocale = nextLocale;\n    sharedWordSegmenter = null;\n}\nconst arabicScriptRe = /\\p{Script=Arabic}/u;\nconst combiningMarkRe = /\\p{M}/u;\nconst decimalDigitRe = /\\p{Nd}/u;\nfunction containsArabicScript(text) {\n    return arabicScriptRe.test(text);\n}\nexport function isCJK(s) {\n    for (const ch of s) {\n        const c = ch.codePointAt(0);\n        if ((c \u003e= 0x4E00 \u0026\u0026 c \u003c= 0x9FFF) ||\n            (c \u003e= 0x3400 \u0026\u0026 c \u003c= 0x4DBF) ||\n            (c \u003e= 0x20000 \u0026\u0026 c \u003c= 0x2A6DF) ||\n            (c \u003e= 0x2A700 \u0026\u0026 c \u003c= 0x2B73F) ||\n            (c \u003e= 0x2B740 \u0026\u0026 c \u003c= 0x2B81F) ||\n            (c \u003e= 0x2B820 \u0026\u0026 c \u003c= 0x2CEAF) ||\n            (c \u003e= 0x2CEB0 \u0026\u0026 c \u003c= 0x2EBEF) ||\n            (c \u003e= 0x30000 \u0026\u0026 c \u003c= 0x3134F) ||\n            (c \u003e= 0xF900 \u0026\u0026 c \u003c= 0xFAFF) ||\n            (c \u003e= 0x2F800 \u0026\u0026 c \u003c= 0x2FA1F) ||\n            (c \u003e= 0x3000 \u0026\u0026 c \u003c= 0x303F) ||\n            (c \u003e= 0x3040 \u0026\u0026 c \u003c= 0x309F) ||\n            (c \u003e= 0x30A0 \u0026\u0026 c \u003c= 0x30FF) ||\n            (c \u003e= 0xAC00 \u0026\u0026 c \u003c= 0xD7AF) ||\n            (c \u003e= 0xFF00 \u0026\u0026 c \u003c= 0xFFEF)) {\n            return true;\n        }\n    }\n    return false;\n}\nexport const kinsokuStart = new Set([\n    '\\uFF0C',\n    '\\uFF0E',\n    '\\uFF01',\n    '\\uFF1A',\n    '\\uFF1B',\n    '\\uFF1F',\n    '\\u3001',\n    '\\u3002',\n    '\\u30FB',\n    '\\uFF09',\n    '\\u3015',\n    '\\u3009',\n    '\\u300B',\n    '\\u300D',\n    '\\u300F',\n    '\\u3011',\n    '\\u3017',\n    '\\u3019',\n    '\\u301B',\n    '\\u30FC',\n    '\\u3005',\n    '\\u303B',\n    '\\u309D',\n    '\\u309E',\n    '\\u30FD',\n    '\\u30FE',\n]);\nexport const kinsokuEnd = new Set([\n    '\"',\n    '(', '[', '{',\n    '“', '‘', '«', '‹',\n    '\\uFF08',\n    '\\u3014',\n    '\\u3008',\n    '\\u300A',\n    '\\u300C',\n    '\\u300E',\n    '\\u3010',\n    '\\u3016',\n    '\\u3018',\n    '\\u301A',\n]);\nconst forwardStickyGlue = new Set([\n    \"'\", '’',\n]);\nexport const leftStickyPunctuation = new Set([\n    '.', ',', '!', '?', ':', ';',\n    '\\u060C',\n    '\\u061B',\n    '\\u061F',\n    '\\u0964',\n    '\\u0965',\n    '\\u104A',\n    '\\u104B',\n    '\\u104C',\n    '\\u104D',\n    '\\u104F',\n    ')', ']', '}',\n    '%',\n    '\"',\n    '”', '’', '»', '›',\n    '…',\n]);\nconst arabicNoSpaceTrailingPunctuation = new Set([\n    ':',\n    '.',\n    '\\u060C',\n    '\\u061B',\n]);\nconst myanmarMedialGlue = new Set([\n    '\\u104F',\n]);\nconst closingQuoteChars = new Set([\n    '”', '’', '»', '›',\n    '\\u300D',\n    '\\u300F',\n    '\\u3011',\n    '\\u300B',\n    '\\u3009',\n    '\\u3015',\n    '\\uFF09',\n]);\nfunction isLeftStickyPunctuationSegment(segment) {\n    if (isEscapedQuoteClusterSegment(segment))\n        return true;\n    let sawPunctuation = false;\n    for (const ch of segment) {\n        if (leftStickyPunctuation.has(ch)) {\n            sawPunctuation = true;\n            continue;\n        }\n        if (sawPunctuation \u0026\u0026 combiningMarkRe.test(ch))\n            continue;\n        return false;\n    }\n    return sawPunctuation;\n}\nfunction isCJKLineStartProhibitedSegment(segment) {\n    for (const ch of segment) {\n        if (!kinsokuStart.has(ch) \u0026\u0026 !leftStickyPunctuation.has(ch))\n            return false;\n    }\n    return segment.length \u003e 0;\n}\nfunction isForwardStickyClusterSegment(segment) {\n    if (isEscapedQuoteClusterSegment(segment))\n        return true;\n    for (const ch of segment) {\n        if (!kinsokuEnd.has(ch) \u0026\u0026 !forwardStickyGlue.has(ch) \u0026\u0026 !combiningMarkRe.test(ch))\n            return false;\n    }\n    return segment.length \u003e 0;\n}\nfunction isEscapedQuoteClusterSegment(segment) {\n    let sawQuote = false;\n    for (const ch of segment) {\n        if (ch === '\\\\' || combiningMarkRe.test(ch))\n            continue;\n        if (kinsokuEnd.has(ch) || leftStickyPunctuation.has(ch) || forwardStickyGlue.has(ch)) {\n            sawQuote = true;\n            continue;\n        }\n        return false;\n    }\n    return sawQuote;\n}\nfunction splitTrailingForwardStickyCluster(text) {\n    const chars = Array.from(text);\n    let splitIndex = chars.length;\n    while (splitIndex \u003e 0) {\n        const ch = chars[splitIndex - 1];\n        if (combiningMarkRe.test(ch)) {\n            splitIndex--;\n            continue;\n        }\n        if (kinsokuEnd.has(ch) || forwardStickyGlue.has(ch)) {\n            splitIndex--;\n            continue;\n        }\n        break;\n    }\n    if (splitIndex \u003c= 0 || splitIndex === chars.length)\n        return null;\n    return {\n        head: chars.slice(0, splitIndex).join(''),\n        tail: chars.slice(splitIndex).join(''),\n    };\n}\nfunction isRepeatedSingleCharRun(segment, ch) {\n    if (segment.length === 0)\n        return false;\n    for (const part of segment) {\n        if (part !== ch)\n            return false;\n    }\n    return true;\n}\nfunction endsWithArabicNoSpacePunctuation(segment) {\n    if (!containsArabicScript(segment) || segment.length === 0)\n        return false;\n    return arabicNoSpaceTrailingPunctuation.has(segment[segment.length - 1]);\n}\nfunction endsWithMyanmarMedialGlue(segment) {\n    if (segment.length === 0)\n        return false;\n    return myanmarMedialGlue.has(segment[segment.length - 1]);\n}\nfunction splitLeadingSpaceAndMarks(segment) {\n    if (segment.length \u003c 2 || segment[0] !== ' ')\n        return null;\n    const marks = segment.slice(1);\n    if (/^\\p{M}+$/u.test(marks)) {\n        return { space: ' ', marks };\n    }\n    return null;\n}\nexport function endsWithClosingQuote(text) {\n    for (let i = text.length - 1; i \u003e= 0; i--) {\n        const ch = text[i];\n        if (closingQuoteChars.has(ch))\n            return true;\n        if (!leftStickyPunctuation.has(ch))\n            return false;\n    }\n    return false;\n}\nfunction classifySegmentBreakChar(ch, whiteSpaceProfile) {\n    if (whiteSpaceProfile.preserveOrdinarySpaces || whiteSpaceProfile.preserveHardBreaks) {\n        if (ch === ' ')\n            return 'preserved-space';\n        if (ch === '\\t')\n            return 'tab';\n        if (whiteSpaceProfile.preserveHardBreaks \u0026\u0026 ch === '\\n')\n            return 'hard-break';\n    }\n    if (ch === ' ')\n        return 'space';\n    if (ch === '\\u00A0' || ch === '\\u202F' || ch === '\\u2060' || ch === '\\uFEFF') {\n        return 'glue';\n    }\n    if (ch === '\\u200B')\n        return 'zero-width-break';\n    if (ch === '\\u00AD')\n        return 'soft-hyphen';\n    return 'text';\n}\nfunction splitSegmentByBreakKind(segment, isWordLike, start, whiteSpaceProfile) {\n    const pieces = [];\n    let currentKind = null;\n    let currentText = '';\n    let currentStart = start;\n    let currentWordLike = false;\n    let offset = 0;\n    for (const ch of segment) {\n        const kind = classifySegmentBreakChar(ch, whiteSpaceProfile);\n        const wordLike = kind === 'text' \u0026\u0026 isWordLike;\n        if (currentKind !== null \u0026\u0026 kind === currentKind \u0026\u0026 wordLike === currentWordLike) {\n            currentText += ch;\n            offset += ch.length;\n            continue;\n        }\n        if (currentKind !== null) {\n            pieces.push({\n                text: currentText,\n                isWordLike: currentWordLike,\n                kind: currentKind,\n                start: currentStart,\n            });\n        }\n        currentKind = kind;\n        currentText = ch;\n        currentStart = start + offset;\n        currentWordLike = wordLike;\n        offset += ch.length;\n    }\n    if (currentKind !== null) {\n        pieces.push({\n            text: currentText,\n            isWordLike: currentWordLike,\n            kind: currentKind,\n            start: currentStart,\n        });\n    }\n    return pieces;\n}\nfunction isTextRunBoundary(kind) {\n    return (kind === 'space' ||\n        kind === 'preserved-space' ||\n        kind === 'zero-width-break' ||\n        kind === 'hard-break');\n}\nconst urlSchemeSegmentRe = /^[A-Za-z][A-Za-z0-9+.-]*:$/;\nfunction isUrlLikeRunStart(segmentation, index) {\n    const text = segmentation.texts[index];\n    if (text.startsWith('www.'))\n        return true;\n    return (urlSchemeSegmentRe.test(text) \u0026\u0026\n        index + 1 \u003c segmentation.len \u0026\u0026\n        segmentation.kinds[index + 1] === 'text' \u0026\u0026\n        segmentation.texts[index + 1] === '//');\n}\nfunction isUrlQueryBoundarySegment(text) {\n    return text.includes('?') \u0026\u0026 (text.includes('://') || text.startsWith('www.'));\n}\nfunction mergeUrlLikeRuns(segmentation) {\n    const texts = segmentation.texts.slice();\n    const isWordLike = segmentation.isWordLike.slice();\n    const kinds = segmentation.kinds.slice();\n    const starts = segmentation.starts.slice();\n    for (let i = 0; i \u003c segmentation.len; i++) {\n        if (kinds[i] !== 'text' || !isUrlLikeRunStart(segmentation, i))\n            continue;\n        let j = i + 1;\n        while (j \u003c segmentation.len \u0026\u0026 !isTextRunBoundary(kinds[j])) {\n            texts[i] += texts[j];\n            isWordLike[i] = true;\n            const endsQueryPrefix = texts[j].includes('?');\n            kinds[j] = 'text';\n            texts[j] = '';\n            j++;\n            if (endsQueryPrefix)\n                break;\n        }\n    }\n    let compactLen = 0;\n    for (let read = 0; read \u003c texts.length; read++) {\n        const text = texts[read];\n        if (text.length === 0)\n            continue;\n        if (compactLen !== read) {\n            texts[compactLen] = text;\n            isWordLike[compactLen] = isWordLike[read];\n            kinds[compactLen] = kinds[read];\n            starts[compactLen] = starts[read];\n        }\n        compactLen++;\n    }\n    texts.length = compactLen;\n    isWordLike.length = compactLen;\n    kinds.length = compactLen;\n    starts.length = compactLen;\n    return {\n        len: compactLen,\n        texts,\n        isWordLike,\n        kinds,\n        starts,\n    };\n}\nfunction mergeUrlQueryRuns(segmentation) {\n    const texts = [];\n    const isWordLike = [];\n    const kinds = [];\n    const starts = [];\n    for (let i = 0; i \u003c segmentation.len; i++) {\n        const text = segmentation.texts[i];\n        texts.push(text);\n        isWordLike.push(segmentation.isWordLike[i]);\n        kinds.push(segmentation.kinds[i]);\n        starts.push(segmentation.starts[i]);\n        if (!isUrlQueryBoundarySegment(text))\n            continue;\n        const nextIndex = i + 1;\n        if (nextIndex \u003e= segmentation.len ||\n            isTextRunBoundary(segmentation.kinds[nextIndex])) {\n            continue;\n        }\n        let queryText = '';\n        const queryStart = segmentation.starts[nextIndex];\n        let j = nextIndex;\n        while (j \u003c segmentation.len \u0026\u0026 !isTextRunBoundary(segmentation.kinds[j])) {\n            queryText += segmentation.texts[j];\n            j++;\n        }\n        if (queryText.length \u003e 0) {\n            texts.push(queryText);\n            isWordLike.push(true);\n            kinds.push('text');\n            starts.push(queryStart);\n            i = j - 1;\n        }\n    }\n    return {\n        len: texts.length,\n        texts,\n        isWordLike,\n        kinds,\n        starts,\n    };\n}\nconst numericJoinerChars = new Set([\n    ':', '-', '/', '×', ',', '.', '+',\n    '\\u2013',\n    '\\u2014',\n]);\nconst asciiPunctuationChainSegmentRe = /^[A-Za-z0-9_]+[,:;]*$/;\nconst asciiPunctuationChainTrailingJoinersRe = /[,:;]+$/;\nfunction segmentContainsDecimalDigit(text) {\n    for (const ch of text) {\n        if (decimalDigitRe.test(ch))\n            return true;\n    }\n    return false;\n}\nfunction isNumericRunSegment(text) {\n    if (text.length === 0)\n        return false;\n    for (const ch of text) {\n        if (decimalDigitRe.test(ch) || numericJoinerChars.has(ch))\n            continue;\n        return false;\n    }\n    return true;\n}\nfunction mergeNumericRuns(segmentation) {\n    const texts = [];\n    const isWordLike = [];\n    const kinds = [];\n    const starts = [];\n    for (let i = 0; i \u003c segmentation.len; i++) {\n        const text = segmentation.texts[i];\n        const kind = segmentation.kinds[i];\n        if (kind === 'text' \u0026\u0026 isNumericRunSegment(text) \u0026\u0026 segmentContainsDecimalDigit(text)) {\n            let mergedText = text;\n            let j = i + 1;\n            while (j \u003c segmentation.len \u0026\u0026\n                segmentation.kinds[j] === 'text' \u0026\u0026\n                isNumericRunSegment(segmentation.texts[j])) {\n                mergedText += segmentation.texts[j];\n                j++;\n            }\n            texts.push(mergedText);\n            isWordLike.push(true);\n            kinds.push('text');\n            starts.push(segmentation.starts[i]);\n            i = j - 1;\n            continue;\n        }\n        texts.push(text);\n        isWordLike.push(segmentation.isWordLike[i]);\n        kinds.push(kind);\n        starts.push(segmentation.starts[i]);\n    }\n    return {\n        len: texts.length,\n        texts,\n        isWordLike,\n        kinds,\n        starts,\n    };\n}\nfunction mergeAsciiPunctuationChains(segmentation) {\n    const texts = [];\n    const isWordLike = [];\n    const kinds = [];\n    const starts = [];\n    for (let i = 0; i \u003c segmentation.len; i++) {\n        const text = segmentation.texts[i];\n        const kind = segmentation.kinds[i];\n        const wordLike = segmentation.isWordLike[i];\n        if (kind === 'text' \u0026\u0026 wordLike \u0026\u0026 asciiPunctuationChainSegmentRe.test(text)) {\n            let mergedText = text;\n            let j = i + 1;\n            while (asciiPunctuationChainTrailingJoinersRe.test(mergedText) \u0026\u0026\n                j \u003c segmentation.len \u0026\u0026\n                segmentation.kinds[j] === 'text' \u0026\u0026\n                segmentation.isWordLike[j] \u0026\u0026\n                asciiPunctuationChainSegmentRe.test(segmentation.texts[j])) {\n                mergedText += segmentation.texts[j];\n                j++;\n            }\n            texts.push(mergedText);\n            isWordLike.push(true);\n            kinds.push('text');\n            starts.push(segmentation.starts[i]);\n            i = j - 1;\n            continue;\n        }\n        texts.push(text);\n        isWordLike.push(wordLike);\n        kinds.push(kind);\n        starts.push(segmentation.starts[i]);\n    }\n    return {\n        len: texts.length,\n        texts,\n        isWordLike,\n        kinds,\n        starts,\n    };\n}\nfunction splitHyphenatedNumericRuns(segmentation) {\n    const texts = [];\n    const isWordLike = [];\n    const kinds = [];\n    const starts = [];\n    for (let i = 0; i \u003c segmentation.len; i++) {\n        const text = segmentation.texts[i];\n        if (segmentation.kinds[i] === 'text' \u0026\u0026 text.includes('-')) {\n            const parts = text.split('-');\n            let shouldSplit = parts.length \u003e 1;\n            for (let j = 0; j \u003c parts.length; j++) {\n                const part = parts[j];\n                if (!shouldSplit)\n                    break;\n                if (part.length === 0 ||\n                    !segmentContainsDecimalDigit(part) ||\n                    !isNumericRunSegment(part)) {\n                    shouldSplit = false;\n                }\n            }\n            if (shouldSplit) {\n                let offset = 0;\n                for (let j = 0; j \u003c parts.length; j++) {\n                    const part = parts[j];\n                    const splitText = j \u003c parts.length - 1 ? `${part}-` : part;\n                    texts.push(splitText);\n                    isWordLike.push(true);\n                    kinds.push('text');\n                    starts.push(segmentation.starts[i] + offset);\n                    offset += splitText.length;\n                }\n                continue;\n            }\n        }\n        texts.push(text);\n        isWordLike.push(segmentation.isWordLike[i]);\n        kinds.push(segmentation.kinds[i]);\n        starts.push(segmentation.starts[i]);\n    }\n    return {\n        len: texts.length,\n        texts,\n        isWordLike,\n        kinds,\n        starts,\n    };\n}\nfunction mergeGlueConnectedTextRuns(segmentation) {\n    const texts = [];\n    const isWordLike = [];\n    const kinds = [];\n    const starts = [];\n    let read = 0;\n    while (read \u003c segmentation.len) {\n        let text = segmentation.texts[read];\n        let wordLike = segmentation.isWordLike[read];\n        let kind = segmentation.kinds[read];\n        let start = segmentation.starts[read];\n        if (kind === 'glue') {\n            let glueText = text;\n            const glueStart = start;\n            read++;\n            while (read \u003c segmentation.len \u0026\u0026 segmentation.kinds[read] === 'glue') {\n                glueText += segmentation.texts[read];\n                read++;\n            }\n            if (read \u003c segmentation.len \u0026\u0026 segmentation.kinds[read] === 'text') {\n                text = glueText + segmentation.texts[read];\n                wordLike = segmentation.isWordLike[read];\n                kind = 'text';\n                start = glueStart;\n                read++;\n            }\n            else {\n                texts.push(glueText);\n                isWordLike.push(false);\n                kinds.push('glue');\n                starts.push(glueStart);\n                continue;\n            }\n        }\n        else {\n            read++;\n        }\n        if (kind === 'text') {\n            while (read \u003c segmentation.len \u0026\u0026 segmentation.kinds[read] === 'glue') {\n                let glueText = '';\n                while (read \u003c segmentation.len \u0026\u0026 segmentation.kinds[read] === 'glue') {\n                    glueText += segmentation.texts[read];\n                    read++;\n                }\n                if (read \u003c segmentation.len \u0026\u0026 segmentation.kinds[read] === 'text') {\n                    text += glueText + segmentation.texts[read];\n                    wordLike = wordLike || segmentation.isWordLike[read];\n                    read++;\n                    continue;\n                }\n                text += glueText;\n            }\n        }\n        texts.push(text);\n        isWordLike.push(wordLike);\n        kinds.push(kind);\n        starts.push(start);\n    }\n    return {\n        len: texts.length,\n        texts,\n        isWordLike,\n        kinds,\n        starts,\n    };\n}\nfunction carryTrailingForwardStickyAcrossCJKBoundary(segmentation) {\n    const texts = segmentation.texts.slice();\n    const isWordLike = segmentation.isWordLike.slice();\n    const kinds = segmentation.kinds.slice();\n    const starts = segmentation.starts.slice();\n    for (let i = 0; i \u003c texts.length - 1; i++) {\n        if (kinds[i] !== 'text' || kinds[i + 1] !== 'text')\n            continue;\n        if (!isCJK(texts[i]) || !isCJK(texts[i + 1]))\n            continue;\n        const split = splitTrailingForwardStickyCluster(texts[i]);\n        if (split === null)\n            continue;\n        texts[i] = split.head;\n        texts[i + 1] = split.tail + texts[i + 1];\n        starts[i + 1] = starts[i] + split.head.length;\n    }\n    return {\n        len: texts.length,\n        texts,\n        isWordLike,\n        kinds,\n        starts,\n    };\n}\nfunction buildMergedSegmentation(normalized, profile, whiteSpaceProfile) {\n    const wordSegmenter = getSharedWordSegmenter();\n    let mergedLen = 0;\n    const mergedTexts = [];\n    const mergedWordLike = [];\n    const mergedKinds = [];\n    const mergedStarts = [];\n    for (const s of wordSegmenter.segment(normalized)) {\n        for (const piece of splitSegmentByBreakKind(s.segment, s.isWordLike ?? false, s.index, whiteSpaceProfile)) {\n            const isText = piece.kind === 'text';\n            if (profile.carryCJKAfterClosingQuote \u0026\u0026\n                isText \u0026\u0026\n                mergedLen \u003e 0 \u0026\u0026\n                mergedKinds[mergedLen - 1] === 'text' \u0026\u0026\n                isCJK(piece.text) \u0026\u0026\n                isCJK(mergedTexts[mergedLen - 1]) \u0026\u0026\n                endsWithClosingQuote(mergedTexts[mergedLen - 1])) {\n                mergedTexts[mergedLen - 1] += piece.text;\n                mergedWordLike[mergedLen - 1] = mergedWordLike[mergedLen - 1] || piece.isWordLike;\n            }\n            else if (isText \u0026\u0026\n                mergedLen \u003e 0 \u0026\u0026\n                mergedKinds[mergedLen - 1] === 'text' \u0026\u0026\n                isCJKLineStartProhibitedSegment(piece.text) \u0026\u0026\n                isCJK(mergedTexts[mergedLen - 1])) {\n                mergedTexts[mergedLen - 1] += piece.text;\n                mergedWordLike[mergedLen - 1] = mergedWordLike[mergedLen - 1] || piece.isWordLike;\n            }\n            else if (isText \u0026\u0026\n                mergedLen \u003e 0 \u0026\u0026\n                mergedKinds[mergedLen - 1] === 'text' \u0026\u0026\n                endsWithMyanmarMedialGlue(mergedTexts[mergedLen - 1])) {\n                mergedTexts[mergedLen - 1] += piece.text;\n                mergedWordLike[mergedLen - 1] = mergedWordLike[mergedLen - 1] || piece.isWordLike;\n            }\n            else if (isText \u0026\u0026\n                mergedLen \u003e 0 \u0026\u0026\n                mergedKinds[mergedLen - 1] === 'text' \u0026\u0026\n                piece.isWordLike \u0026\u0026\n                containsArabicScript(piece.text) \u0026\u0026\n                endsWithArabicNoSpacePunctuation(mergedTexts[mergedLen - 1])) {\n                mergedTexts[mergedLen - 1] += piece.text;\n                mergedWordLike[mergedLen - 1] = true;\n            }\n            else if (isText \u0026\u0026\n                !piece.isWordLike \u0026\u0026\n                mergedLen \u003e 0 \u0026\u0026\n                mergedKinds[mergedLen - 1] === 'text' \u0026\u0026\n                piece.text.length === 1 \u0026\u0026\n                piece.text !== '-' \u0026\u0026\n                piece.text !== '—' \u0026\u0026\n                isRepeatedSingleCharRun(mergedTexts[mergedLen - 1], piece.text)) {\n                mergedTexts[mergedLen - 1] += piece.text;\n            }\n            else if (isText \u0026\u0026\n                !piece.isWordLike \u0026\u0026\n                mergedLen \u003e 0 \u0026\u0026\n                mergedKinds[mergedLen - 1] === 'text' \u0026\u0026\n                (isLeftStickyPunctuationSegment(piece.text) ||\n                    (piece.text === '-' \u0026\u0026 mergedWordLike[mergedLen - 1]))) {\n                mergedTexts[mergedLen - 1] += piece.text;\n            }\n            else {\n                mergedTexts[mergedLen] = piece.text;\n                mergedWordLike[mergedLen] = piece.isWordLike;\n                mergedKinds[mergedLen] = piece.kind;\n                mergedStarts[mergedLen] = piece.start;\n                mergedLen++;\n            }\n        }\n    }\n    for (let i = 1; i \u003c mergedLen; i++) {\n        if (mergedKinds[i] === 'text' \u0026\u0026\n            !mergedWordLike[i] \u0026\u0026\n            isEscapedQuoteClusterSegment(mergedTexts[i]) \u0026\u0026\n            mergedKinds[i - 1] === 'text') {\n            mergedTexts[i - 1] += mergedTexts[i];\n            mergedWordLike[i - 1] = mergedWordLike[i - 1] || mergedWordLike[i];\n            mergedTexts[i] = '';\n        }\n    }\n    for (let i = mergedLen - 2; i \u003e= 0; i--) {\n        if (mergedKinds[i] === 'text' \u0026\u0026 !mergedWordLike[i] \u0026\u0026 isForwardStickyClusterSegment(mergedTexts[i])) {\n            let j = i + 1;\n            while (j \u003c mergedLen \u0026\u0026 mergedTexts[j] === '')\n                j++;\n            if (j \u003c mergedLen \u0026\u0026 mergedKinds[j] === 'text') {\n                mergedTexts[j] = mergedTexts[i] + mergedTexts[j];\n                mergedStarts[j] = mergedStarts[i];\n                mergedTexts[i] = '';\n            }\n        }\n    }\n    let compactLen = 0;\n    for (let read = 0; read \u003c mergedLen; read++) {\n        const text = mergedTexts[read];\n        if (text.length === 0)\n            continue;\n        if (compactLen !== read) {\n            mergedTexts[compactLen] = text;\n            mergedWordLike[compactLen] = mergedWordLike[read];\n            mergedKinds[compactLen] = mergedKinds[read];\n            mergedStarts[compactLen] = mergedStarts[read];\n        }\n        compactLen++;\n    }\n    mergedTexts.length = compactLen;\n    mergedWordLike.length = compactLen;\n    mergedKinds.length = compactLen;\n    mergedStarts.length = compactLen;\n    const compacted = mergeGlueConnectedTextRuns({\n        len: compactLen,\n        texts: mergedTexts,\n        isWordLike: mergedWordLike,\n        kinds: mergedKinds,\n        starts: mergedStarts,\n    });\n    const withMergedUrls = carryTrailingForwardStickyAcrossCJKBoundary(mergeAsciiPunctuationChains(splitHyphenatedNumericRuns(mergeNumericRuns(mergeUrlQueryRuns(mergeUrlLikeRuns(compacted))))));\n    for (let i = 0; i \u003c withMergedUrls.len - 1; i++) {\n        const split = splitLeadingSpaceAndMarks(withMergedUrls.texts[i]);\n        if (split === null)\n            continue;\n        if ((withMergedUrls.kinds[i] !== 'space' \u0026\u0026 withMergedUrls.kinds[i] !== 'preserved-space') ||\n            withMergedUrls.kinds[i + 1] !== 'text' ||\n            !containsArabicScript(withMergedUrls.texts[i + 1])) {\n            continue;\n        }\n        withMergedUrls.texts[i] = split.space;\n        withMergedUrls.isWordLike[i] = false;\n        withMergedUrls.kinds[i] = withMergedUrls.kinds[i] === 'preserved-space' ? 'preserved-space' : 'space';\n        withMergedUrls.texts[i + 1] = split.marks + withMergedUrls.texts[i + 1];\n        withMergedUrls.starts[i + 1] = withMergedUrls.starts[i] + split.space.length;\n    }\n    return withMergedUrls;\n}\nfunction compileAnalysisChunks(segmentation, whiteSpaceProfile) {\n    if (segmentation.len === 0)\n        return [];\n    if (!whiteSpaceProfile.preserveHardBreaks) {\n        return [{\n                startSegmentIndex: 0,\n                endSegmentIndex: segmentation.len,\n                consumedEndSegmentIndex: segmentation.len,\n            }];\n    }\n    const chunks = [];\n    let startSegmentIndex = 0;\n    for (let i = 0; i \u003c segmentation.len; i++) {\n        if (segmentation.kinds[i] !== 'hard-break')\n            continue;\n        chunks.push({\n            startSegmentIndex,\n            endSegmentIndex: i,\n            consumedEndSegmentIndex: i + 1,\n        });\n        startSegmentIndex = i + 1;\n    }\n    if (startSegmentIndex \u003c segmentation.len) {\n        chunks.push({\n            startSegmentIndex,\n            endSegmentIndex: segmentation.len,\n            consumedEndSegmentIndex: segmentation.len,\n        });\n    }\n    return chunks;\n}\nexport function analyzeText(text, profile, whiteSpace = 'normal') {\n    const whiteSpaceProfile = getWhiteSpaceProfile(whiteSpace);\n    const normalized = whiteSpaceProfile.mode === 'pre-wrap'\n        ? normalizeWhitespacePreWrap(text)\n        : normalizeWhitespaceNormal(text);\n    if (normalized.length === 0) {\n        return {\n            normalized,\n            chunks: [],\n            len: 0,\n            texts: [],\n            isWordLike: [],\n            kinds: [],\n            starts: [],\n        };\n    }\n    const segmentation = buildMergedSegmentation(normalized, profile, whiteSpaceProfile);\n    return {\n        normalized,\n        chunks: compileAnalysisChunks(segmentation, whiteSpaceProfile),\n        ...segmentation,\n    };\n}\n","import { isCJK } from './analysis.js';\nlet measureContext = null;\nconst segmentMetricCaches = new Map();\nlet cachedEngineProfile = null;\nconst emojiPresentationRe = /\\p{Emoji_Presentation}/u;\nconst maybeEmojiRe = /[\\p{Emoji_Presentation}\\p{Extended_Pictographic}\\p{Regional_Indicator}\\uFE0F\\u20E3]/u;\nlet sharedGraphemeSegmenter = null;\nconst emojiCorrectionCache = new Map();\nexport function getMeasureContext() {\n    if (measureContext !== null)\n        return measureContext;\n    if (typeof OffscreenCanvas !== 'undefined') {\n        measureContext = new OffscreenCanvas(1, 1).getContext('2d');\n        return measureContext;\n    }\n    if (typeof document !== 'undefined') {\n        measureContext = document.createElement('canvas').getContext('2d');\n        return measureContext;\n    }\n    throw new Error('Text measurement requires OffscreenCanvas or a DOM canvas context.');\n}\nexport function getSegmentMetricCache(font) {\n    let cache = segmentMetricCaches.get(font);\n    if (!cache) {\n        cache = new Map();\n        segmentMetricCaches.set(font, cache);\n    }\n    return cache;\n}\nexport function getSegmentMetrics(seg, cache) {\n    let metrics = cache.get(seg);\n    if (metrics === undefined) {\n        const ctx = getMeasureContext();\n        metrics = {\n            width: ctx.measureText(seg).width,\n            containsCJK: isCJK(seg),\n        };\n        cache.set(seg, metrics);\n    }\n    return metrics;\n}\nexport function getEngineProfile() {\n    if (cachedEngineProfile !== null)\n        return cachedEngineProfile;\n    if (typeof navigator === 'undefined') {\n        cachedEngineProfile = {\n            lineFitEpsilon: 0.005,\n            carryCJKAfterClosingQuote: false,\n            preferPrefixWidthsForBreakableRuns: false,\n            preferEarlySoftHyphenBreak: false,\n        };\n        return cachedEngineProfile;\n    }\n    const ua = navigator.userAgent;\n    const vendor = navigator.vendor;\n    const isSafari = vendor === 'Apple Computer, Inc.' \u0026\u0026\n        ua.includes('Safari/') \u0026\u0026\n        !ua.includes('Chrome/') \u0026\u0026\n        !ua.includes('Chromium/') \u0026\u0026\n        !ua.includes('CriOS/') \u0026\u0026\n        !ua.includes('FxiOS/') \u0026\u0026\n        !ua.includes('EdgiOS/');\n    const isChromium = ua.includes('Chrome/') ||\n        ua.includes('Chromium/') ||\n        ua.includes('CriOS/') ||\n        ua.includes('Edg/');\n    cachedEngineProfile = {\n        lineFitEpsilon: isSafari ? 1 / 64 : 0.005,\n        carryCJKAfterClosingQuote: isChromium,\n        preferPrefixWidthsForBreakableRuns: isSafari,\n        preferEarlySoftHyphenBreak: isSafari,\n    };\n    return cachedEngineProfile;\n}\nexport function parseFontSize(font) {\n    const m = font.match(/(\\d+(?:\\.\\d+)?)\\s*px/);\n    return m ? parseFloat(m[1]) : 16;\n}\nfunction getSharedGraphemeSegmenter() {\n    if (sharedGraphemeSegmenter === null) {\n        sharedGraphemeSegmenter = new Intl.Segmenter(undefined, { granularity: 'grapheme' });\n    }\n    return sharedGraphemeSegmenter;\n}\nfunction isEmojiGrapheme(g) {\n    return emojiPresentationRe.test(g) || g.includes('\\uFE0F');\n}\nexport function textMayContainEmoji(text) {\n    return maybeEmojiRe.test(text);\n}\nfunction getEmojiCorrection(font, fontSize) {\n    let correction = emojiCorrectionCache.get(font);\n    if (correction !== undefined)\n        return correction;\n    const ctx = getMeasureContext();\n    ctx.font = font;\n    const canvasW = ctx.measureText('\\u{1F600}').width;\n    correction = 0;\n    if (canvasW \u003e fontSize + 0.5 \u0026\u0026\n        typeof document !== 'undefined' \u0026\u0026\n        document.body !== null) {\n        const span = document.createElement('span');\n        span.style.font = font;\n        span.style.display = 'inline-block';\n        span.style.visibility = 'hidden';\n        span.style.position = 'absolute';\n        span.textContent = '\\u{1F600}';\n        document.body.appendChild(span);\n        const domW = span.getBoundingClientRect().width;\n        document.body.removeChild(span);\n        if (canvasW - domW \u003e 0.5) {\n            correction = canvasW - domW;\n        }\n    }\n    emojiCorrectionCache.set(font, correction);\n    return correction;\n}\nfunction countEmojiGraphemes(text) {\n    let count = 0;\n    const graphemeSegmenter = getSharedGraphemeSegmenter();\n    for (const g of graphemeSegmenter.segment(text)) {\n        if (isEmojiGrapheme(g.segment))\n            count++;\n    }\n    return count;\n}\nfunction getEmojiCount(seg, metrics) {\n    if (metrics.emojiCount === undefined) {\n        metrics.emojiCount = countEmojiGraphemes(seg);\n    }\n    return metrics.emojiCount;\n}\nexport function getCorrectedSegmentWidth(seg, metrics, emojiCorrection) {\n    if (emojiCorrection === 0)\n        return metrics.width;\n    return metrics.width - getEmojiCount(seg, metrics) * emojiCorrection;\n}\nexport function getSegmentGraphemeWidths(seg, metrics, cache, emojiCorrection) {\n    if (metrics.graphemeWidths !== undefined)\n        return metrics.graphemeWidths;\n    const widths = [];\n    const graphemeSegmenter = getSharedGraphemeSegmenter();\n    for (const gs of graphemeSegmenter.segment(seg)) {\n        const graphemeMetrics = getSegmentMetrics(gs.segment, cache);\n        widths.push(getCorrectedSegmentWidth(gs.segment, graphemeMetrics, emojiCorrection));\n    }\n    metrics.graphemeWidths = widths.length \u003e 1 ? widths : null;\n    return metrics.graphemeWidths;\n}\nexport function getSegmentGraphemePrefixWidths(seg, metrics, cache, emojiCorrection) {\n    if (metrics.graphemePrefixWidths !== undefined)\n        return metrics.graphemePrefixWidths;\n    const prefixWidths = [];\n    const graphemeSegmenter = getSharedGraphemeSegmenter();\n    let prefix = '';\n    for (const gs of graphemeSegmenter.segment(seg)) {\n        prefix += gs.segment;\n        const prefixMetrics = getSegmentMetrics(prefix, cache);\n        prefixWidths.push(getCorrectedSegmentWidth(prefix, prefixMetrics, emojiCorrection));\n    }\n    metrics.graphemePrefixWidths = prefixWidths.length \u003e 1 ? prefixWidths : null;\n    return metrics.graphemePrefixWidths;\n}\nexport function getFontMeasurementState(font, needsEmojiCorrection) {\n    const ctx = getMeasureContext();\n    ctx.font = font;\n    const cache = getSegmentMetricCache(font);\n    const fontSize = parseFontSize(font);\n    const emojiCorrection = needsEmojiCorrection ? getEmojiCorrection(font, fontSize) : 0;\n    return { cache, fontSize, emojiCorrection };\n}\nexport function clearMeasurementCaches() {\n    segmentMetricCaches.clear();\n    emojiCorrectionCache.clear();\n    sharedGraphemeSegmenter = null;\n}\n","import { getEngineProfile } from './measurement.js';\nfunction canBreakAfter(kind) {\n    return (kind === 'space' ||\n        kind === 'preserved-space' ||\n        kind === 'tab' ||\n        kind === 'zero-width-break' ||\n        kind === 'soft-hyphen');\n}\nfunction isSimpleCollapsibleSpace(kind) {\n    return kind === 'space';\n}\nfunction getTabAdvance(lineWidth, tabStopAdvance) {\n    if (tabStopAdvance \u003c= 0)\n        return 0;\n    const remainder = lineWidth % tabStopAdvance;\n    if (Math.abs(remainder) \u003c= 1e-6)\n        return tabStopAdvance;\n    return tabStopAdvance - remainder;\n}\nfunction getBreakableAdvance(graphemeWidths, graphemePrefixWidths, graphemeIndex, preferPrefixWidths) {\n    if (!preferPrefixWidths || graphemePrefixWidths === null) {\n        return graphemeWidths[graphemeIndex];\n    }\n    return graphemePrefixWidths[graphemeIndex] - (graphemeIndex \u003e 0 ? graphemePrefixWidths[graphemeIndex - 1] : 0);\n}\nfunction fitSoftHyphenBreak(graphemeWidths, initialWidth, maxWidth, lineFitEpsilon, discretionaryHyphenWidth, cumulativeWidths) {\n    let fitCount = 0;\n    let fittedWidth = initialWidth;\n    while (fitCount \u003c graphemeWidths.length) {\n        const nextWidth = cumulativeWidths\n            ? initialWidth + graphemeWidths[fitCount]\n            : fittedWidth + graphemeWidths[fitCount];\n        const nextLineWidth = fitCount + 1 \u003c graphemeWidths.length\n            ? nextWidth + discretionaryHyphenWidth\n            : nextWidth;\n        if (nextLineWidth \u003e maxWidth + lineFitEpsilon)\n            break;\n        fittedWidth = nextWidth;\n        fitCount++;\n    }\n    return { fitCount, fittedWidth };\n}\nfunction findChunkIndexForStart(prepared, segmentIndex) {\n    for (let i = 0; i \u003c prepared.chunks.length; i++) {\n        const chunk = prepared.chunks[i];\n        if (segmentIndex \u003c chunk.consumedEndSegmentIndex)\n            return i;\n    }\n    return -1;\n}\nexport function normalizeLineStart(prepared, start) {\n    let segmentIndex = start.segmentIndex;\n    const graphemeIndex = start.graphemeIndex;\n    if (segmentIndex \u003e= prepared.widths.length)\n        return null;\n    if (graphemeIndex \u003e 0)\n        return start;\n    const chunkIndex = findChunkIndexForStart(prepared, segmentIndex);\n    if (chunkIndex \u003c 0)\n        return null;\n    const chunk = prepared.chunks[chunkIndex];\n    if (chunk.startSegmentIndex === chunk.endSegmentIndex \u0026\u0026 segmentIndex === chunk.startSegmentIndex) {\n        return { segmentIndex, graphemeIndex: 0 };\n    }\n    if (segmentIndex \u003c chunk.startSegmentIndex)\n        segmentIndex = chunk.startSegmentIndex;\n    while (segmentIndex \u003c chunk.endSegmentIndex) {\n        const kind = prepared.kinds[segmentIndex];\n        if (kind !== 'space' \u0026\u0026 kind !== 'zero-width-break' \u0026\u0026 kind !== 'soft-hyphen') {\n            return { segmentIndex, graphemeIndex: 0 };\n        }\n        segmentIndex++;\n    }\n    if (chunk.consumedEndSegmentIndex \u003e= prepared.widths.length)\n        return null;\n    return { segmentIndex: chunk.consumedEndSegmentIndex, graphemeIndex: 0 };\n}\nexport function countPreparedLines(prepared, maxWidth) {\n    if (prepared.simpleLineWalkFastPath) {\n        return countPreparedLinesSimple(prepared, maxWidth);\n    }\n    return walkPreparedLines(prepared, maxWidth);\n}\nfunction countPreparedLinesSimple(prepared, maxWidth) {\n    const { widths, kinds, breakableWidths, breakablePrefixWidths } = prepared;\n    if (widths.length === 0)\n        return 0;\n    const engineProfile = getEngineProfile();\n    const lineFitEpsilon = engineProfile.lineFitEpsilon;\n    let lineCount = 0;\n    let lineW = 0;\n    let hasContent = false;\n    function placeOnFreshLine(segmentIndex) {\n        const w = widths[segmentIndex];\n        if (w \u003e maxWidth \u0026\u0026 breakableWidths[segmentIndex] !== null) {\n            const gWidths = breakableWidths[segmentIndex];\n            const gPrefixWidths = breakablePrefixWidths[segmentIndex] ?? null;\n            lineW = 0;\n            for (let g = 0; g \u003c gWidths.length; g++) {\n                const gw = getBreakableAdvance(gWidths, gPrefixWidths, g, engineProfile.preferPrefixWidthsForBreakableRuns);\n                if (lineW \u003e 0 \u0026\u0026 lineW + gw \u003e maxWidth + lineFitEpsilon) {\n                    lineCount++;\n                    lineW = gw;\n                }\n                else {\n                    if (lineW === 0)\n                        lineCount++;\n                    lineW += gw;\n                }\n            }\n        }\n        else {\n            lineW = w;\n            lineCount++;\n        }\n        hasContent = true;\n    }\n    for (let i = 0; i \u003c widths.length; i++) {\n        const w = widths[i];\n        const kind = kinds[i];\n        if (!hasContent) {\n            placeOnFreshLine(i);\n            continue;\n        }\n        const newW = lineW + w;\n        if (newW \u003e maxWidth + lineFitEpsilon) {\n            if (isSimpleCollapsibleSpace(kind))\n                continue;\n            lineW = 0;\n            hasContent = false;\n            placeOnFreshLine(i);\n            continue;\n        }\n        lineW = newW;\n    }\n    if (!hasContent)\n        return lineCount + 1;\n    return lineCount;\n}\nfunction walkPreparedLinesSimple(prepared, maxWidth, onLine) {\n    const { widths, kinds, breakableWidths, breakablePrefixWidths } = prepared;\n    if (widths.length === 0)\n        return 0;\n    const engineProfile = getEngineProfile();\n    const lineFitEpsilon = engineProfile.lineFitEpsilon;\n    let lineCount = 0;\n    let lineW = 0;\n    let hasContent = false;\n    let lineStartSegmentIndex = 0;\n    let lineStartGraphemeIndex = 0;\n    let lineEndSegmentIndex = 0;\n    let lineEndGraphemeIndex = 0;\n    let pendingBreakSegmentIndex = -1;\n    let pendingBreakPaintWidth = 0;\n    function clearPendingBreak() {\n        pendingBreakSegmentIndex = -1;\n        pendingBreakPaintWidth = 0;\n    }\n    function emitCurrentLine(endSegmentIndex = lineEndSegmentIndex, endGraphemeIndex = lineEndGraphemeIndex, width = lineW) {\n        lineCount++;\n        onLine?.({\n            startSegmentIndex: lineStartSegmentIndex,\n            startGraphemeIndex: lineStartGraphemeIndex,\n            endSegmentIndex,\n            endGraphemeIndex,\n            width,\n        });\n        lineW = 0;\n        hasContent = false;\n        clearPendingBreak();\n    }\n    function startLineAtSegment(segmentIndex, width) {\n        hasContent = true;\n        lineStartSegmentIndex = segmentIndex;\n        lineStartGraphemeIndex = 0;\n        lineEndSegmentIndex = segmentIndex + 1;\n        lineEndGraphemeIndex = 0;\n        lineW = width;\n    }\n    function startLineAtGrapheme(segmentIndex, graphemeIndex, width) {\n        hasContent = true;\n        lineStartSegmentIndex = segmentIndex;\n        lineStartGraphemeIndex = graphemeIndex;\n        lineEndSegmentIndex = segmentIndex;\n        lineEndGraphemeIndex = graphemeIndex + 1;\n        lineW = width;\n    }\n    function appendWholeSegment(segmentIndex, width) {\n        if (!hasContent) {\n            startLineAtSegment(segmentIndex, width);\n            return;\n        }\n        lineW += width;\n        lineEndSegmentIndex = segmentIndex + 1;\n        lineEndGraphemeIndex = 0;\n    }\n    function updatePendingBreak(segmentIndex, segmentWidth) {\n        if (!canBreakAfter(kinds[segmentIndex]))\n            return;\n        pendingBreakSegmentIndex = segmentIndex + 1;\n        pendingBreakPaintWidth = lineW - segmentWidth;\n    }\n    function appendBreakableSegment(segmentIndex) {\n        appendBreakableSegmentFrom(segmentIndex, 0);\n    }\n    function appendBreakableSegmentFrom(segmentIndex, startGraphemeIndex) {\n        const gWidths = breakableWidths[segmentIndex];\n        const gPrefixWidths = breakablePrefixWidths[segmentIndex] ?? null;\n        for (let g = startGraphemeIndex; g \u003c gWidths.length; g++) {\n            const gw = getBreakableAdvance(gWidths, gPrefixWidths, g, engineProfile.preferPrefixWidthsForBreakableRuns);\n            if (!hasContent) {\n                startLineAtGrapheme(segmentIndex, g, gw);\n                continue;\n            }\n            if (lineW + gw \u003e maxWidth + lineFitEpsilon) {\n                emitCurrentLine();\n                startLineAtGrapheme(segmentIndex, g, gw);\n            }\n            else {\n                lineW += gw;\n                lineEndSegmentIndex = segmentIndex;\n                lineEndGraphemeIndex = g + 1;\n            }\n        }\n        if (hasContent \u0026\u0026 lineEndSegmentIndex === segmentIndex \u0026\u0026 lineEndGraphemeIndex === gWidths.length) {\n            lineEndSegmentIndex = segmentIndex + 1;\n            lineEndGraphemeIndex = 0;\n        }\n    }\n    let i = 0;\n    while (i \u003c widths.length) {\n        const w = widths[i];\n        const kind = kinds[i];\n        if (!hasContent) {\n            if (w \u003e maxWidth \u0026\u0026 breakableWidths[i] !== null) {\n                appendBreakableSegment(i);\n            }\n            else {\n                startLineAtSegment(i, w);\n            }\n            updatePendingBreak(i, w);\n            i++;\n            continue;\n        }\n        const newW = lineW + w;\n        if (newW \u003e maxWidth + lineFitEpsilon) {\n            if (canBreakAfter(kind)) {\n                appendWholeSegment(i, w);\n                emitCurrentLine(i + 1, 0, lineW - w);\n                i++;\n                continue;\n            }\n            if (pendingBreakSegmentIndex \u003e= 0) {\n                emitCurrentLine(pendingBreakSegmentIndex, 0, pendingBreakPaintWidth);\n                continue;\n            }\n            if (w \u003e maxWidth \u0026\u0026 breakableWidths[i] !== null) {\n                emitCurrentLine();\n                appendBreakableSegment(i);\n                i++;\n                continue;\n            }\n            emitCurrentLine();\n            continue;\n        }\n        appendWholeSegment(i, w);\n        updatePendingBreak(i, w);\n        i++;\n    }\n    if (hasContent)\n        emitCurrentLine();\n    return lineCount;\n}\nexport function walkPreparedLines(prepared, maxWidth, onLine) {\n    if (prepared.simpleLineWalkFastPath) {\n        return walkPreparedLinesSimple(prepared, maxWidth, onLine);\n    }\n    const { widths, lineEndFitAdvances, lineEndPaintAdvances, kinds, breakableWidths, breakablePrefixWidths, discretionaryHyphenWidth, tabStopAdvance, chunks, } = prepared;\n    if (widths.length === 0 || chunks.length === 0)\n        return 0;\n    const engineProfile = getEngineProfile();\n    const lineFitEpsilon = engineProfile.lineFitEpsilon;\n    let lineCount = 0;\n    let lineW = 0;\n    let hasContent = false;\n    let lineStartSegmentIndex = 0;\n    let lineStartGraphemeIndex = 0;\n    let lineEndSegmentIndex = 0;\n    let lineEndGraphemeIndex = 0;\n    let pendingBreakSegmentIndex = -1;\n    let pendingBreakFitWidth = 0;\n    let pendingBreakPaintWidth = 0;\n    let pendingBreakKind = null;\n    function clearPendingBreak() {\n        pendingBreakSegmentIndex = -1;\n        pendingBreakFitWidth = 0;\n        pendingBreakPaintWidth = 0;\n        pendingBreakKind = null;\n    }\n    function emitCurrentLine(endSegmentIndex = lineEndSegmentIndex, endGraphemeIndex = lineEndGraphemeIndex, width = lineW) {\n        lineCount++;\n        onLine?.({\n            startSegmentIndex: lineStartSegmentIndex,\n            startGraphemeIndex: lineStartGraphemeIndex,\n            endSegmentIndex,\n            endGraphemeIndex,\n            width,\n        });\n        lineW = 0;\n        hasContent = false;\n        clearPendingBreak();\n    }\n    function startLineAtSegment(segmentIndex, width) {\n        hasContent = true;\n        lineStartSegmentIndex = segmentIndex;\n        lineStartGraphemeIndex = 0;\n        lineEndSegmentIndex = segmentIndex + 1;\n        lineEndGraphemeIndex = 0;\n        lineW = width;\n    }\n    function startLineAtGrapheme(segmentIndex, graphemeIndex, width) {\n        hasContent = true;\n        lineStartSegmentIndex = segmentIndex;\n        lineStartGraphemeIndex = graphemeIndex;\n        lineEndSegmentIndex = segmentIndex;\n        lineEndGraphemeIndex = graphemeIndex + 1;\n        lineW = width;\n    }\n    function appendWholeSegment(segmentIndex, width) {\n        if (!hasContent) {\n            startLineAtSegment(segmentIndex, width);\n            return;\n        }\n        lineW += width;\n        lineEndSegmentIndex = segmentIndex + 1;\n        lineEndGraphemeIndex = 0;\n    }\n    function updatePendingBreakForWholeSegment(segmentIndex, segmentWidth) {\n        if (!canBreakAfter(kinds[segmentIndex]))\n            return;\n        const fitAdvance = kinds[segmentIndex] === 'tab' ? 0 : lineEndFitAdvances[segmentIndex];\n        const paintAdvance = kinds[segmentIndex] === 'tab' ? segmentWidth : lineEndPaintAdvances[segmentIndex];\n        pendingBreakSegmentIndex = segmentIndex + 1;\n        pendingBreakFitWidth = lineW - segmentWidth + fitAdvance;\n        pendingBreakPaintWidth = lineW - segmentWidth + paintAdvance;\n        pendingBreakKind = kinds[segmentIndex];\n    }\n    function appendBreakableSegment(segmentIndex) {\n        appendBreakableSegmentFrom(segmentIndex, 0);\n    }\n    function appendBreakableSegmentFrom(segmentIndex, startGraphemeIndex) {\n        const gWidths = breakableWidths[segmentIndex];\n        const gPrefixWidths = breakablePrefixWidths[segmentIndex] ?? null;\n        for (let g = startGraphemeIndex; g \u003c gWidths.length; g++) {\n            const gw = getBreakableAdvance(gWidths, gPrefixWidths, g, engineProfile.preferPrefixWidthsForBreakableRuns);\n            if (!hasContent) {\n                startLineAtGrapheme(segmentIndex, g, gw);\n                continue;\n            }\n            if (lineW + gw \u003e maxWidth + lineFitEpsilon) {\n                emitCurrentLine();\n                startLineAtGrapheme(segmentIndex, g, gw);\n            }\n            else {\n                lineW += gw;\n                lineEndSegmentIndex = segmentIndex;\n                lineEndGraphemeIndex = g + 1;\n            }\n        }\n        if (hasContent \u0026\u0026 lineEndSegmentIndex === segmentIndex \u0026\u0026 lineEndGraphemeIndex === gWidths.length) {\n            lineEndSegmentIndex = segmentIndex + 1;\n            lineEndGraphemeIndex = 0;\n        }\n    }\n    function continueSoftHyphenBreakableSegment(segmentIndex) {\n        if (pendingBreakKind !== 'soft-hyphen')\n            return false;\n        const gWidths = breakableWidths[segmentIndex];\n        if (gWidths === null)\n            return false;\n        const fitWidths = engineProfile.preferPrefixWidthsForBreakableRuns\n            ? breakablePrefixWidths[segmentIndex] ?? gWidths\n            : gWidths;\n        const usesPrefixWidths = fitWidths !== gWidths;\n        const { fitCount, fittedWidth } = fitSoftHyphenBreak(fitWidths, lineW, maxWidth, lineFitEpsilon, discretionaryHyphenWidth, usesPrefixWidths);\n        if (fitCount === 0)\n            return false;\n        lineW = fittedWidth;\n        lineEndSegmentIndex = segmentIndex;\n        lineEndGraphemeIndex = fitCount;\n        clearPendingBreak();\n        if (fitCount === gWidths.length) {\n            lineEndSegmentIndex = segmentIndex + 1;\n            lineEndGraphemeIndex = 0;\n            return true;\n        }\n        emitCurrentLine(segmentIndex, fitCount, fittedWidth + discretionaryHyphenWidth);\n        appendBreakableSegmentFrom(segmentIndex, fitCount);\n        return true;\n    }\n    function emitEmptyChunk(chunk) {\n        lineCount++;\n        onLine?.({\n            startSegmentIndex: chunk.startSegmentIndex,\n            startGraphemeIndex: 0,\n            endSegmentIndex: chunk.consumedEndSegmentIndex,\n            endGraphemeIndex: 0,\n            width: 0,\n        });\n        clearPendingBreak();\n    }\n    for (let chunkIndex = 0; chunkIndex \u003c chunks.length; chunkIndex++) {\n        const chunk = chunks[chunkIndex];\n        if (chunk.startSegmentIndex === chunk.endSegmentIndex) {\n            emitEmptyChunk(chunk);\n            continue;\n        }\n        hasContent = false;\n        lineW = 0;\n        lineStartSegmentIndex = chunk.startSegmentIndex;\n        lineStartGraphemeIndex = 0;\n        lineEndSegmentIndex = chunk.startSegmentIndex;\n        lineEndGraphemeIndex = 0;\n        clearPendingBreak();\n        let i = chunk.startSegmentIndex;\n        while (i \u003c chunk.endSegmentIndex) {\n            const kind = kinds[i];\n            const w = kind === 'tab' ? getTabAdvance(lineW, tabStopAdvance) : widths[i];\n            if (kind === 'soft-hyphen') {\n                if (hasContent) {\n                    lineEndSegmentIndex = i + 1;\n                    lineEndGraphemeIndex = 0;\n                    pendingBreakSegmentIndex = i + 1;\n                    pendingBreakFitWidth = lineW + discretionaryHyphenWidth;\n                    pendingBreakPaintWidth = lineW + discretionaryHyphenWidth;\n                    pendingBreakKind = kind;\n                }\n                i++;\n                continue;\n            }\n            if (!hasContent) {\n                if (w \u003e maxWidth \u0026\u0026 breakableWidths[i] !== null) {\n                    appendBreakableSegment(i);\n                }\n                else {\n                    startLineAtSegment(i, w);\n                }\n                updatePendingBreakForWholeSegment(i, w);\n                i++;\n                continue;\n            }\n            const newW = lineW + w;\n            if (newW \u003e maxWidth + lineFitEpsilon) {\n                const currentBreakFitWidth = lineW + (kind === 'tab' ? 0 : lineEndFitAdvances[i]);\n                const currentBreakPaintWidth = lineW + (kind === 'tab' ? w : lineEndPaintAdvances[i]);\n                if (pendingBreakKind === 'soft-hyphen' \u0026\u0026\n                    engineProfile.preferEarlySoftHyphenBreak \u0026\u0026\n                    pendingBreakFitWidth \u003c= maxWidth + lineFitEpsilon) {\n                    emitCurrentLine(pendingBreakSegmentIndex, 0, pendingBreakPaintWidth);\n                    continue;\n                }\n                if (pendingBreakKind === 'soft-hyphen' \u0026\u0026 continueSoftHyphenBreakableSegment(i)) {\n                    i++;\n                    continue;\n                }\n                if (canBreakAfter(kind) \u0026\u0026 currentBreakFitWidth \u003c= maxWidth + lineFitEpsilon) {\n                    appendWholeSegment(i, w);\n                    emitCurrentLine(i + 1, 0, currentBreakPaintWidth);\n                    i++;\n                    continue;\n                }\n                if (pendingBreakSegmentIndex \u003e= 0 \u0026\u0026 pendingBreakFitWidth \u003c= maxWidth + lineFitEpsilon) {\n                    emitCurrentLine(pendingBreakSegmentIndex, 0, pendingBreakPaintWidth);\n                    continue;\n                }\n                if (w \u003e maxWidth \u0026\u0026 breakableWidths[i] !== null) {\n                    emitCurrentLine();\n                    appendBreakableSegment(i);\n                    i++;\n                    continue;\n                }\n                emitCurrentLine();\n                continue;\n            }\n            appendWholeSegment(i, w);\n            updatePendingBreakForWholeSegment(i, w);\n            i++;\n        }\n        if (hasContent) {\n            const finalPaintWidth = pendingBreakSegmentIndex === chunk.consumedEndSegmentIndex\n                ? pendingBreakPaintWidth\n                : lineW;\n            emitCurrentLine(chunk.consumedEndSegmentIndex, 0, finalPaintWidth);\n        }\n    }\n    return lineCount;\n}\nexport function layoutNextLineRange(prepared, start, maxWidth) {\n    const normalizedStart = normalizeLineStart(prepared, start);\n    if (normalizedStart === null)\n        return null;\n    if (prepared.simpleLineWalkFastPath) {\n        return layoutNextLineRangeSimple(prepared, normalizedStart, maxWidth);\n    }\n    const chunkIndex = findChunkIndexForStart(prepared, normalizedStart.segmentIndex);\n    if (chunkIndex \u003c 0)\n        return null;\n    const chunk = prepared.chunks[chunkIndex];\n    if (chunk.startSegmentIndex === chunk.endSegmentIndex) {\n        return {\n            startSegmentIndex: chunk.startSegmentIndex,\n            startGraphemeIndex: 0,\n            endSegmentIndex: chunk.consumedEndSegmentIndex,\n            endGraphemeIndex: 0,\n            width: 0,\n        };\n    }\n    const { widths, lineEndFitAdvances, lineEndPaintAdvances, kinds, breakableWidths, breakablePrefixWidths, discretionaryHyphenWidth, tabStopAdvance, } = prepared;\n    const engineProfile = getEngineProfile();\n    const lineFitEpsilon = engineProfile.lineFitEpsilon;\n    let lineW = 0;\n    let hasContent = false;\n    const lineStartSegmentIndex = normalizedStart.segmentIndex;\n    const lineStartGraphemeIndex = normalizedStart.graphemeIndex;\n    let lineEndSegmentIndex = lineStartSegmentIndex;\n    let lineEndGraphemeIndex = lineStartGraphemeIndex;\n    let pendingBreakSegmentIndex = -1;\n    let pendingBreakFitWidth = 0;\n    let pendingBreakPaintWidth = 0;\n    let pendingBreakKind = null;\n    function clearPendingBreak() {\n        pendingBreakSegmentIndex = -1;\n        pendingBreakFitWidth = 0;\n        pendingBreakPaintWidth = 0;\n        pendingBreakKind = null;\n    }\n    function finishLine(endSegmentIndex = lineEndSegmentIndex, endGraphemeIndex = lineEndGraphemeIndex, width = lineW) {\n        if (!hasContent)\n            return null;\n        return {\n            startSegmentIndex: lineStartSegmentIndex,\n            startGraphemeIndex: lineStartGraphemeIndex,\n            endSegmentIndex,\n            endGraphemeIndex,\n            width,\n        };\n    }\n    function startLineAtSegment(segmentIndex, width) {\n        hasContent = true;\n        lineEndSegmentIndex = segmentIndex + 1;\n        lineEndGraphemeIndex = 0;\n        lineW = width;\n    }\n    function startLineAtGrapheme(segmentIndex, graphemeIndex, width) {\n        hasContent = true;\n        lineEndSegmentIndex = segmentIndex;\n        lineEndGraphemeIndex = graphemeIndex + 1;\n        lineW = width;\n    }\n    function appendWholeSegment(segmentIndex, width) {\n        if (!hasContent) {\n            startLineAtSegment(segmentIndex, width);\n            return;\n        }\n        lineW += width;\n        lineEndSegmentIndex = segmentIndex + 1;\n        lineEndGraphemeIndex = 0;\n    }\n    function updatePendingBreakForWholeSegment(segmentIndex, segmentWidth) {\n        if (!canBreakAfter(kinds[segmentIndex]))\n            return;\n        const fitAdvance = kinds[segmentIndex] === 'tab' ? 0 : lineEndFitAdvances[segmentIndex];\n        const paintAdvance = kinds[segmentIndex] === 'tab' ? segmentWidth : lineEndPaintAdvances[segmentIndex];\n        pendingBreakSegmentIndex = segmentIndex + 1;\n        pendingBreakFitWidth = lineW - segmentWidth + fitAdvance;\n        pendingBreakPaintWidth = lineW - segmentWidth + paintAdvance;\n        pendingBreakKind = kinds[segmentIndex];\n    }\n    function appendBreakableSegmentFrom(segmentIndex, startGraphemeIndex) {\n        const gWidths = breakableWidths[segmentIndex];\n        const gPrefixWidths = breakablePrefixWidths[segmentIndex] ?? null;\n        for (let g = startGraphemeIndex; g \u003c gWidths.length; g++) {\n            const gw = getBreakableAdvance(gWidths, gPrefixWidths, g, engineProfile.preferPrefixWidthsForBreakableRuns);\n            if (!hasContent) {\n                startLineAtGrapheme(segmentIndex, g, gw);\n                continue;\n            }\n            if (lineW + gw \u003e maxWidth + lineFitEpsilon) {\n                return finishLine();\n            }\n            lineW += gw;\n            lineEndSegmentIndex = segmentIndex;\n            lineEndGraphemeIndex = g + 1;\n        }\n        if (hasContent \u0026\u0026 lineEndSegmentIndex === segmentIndex \u0026\u0026 lineEndGraphemeIndex === gWidths.length) {\n            lineEndSegmentIndex = segmentIndex + 1;\n            lineEndGraphemeIndex = 0;\n        }\n        return null;\n    }\n    function maybeFinishAtSoftHyphen(segmentIndex) {\n        if (pendingBreakKind !== 'soft-hyphen' || pendingBreakSegmentIndex \u003c 0)\n            return null;\n        const gWidths = breakableWidths[segmentIndex] ?? null;\n        if (gWidths !== null) {\n            const fitWidths = engineProfile.preferPrefixWidthsForBreakableRuns\n                ? breakablePrefixWidths[segmentIndex] ?? gWidths\n                : gWidths;\n            const usesPrefixWidths = fitWidths !== gWidths;\n            const { fitCount, fittedWidth } = fitSoftHyphenBreak(fitWidths, lineW, maxWidth, lineFitEpsilon, discretionaryHyphenWidth, usesPrefixWidths);\n            if (fitCount === gWidths.length) {\n                lineW = fittedWidth;\n                lineEndSegmentIndex = segmentIndex + 1;\n                lineEndGraphemeIndex = 0;\n                clearPendingBreak();\n                return null;\n            }\n            if (fitCount \u003e 0) {\n                return finishLine(segmentIndex, fitCount, fittedWidth + discretionaryHyphenWidth);\n            }\n        }\n        if (pendingBreakFitWidth \u003c= maxWidth + lineFitEpsilon) {\n            return finishLine(pendingBreakSegmentIndex, 0, pendingBreakPaintWidth);\n        }\n        return null;\n    }\n    for (let i = normalizedStart.segmentIndex; i \u003c chunk.endSegmentIndex; i++) {\n        const kind = kinds[i];\n        const startGraphemeIndex = i === normalizedStart.segmentIndex ? normalizedStart.graphemeIndex : 0;\n        const w = kind === 'tab' ? getTabAdvance(lineW, tabStopAdvance) : widths[i];\n        if (kind === 'soft-hyphen' \u0026\u0026 startGraphemeIndex === 0) {\n            if (hasContent) {\n                lineEndSegmentIndex = i + 1;\n                lineEndGraphemeIndex = 0;\n                pendingBreakSegmentIndex = i + 1;\n                pendingBreakFitWidth = lineW + discretionaryHyphenWidth;\n                pendingBreakPaintWidth = lineW + discretionaryHyphenWidth;\n                pendingBreakKind = kind;\n            }\n            continue;\n        }\n        if (!hasContent) {\n            if (startGraphemeIndex \u003e 0) {\n                const line = appendBreakableSegmentFrom(i, startGraphemeIndex);\n                if (line !== null)\n                    return line;\n            }\n            else if (w \u003e maxWidth \u0026\u0026 breakableWidths[i] !== null) {\n                const line = appendBreakableSegmentFrom(i, 0);\n                if (line !== null)\n                    return line;\n            }\n            else {\n                startLineAtSegment(i, w);\n            }\n            updatePendingBreakForWholeSegment(i, w);\n            continue;\n        }\n        const newW = lineW + w;\n        if (newW \u003e maxWidth + lineFitEpsilon) {\n            const currentBreakFitWidth = lineW + (kind === 'tab' ? 0 : lineEndFitAdvances[i]);\n            const currentBreakPaintWidth = lineW + (kind === 'tab' ? w : lineEndPaintAdvances[i]);\n            if (pendingBreakKind === 'soft-hyphen' \u0026\u0026\n                engineProfile.preferEarlySoftHyphenBreak \u0026\u0026\n                pendingBreakFitWidth \u003c= maxWidth + lineFitEpsilon) {\n                return finishLine(pendingBreakSegmentIndex, 0, pendingBreakPaintWidth);\n            }\n            const softBreakLine = maybeFinishAtSoftHyphen(i);\n            if (softBreakLine !== null)\n                return softBreakLine;\n            if (canBreakAfter(kind) \u0026\u0026 currentBreakFitWidth \u003c= maxWidth + lineFitEpsilon) {\n                appendWholeSegment(i, w);\n                return finishLine(i + 1, 0, currentBreakPaintWidth);\n            }\n            if (pendingBreakSegmentIndex \u003e= 0 \u0026\u0026 pendingBreakFitWidth \u003c= maxWidth + lineFitEpsilon) {\n                return finishLine(pendingBreakSegmentIndex, 0, pendingBreakPaintWidth);\n            }\n            if (w \u003e maxWidth \u0026\u0026 breakableWidths[i] !== null) {\n                const currentLine = finishLine();\n                if (currentLine !== null)\n                    return currentLine;\n                const line = appendBreakableSegmentFrom(i, 0);\n                if (line !== null)\n                    return line;\n            }\n            return finishLine();\n        }\n        appendWholeSegment(i, w);\n        updatePendingBreakForWholeSegment(i, w);\n    }\n    if (pendingBreakSegmentIndex === chunk.consumedEndSegmentIndex \u0026\u0026 lineEndGraphemeIndex === 0) {\n        return finishLine(chunk.consumedEndSegmentIndex, 0, pendingBreakPaintWidth);\n    }\n    return finishLine(chunk.consumedEndSegmentIndex, 0, lineW);\n}\nfunction layoutNextLineRangeSimple(prepared, normalizedStart, maxWidth) {\n    const { widths, kinds, breakableWidths, breakablePrefixWidths } = prepared;\n    const engineProfile = getEngineProfile();\n    const lineFitEpsilon = engineProfile.lineFitEpsilon;\n    let lineW = 0;\n    let hasContent = false;\n    const lineStartSegmentIndex = normalizedStart.segmentIndex;\n    const lineStartGraphemeIndex = normalizedStart.graphemeIndex;\n    let lineEndSegmentIndex = lineStartSegmentIndex;\n    let lineEndGraphemeIndex = lineStartGraphemeIndex;\n    let pendingBreakSegmentIndex = -1;\n    let pendingBreakPaintWidth = 0;\n    function finishLine(endSegmentIndex = lineEndSegmentIndex, endGraphemeIndex = lineEndGraphemeIndex, width = lineW) {\n        if (!hasContent)\n            return null;\n        return {\n            startSegmentIndex: lineStartSegmentIndex,\n            startGraphemeIndex: lineStartGraphemeIndex,\n            endSegmentIndex,\n            endGraphemeIndex,\n            width,\n        };\n    }\n    function startLineAtSegment(segmentIndex, width) {\n        hasContent = true;\n        lineEndSegmentIndex = segmentIndex + 1;\n        lineEndGraphemeIndex = 0;\n        lineW = width;\n    }\n    function startLineAtGrapheme(segmentIndex, graphemeIndex, width) {\n        hasContent = true;\n        lineEndSegmentIndex = segmentIndex;\n        lineEndGraphemeIndex = graphemeIndex + 1;\n        lineW = width;\n    }\n    function appendWholeSegment(segmentIndex, width) {\n        if (!hasContent) {\n            startLineAtSegment(segmentIndex, width);\n            return;\n        }\n        lineW += width;\n        lineEndSegmentIndex = segmentIndex + 1;\n        lineEndGraphemeIndex = 0;\n    }\n    function updatePendingBreak(segmentIndex, segmentWidth) {\n        if (!canBreakAfter(kinds[segmentIndex]))\n            return;\n        pendingBreakSegmentIndex = segmentIndex + 1;\n        pendingBreakPaintWidth = lineW - segmentWidth;\n    }\n    function appendBreakableSegmentFrom(segmentIndex, startGraphemeIndex) {\n        const gWidths = breakableWidths[segmentIndex];\n        const gPrefixWidths = breakablePrefixWidths[segmentIndex] ?? null;\n        for (let g = startGraphemeIndex; g \u003c gWidths.length; g++) {\n            const gw = getBreakableAdvance(gWidths, gPrefixWidths, g, engineProfile.preferPrefixWidthsForBreakableRuns);\n            if (!hasContent) {\n                startLineAtGrapheme(segmentIndex, g, gw);\n                continue;\n            }\n            if (lineW + gw \u003e maxWidth + lineFitEpsilon) {\n                return finishLine();\n            }\n            lineW += gw;\n            lineEndSegmentIndex = segmentIndex;\n            lineEndGraphemeIndex = g + 1;\n        }\n        if (hasContent \u0026\u0026 lineEndSegmentIndex === segmentIndex \u0026\u0026 lineEndGraphemeIndex === gWidths.length) {\n            lineEndSegmentIndex = segmentIndex + 1;\n            lineEndGraphemeIndex = 0;\n        }\n        return null;\n    }\n    for (let i = normalizedStart.segmentIndex; i \u003c widths.length; i++) {\n        const w = widths[i];\n        const kind = kinds[i];\n        const startGraphemeIndex = i === normalizedStart.segmentIndex ? normalizedStart.graphemeIndex : 0;\n        if (!hasContent) {\n            if (startGraphemeIndex \u003e 0) {\n                const line = appendBreakableSegmentFrom(i, startGraphemeIndex);\n                if (line !== null)\n                    return line;\n            }\n            else if (w \u003e maxWidth \u0026\u0026 breakableWidths[i] !== null) {\n                const line = appendBreakableSegmentFrom(i, 0);\n                if (line !== null)\n                    return line;\n            }\n            else {\n                startLineAtSegment(i, w);\n            }\n            updatePendingBreak(i, w);\n            continue;\n        }\n        const newW = lineW + w;\n        if (newW \u003e maxWidth + lineFitEpsilon) {\n            if (canBreakAfter(kind)) {\n                appendWholeSegment(i, w);\n                return finishLine(i + 1, 0, lineW - w);\n            }\n            if (pendingBreakSegmentIndex \u003e= 0) {\n                return finishLine(pendingBreakSegmentIndex, 0, pendingBreakPaintWidth);\n            }\n            if (w \u003e maxWidth \u0026\u0026 breakableWidths[i] !== null) {\n                const currentLine = finishLine();\n                if (currentLine !== null)\n                    return currentLine;\n                const line = appendBreakableSegmentFrom(i, 0);\n                if (line !== null)\n                    return line;\n            }\n            return finishLine();\n        }\n        appendWholeSegment(i, w);\n        updatePendingBreak(i, w);\n    }\n    return finishLine();\n}\n","// Text measurement for browser environments using canvas measureText.\n//\n// Problem: DOM-based text measurement (getBoundingClientRect, offsetHeight)\n// forces synchronous layout reflow. When components independently measure text,\n// each measurement triggers a reflow of the entire document. This creates\n// read/write interleaving that can cost 30ms+ per frame for 500 text blocks.\n//\n// Solution: two-phase measurement centered around canvas measureText.\n//   prepare(text, font) — segments text via Intl.Segmenter, measures each word\n//     via canvas, caches widths, and does one cached DOM calibration read per\n//     font when emoji correction is needed. Call once when text first appears.\n//   layout(prepared, maxWidth, lineHeight) — walks cached word widths with pure\n//     arithmetic to count lines and compute height. Call on every resize.\n//     ~0.0002ms per text.\n//\n// i18n: Intl.Segmenter handles CJK (per-character breaking), Thai, Arabic, etc.\n//   Bidi: simplified rich-path metadata for mixed LTR/RTL custom rendering.\n//   Punctuation merging: \"better.\" measured as one unit (matches CSS behavior).\n//   Trailing whitespace: hangs past line edge without triggering breaks (CSS behavior).\n//   overflow-wrap: pre-measured grapheme widths enable character-level word breaking.\n//\n// Emoji correction: Chrome/Firefox canvas measures emoji wider than DOM at font\n//   sizes \u003c24px on macOS (Apple Color Emoji). The inflation is constant per emoji\n//   grapheme at a given size, font-independent. Auto-detected by comparing canvas\n//   vs actual DOM emoji width (one cached DOM read per font). Safari canvas and\n//   DOM agree (both wider than fontSize), so correction = 0 there.\n//\n// Limitations:\n//   - system-ui font: canvas resolves to different optical variants than DOM on macOS.\n//     Use named fonts (Helvetica, Inter, etc.) for guaranteed accuracy.\n//     See RESEARCH.md \"Discovery: system-ui font resolution mismatch\".\n//\n// Based on Sebastian Markbage's text-layout research (github.com/chenglou/text-layout).\nimport { computeSegmentLevels } from './bidi.js';\nimport { analyzeText, clearAnalysisCaches, endsWithClosingQuote, isCJK, kinsokuEnd, kinsokuStart, leftStickyPunctuation, setAnalysisLocale, } from './analysis.js';\nimport { clearMeasurementCaches, getCorrectedSegmentWidth, getEngineProfile, getFontMeasurementState, getSegmentGraphemePrefixWidths, getSegmentGraphemeWidths, getSegmentMetrics, textMayContainEmoji, } from './measurement.js';\nimport { countPreparedLines, layoutNextLineRange as stepPreparedLineRange, walkPreparedLines, } from './line-break.js';\nlet sharedGraphemeSegmenter = null;\n// Rich-path only. Reuses grapheme splits while materializing multiple lines\n// from the same prepared handle, without pushing that cache into the API.\nlet sharedLineTextCaches = new WeakMap();\nfunction getSharedGraphemeSegmenter() {\n    if (sharedGraphemeSegmenter === null) {\n        sharedGraphemeSegmenter = new Intl.Segmenter(undefined, { granularity: 'grapheme' });\n    }\n    return sharedGraphemeSegmenter;\n}\n// --- Public API ---\nfunction createEmptyPrepared(includeSegments) {\n    if (includeSegments) {\n        return {\n            widths: [],\n            lineEndFitAdvances: [],\n            lineEndPaintAdvances: [],\n            kinds: [],\n            simpleLineWalkFastPath: true,\n            segLevels: null,\n            breakableWidths: [],\n            breakablePrefixWidths: [],\n            discretionaryHyphenWidth: 0,\n            tabStopAdvance: 0,\n            chunks: [],\n            segments: [],\n        };\n    }\n    return {\n        widths: [],\n        lineEndFitAdvances: [],\n        lineEndPaintAdvances: [],\n        kinds: [],\n        simpleLineWalkFastPath: true,\n        segLevels: null,\n        breakableWidths: [],\n        breakablePrefixWidths: [],\n        discretionaryHyphenWidth: 0,\n        tabStopAdvance: 0,\n        chunks: [],\n    };\n}\nfunction measureAnalysis(analysis, font, includeSegments) {\n    const graphemeSegmenter = getSharedGraphemeSegmenter();\n    const engineProfile = getEngineProfile();\n    const { cache, emojiCorrection } = getFontMeasurementState(font, textMayContainEmoji(analysis.normalized));\n    const discretionaryHyphenWidth = getCorrectedSegmentWidth('-', getSegmentMetrics('-', cache), emojiCorrection);\n    const spaceWidth = getCorrectedSegmentWidth(' ', getSegmentMetrics(' ', cache), emojiCorrection);\n    const tabStopAdvance = spaceWidth * 8;\n    if (analysis.len === 0)\n        return createEmptyPrepared(includeSegments);\n    const widths = [];\n    const lineEndFitAdvances = [];\n    const lineEndPaintAdvances = [];\n    const kinds = [];\n    let simpleLineWalkFastPath = analysis.chunks.length \u003c= 1;\n    const segStarts = includeSegments ? [] : null;\n    const breakableWidths = [];\n    const breakablePrefixWidths = [];\n    const segments = includeSegments ? [] : null;\n    const preparedStartByAnalysisIndex = Array.from({ length: analysis.len });\n    const preparedEndByAnalysisIndex = Array.from({ length: analysis.len });\n    function pushMeasuredSegment(text, width, lineEndFitAdvance, lineEndPaintAdvance, kind, start, breakable, breakablePrefix) {\n        if (kind !== 'text' \u0026\u0026 kind !== 'space' \u0026\u0026 kind !== 'zero-width-break') {\n            simpleLineWalkFastPath = false;\n        }\n        widths.push(width);\n        lineEndFitAdvances.push(lineEndFitAdvance);\n        lineEndPaintAdvances.push(lineEndPaintAdvance);\n        kinds.push(kind);\n        segStarts?.push(start);\n        breakableWidths.push(breakable);\n        breakablePrefixWidths.push(breakablePrefix);\n        if (segments !== null)\n            segments.push(text);\n    }\n    for (let mi = 0; mi \u003c analysis.len; mi++) {\n        preparedStartByAnalysisIndex[mi] = widths.length;\n        const segText = analysis.texts[mi];\n        const segWordLike = analysis.isWordLike[mi];\n        const segKind = analysis.kinds[mi];\n        const segStart = analysis.starts[mi];\n        if (segKind === 'soft-hyphen') {\n            pushMeasuredSegment(segText, 0, discretionaryHyphenWidth, discretionaryHyphenWidth, segKind, segStart, null, null);\n            preparedEndByAnalysisIndex[mi] = widths.length;\n            continue;\n        }\n        if (segKind === 'hard-break') {\n            pushMeasuredSegment(segText, 0, 0, 0, segKind, segStart, null, null);\n            preparedEndByAnalysisIndex[mi] = widths.length;\n            continue;\n        }\n        if (segKind === 'tab') {\n            pushMeasuredSegment(segText, 0, 0, 0, segKind, segStart, null, null);\n            preparedEndByAnalysisIndex[mi] = widths.length;\n            continue;\n        }\n        const segMetrics = getSegmentMetrics(segText, cache);\n        if (segKind === 'text' \u0026\u0026 segMetrics.containsCJK) {\n            let unitText = '';\n            let unitStart = 0;\n            for (const gs of graphemeSegmenter.segment(segText)) {\n                const grapheme = gs.segment;\n                if (unitText.length === 0) {\n                    unitText = grapheme;\n                    unitStart = gs.index;\n                    continue;\n                }\n                if (kinsokuEnd.has(unitText) ||\n                    kinsokuStart.has(grapheme) ||\n                    leftStickyPunctuation.has(grapheme) ||\n                    (engineProfile.carryCJKAfterClosingQuote \u0026\u0026\n                        isCJK(grapheme) \u0026\u0026\n                        endsWithClosingQuote(unitText))) {\n                    unitText += grapheme;\n                    continue;\n                }\n                const unitMetrics = getSegmentMetrics(unitText, cache);\n                const w = getCorrectedSegmentWidth(unitText, unitMetrics, emojiCorrection);\n                pushMeasuredSegment(unitText, w, w, w, 'text', segStart + unitStart, null, null);\n                unitText = grapheme;\n                unitStart = gs.index;\n            }\n            if (unitText.length \u003e 0) {\n                const unitMetrics = getSegmentMetrics(unitText, cache);\n                const w = getCorrectedSegmentWidth(unitText, unitMetrics, emojiCorrection);\n                pushMeasuredSegment(unitText, w, w, w, 'text', segStart + unitStart, null, null);\n            }\n            preparedEndByAnalysisIndex[mi] = widths.length;\n            continue;\n        }\n        const w = getCorrectedSegmentWidth(segText, segMetrics, emojiCorrection);\n        const lineEndFitAdvance = segKind === 'space' || segKind === 'preserved-space' || segKind === 'zero-width-break'\n            ? 0\n            : w;\n        const lineEndPaintAdvance = segKind === 'space' || segKind === 'zero-width-break'\n            ? 0\n            : w;\n        if (segWordLike \u0026\u0026 segText.length \u003e 1) {\n            const graphemeWidths = getSegmentGraphemeWidths(segText, segMetrics, cache, emojiCorrection);\n            const graphemePrefixWidths = engineProfile.preferPrefixWidthsForBreakableRuns\n                ? getSegmentGraphemePrefixWidths(segText, segMetrics, cache, emojiCorrection)\n                : null;\n            pushMeasuredSegment(segText, w, lineEndFitAdvance, lineEndPaintAdvance, segKind, segStart, graphemeWidths, graphemePrefixWidths);\n        }\n        else {\n            pushMeasuredSegment(segText, w, lineEndFitAdvance, lineEndPaintAdvance, segKind, segStart, null, null);\n        }\n        preparedEndByAnalysisIndex[mi] = widths.length;\n    }\n    const chunks = mapAnalysisChunksToPreparedChunks(analysis.chunks, preparedStartByAnalysisIndex, preparedEndByAnalysisIndex);\n    const segLevels = segStarts === null ? null : computeSegmentLevels(analysis.normalized, segStarts);\n    if (segments !== null) {\n        return {\n            widths,\n            lineEndFitAdvances,\n            lineEndPaintAdvances,\n            kinds,\n            simpleLineWalkFastPath,\n            segLevels,\n            breakableWidths,\n            breakablePrefixWidths,\n            discretionaryHyphenWidth,\n            tabStopAdvance,\n            chunks,\n            segments,\n        };\n    }\n    return {\n        widths,\n        lineEndFitAdvances,\n        lineEndPaintAdvances,\n        kinds,\n        simpleLineWalkFastPath,\n        segLevels,\n        breakableWidths,\n        breakablePrefixWidths,\n        discretionaryHyphenWidth,\n        tabStopAdvance,\n        chunks,\n    };\n}\nfunction mapAnalysisChunksToPreparedChunks(chunks, preparedStartByAnalysisIndex, preparedEndByAnalysisIndex) {\n    const preparedChunks = [];\n    for (let i = 0; i \u003c chunks.length; i++) {\n        const chunk = chunks[i];\n        const startSegmentIndex = chunk.startSegmentIndex \u003c preparedStartByAnalysisIndex.length\n            ? preparedStartByAnalysisIndex[chunk.startSegmentIndex]\n            : preparedEndByAnalysisIndex[preparedEndByAnalysisIndex.length - 1] ?? 0;\n        const endSegmentIndex = chunk.endSegmentIndex \u003c preparedStartByAnalysisIndex.length\n            ? preparedStartByAnalysisIndex[chunk.endSegmentIndex]\n            : preparedEndByAnalysisIndex[preparedEndByAnalysisIndex.length - 1] ?? 0;\n        const consumedEndSegmentIndex = chunk.consumedEndSegmentIndex \u003c preparedStartByAnalysisIndex.length\n            ? preparedStartByAnalysisIndex[chunk.consumedEndSegmentIndex]\n            : preparedEndByAnalysisIndex[preparedEndByAnalysisIndex.length - 1] ?? 0;\n        preparedChunks.push({\n            startSegmentIndex,\n            endSegmentIndex,\n            consumedEndSegmentIndex,\n        });\n    }\n    return preparedChunks;\n}\nfunction prepareInternal(text, font, includeSegments, options) {\n    const analysis = analyzeText(text, getEngineProfile(), options?.whiteSpace);\n    return measureAnalysis(analysis, font, includeSegments);\n}\n// Diagnostic-only helper used by the browser benchmark harness to separate the\n// text-analysis and measurement phases without duplicating the prepare logic.\nexport function profilePrepare(text, font, options) {\n    const t0 = performance.now();\n    const analysis = analyzeText(text, getEngineProfile(), options?.whiteSpace);\n    const t1 = performance.now();\n    const prepared = measureAnalysis(analysis, font, false);\n    const t2 = performance.now();\n    let breakableSegments = 0;\n    for (const widths of prepared.breakableWidths) {\n        if (widths !== null)\n            breakableSegments++;\n    }\n    return {\n        analysisMs: t1 - t0,\n        measureMs: t2 - t1,\n        totalMs: t2 - t0,\n        analysisSegments: analysis.len,\n        preparedSegments: prepared.widths.length,\n        breakableSegments,\n    };\n}\n// Prepare text for layout. Segments the text, measures each segment via canvas,\n// and stores the widths for fast relayout at any width. Call once per text block\n// (e.g. when a comment first appears). The result is width-independent — the\n// same PreparedText can be laid out at any maxWidth and lineHeight via layout().\n//\n// Steps:\n//   1. Normalize collapsible whitespace (CSS white-space: normal behavior)\n//   2. Segment via Intl.Segmenter (handles CJK, Thai, etc.)\n//   3. Merge punctuation into preceding word (\"better.\" as one unit)\n//   4. Split CJK words into individual graphemes (per-character line breaks)\n//   5. Measure each segment via canvas measureText, cache by (segment, font)\n//   6. Pre-measure graphemes of long words (for overflow-wrap: break-word)\n//   7. Correct emoji canvas inflation (auto-detected per font size)\n//   8. Optionally compute rich-path bidi metadata for custom renderers\nexport function prepare(text, font, options) {\n    return prepareInternal(text, font, false, options);\n}\n// Rich variant used by callers that need enough information to render the\n// laid-out lines themselves.\nexport function prepareWithSegments(text, font, options) {\n    return prepareInternal(text, font, true, options);\n}\nfunction getInternalPrepared(prepared) {\n    return prepared;\n}\n// Layout prepared text at a given max width and caller-provided lineHeight.\n// Pure arithmetic on cached widths — no canvas calls, no DOM reads, no string\n// operations, no allocations.\n// ~0.0002ms per text block. Call on every resize.\n//\n// Line breaking rules (matching CSS white-space: normal + overflow-wrap: break-word):\n//   - Break before any non-space segment that would overflow the line\n//   - Trailing whitespace hangs past the line edge (doesn't trigger breaks)\n//   - Segments wider than maxWidth are broken at grapheme boundaries\nexport function layout(prepared, maxWidth, lineHeight) {\n    // Keep the resize hot path specialized. `layoutWithLines()` shares the same\n    // break semantics but also tracks line ranges; the extra bookkeeping is too\n    // expensive to pay on every hot-path `layout()` call.\n    const lineCount = countPreparedLines(getInternalPrepared(prepared), maxWidth);\n    return { lineCount, height: lineCount * lineHeight };\n}\nfunction getSegmentGraphemes(segmentIndex, segments, cache) {\n    let graphemes = cache.get(segmentIndex);\n    if (graphemes !== undefined)\n        return graphemes;\n    graphemes = [];\n    const graphemeSegmenter = getSharedGraphemeSegmenter();\n    for (const gs of graphemeSegmenter.segment(segments[segmentIndex])) {\n        graphemes.push(gs.segment);\n    }\n    cache.set(segmentIndex, graphemes);\n    return graphemes;\n}\nfunction getLineTextCache(prepared) {\n    let cache = sharedLineTextCaches.get(prepared);\n    if (cache !== undefined)\n        return cache;\n    cache = new Map();\n    sharedLineTextCaches.set(prepared, cache);\n    return cache;\n}\nfunction lineHasDiscretionaryHyphen(kinds, startSegmentIndex, startGraphemeIndex, endSegmentIndex) {\n    return (endSegmentIndex \u003e 0 \u0026\u0026\n        kinds[endSegmentIndex - 1] === 'soft-hyphen' \u0026\u0026\n        !(startSegmentIndex === endSegmentIndex \u0026\u0026 startGraphemeIndex \u003e 0));\n}\nfunction buildLineTextFromRange(segments, kinds, cache, startSegmentIndex, startGraphemeIndex, endSegmentIndex, endGraphemeIndex) {\n    let text = '';\n    const endsWithDiscretionaryHyphen = lineHasDiscretionaryHyphen(kinds, startSegmentIndex, startGraphemeIndex, endSegmentIndex);\n    for (let i = startSegmentIndex; i \u003c endSegmentIndex; i++) {\n        if (kinds[i] === 'soft-hyphen' || kinds[i] === 'hard-break')\n            continue;\n        if (i === startSegmentIndex \u0026\u0026 startGraphemeIndex \u003e 0) {\n            text += getSegmentGraphemes(i, segments, cache).slice(startGraphemeIndex).join('');\n        }\n        else {\n            text += segments[i];\n        }\n    }\n    if (endGraphemeIndex \u003e 0) {\n        if (endsWithDiscretionaryHyphen)\n            text += '-';\n        text += getSegmentGraphemes(endSegmentIndex, segments, cache).slice(startSegmentIndex === endSegmentIndex ? startGraphemeIndex : 0, endGraphemeIndex).join('');\n    }\n    else if (endsWithDiscretionaryHyphen) {\n        text += '-';\n    }\n    return text;\n}\nfunction createLayoutLine(prepared, cache, width, startSegmentIndex, startGraphemeIndex, endSegmentIndex, endGraphemeIndex) {\n    return {\n        text: buildLineTextFromRange(prepared.segments, prepared.kinds, cache, startSegmentIndex, startGraphemeIndex, endSegmentIndex, endGraphemeIndex),\n        width,\n        start: {\n            segmentIndex: startSegmentIndex,\n            graphemeIndex: startGraphemeIndex,\n        },\n        end: {\n            segmentIndex: endSegmentIndex,\n            graphemeIndex: endGraphemeIndex,\n        },\n    };\n}\nfunction materializeLayoutLine(prepared, cache, line) {\n    return createLayoutLine(prepared, cache, line.width, line.startSegmentIndex, line.startGraphemeIndex, line.endSegmentIndex, line.endGraphemeIndex);\n}\nfunction toLayoutLineRange(line) {\n    return {\n        width: line.width,\n        start: {\n            segmentIndex: line.startSegmentIndex,\n            graphemeIndex: line.startGraphemeIndex,\n        },\n        end: {\n            segmentIndex: line.endSegmentIndex,\n            graphemeIndex: line.endGraphemeIndex,\n        },\n    };\n}\nfunction stepLineRange(prepared, start, maxWidth) {\n    const line = stepPreparedLineRange(prepared, start, maxWidth);\n    if (line === null)\n        return null;\n    return toLayoutLineRange(line);\n}\nfunction materializeLine(prepared, line) {\n    return createLayoutLine(prepared, getLineTextCache(prepared), line.width, line.start.segmentIndex, line.start.graphemeIndex, line.end.segmentIndex, line.end.graphemeIndex);\n}\n// Batch low-level line geometry pass. This is the non-materializing counterpart\n// to layoutWithLines(), useful for shrinkwrap and other aggregate geometry work.\nexport function walkLineRanges(prepared, maxWidth, onLine) {\n    if (prepared.widths.length === 0)\n        return 0;\n    return walkPreparedLines(getInternalPrepared(prepared), maxWidth, line =\u003e {\n        onLine(toLayoutLineRange(line));\n    });\n}\nexport function layoutNextLine(prepared, start, maxWidth) {\n    const line = stepLineRange(prepared, start, maxWidth);\n    if (line === null)\n        return null;\n    return materializeLine(prepared, line);\n}\n// Rich layout API for callers that want the actual line contents and widths.\n// Caller still supplies lineHeight at layout time. Mirrors layout()'s break\n// decisions, but keeps extra per-line bookkeeping so it should stay off the\n// resize hot path.\nexport function layoutWithLines(prepared, maxWidth, lineHeight) {\n    const lines = [];\n    if (prepared.widths.length === 0)\n        return { lineCount: 0, height: 0, lines };\n    const graphemeCache = getLineTextCache(prepared);\n    const lineCount = walkPreparedLines(getInternalPrepared(prepared), maxWidth, line =\u003e {\n        lines.push(materializeLayoutLine(prepared, graphemeCache, line));\n    });\n    return { lineCount, height: lineCount * lineHeight, lines };\n}\nexport function clearCache() {\n    clearAnalysisCaches();\n    sharedGraphemeSegmenter = null;\n    sharedLineTextCaches = new WeakMap();\n    clearMeasurementCaches();\n}\nexport function setLocale(locale) {\n    setAnalysisLocale(locale);\n    clearCache();\n}\n"],"version":3}