rapier-markdown-kit 1.1.102 → 1.2.3

package/dist/agent/vendor/pretext/prepare.js

@@ -0,0 +1,807 @@
+/*! Pretext Unreleased (bac1774c0) | MIT; BSD/Unicode/ICU notices in LICENSE | Copyright (c) 2026 Pretext contributors */
+// Preparation's measurement phase: each segment of a text analysis measured in a font, with
+// the facts the line walkers read at a line's edges. layout.ts and rich-inline.ts prepare
+// through it, as they walk through line-break.ts.
+
+import { observeSegmentEntries, textMayHaveEntryGeometry,                           } from './entry-geometry.js'
+import { getHanKerningTrims, textMayHanKern,                      } from './han-kerning.js'
+import { findGraphemeEnds,                    } from './graphemes.js'
+import { scriptClassFacts } from './generated/engine-break-data.js'
+import { DEFAULT_IGNORABLE, getClass, hasProperty, lazyRegExp, unpackClasses,                 } from './line-breaks.js'
+import {
+  CONTROL,
+  HARD_BREAK,
+  KIND_BITS,
+  ONE_CLUSTER,
+  PRESERVED_SPACE,
+  SOFT_HYPHEN,
+  SPACE,
+  SPACED,
+  TAB,
+  TEXT,
+  UNBROKEN,
+  ZERO_WIDTH_BREAK,
+  ZERO_WIDTH_GLUE,
+                       
+                    
+} from './analysis.js'
+import {
+                        
+                     
+                       
+  getCorrectedSegmentWidth,
+  getEmojiCorrection,
+  getFollowingSpaceMetrics,
+  getFontMeasurement,
+  getFontSpaceKerning,
+  getHyphenText,
+  getSegmentFit,
+  getSegmentMetrics,
+  getSpaceKerning,
+  getSpaceWidth,
+  getTextWidth,
+  measureWithLetterSpacing,
+  noSpaceKerning,
+  textMayContainEmoji,
+                  
+                      
+  zeros,
+} from './measurement.js'
+                                               
+                                                            
+                                                      
+
+// Text and spaces take letter spacing after each grapheme; a ZWSP takes none.
+function countRenderedSpacingGraphemes(text        , kind                 , graphemeTable               )         {
+  return kind === ZERO_WIDTH_BREAK ? 0 : findGraphemeEnds(graphemeTable, text, 0, text.length, null)
+}
+
+function addInternalLetterSpacing(width        , graphemeCount        , letterSpacing        )         {
+  return graphemeCount > 1 ? width + (graphemeCount - 1) * letterSpacing : width
+}
+
+// Code points that WebKit's FontCascade::characterRangeCodePath sends to the
+// complex text path, stored as start/end pairs. So does a ZWJ after an emoji.
+const complexTextPathRanges = [
+  0x02E5, 0x02E9, 0x0300, 0x036F, 0x0591, 0x05BD, 0x05BF, 0x05CF, 0x0600, 0x109F,
+  0x1100, 0x11FF, 0x135D, 0x135F, 0x1700, 0x18AF, 0x1900, 0x194F, 0x1980, 0x19DF,
+  0x1A00, 0x1CFF, 0x1DC0, 0x1DFF, 0x20D0, 0x20FF, 0x26F9, 0x26F9, 0x2CEF, 0x2CF1,
+  0x302A, 0x302F, 0x3099, 0x309C, 0xA67C, 0xA67D, 0xA6F0, 0xA6F1, 0xA800, 0xABFF,
+  0xD7B0, 0xD7FF, 0xFE00, 0xFE0F, 0xFE20, 0xFE2F, 0x10A00, 0x10A5F, 0x11000, 0x110CF,
+  0x11100, 0x111DF, 0x11200, 0x1124F, 0x112B0, 0x1137F, 0x11400, 0x114DF, 0x11580, 0x1165F,
+  0x11680, 0x116CF, 0x11700, 0x11CBF, 0x16B00, 0x16B8F, 0x1E900, 0x1E95F, 0x1F1E6, 0x1F1FF,
+  0x1F3FB, 0x1F3FF, 0xE0000, 0xE007F, 0xE0100, 0xE01EF,
+]         
+
+const extendedPictographicRe = /\p{Extended_Pictographic}/u
+const leadingCombiningMarkRe = lazyRegExp(String.raw`^\p{M}`, 'u')
+// Decimal digits and the joiners of numbers, times and dates.
+const numericRunRe = /^[\p{Nd}:\-/×,.+\u2013\u2014]+$/u
+const markRunRe = /^\p{M}+$/u
+const nonspacingMarkRunRe = /^\p{Mn}+$/u
+const controlOrMarkRunRe = /^(?:[\p{Cc}\u2028\u2029]|\p{M}+)$/u
+const controlCharacterRe = /^[\p{Cc}\u2028\u2029]$/u
+// The fewest UTF-16 units of a long chain of mark runs that a run's context keeps after
+// the grapheme (getMarkContext): measured after the whole chain, a long chain prepared in
+// time that grows with the square of its length. Safari gives a run a width that depends
+// on how far it sits from the grapheme, up to 61 units in the chains measured
+// (RESEARCH.md, Break Opportunities From Engine Data), so a context that keeps fewer
+// moves widths there.
+const MARK_CHAIN_CONTEXT_UNITS = 96
+
+function needsComplexTextPath(text        )          {
+  let previousIsEmoji = false
+  for (let i = 0; i < text.length;) {
+    const codePoint = text.codePointAt(i) 
+    i += codePoint > 0xFFFF ? 2 : 1
+    if (codePoint === 0x200D && previousIsEmoji) return true
+    previousIsEmoji = codePoint > 0xFFFF && extendedPictographicRe.test(String.fromCodePoint(codePoint))
+    for (let range = 0; range < complexTextPathRanges.length && codePoint >= complexTextPathRanges[range] ; range += 2) {
+      if (codePoint <= complexTextPathRanges[range + 1] ) return true
+    }
+  }
+  return false
+}
+
+const explicitBidiControlRe = /[\u202A-\u202E\u2066-\u2069]/
+// Format characters stand for bidi class BN, except the direction marks LRM,
+// RLM and ALM, which are strong characters like letters.
+const trailingFormatCharacterRe = /(?![\u200E\u200F\u061C])\p{Cf}$/u
+// Letters in the right-to-left blocks have bidi class R or AL, as do RLM and
+// ALM. Every other letter except modifier letters has class L, as does LRM.
+const rightToLeftLetterRe = /[\u0590-\u08FF\uFB1D-\uFDFF\uFE70-\uFEFF\u200F\u{10800}-\u{10FFF}\u{1E800}-\u{1EFFF}]/u
+// Either of the two: a right-to-left letter or an explicit bidi control.
+const mixedDirectionRe = /[\u0590-\u08FF\uFB1D-\uFDFF\uFE70-\uFEFF\u200F\u{10800}-\u{10FFF}\u{1E800}-\u{1EFFF}\u202A-\u202E\u2066-\u2069]/u
+// The last letter or direction mark before format characters other than a soft
+// hyphen, and the first letter, direction mark or ASCII digit after the space,
+// past spaces and format characters.
+const letterBeforeFormatTailRe = lazyRegExp(String.raw`([\p{Lu}\p{Ll}\p{Lt}\p{Lo}\u200E\u200F\u061C])\p{M}*(?:(?![\u00AD\u200E\u200F\u061C])\p{Cf})+$`, 'u')
+const letterAfterSpacesRe = lazyRegExp(String.raw` (?: |(?![\u200E\u200F\u061C])\p{Cf})*([0-9\p{Lu}\p{Ll}\p{Lt}\p{Lo}\u200E\u200F\u061C])`, 'uy')
+
+function isSpaceKind(kind        )          {
+  return kind === SPACE || kind === PRESERVED_SPACE
+}
+
+// Blink splits a text into script runs and shapes each apart (ScriptRunIterator,
+// script_run_iterator.cc; HarfBuzzShaper::Shape, harfbuzz_shaper.cc:1063-1104). Two rules of
+// the Chromium profile turn on the run a character is in: a word kerns with a space only
+// where the two share a run (spaceSharesScriptRun), and the letters of a run in a script
+// whose letters join take no letter spacing (getUnspacedGraphemes). Both read the runs
+// through readScriptRuns, with a character's scripts as bits: Cyrillic, Greek, Latin, one bit
+// for the seven scripts whose letters join, and one for every other script, so two scripts
+// that share a bit read as one; a character of any script has all five. Cyrillic, Greek and
+// Latin are in Blink's order for a Common character's extensions, by ICU script code with
+// Latin last (GetScripts, :191-198), so a run's lowest bit is the script it resolves to. A
+// character's scripts, and a few facts more in the bits above them, come from ICU's Script,
+// Script_Extensions and bracket pairs as Chrome's build holds them, and Firefox's: a class
+// for every code point ('chromium/script') and each class's bits (scriptClassFacts).
+// scripts/generate-engine-break-data.ts has which scripts a character is given there, and
+// what that leaves out.
+export const OTHER_SCRIPT = 1
+export const CYRILLIC_SCRIPT = 2
+export const GREEK_SCRIPT = 4
+export const LATIN_SCRIPT = 8
+export const CURSIVE_SCRIPT = 16
+export const ANY_SCRIPT = 31
+// A mark that scripts list, as they do the Arabic vowel signs, is of any script itself and has
+// those scripts in the next five bits. A Common character that no script lists takes them
+// from such a mark right after it (FetchNextCharacter, :624-635), so a digit or a dotted circle
+// that carries a fatha starts an Arabic run.
+export const MARK_SCRIPTS_SHIFT = 5
+export const TAKES_MARK_SCRIPTS = 1 << 10
+// A character whose own script, whatever else lists it, is one whose letters join.
+export const CURSIVE_LETTER = 1 << 11
+// A paired bracket, and from this bit up a closing bracket's code less its opening bracket's.
+export const OPENING_BRACKET = 1 << 12
+export const CLOSING_BRACKET = 1 << 13
+export const OPENING_BRACKET_SHIFT = 14
+
+// Every code point's class, unpacked when a text first asks for a script.
+let scriptClasses                    = null
+function getScriptFacts(c        )         {
+  return scriptClassFacts[getClass(scriptClasses ??= unpackClasses('chromium/script'), c)] 
+}
+
+// The facts of the character at text[i], with the scripts it has there, as Blink reads them
+// (GetScripts, script_run_iterator.cc:118-215).
+function getScriptFactsAt(text        , i        )         {
+  const c = text.codePointAt(i) 
+  const facts = getScriptFacts(c)
+  const next = i + (c > 0xFFFF ? 2 : 1)
+  if ((facts & TAKES_MARK_SCRIPTS) !== 0 && next < text.length) {
+    const markScripts = getScriptFacts(text.codePointAt(next) ) >> MARK_SCRIPTS_SHIFT & ANY_SCRIPT
+    if (markScripts !== 0) return facts & ~ANY_SCRIPT | markScripts
+  }
+  return facts
+}
+
+// Whether a text holds a character whose scripts are cursive, or a mark that gives them: no
+// other text has a grapheme that takes no letter spacing. ASCII, which is Latin letters and
+// Common characters, has neither.
+function mayHoldCursive(text        )          {
+  for (let i = 0; i < text.length; i++) {
+    if (text.charCodeAt(i) < 0x80) continue
+    const facts = getScriptFacts(text.codePointAt(i) )
+    if ((facts & ANY_SCRIPT) === CURSIVE_SCRIPT || (facts >> MARK_SCRIPTS_SHIFT & ANY_SCRIPT) === CURSIVE_SCRIPT) return true
+  }
+  return false
+}
+
+// How far a text's script runs are read, the scripts the run there can be in, and each
+// bracket open there: its opening character, then the script of the run it was opened in,
+// 0 while that run goes on.
+                                                                           
+
+// The scripts of the run text[to - 1] is in, read on from the last call as
+// ScriptRunIterator::Consume reads them (script_run_iterator.cc:325-429): a run keeps the
+// scripts its characters share and ends before one that shares none. A run of no script yet
+// takes the script of the first character after it that has one, so the read goes on to that
+// character. A closing bracket takes the script of the run its opening bracket is in, once
+// that run has ended, among the last 32 opened, and closes the ones opened since; its own
+// stays open, so a second closing bracket goes back to that run too (OpenBracket,
+// CloseBracket and FixupStack, :431-489, :567-590).
+function readScriptRuns(runs            , text        , to        )         {
+  const { openBrackets } = runs
+  while (runs.read < to || (runs.scripts === ANY_SCRIPT && runs.read < text.length)) {
+    const c = text.codePointAt(runs.read) 
+    const facts = getScriptFactsAt(text, runs.read)
+    let scripts = facts & ANY_SCRIPT
+    // No bracket's code is as low as a run's script.
+    const opened = (facts & CLOSING_BRACKET) !== 0 ? openBrackets.lastIndexOf(c - (facts >> OPENING_BRACKET_SHIFT)) : -1
+    if (opened >= 0) {
+      if (openBrackets[opened + 1] !== 0) scripts = openBrackets[opened + 1] 
+      openBrackets.length = opened + 2
+    }
+    if ((runs.scripts & scripts) !== 0) {
+      runs.scripts &= scripts
+    } else {
+      // The run that ends resolves to its first script (ResolveCurrentScript, :639-642), which
+      // the brackets opened in it take.
+      for (let k = openBrackets.length - 1; k > 0 && openBrackets[k] === 0; k -= 2) openBrackets[k] = runs.scripts & -runs.scripts
+      runs.scripts = scripts
+    }
+    if ((facts & OPENING_BRACKET) !== 0) {
+      if (openBrackets.length === 64) openBrackets.splice(0, 2)
+      openBrackets.push(c, 0)
+    }
+    runs.read += c > 0xFFFF ? 2 : 1
+  }
+  return runs.scripts
+}
+
+// Whether the space before the text segment text[at..end) is in the script run of the segment's
+// first character past default ignorables, the one it kerns with: a space joins the run of the
+// text before it (ScriptRunIterator::MergeSets, :490-510). The nearest character before the
+// space that has one script names that run, so the search back starts before the space, at
+// text[at - 2], and ends there; a closing bracket, or a character of several scripts, takes its
+// script from the runs before it, which are then read.
+function spaceSharesScriptRun(runs            , text        , at        , end        )          {
+  let scripts = getScriptFactsAt(text, at) & ANY_SCRIPT
+  // A default ignorable with a script of its own, as U+3164, counts as the word's first letter.
+  for (let first = at; scripts === ANY_SCRIPT && first + 1 < end && hasProperty(text.charCodeAt(first), DEFAULT_IGNORABLE); first++) scripts = getScriptFactsAt(text, first + 1) & ANY_SCRIPT
+  if (scripts === ANY_SCRIPT) return true
+  for (let i = at - 2; i >= 0; i--) {
+    if ((text.charCodeAt(i) & 0xFC00) === 0xDC00 && i > 0) i--
+    const facts = getScriptFactsAt(text, i)
+    if ((facts & CLOSING_BRACKET) !== 0) break
+    const before = facts & ANY_SCRIPT
+    if (before === ANY_SCRIPT) continue
+    if ((before & (before - 1)) === 0) return (before & scripts) !== 0
+    break
+  }
+  return (readScriptRuns(runs, text, at) & scripts) !== 0
+}
+
+// The scripts whose letters join, Arabic, Syriac, N'Ko, Mandaic, Mongolian, Phags-pa and
+// Hanifi Rohingya, take no letter spacing in Blink and Gecko, which name the same seven
+// (IsCursiveScript, shape_result.cc:977-990; UnicodeProperties.h:350-355). Gecko asks the
+// script of a cluster's first character (GetSpacingInternal, nsTextFrame.cpp:4202-4213), so
+// digits and punctuation among the letters keep their spacing. Blink asks the script of the
+// shaping run the cluster is in and spaces only its spaces (ComputeSpacing,
+// shape_result_spacing.cc:103-131, behind the runtime flag
+// IgnoreLetterSpacingInCursiveScripts): a run takes in the characters of no script after
+// it, the ones that start the text, and the punctuation its script shares, so of an Arabic
+// word, a space and `123.` only the space is spaced. That is Chrome since 149; 138 to 148
+// don't space the run's spaces either, and before 138 every letter is spaced, which no
+// version check here follows (ENGINE_FOLLOWUPS.md, Letter spacing). WebKit spaces every
+// glyph with an advance. Chrome 154, Firefox 156 and webkit-host lay 67 strings out so
+// (2026-10-03). The profile's unspacedCursive names the engine's rule. This gives the
+// graphemes of the text segment text[start..end) that take no letter spacing, as ascending
+// indices, or null without any: in Gecko, which is given no runs, those whose first
+// character is a letter of a cursive script; in Blink those whose first character is in a
+// run that resolves to one and isn't a no-break space. A rich item's text starts a run of
+// its own (ENGINE_FOLLOWUPS.md, Letter spacing).
+function getUnspacedGraphemes(text        , start        , end        , graphemeTable               , runs                   )                  {
+  const ends = new Int32Array(end - start)
+  const count = findGraphemeEnds(graphemeTable, text, start, end, ends)
+  let unspaced                  = null
+  for (let g = 0, at = start; g < count; at = ends[g++] ) {
+    const joins = runs === null ? (getScriptFacts(text.codePointAt(at) ) & CURSIVE_LETTER) !== 0
+      : readScriptRuns(runs, text, at + 1) === CURSIVE_SCRIPT && text.charCodeAt(at) !== 0xA0
+    if (joins) (unspaced ??= []).push(g)
+  }
+  return unspaced
+}
+
+// Bidi class B: the characters that end a bidi paragraph.
+function isParagraphSeparatorCode(code        )          {
+  return code === 0x0a || code === 0x0d || (code >= 0x1c && code <= 0x1e) || code === 0x85 || code === 0x2029
+}
+
+// The lists of a rich-inline paragraph's handle that each item's measurement adds its segments
+// to; `segmentFlags` has room for them from `widths.length` on.
+                              
+                  
+                          
+                                           
+ 
+
+// Measures segments [from, to) of an analysis in a font, alone: all of a text's, or those of one
+// item of a rich-inline paragraph (RESEARCH.md, Rich Inline As One Paragraph), where only the
+// marks Blink halts and a run of U+3000 read the text around the item (getHanKerningTrims,
+// addIdeographicSpaceHangs). Each segment's width, flags byte and advances go on the end of
+// three lists: a text's own, or for an item its paragraph's, so an item is measured with no
+// copy of its part of the analysis and no lists of its own to copy from. The handle returned
+// holds those lists; what else it holds is the measured segments' alone, each list from the
+// first of them.
+export function measureAnalysis(
+  analysis              ,
+  from        ,
+  to        ,
+  font        ,
+  includeSegments         ,
+  letterSpacing        ,
+  engineProfile               ,
+  language               ,
+  // Whether text segments take emergency breaks between graphemes: an atomic rich item,
+  // which is only laid out whole, takes none.
+  overflowBreaks         ,
+  // The paragraph's lists for a rich-inline item, null for a text.
+  paragraph                       ,
+  paragraphHyphen = null,
+)                                                                             {
+  const { normalized, texts, starts, flags } = analysis
+  // The measured text and where it starts in the analysis's: what is asked of the whole text
+  // is asked of it, and places in it count from its start.
+  const ownStart = from === 0 ? 0 : starts[from] 
+  const own = from === 0 && to === flags.length ? normalized : to === from + 1 ? texts[from]  : normalized.slice(ownStart, to < flags.length ? starts[to]  : normalized.length)
+  // A text's lists are made here, where they are filled, and not by its caller: V8 types a
+  // list by what the `[]` that made it has seen, and with every caller making them, in a loop
+  // that pushed, Chrome prepared long texts 5-11% slower and Firefox walked CJK lines 12%
+  // slower. A paragraph's lists are its caller's, and the measuring loop below stores by index
+  // for them. With those stores a text's lists made by its caller weren't timed, so whether
+  // they still have to be made here isn't known (RESEARCH.md, Keeping Work Bounded, JavaScript
+  // Engines, under A list made where it is filled).
+  const widths           = paragraph === null ? [] : paragraph.widths
+  // An engine's scan makes one prepared segment per analysis segment, whose flags the
+  // walkers, layout()'s count and rich-inline layout read where the scan gives no break.
+  const segmentFlags = paragraph === null ? new Uint8Array(to - from) : paragraph.segmentFlags
+  const breakableFitAdvances                      = paragraph === null ? [] : paragraph.breakableFitAdvances
+  const segments = includeSegments ? []             : null
+  // Where the first measured segment goes in the lists.
+  const base = widths.length
+  const hasLetterSpacing = letterSpacing !== 0
+  const fontMeasurement = getFontMeasurement(font, language, hasLetterSpacing)
+  const emojiCorrection = textMayContainEmoji(own) ? getEmojiCorrection(font, fontMeasurement) : 0
+  const spaceWidth = getSpaceWidth(fontMeasurement)
+  // The advance between tab stops: eight spaces, each with its letter spacing where the
+  // engine counts it (EngineProfile's letterSpaceTabStops). Gecko rounds the space and the
+  // letter spacing to app units, sixtieths of a pixel, each on its own
+  // (ComputeTabWidthAppUnits, nsTextFrame.cpp:3875-3906).
+  const tabStopSpacing = engineProfile.letterSpaceTabStops ? letterSpacing : 0
+  const tabStopAdvance = engineProfile.tabsInAppUnits
+    ? (Math.round(spaceWidth * 60) + Math.round(tabStopSpacing * 60)) * 8 / 60
+    : (spaceWidth + tabStopSpacing) * 8
+  // The least a tab advances, measured at a text's first tab (EngineProfile's tabMinimumCharacter).
+  let minimumTabAdvance = 0
+  // Only a segment holding a default-ignorable code point has entry geometry, so text
+  // without one doesn't look for it.
+  const entryFitBasis = engineProfile.entryFitBasis !== 'disabled' && textMayHaveEntryGeometry(own) ? engineProfile.entryFitBasis : 'disabled'
+
+  // A collapsed space's first source character, for engines that look at the
+  // source after a text item.
+  function getSpaceSourceCode(analysisIndex        )         {
+    const start = starts[analysisIndex] 
+    return analysis.spaceSources === null ? normalized.charCodeAt(start) : analysis.spaceSources[start] 
+  }
+
+  // A WebKit text item runs to its next break opportunity, so it also owns any
+  // zero-width breaks before the space. The item is measured with one following
+  // U+0020 minus an unshaped space, which keeps the kerning between the item's
+  // end and that space. With letter spacing the same measurement also moves the
+  // space's gap onto the item and clamps the item at zero, which the
+  // per-grapheme gap model does not represent, so only the unspaced case takes
+  // the kerning. A soft hyphen before the space also takes none: on an RTL page
+  // WebKit needs about a hyphen's width more to fit such an item, and
+  // preparation cannot see the page direction. Returns the zero-width breaks
+  // between the text and the space, or null when the text takes no kerning.
+  function getFollowingSpaceTail(analysisIndex        , text        )                {
+    if (!engineProfile.measureTextWithFollowingSpace || hasLetterSpacing) return null
+    let next = analysisIndex + 1
+    while (next < to && (flags[next]  & KIND_BITS) === ZERO_WIDTH_BREAK) next++
+    if (next >= to) return null
+    const nextKind = flags[next]  & KIND_BITS
+    if ((nextKind !== SPACE && nextKind !== PRESERVED_SPACE) || getSpaceSourceCode(next) !== 0x20) return null
+    const tail = normalized.slice(starts[analysisIndex + 1], starts[next])
+    return formatTailStaysWithWord(tail === '' ? text : text + tail, starts[next]  - ownStart) ? tail : null
+  }
+
+  // Text directly before such a space is measured together with the space
+  // instead of alone, so its kerned width costs no extra Canvas call. Other
+  // occurrences of the same text measure it alone.
+  function getTextMetrics(text        , followingSpaceTail               )                 {
+    return followingSpaceTail === '' ? getFollowingSpaceMetrics(text, fontMeasurement) : getSegmentMetrics(text, fontMeasurement)
+  }
+
+  // A zero-width break before the space ends the measured item, so only the
+  // item's kerning with the space is added to the text's own width.
+  function getTailKerning(item        )         {
+    return getFollowingSpaceMetrics(item, fontMeasurement).width - getSegmentMetrics(item, fontMeasurement).width - spaceWidth
+  }
+
+  // WebKit splits text items where resolved bidi levels change before it
+  // measures them. Format characters between a word and the space resolve with
+  // that space, so they stay in the word's item, and the word's last glyph keeps
+  // its kerning with the space, only when the space resolves to the word's
+  // direction. Without the paragraph direction that is known when the word's last
+  // letter or direction mark and the first one after the space have the same
+  // direction, with only spaces and format characters between (UAX #9 N1).
+  // Explicit embeddings, overrides and isolates end with their paragraph (UAX #9
+  // X8), so only controls in the space's own paragraph leave its direction
+  // unknown. Spaces arrive in order, so each paragraph is scanned once.
+  let hasExplicitBidiControls                 = null
+  let controlParagraphEnd = -1
+  let paragraphHasExplicitBidiControls = false
+  function spaceParagraphHasExplicitBidiControls(spaceStart        )          {
+    hasExplicitBidiControls ??= explicitBidiControlRe.test(own)
+    if (!hasExplicitBidiControls) return false
+    if (spaceStart < controlParagraphEnd) return paragraphHasExplicitBidiControls
+    let start = spaceStart
+    while (start > 0 && !isParagraphSeparatorCode(own.charCodeAt(start - 1))) start--
+    let end = spaceStart
+    while (end < own.length && !isParagraphSeparatorCode(own.charCodeAt(end))) end++
+    controlParagraphEnd = end
+    paragraphHasExplicitBidiControls = explicitBidiControlRe.test(own.slice(start, end))
+    return paragraphHasExplicitBidiControls
+  }
+  function formatTailStaysWithWord(item        , spaceStart        )          {
+    if (!trailingFormatCharacterRe.test(item)) return true
+    const before = letterBeforeFormatTailRe().exec(item)
+    if (before === null) return false
+    letterAfterSpacesRe().lastIndex = spaceStart
+    const after = letterAfterSpacesRe().exec(own)
+    if (after === null) return false
+    // An ASCII digit takes the direction of the text before it (UAX #9 W7 and N1).
+    const next = after[1] 
+    return (next.charCodeAt(0) <= 0x39 || rightToLeftLetterRe.test(before[1] ) === rightToLeftLetterRe.test(next)) &&
+      !spaceParagraphHasExplicitBidiControls(spaceStart)
+  }
+
+  // The source a run of combining marks shapes after when only zero-width glue,
+  // controls or other such runs, with no break, separate the run from the grapheme
+  // before it: that grapheme and what separates them. Without the separators, Canvas
+  // can compose the marks with the grapheme or draw both in another font. A walk that
+  // reaches the last run that asked takes that run's answer, so each segment is walked
+  // and each grapheme found once, however many runs share it. Once what separates them
+  // passes MARK_CHAIN_CONTEXT_UNITS, the context keeps the grapheme and the fewest of the
+  // chain's last runs, each with the separators before it, that hold at least that many
+  // units: in Chrome, Safari and Firefox, runs of 1 to 400 marks then measure as they do
+  // after the whole chain, to 0.002px, and without the grapheme some took 25px less
+  // (RESEARCH.md, Break Opportunities From Engine Data).
+  let markRunIndex = -1
+  let markBaseStart = -1 // where that run's grapheme starts in the normalized text, or -1
+  let markChainStart = -1 // the segment after that grapheme
+  let markChainKept = -1 // the first segment of the chain the context keeps
+  // Asked only for a text segment no break comes before.
+  function getMarkContext(analysisIndex        , text        )                {
+    if (!markRunRe.test(text)) return null
+    let baseStart = -1
+    for (let k = analysisIndex - 1; k >= from; k--) {
+      const kind = flags[k]  & KIND_BITS
+      const start = starts[k] 
+      const end = starts[k + 1] 
+      if (kind === ZERO_WIDTH_GLUE || ((kind === TEXT || kind === CONTROL) && controlOrMarkRunRe.test(texts[k] ))) {
+        if (k !== markRunIndex) continue
+        baseStart = markBaseStart
+      } else if (kind === TEXT) {
+        const ends = new Int32Array(end - start)
+        const count = findGraphemeEnds(engineProfile.graphemeTable, normalized, start, end, ends)
+        baseStart = count > 1 ? ends[count - 2]  : start
+        markChainStart = markChainKept = k + 1
+      }
+      break
+    }
+    markRunIndex = analysisIndex
+    markBaseStart = baseStart
+    if (baseStart < 0) return null
+    const start = starts[analysisIndex] 
+    if (start - baseStart <= MARK_CHAIN_CONTEXT_UNITS) return normalized.slice(baseStart, start)
+    // The kept part starts after the grapheme or a run of marks, moves only forward and
+    // never holds fewer than MARK_CHAIN_CONTEXT_UNITS.
+    for (let k = markChainKept + 1; start - starts[k]  >= MARK_CHAIN_CONTEXT_UNITS; k++) {
+      if (markRunRe.test(texts[k - 1] )) markChainKept = k
+    }
+    if (markChainKept === markChainStart) return normalized.slice(baseStart, start)
+    return normalized.slice(baseStart, starts[markChainStart]) + normalized.slice(starts[markChainKept], start)
+  }
+
+  // The font's kerning with the space where words take Blink's kerning with the spaces beside
+  // them, or null. Blink shapes nothing across a change of direction
+  // (ShouldBreakShapingBeforeText, inline_node.cc:472-490), and which spaces share a word's
+  // direction depends on the paragraph's, which preparation can't see, so text with a
+  // right-to-left letter or an explicit bidi control takes none.
+  let fontSpaceKerning = engineProfile.kernsSpacesInScriptRun && own.includes(' ') ? getFontSpaceKerning(fontMeasurement) : null
+  if (fontSpaceKerning !== null && mixedDirectionRe.test(own)) fontSpaceKerning = null
+  const scriptRuns             = { read: 0, scripts: ANY_SCRIPT, openBrackets: [] }
+  // What the word before a space adds to that space, the next segment.
+  let spaceShare = 0
+
+  // Whether the text may hold graphemes that take no letter spacing in this engine.
+  const cursiveSpacing = hasLetterSpacing && engineProfile.unspacedCursive !== 'none' && mayHoldCursive(own)
+
+  // Text of the simple walkers' kinds without letter spacing. They lay it out where
+  // the scan breaks at every segment boundary, and layout() counts it with the
+  // simple stepper where it doesn't (countPreparedLines).
+  let simpleKinds = !hasLetterSpacing
+  let entryGeometry                                         = null
+  let lineStartProhibitions                               = null
+  let breakableLineStartExtras                             = null
+  // WebKit's line-start rule applies only in text holding a code unit above U+00FF.
+  const keepsLineStartPunctuation = engineProfile.keepsLineStartPunctuation && /[\u0100-\uFFFF]/.test(own)
+  let discretionaryHyphenContexts                  = null
+  let previousJoinablePiece                = null
+  let previousJoinableMetrics                        = null
+
+  // Pieces split by a soft hyphen are measured apart, but Blink and Gecko shape
+  // the unbroken text together: cursive joins, marks and kerning across the soft
+  // hyphen. Canvas shows how much narrower the neighbors measure joined than
+  // apart, which isolated widths can't show when proving that a hyphen overflows.
+  // WebKit's return fits each side as measured alone and takes none (unfitHyphenRetreat).
+  const returnFitsEachSideAlone = engineProfile.unfitHyphenRetreat === 'full-width-or-first'
+  function getJoinedNarrowing(analysisIndex        , before               , beforeMetrics                       )         {
+    if (before === null) return 0
+    let next = analysisIndex + 1
+    while (next < to && (flags[next]  & KIND_BITS) === SOFT_HYPHEN) next++
+    if (next >= to || (flags[next]  & KIND_BITS) !== TEXT) return 0
+    const after = texts[next] 
+    const apart = getCorrectedSegmentWidth(before, beforeMetrics , fontMeasurement, emojiCorrection) + getTextWidth(after, fontMeasurement, emojiCorrection)
+    const together = getTextWidth(before + after, fontMeasurement, emojiCorrection)
+    return apart - together > engineProfile.lineFitEpsilon ? apart - together : 0
+  }
+
+  function getEntryGeometry(text        , fit            , width        , fitBasis                      )                              {
+    // The fit fixes the text, font and advances, and Pretext sets no other context state.
+    // The WebKit profile moves the advances by a following space, and it observes no
+    // entries; the Chromium profile's kerning with a space is in the width alone, which
+    // its fresh entries don't read.
+    const cached = fit.entryGeometry
+    if (cached !== null && cached.letterSpacing === letterSpacing && cached.emojiCorrection === emojiCorrection) return cached.geometry
+    const geometry = observeSegmentEntries(text, fit.advances , letterSpacing, width, fitBasis,
+      source => measureWithLetterSpacing(source, letterSpacing, emojiCorrection, fontMeasurement))
+    // Replacing this last observation leaves prepared copies intact.
+    fit.entryGeometry = { letterSpacing, emojiCorrection, geometry }
+    return geometry
+  }
+
+  // A text segment's width as measured: alone, or together with the following space less
+  // that space, plus the item's kerning with a space that follows zero-width breaks. Apart
+  // from the loop below, whose code JavaScriptCore otherwise never optimizes fully on CJK
+  // text (RESEARCH.md, Keeping Work Bounded).
+  function getTextSegmentWidth(text        , textMetrics                , measuredWithSpace         , followingSpaceKerning        )         {
+    return getCorrectedSegmentWidth(text, textMetrics, fontMeasurement, emojiCorrection) - (measuredWithSpace ? spaceWidth : 0) + followingSpaceKerning
+  }
+
+  // Each segment is stored at its index: `at` in the text's or the paragraph's three lists,
+  // `mi - from` in the lists of the measured segments alone. Stored and not pushed, for V8:
+  // once it has deoptimized at a push onto a paragraph's list, it compiles that push as a call
+  // from then on, for texts too. With stores Chrome 154 prepares plain text again 4-9% faster
+  // than with pushes on a page of mostly plain text whose first rich paragraphs are short, and
+  // they cost about 1% of preparing a text again in Safari 27, 1.9% at most in one run
+  // (RESEARCH.md, Keeping Work Bounded, JavaScript Engines, under A list made where it is
+  // filled; Decisions Log, 2026-10-09, a paragraph's lists).
+  for (let mi = from, at = base; mi < to; mi++, at++) {
+    const text = texts[mi] 
+    const segment = flags[mi] 
+    const kind = (segment & KIND_BITS)                   
+    let width = 0
+    // Graphemes that take letter spacing after them.
+    let spacingGraphemeCount = 0
+    let fitAdvances                  = null
+    let entry                              = null
+    let prohibitions                    = null
+    switch (kind) {
+      case TEXT: {
+        // A control the engine hides takes no advance, only letter spacing.
+        if (engineProfile.hidesControlCharacters && controlCharacterRe.test(text)) {
+          spacingGraphemeCount = 1
+          break
+        }
+        // Such a run of marks adds its context with the marks, minus the context, and
+        // takes no letter spacing of its own. Only a segment no break comes before can be
+        // one, and the test is here so that the others make no call: with it Chrome 154
+        // prepares CJK text again 2.6% faster than with a call for every text segment, which
+        // V8 didn't inline (RESEARCH.md, Keeping Work Bounded, JavaScript Engines, under V8's
+        // inlining budgets and the mark context).
+        const markContext = (segment & UNBROKEN) === 0 ? null : getMarkContext(mi, text)
+        if (markContext !== null) {
+          width = engineProfile.shapesMarksAcrossSoftHyphen && texts[mi - 1] === '\u00AD' && nonspacingMarkRunRe.test(text)
+            ? 0
+            : getTextWidth(markContext + text, fontMeasurement, emojiCorrection) - getTextWidth(markContext, fontMeasurement, emojiCorrection)
+          break
+        }
+        // With an empty following-space tail, the text is measured together with the
+        // space; with a zero-width tail, the item's kerning is added.
+        const followingSpaceTail = getFollowingSpaceTail(mi, text)
+        const measuredWithSpace = followingSpaceTail === ''
+        const textMetrics = getTextMetrics(text, followingSpaceTail)
+        previousJoinablePiece = text
+        previousJoinableMetrics = textMetrics
+        let followingSpaceKerning = followingSpaceTail === null || measuredWithSpace ? 0 : getTailKerning(text + followingSpaceTail)
+        if (fontSpaceKerning !== null && textMetrics.spaceKerning !== noSpaceKerning) {
+          const spaceBefore = mi > from && isSpaceKind(flags[mi - 1]  & KIND_BITS)
+          const spaceAfter = mi + 1 < to && isSpaceKind(flags[mi + 1]  & KIND_BITS)
+          if (spaceBefore || spaceAfter) {
+            const kerning = textMetrics.spaceKerning ?? getSpaceKerning(text, textMetrics, fontMeasurement, fontSpaceKerning)
+            if (spaceAfter) {
+              // Premise: a kerning that tightens the word and the space after it goes on the
+              // space, which hangs, so a line that ends there has the word without it, as in
+              // Blink under a text-align other than start and for text whose element has a
+              // decoration or a background (NeedsAccurateEndPosition, line_breaker.cc:255-268).
+              // One that widens stays on the word, whose end Blink finds in the run shaped
+              // whole. In other text a line's last word is wider here than there by the
+              // kerning, never narrower (RESEARCH.md, Kerning At Line Edges).
+              followingSpaceKerning = Math.max(kerning.after, 0)
+              spaceShare = Math.min(kerning.after, 0)
+            }
+            // The space takes its kerning with this word, and takes it along where it hangs: a
+            // line that breaks between the two is shaped again without it
+            // (shaping_line_breaker.cc:307-324). Preserved spaces that start the text or follow
+            // a forced break are a Blink item of their own (inline_items_builder.cc:988-1034),
+            // which kerns with nothing.
+            if (spaceBefore && kerning.before !== 0 &&
+              !((flags[mi - 1]  & KIND_BITS) === PRESERVED_SPACE && (mi === from + 1 || (flags[mi - 2]  & KIND_BITS) === HARD_BREAK)) &&
+              spaceSharesScriptRun(scriptRuns, own, starts[mi]  - ownStart, starts[mi]  - ownStart + text.length)) {
+              widths[at - 1] = widths[at - 1]  + kerning.before
+            }
+          }
+        }
+        width = getTextSegmentWidth(text, textMetrics, measuredWithSpace, followingSpaceKerning)
+        // The walkers put a gap after every grapheme of a spaced segment, so a grapheme
+        // the engine gives none takes one back from its advance, here and in the advances
+        // a break inside the segment falls by.
+        let unspaced                  = null
+        if (hasLetterSpacing) {
+          spacingGraphemeCount = countRenderedSpacingGraphemes(text, kind, engineProfile.graphemeTable)
+          if (cursiveSpacing) {
+            unspaced = getUnspacedGraphemes(own, starts[mi]  - ownStart, starts[mi]  - ownStart + text.length, engineProfile.graphemeTable, engineProfile.unspacedCursive === 'run' ? scriptRuns : null)
+            if (unspaced !== null) width -= unspaced.length * letterSpacing
+          }
+        }
+        // Under break-word, Blink retries an overflowing line with a break allowed between
+        // any two graphemes (line_breaker.cc), WebKit searches the word's grapheme prefixes
+        // (TextUtil::breakWord) and Gecko may wrap before any cluster (gfxTextRun.cpp:1069-1072),
+        // so every text segment takes emergency grapheme breaks, unless it is one Gecko cluster
+        // or an atomic item's.
+        if (!overflowBreaks || (segment & ONE_CLUSTER) !== 0 || text.length === 1) break
+        const fitMode                   = letterSpacing !== 0 ? 'segment-prefixes'
+          : numericRunRe.test(text) ? 'pair-context'
+          : textMetrics.width < engineProfile.prefixFitMinWidth ? 'sum-graphemes'
+          : engineProfile.cutWordFit
+        const fit = getSegmentFit(text, textMetrics, fontMeasurement, emojiCorrection, fitMode,
+          measuredWithSpace ? spaceWidth : null, engineProfile.keepsLineStartPunctuation)
+        fitAdvances = fit.advances
+        if (fitAdvances === null) break
+        // A difference from the advance, so it holds whatever the advances take below.
+        if (fit.lineStartExtras !== null) (breakableLineStartExtras ??= new Array                 (to - from).fill(null))[mi - from] = fit.lineStartExtras
+        // The cached advances are shared by every occurrence of this text; only
+        // the final grapheme touches the following space.
+        if (followingSpaceKerning !== 0) {
+          fitAdvances = fitAdvances.slice()
+          fitAdvances[fitAdvances.length - 1] = fitAdvances[fitAdvances.length - 1]  + followingSpaceKerning
+        }
+        // Such a segment takes no entry geometry, whose fresh widths Canvas would space
+        // by its own rule (ENGINE_FOLLOWUPS.md, Letter spacing).
+        if (unspaced !== null) {
+          fitAdvances = fitAdvances.slice()
+          for (let k = 0; k < unspaced.length; k++) fitAdvances[unspaced[k] ] = fitAdvances[unspaced[k] ]  - letterSpacing
+        } else if (entryFitBasis !== 'disabled') {
+          entry = getEntryGeometry(text, fit, addInternalLetterSpacing(width, spacingGraphemeCount, letterSpacing), entryFitBasis)
+        }
+        if (keepsLineStartPunctuation) prohibitions = fit.lineStartProhibitions
+        break
+      }
+      case SPACE:
+      case PRESERVED_SPACE:
+      case ZERO_WIDTH_BREAK:
+        width = getTextWidth(text, fontMeasurement, emojiCorrection) + spaceShare
+        spaceShare = 0
+        if (hasLetterSpacing) spacingGraphemeCount = countRenderedSpacingGraphemes(text, kind, engineProfile.graphemeTable)
+        break
+      case TAB:
+        if (engineProfile.letterSpaceTabs) spacingGraphemeCount = 1
+        if (minimumTabAdvance === 0) minimumTabAdvance = getTextWidth(engineProfile.tabMinimumCharacter, fontMeasurement, emojiCorrection) / 2
+        break
+      case CONTROL: {
+        width = getTextWidth(text, fontMeasurement, emojiCorrection)
+        // NEL shares a WebKit text item with the text before it and with
+        // combining marks after it, and the complex text path spaces it. Complex
+        // text shares the item only when its direction matches the page's, which
+        // preparation cannot see, so NEL next to complex text keeps its spacing.
+        const nextText = mi + 1 < to ? texts[mi + 1]  : ''
+        if (hasLetterSpacing && (
+          (mi > from && (flags[mi - 1]  & KIND_BITS) === TEXT && needsComplexTextPath(texts[mi - 1] )) ||
+          (leadingCombiningMarkRe().test(nextText) && needsComplexTextPath(nextText))
+        )) spacingGraphemeCount = 1
+        break
+      }
+      case SOFT_HYPHEN:
+      case ZERO_WIDTH_GLUE:
+      case HARD_BREAK:
+        break
+    }
+    if (kind !== TEXT && kind !== SPACE && kind !== ZERO_WIDTH_BREAK) simpleKinds = false
+    if (kind !== TEXT && kind !== SOFT_HYPHEN) previousJoinablePiece = null
+    segmentFlags[at] = (segment & ~ONE_CLUSTER) | (hasLetterSpacing && spacingGraphemeCount > 0 ? SPACED : 0)
+    widths[at] = addInternalLetterSpacing(width, spacingGraphemeCount, letterSpacing)
+    breakableFitAdvances[at] = fitAdvances
+    if (entry !== null && entryGeometry === null) entryGeometry = Array.from({ length: mi - from }, () => null)
+    if (entryGeometry !== null) entryGeometry[mi - from] = entry
+    if (prohibitions !== null && lineStartProhibitions === null) lineStartProhibitions = Array.from({ length: mi - from }, () => null)
+    if (lineStartProhibitions !== null) lineStartProhibitions[mi - from] = prohibitions
+    if (segments !== null) segments[mi - from] = text
+    // Contexts for every segment of soft hyphens, whatever its kind here, one that is glue
+    // too, where the scan gives no break after it: a handle with contexts is one whose lines
+    // return from an unfit hyphen, measured below.
+    if (kind !== TEXT && text.charCodeAt(0) === 0xAD) {
+      discretionaryHyphenContexts ??= zeros(mi - from)
+      discretionaryHyphenContexts[mi - from] = returnFitsEachSideAlone ? 0 : getJoinedNarrowing(mi, previousJoinablePiece, previousJoinableMetrics)
+    } else if (discretionaryHyphenContexts !== null) {
+      discretionaryHyphenContexts[mi - from] = 0
+    }
+  }
+
+  // The hyphen a chosen soft hyphen paints, which only a text that holds one asks for, with
+  // the gap before it, plus the hyphen's own spacing where the engine letter-spaces it.
+  const hyphenText = paragraphHyphen ?? (discretionaryHyphenContexts === null ? '-' : engineProfile.hyphenFromPrimaryFont ? getHyphenText(fontMeasurement) : '\u2010')
+  const discretionaryHyphenWidth = getTextWidth(hyphenText, fontMeasurement, emojiCorrection) +
+    (letterSpacing === 0 ? 0 : letterSpacing * (engineProfile.letterSpaceDiscretionaryHyphen ? 2 : 1))
+
+  // A segment's width is its width between the text before and after it; one that starts
+  // a line takes back the halt Blink gives its first character there.
+  let hanKerning                  = { widthTrims: null, lineStartExtras: null, lineEndTrims: null, overflowLineEndTrims: null }
+  if (engineProfile.hanKerning && textMayHanKern(own)) {
+    hanKerning = getHanKerningTrims(fontMeasurement, analysis, from, to)
+    const trims = hanKerning.widthTrims
+    if (trims !== null) for (let i = 0; i < trims.length; i++) widths[base + i] = widths[base + i]  - trims[i] 
+  }
+  let lineEndTrims = hanKerning.lineEndTrims
+  if (engineProfile.hangsIdeographicSpace && own.includes('\u3000')) {
+    lineEndTrims = addIdeographicSpaceHangs(lineEndTrims, analysis, fontMeasurement, letterSpacing, discretionaryHyphenWidth, from, to)
+  }
+  const prepared = {
+    widths,
+    segmentFlags,
+    simpleLineWalkFastPath: simpleKinds && !analysis.hasUnbroken,
+    simpleLineCountFastPath: simpleKinds,
+    breakableFitAdvances,
+    entryGeometry,
+    letterSpacing,
+    discretionaryHyphenWidth,
+    discretionaryHyphenContexts,
+    lineStartProhibitions,
+    breakableLineStartExtras,
+    lineStartExtras: hanKerning.lineStartExtras,
+    lineEndTrims,
+    overflowLineEndTrims: hanKerning.overflowLineEndTrims,
+    tabStopAdvance,
+    minimumTabAdvance,
+  }                                                                              
+  if (segments !== null) prepared.segments = segments
+  return prepared
+}
+
+// Blink (Chrome 153) hangs a run of U+3000 that ends a line, as it hangs spaces: ShapingLineBreaker
+// counts U+3000 as a breakable space (IsBreakableSpace, shaping_line_breaker.cc:38-41, with
+// Character::IsOtherSpaceSeparator, character.h:156-158), so a line whose width runs out on
+// the run ends after it and fits without it (shaping_line_breaker.cc:384-452), and the line
+// breaker keeps the run as trailing space (HandleTrailingSpaces, line_breaker.cc:2447-2514),
+// in normal and pre-wrap white space alike. A text segment that ends in such a run, where a
+// line can end after it or a collapsible space follows, which hangs with it, drops the run
+// and its letter spacing at a line end. The line then ends where the run starts
+// (shaping_line_breaker.cc:490-493), so after a soft hyphen it ends with a hyphen
+// (SetBreakOffset, shaping_line_breaker.cc:212-216), which has to fit. Gecko (Firefox 156)
+// marks U+3000 as a space glyph, like SPACE (SetupClusterBoundaries, gfxFont.cpp:749-750), and
+// BreakAndMeasureText fits a line without its trailing space glyphs (gfxTextRun.cpp:1152-1160,
+// 1175), so Firefox hangs the run too. `trims` holds segments [from, to) of the analysis, a
+// rich-inline item's in its paragraph's, from index 0. A run that ends an item hangs whatever
+// the next item starts with, as the engines hang it wherever a line ends; a text's run before
+// a ZWSP, a soft hyphen or a character no line starts with doesn't yet (ENGINE_FOLLOWUPS.md,
+// Line edges).
+function addIdeographicSpaceHangs(
+  trims                 ,
+  analysis              ,
+  measurement                 ,
+  letterSpacing        ,
+  hyphenWidth        ,
+  from        ,
+  to        ,
+)                  {
+  const { normalized, starts, flags } = analysis
+  for (let i = from; i < to; i++) {
+    const end = i + 1 < flags.length ? starts[i + 1]  : normalized.length
+    if ((flags[i]  & KIND_BITS) !== TEXT || normalized.charCodeAt(end - 1) !== 0x3000) continue
+    if (i + 1 < to) {
+      const next = flags[i + 1]  & KIND_BITS
+      if (next !== HARD_BREAK && next !== SPACE && !(next === TEXT && (flags[i + 1]  & UNBROKEN) === 0)) continue
+    }
+    let start = end - 1
+    while (start > starts[i]  && normalized.charCodeAt(start - 1) === 0x3000) start--
+    const run = normalized.slice(start, end)
+    const afterSoftHyphen = i > 0 && start === starts[i] && normalized.charCodeAt(start - 1) === 0xAD
+    const hang = getSegmentMetrics(run, measurement).width + run.length * letterSpacing - (afterSoftHyphen ? hyphenWidth : 0)
+    if (hang <= 0) continue
+    trims ??= zeros(to - from)
+    trims[i - from] = trims[i - from]  + hang
+  }
+  return trims
+}