@weasel-js/core 1.9.3 → 1.10.0

package/dist/features/text/domRuns.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"domRuns.js","names":["solidColor","p","TRANSFORMS","EMPTY_STYLE","parseLetterSpacing","n","raw","unit","isSmallCapsPiece","el","cssFontVariant","v","styleStateFromElement","parent","next","tag","fw","ownWeight","fs","td","size","va","rawShift","shift","tt","fv","family","ls","px","styleEquals","a","b","toRun","run","style","BREAK_ATTR","restoreBreak","text","code","appendOverlayText","from","c","isHardLineBreak","span","domToRuns","fragments","visit","node","restored","nextStyle","child","runs","j","merged","f","SMALL_CAPS_SCALE_PROPERTY","smallCapsPieces","shown","transformRunTexts","transform","caps","smallCapsText","small","s","i","out","at","ch","last","writeSmallCaps","piece","SMALL_CAPS_SCALE","runsToDom","DEFAULT_TEXT_STYLE","base","scale","smallCapsScaleFor","numericWeight","cssFontFamily","color","decorations","sourceText","piecesMatch","want","have","normalizeSmallCaps","changed","variant","t","charOffsetToDomPosition","remaining","offset","walker","len","domPositionToCharOffset","total","cur","point"],"sources":["../../../src/features/text/domRuns.ts"],"sourcesContent":["/**\n * Pure DOM ↔ `StyledRun[]` serializers for the contenteditable overlay\n * used by `useTextEdit`. The overlay's children are a flat sequence of\n * `<span data-run>` elements, each carrying one run's text and inline\n * styles. Newlines inside a run are literal `\\n` characters; the overlay\n * has `white-space: pre-wrap` so they render as line breaks. The browser\n * breaks at no other UAX #14 hard break, so each of those is written as a\n * `<span data-break>` holding a `\\n` in its place — one character for one,\n * which keeps DOM offsets equal to source offsets.\n *\n * A small-caps run is the one exception to one text node per span: its\n * lowercase letters sit in `<span data-small-caps>` pieces, uppercased and\n * sized at the scale the canvas draws them with, since a browser's own\n * synthesis uses a fixed factor of its own. The pieces are presentation\n * only — `domToRuns` reads straight through them.\n */\n\nimport type { FillStyle } from '@weasel-js/paint';\nimport {\n  DEFAULT_TEXT_STYLE, isHardLineBreak, numericWeight, smallCapsScaleFor, smallCapsText, transformRunTexts,\n  SMALL_CAPS_SCALE,\n  type FontVariantCaps, type ResolvedTextStyle, type StyledRun, type TextTransform,\n} from '@weasel-js/text';\nimport { cssFontFamily } from '@weasel-js/font';\n\nfunction solidColor(p: FillStyle | undefined): string | null {\n  if (!p) return null;\n  if ('color' in p) return p.color;\n  return null;\n}\n\ninterface StyleState {\n  bold: boolean;\n  italic: boolean;\n  underline: boolean;\n  strikethrough: boolean;\n  overline: boolean;\n  fontWeight?: number;\n  fontSize?: number;\n  fontFamily?: string;\n  color?: string;\n  letterSpacing?: number;\n  script?: 'super' | 'sub';\n  baselineShift?: number;\n  fontScale?: number;\n  textTransform?: TextTransform;\n  fontVariantCaps?: FontVariantCaps;\n}\n\nconst TRANSFORMS: ReadonlySet<string> = new Set(['none', 'uppercase', 'lowercase', 'capitalize']);\n\nconst EMPTY_STYLE: StyleState = {\n  bold: false,\n  italic: false,\n  underline: false,\n  strikethrough: false,\n  overline: false,\n};\n\n/**\n * Parse a CSS `letter-spacing` value into world units. `runsToDom` only ever\n * writes `px`, but paste is a live path into the contenteditable and CSSOM\n * keeps whatever unit the pasted markup used. Any other unit is still\n * numerically coerced — `parseFloat` reads the leading digits — but flagged,\n * since e.g. `0.1em` silently becomes `0.1` world units, off by a factor of\n * the font size. Mirrors `parseLetterSpacing` in the SVG reader.\n */\nfunction parseLetterSpacing(raw: string): number | undefined {\n  const n = parseFloat(raw);\n  if (!Number.isFinite(n)) return undefined;\n  const unit = /^-?[\\d.]+([a-z%]+)$/i.exec(raw.trim())?.[1]?.toLowerCase();\n  if (unit && unit !== 'px') {\n    console.warn(\n      `weasel domRuns: letter-spacing \"${raw}\" uses unit \"${unit}\", which is not converted; treated as ${n} world units`,\n    );\n  }\n  return n;\n}\n\n/** A small-caps piece is presentation `runsToDom` split a run into, not styling. */\nconst isSmallCapsPiece = (el: Element): boolean => el.hasAttribute('data-small-caps');\n\n/** The element's own `font-variant`, from the shorthand or the caps longhand\n *  pasted markup may carry alone. */\nfunction cssFontVariant(el: HTMLElement): FontVariantCaps | undefined {\n  const v = el.style.fontVariant || el.style.getPropertyValue('font-variant-caps');\n  return v === 'small-caps' || v === 'normal' ? v : undefined;\n}\n\nfunction styleStateFromElement(el: Element, parent: StyleState): StyleState {\n  if (isSmallCapsPiece(el)) return parent;\n  const next: StyleState = { ...parent };\n  const tag = el.tagName;\n  if (tag === 'B' || tag === 'STRONG') {\n    next.bold = true;\n    next.fontWeight = undefined;\n  }\n  if (tag === 'I' || tag === 'EM') next.italic = true;\n  // `runsToDom` never emits these, but a browser contenteditable can (Cmd+U\n  // runs the native `underline` command, which produces `<u>` in Chrome), so\n  // read them for the same reason `<b>`/`<i>` are read.\n  if (tag === 'U') next.underline = true;\n  if (tag === 'S' || tag === 'STRIKE' || tag === 'DEL') next.strikethrough = true;\n  if (tag === 'SUP') next.script = 'super';\n  if (tag === 'SUB') next.script = 'sub';\n  if (el instanceof HTMLElement) {\n    // 700 and 400 are the bold flag on and off, which is what pasted markup\n    // means by them. A run's own weight is written with an attribute beside\n    // the CSS, so a stored 400 or 700 comes back as the weight it was.\n    const fw = el.style.fontWeight;\n    const ownWeight = Number(el.getAttribute('data-font-weight') ?? fw);\n    if (el.hasAttribute('data-font-weight') || !['', '700', 'bold', '400', 'normal'].includes(fw)) {\n      if (Number.isFinite(ownWeight) && ownWeight > 0) {\n        next.fontWeight = ownWeight;\n        next.bold = false;\n      }\n    } else if (fw !== '') {\n      next.bold = fw === '700' || fw === 'bold';\n      next.fontWeight = undefined;\n    }\n    const fs = el.style.fontStyle;\n    if (fs === 'italic') next.italic = true;\n    if (fs === 'normal') next.italic = false;\n    // Decoration accumulates down the tree — unlike `font-weight`/`font-style`\n    // above, `text-decoration` does not inherit, it *propagates*, and a\n    // descendant cannot cancel what an ancestor drew. So OR the flags in\n    // rather than overwriting: `<u><span style=\"text-decoration: line-through\">`\n    // renders both lines, and that is a reachable shape here, since `runsToDom`\n    // emits the span and an unintercepted Cmd+U supplies the `<u>`. An explicit\n    // `none` contributes no tokens and cancels nothing.\n    //\n    // A declaration block carrying only the longhand serializes the shorthand\n    // as `''` (the shorthand needs the full set), and browsers and pasted HTML\n    // both produce that, so fall back to `text-decoration-line`.\n    const td = el.style.textDecoration || el.style.textDecorationLine;\n    if (td && !td.includes('none')) {\n      next.underline ||= td.includes('underline');\n      next.strikethrough ||= td.includes('line-through');\n      next.overline ||= td.includes('overline');\n    }\n    // A percentage is `fontScale`'s own spelling — CSS resolves it against the\n    // parent, which is exactly what the field means. Any other unit is an\n    // absolute size.\n    if (el.style.fontSize) {\n      const size = parseFloat(el.style.fontSize);\n      if (Number.isFinite(size)) {\n        if (el.style.fontSize.trim().endsWith('%')) next.fontScale = size / 100;\n        else next.fontSize = size;\n      }\n    }\n    const va = el.style.verticalAlign;\n    if (va === 'super' || va === 'sub') next.script = va === 'super' ? 'super' : 'sub';\n    if (va === 'baseline') next.script = undefined;\n    const rawShift = el.getAttribute('data-baseline-shift');\n    if (rawShift != null) {\n      const shift = parseFloat(rawShift);\n      if (Number.isFinite(shift)) next.baselineShift = shift;\n    }\n    const tt = el.style.textTransform;\n    if (TRANSFORMS.has(tt)) next.textTransform = tt as TextTransform;\n    const fv = cssFontVariant(el);\n    if (fv) next.fontVariantCaps = fv;\n    // The attribute holds the run's family; the CSS holds the face it maps to.\n    const family = el.getAttribute('data-font-family') ?? el.style.fontFamily;\n    if (family) next.fontFamily = family;\n    if (el.style.color) next.color = el.style.color;\n    const ls = el.style.letterSpacing;\n    if (ls === 'normal') {\n      next.letterSpacing = undefined;\n    } else if (ls) {\n      const px = parseLetterSpacing(ls);\n      if (px != null) next.letterSpacing = px;\n    }\n  }\n  return next;\n}\n\nfunction styleEquals(a: StyleState, b: StyleState): boolean {\n  return (\n    a.bold === b.bold &&\n    a.italic === b.italic &&\n    a.underline === b.underline &&\n    a.strikethrough === b.strikethrough &&\n    a.overline === b.overline &&\n    a.fontWeight === b.fontWeight &&\n    a.fontSize === b.fontSize &&\n    a.fontFamily === b.fontFamily &&\n    a.color === b.color &&\n    a.letterSpacing === b.letterSpacing &&\n    a.script === b.script &&\n    a.baselineShift === b.baselineShift &&\n    a.fontScale === b.fontScale &&\n    a.textTransform === b.textTransform &&\n    a.fontVariantCaps === b.fontVariantCaps\n  );\n}\n\nfunction toRun(text: string, style: StyleState): StyledRun {\n  const run: StyledRun = { text };\n  if (style.bold) run.bold = true;\n  if (style.italic) run.italic = true;\n  if (style.fontWeight != null) run.fontWeight = style.fontWeight;\n  if (style.fontSize != null) run.fontSize = style.fontSize;\n  if (style.fontFamily != null) run.fontFamily = style.fontFamily;\n  if (style.color != null) run.fill = { fill: 'solid', color: style.color };\n  // `letterSpacing: 0` is a meaningful override (it cancels node-level\n  // tracking for this run), so test for presence, not truthiness.\n  if (style.letterSpacing != null) run.letterSpacing = style.letterSpacing;\n  // Run-level flags are additive over the node style — a run cannot un-set\n  // one — so an undecorated run gets an absent key, never `false`.\n  if (style.underline) run.underline = true;\n  if (style.strikethrough) run.strikethrough = true;\n  if (style.overline) run.overline = true;\n  if (style.script != null) run.script = style.script;\n  // Both are meaningful at values that test falsy — a 0 shift cancels an\n  // inherited script's rise — so test for presence, as `letterSpacing` does.\n  if (style.baselineShift != null) run.baselineShift = style.baselineShift;\n  if (style.fontScale != null) run.fontScale = style.fontScale;\n  if (style.textTransform != null) run.textTransform = style.textTransform;\n  if (style.fontVariantCaps != null) run.fontVariantCaps = style.fontVariantCaps;\n  return run;\n}\n\nconst BREAK_ATTR = 'data-break';\n\n/** A break stand-in's source text: its hard break, and anything typed into it after. */\nfunction restoreBreak(el: Element): string {\n  const text = el.textContent ?? '';\n  const code = parseInt(el.getAttribute(BREAK_ATTR) ?? '', 16);\n  return text.startsWith('\\n') && Number.isFinite(code) ? String.fromCharCode(code) + text.slice(1) : text;\n}\n\n/**\n * Append `text` to `parent` as the overlay sets it: a hard break the browser\n * would not break at becomes a `<span data-break>` holding a `\\n`, carrying\n * the original's code as hex for `domToRuns` to restore. A CR that opens a\n * CRLF is left as it is — the LF breaks, and the CR draws nothing.\n */\nexport function appendOverlayText(parent: Node, text: string): void {\n  let from = 0;\n  for (let i = 0; i < text.length; i++) {\n    const c = text.charCodeAt(i);\n    if (c === 10 || !isHardLineBreak(c) || (c === 13 && text.charCodeAt(i + 1) === 10)) continue;\n    if (i > from) parent.appendChild(document.createTextNode(text.slice(from, i)));\n    const span = document.createElement('span');\n    span.setAttribute(BREAK_ATTR, c.toString(16));\n    span.textContent = '\\n';\n    parent.appendChild(span);\n    from = i + 1;\n  }\n  if (from < text.length) parent.appendChild(document.createTextNode(text.slice(from)));\n}\n\n/** Walk an overlay tree and emit a coalesced `StyledRun[]`. */\nexport function domToRuns(parent: HTMLElement): StyledRun[] {\n  const fragments: Array<{ text: string; style: StyleState }> = [];\n\n  function visit(node: Node, style: StyleState): void {\n    if (node.nodeType === Node.TEXT_NODE) {\n      const text = (node as Text).data;\n      if (text.length > 0) fragments.push({ text, style });\n      return;\n    }\n    if (node.nodeType !== Node.ELEMENT_NODE) return;\n    const el = node as Element;\n    if (el.tagName === 'BR') {\n      fragments.push({ text: '\\n', style });\n      return;\n    }\n    if (el.hasAttribute(BREAK_ATTR)) {\n      const restored = restoreBreak(el);\n      if (restored.length > 0) fragments.push({ text: restored, style });\n      return;\n    }\n    if (el.tagName === 'DIV' && fragments.length > 0) {\n      fragments.push({ text: '\\n', style });\n    }\n    const nextStyle = styleStateFromElement(el, style);\n    for (const child of Array.from(el.childNodes)) {\n      visit(child, nextStyle);\n    }\n  }\n\n  for (const child of Array.from(parent.childNodes)) {\n    visit(child, EMPTY_STYLE);\n  }\n\n  // Coalesce adjacent fragments with identical style.\n  const runs: StyledRun[] = [];\n  let i = 0;\n  while (i < fragments.length) {\n    let j = i + 1;\n    while (j < fragments.length && styleEquals(fragments[i].style, fragments[j].style)) {\n      j++;\n    }\n    const merged = fragments.slice(i, j).map((f) => f.text).join('');\n    runs.push(toRun(merged, fragments[i].style));\n    i = j;\n  }\n  return runs;\n}\n\n/** What a run inherits from its node, for the overlay's small caps: which\n *  runs have it, and the face and transform that decide their pieces. */\nexport type OverlayRunBase = Pick<\n  ResolvedTextStyle, 'fontFamily' | 'fontWeight' | 'fontStyle' | 'textTransform' | 'fontVariantCaps'\n>;\n\n/** The custom property carrying a small-caps run's scale down to its pieces. */\nexport const SMALL_CAPS_SCALE_PROPERTY = '--weasel-small-caps';\n\n/** A run's source text cut where small caps changes size, per `smallCapsText`\n *  over the text as `transform` draws it. */\nfunction smallCapsPieces(text: string, transform: TextTransform): Array<{ text: string; small: boolean }> {\n  const [shown] = transformRunTexts([text], [transform]);\n  const caps = smallCapsText(shown.text, shown.srcMap);\n  const small = new Array<boolean>(text.length).fill(false);\n  caps.small?.forEach((s, i) => {\n    if (s) small[caps.srcMap ? caps.srcMap.starts[i] : i] = true;\n  });\n  const out: Array<{ text: string; small: boolean }> = [];\n  let at = 0;\n  for (const ch of text) {\n    const last = out[out.length - 1];\n    if (last && last.small === small[at]) last.text += ch;\n    else out.push({ text: ch, small: small[at] });\n    at += ch.length;\n  }\n  return out;\n}\n\n/** Replace `span`'s children with `text`, its small-caps letters in pieces. */\nfunction writeSmallCaps(span: HTMLElement, text: string, transform: TextTransform): void {\n  span.replaceChildren();\n  for (const p of smallCapsPieces(text, transform)) {\n    if (!p.small) { appendOverlayText(span, p.text); continue; }\n    const piece = document.createElement('span');\n    piece.setAttribute('data-small-caps', '');\n    piece.style.fontSize = `calc(var(${SMALL_CAPS_SCALE_PROPERTY}, ${SMALL_CAPS_SCALE}) * 1em)`;\n    piece.style.textTransform = 'uppercase';\n    piece.textContent = p.text;\n    span.appendChild(piece);\n  }\n}\n\n/**\n * Build a flat sequence of `<span data-run>` children from `runs`, replacing\n * any existing children of `parent`. `base` is the node's style, which a run\n * inheriting small caps needs to be split by; without it the kit defaults\n * stand in.\n */\nexport function runsToDom(\n  runs: readonly StyledRun[],\n  parent: HTMLElement,\n  base: OverlayRunBase = DEFAULT_TEXT_STYLE,\n): void {\n  parent.replaceChildren();\n  for (const run of runs) {\n    const span = document.createElement('span');\n    span.setAttribute('data-run', '');\n    if ((run.fontVariantCaps ?? base.fontVariantCaps) === 'small-caps') {\n      const scale = smallCapsScaleFor(\n        run.fontFamily ?? base.fontFamily,\n        run.fontWeight ?? (run.bold ? 700 : numericWeight(base.fontWeight)),\n        run.italic ? 'italic' : base.fontStyle,\n      );\n      span.style.setProperty(SMALL_CAPS_SCALE_PROPERTY, String(scale));\n      writeSmallCaps(span, run.text, run.textTransform ?? base.textTransform);\n    } else {\n      appendOverlayText(span, run.text);\n    }\n    // CSS as well as the pieces: it is what pasted markup says, and it gives a\n    // letter typed outside a piece a small cap until the next normalize.\n    if (run.fontVariantCaps != null) span.style.fontVariant = run.fontVariantCaps;\n    if (run.fontWeight != null) {\n      span.style.fontWeight = String(run.fontWeight);\n      span.setAttribute('data-font-weight', String(run.fontWeight));\n    } else if (run.bold) span.style.fontWeight = '700';\n    if (run.italic) span.style.fontStyle = 'italic';\n    // An absolute size wins over a relative one, as it does in `resolveRuns`.\n    if (run.fontSize != null) span.style.fontSize = `${run.fontSize}px`;\n    else if (run.fontScale != null) span.style.fontSize = `${run.fontScale * 100}%`;\n    if (run.fontFamily != null) {\n      span.style.fontFamily = cssFontFamily(run.fontFamily, {\n        weight: run.fontWeight ?? (run.bold ? 700 : undefined),\n        style: run.italic ? 'italic' : undefined,\n      });\n      span.setAttribute('data-font-family', run.fontFamily);\n    }\n    const color = solidColor(run.fill);\n    if (color != null) span.style.color = color;\n    // Decoration goes on the span as an inline style rather than `<u>`/`<s>`\n    // wrappers: one representation for `domToRuns` to unwrap, and one element\n    // per run so the caret-offset walkers stay flat.\n    const decorations: string[] = [];\n    if (run.underline) decorations.push('underline');\n    if (run.strikethrough) decorations.push('line-through');\n    if (run.overline) decorations.push('overline');\n    if (decorations.length > 0) span.style.textDecoration = decorations.join(' ');\n    if (run.script != null) span.style.verticalAlign = run.script;\n    // The one run field with no CSS spelling: `vertical-align` takes a length\n    // or a percentage of the *line height*, and this is a fraction of the\n    // parent's font size. An attribute keeps the round-trip exact; the canvas\n    // underneath is what actually draws the run at its offset.\n    if (run.baselineShift != null) {\n      span.setAttribute('data-baseline-shift', String(run.baselineShift));\n    }\n    // World units — the overlay's own node-level tracking is screen-scaled,\n    // but a run override is stored as-is so the round-trip is lossless. CSS\n    // `letter-spacing` is inherited and a child declaration *replaces* the\n    // inherited value, so this composes with the overlay's rather than adding.\n    if (run.letterSpacing != null) span.style.letterSpacing = `${run.letterSpacing}px`;\n    // CSS draws the transform, so the span's text stays the source and the\n    // caret-offset walkers below need no map.\n    if (run.textTransform != null) span.style.textTransform = run.textTransform;\n    parent.appendChild(span);\n  }\n}\n\n/** `el`'s text as `domToRuns` reads it: each break stand-in restored. */\nfunction sourceText(el: Element): string {\n  let out = '';\n  for (const n of el.childNodes) {\n    if (n.nodeType === Node.TEXT_NODE) out += (n as Text).data;\n    else if (n instanceof Element) out += n.hasAttribute(BREAK_ATTR) ? restoreBreak(n) : sourceText(n);\n  }\n  return out;\n}\n\n/** Whether `span`'s children are the pieces `writeSmallCaps` would write. */\nfunction piecesMatch(span: HTMLElement, transform: TextTransform): boolean {\n  const want = smallCapsPieces(sourceText(span), transform);\n  const have: Array<{ text: string; small: boolean }> = [];\n  for (const n of span.childNodes) {\n    let small: boolean;\n    let text: string;\n    if (n.nodeType === Node.TEXT_NODE) { small = false; text = (n as Text).data; }\n    else if (n instanceof HTMLElement && n.hasAttribute(BREAK_ATTR)) { small = false; text = restoreBreak(n); }\n    else if (n instanceof HTMLElement && isSmallCapsPiece(n) && n.children.length === 0) { small = true; text = n.textContent ?? ''; }\n    else return false;\n    if (text.length === 0) continue;\n    const last = have[have.length - 1];\n    if (last && last.small === small) last.text += text;\n    else have.push({ text, small });\n  }\n  return want.length === have.length\n    && want.every((p, i) => p.text === have[i].text && p.small === have[i].small);\n}\n\n/**\n * Put every run span's small-caps pieces back where its text now needs them —\n * typing lands a letter in whichever piece holds the caret, not the one its\n * case belongs in. Returns whether anything was rewritten, which moves the\n * DOM selection: the caller restores it by character offset.\n */\nexport function normalizeSmallCaps(parent: HTMLElement): boolean {\n  let changed = false;\n  const visit = (el: HTMLElement, variant: FontVariantCaps, transform: TextTransform): void => {\n    const v = cssFontVariant(el) ?? variant;\n    const tt = el.style.textTransform;\n    const t = TRANSFORMS.has(tt) ? (tt as TextTransform) : transform;\n    if (el.hasAttribute('data-run')) {\n      if (v === 'small-caps') {\n        if (!piecesMatch(el, t)) { writeSmallCaps(el, sourceText(el), t); changed = true; }\n      } else if (el.querySelector('[data-small-caps]')) {\n        const text = sourceText(el);\n        el.replaceChildren();\n        appendOverlayText(el, text);\n        changed = true;\n      }\n      return;\n    }\n    for (const child of el.children) if (child instanceof HTMLElement) visit(child, v, t);\n  };\n  visit(parent, 'normal', 'none');\n  return changed;\n}\n\n/**\n * Walk the overlay's text nodes in document order and find the text node\n * + offset that corresponds to plain-text character position `offset`.\n * Offsets beyond the total text length clamp to the end of the last text\n * node. Returns `{ node: parent, offset: 0 }` when there are no text nodes.\n */\nexport function charOffsetToDomPosition(\n  parent: HTMLElement,\n  offset: number,\n): { node: Node; offset: number } | null {\n  let remaining = offset;\n  const walker = document.createTreeWalker(parent, NodeFilter.SHOW_TEXT);\n  let last: Text | null = null;\n  let node = walker.nextNode() as Text | null;\n  while (node) {\n    const len = node.data.length;\n    if (remaining <= len) {\n      return { node, offset: remaining };\n    }\n    remaining -= len;\n    last = node;\n    node = walker.nextNode() as Text | null;\n  }\n  if (last) return { node: last, offset: last.data.length };\n  return { node: parent, offset: 0 };\n}\n\n/**\n * Inverse of `charOffsetToDomPosition`. Walks text nodes in document order;\n * sums the lengths of every text node preceding `node` and adds `offset`.\n *\n * When `node` is an element the DOM offset indexes *child nodes*, not\n * characters, so it can't simply be added — `(overlay, 0)` is the start of\n * the text and `(overlay, childNodes.length)` its end. That shape is not\n * exotic: `Range.selectNodeContents`, which `useTextEdit` uses for its\n * select-all caret, produces exactly it. So resolve an element position by\n * counting the text that precedes the boundary point. A text node can never\n * *contain* that point (the container isn't one), so each is wholly before\n * or wholly after it.\n */\nexport function domPositionToCharOffset(\n  parent: HTMLElement,\n  node: Node,\n  offset: number,\n): number {\n  let total = 0;\n  const walker = document.createTreeWalker(parent, NodeFilter.SHOW_TEXT);\n  let cur = walker.nextNode() as Text | null;\n  if (node.nodeType === Node.TEXT_NODE) {\n    while (cur) {\n      if (cur === node) return total + offset;\n      total += cur.data.length;\n      cur = walker.nextNode() as Text | null;\n    }\n    return total;\n  }\n  const point = document.createRange();\n  point.setStart(node, Math.max(0, Math.min(offset, node.childNodes.length)));\n  point.collapse(true);\n  while (cur) {\n    if (point.comparePoint(cur, 0) < 0) total += cur.data.length;\n    cur = walker.nextNode() as Text | null;\n  }\n  return total;\n}\n"],"mappings":"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"}

package/dist/features/text/fitTextPose.js

@@ -1,38 +0,0 @@
-import { layoutTextPose as e } from "@weasel-js/text";
-//#region src/features/text/fitTextPose.ts
-function t(t, r = {}) {
-	let i = r.axis ?? "height", { padX: a, padY: o } = n(r.padding), { bounds: s } = e(i === "height" ? {
-		...t,
-		width: t.width - a * 2
-	} : {
-		...t,
-		style: {
-			...t.style,
-			wrap: !1
-		}
-	}).laid;
-	return i === "height" ? {
-		...t,
-		height: s.height + o * 2
-	} : {
-		...t,
-		width: s.width + a * 2,
-		height: s.height + o * 2
-	};
-}
-function n(e) {
-	return e == null ? {
-		padX: 0,
-		padY: 0
-	} : typeof e == "number" ? {
-		padX: e,
-		padY: e
-	} : {
-		padX: e.x ?? 0,
-		padY: e.y ?? 0
-	};
-}
-//#endregion
-export { t as fitTextPose };
-
-//# sourceMappingURL=fitTextPose.js.map

package/dist/features/text/fitTextPose.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"fitTextPose.js","names":["fitTextPose","axis","opts","resolvePadding","layoutTextPose","pose","padX","bounds","padY","p"],"sources":["../../../src/features/text/fitTextPose.ts"],"sourcesContent":["/**\n * Resize a text node's pose to fit its content. Pure helper — does not own\n * scene state. Call it whenever the text, style, or relevant axis changes,\n * and write the returned pose back through your adapter.\n *\n * Two modes:\n *\n *   - `axis: 'height'` (default): keep `pose.width`, recompute `height` as\n *     the block height plus optional vertical padding — wrapped at the width\n *     inside the horizontal padding when the style declares `wrap`. The\n *     common case for column-layout text — chat bubbles, sticky notes.\n *\n *   - `axis: 'both'`: ignore wrapping; recompute both `width` (longest\n *     `\\n`-split line) and `height` (line count × line height) plus padding.\n *     For badges and inline labels where the rect hugs the text on both\n *     axes. Newlines are still respected.\n *\n * `pose.x` / `pose.y` are preserved. The caller picks the anchor — if you\n * want a different growth direction (e.g. anchor bottom-right), adjust\n * `x` / `y` after calling.\n */\n\nimport { layoutTextPose } from '@weasel-js/text';\nimport type { TextPose } from '@weasel-js/text';\n\n/** Options for `fitTextPose`. */\nexport interface FitTextPoseOptions {\n  /** Which axis (or axes) to recompute. Default: `'height'`. */\n  axis?: 'height' | 'both';\n  /** Padding (world units) added to all four sides. Default 0. */\n  padding?: number | { x?: number; y?: number };\n}\n\n/** Recompute a `TextPose`'s `width`/`height` to fit its content; pure helper, doesn't mutate scene state. */\nexport function fitTextPose(\n  pose: TextPose,\n  opts: FitTextPoseOptions = {},\n): TextPose {\n  const axis = opts.axis ?? 'height';\n  const { padX, padY } = resolvePadding(opts.padding);\n  const { bounds } = layoutTextPose(axis === 'height'\n    ? { ...pose, width: pose.width - padX * 2 }\n    : { ...pose, style: { ...pose.style, wrap: false } }).laid;\n  if (axis === 'height') return { ...pose, height: bounds.height + padY * 2 };\n  return {\n    ...pose,\n    width: bounds.width + padX * 2,\n    height: bounds.height + padY * 2,\n  };\n}\n\nfunction resolvePadding(p: FitTextPoseOptions['padding']): { padX: number; padY: number } {\n  if (p == null) return { padX: 0, padY: 0 };\n  if (typeof p === 'number') return { padX: p, padY: p };\n  return { padX: p.x ?? 0, padY: p.y ?? 0 };\n}\n"],"mappings":";;AAkCA,SAAgBA,EACd,GACA,IAA2B,CAAC,GAClB;CACV,IAAMC,IAAOC,EAAK,QAAQ,UACpB,EAAE,SAAM,YAASC,EAAeD,EAAK,OAAO,GAC5C,EAAE,cAAWE,EAAeH,MAAS,WACvC;EAAE,GAAGI;EAAM,OAAOA,EAAK,QAAQC,IAAO;CAAE,IACxC;EAAE,GAAGD;EAAM,OAAO;GAAE,GAAGA,EAAK;GAAO,MAAM;EAAM;CAAE,CAAC,CAAC,CAAC;CAExD,OADIJ,MAAS,WAAiB;EAAE,GAAGI;EAAM,QAAQE,EAAO,SAASC,IAAO;CAAE,IACnE;EACL,GAAGH;EACH,OAAOE,EAAO,QAAQD,IAAO;EAC7B,QAAQC,EAAO,SAASC,IAAO;CACjC;AACF;AAEA,SAASL,EAAe,GAAkE;CAGxF,OAFIM,KAAK,OAAa;EAAE,MAAM;EAAG,MAAM;CAAE,IACrC,OAAOA,KAAM,WAAiB;EAAE,MAAMA;EAAG,MAAMA;CAAE,IAC9C;EAAE,MAAMA,EAAE,KAAK;EAAG,MAAMA,EAAE,KAAK;CAAE;AAC1C"}

package/dist/features/text/hitTest.js

@@ -1,45 +0,0 @@
-import { layoutTextPose as e } from "@weasel-js/text";
-//#region src/features/text/hitTest.ts
-function t(e) {
-	let t = [];
-	for (let n of e) {
-		let e = t[t.length - 1];
-		if (e && e.srcIndex === n.srcIndex && e.srcEnd === n.srcEnd) {
-			let r = Math.min(e.x, n.x), i = Math.max(e.x + e.advance, n.x + n.advance);
-			t[t.length - 1] = {
-				...e,
-				x: r,
-				advance: i - r
-			};
-		} else t.push(n);
-	}
-	return t;
-}
-function n(e, t, n, r = {}) {
-	let i = r.padding ?? 0;
-	return e >= n.x - i && e <= n.x + n.width + i && t >= n.y - i && t <= n.y + n.height + i;
-}
-function r(n, r, i) {
-	let { laid: a, x: o, y: s } = e(i), c = a.lines;
-	if (c.length === 0) return 0;
-	let l = c[c.length - 1];
-	if (r < s + c[0].y0) return c[0].cells[0]?.srcIndex ?? c[0].srcEnd;
-	if (r >= s + l.y1) return l.srcEnd;
-	let u = l;
-	for (let e of c) if (r < s + e.y1) {
-		u = e;
-		break;
-	}
-	if (u.cells.length === 0) return u.srcEnd;
-	let d = t(u.cells), f = d.map((e, t) => t).sort((e, t) => d[e].x - d[t].x);
-	for (let e of f) {
-		let t = d[e];
-		if (!(n >= o + t.x + t.advance / 2)) return t.level % 2 == 1 ? t.srcEnd : t.srcIndex;
-	}
-	let p = d[f[f.length - 1]];
-	return p.level % 2 == 1 ? p.srcIndex : p.srcEnd;
-}
-//#endregion
-export { r as caretIndexAt, n as pointInTextPose };
-
-//# sourceMappingURL=hitTest.js.map

package/dist/features/text/hitTest.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"hitTest.js","names":["sourceClusters","out","c","cells","prev","x0","x1","pointInTextPose","p","opts","x","pose","y","caretIndexAt","dx","dy","layoutTextPose","lines","laid","last","line","candidate","visual","i","a","b","trailing"],"sources":["../../../src/features/text/hitTest.ts"],"sourcesContent":["/**\n * Hit-testing for text nodes.\n *\n * `pointInTextPose` does a coarse pose-rect test — suitable for click-to-edit\n * where the pose rect is the authoritative bounding box (selection outline,\n * drag target).\n *\n * `caretIndexAt` does the finer test: given a world-space (x, y) inside the\n * pose, returns the corresponding character offset so the consumer can place\n * the caret on click. It reads the caret stops off `layoutTextPose`, the\n * layout the painters draw and `textLineBoxes` picks against, so the caret\n * cannot land on a different line — or between different glyphs — than the\n * one under the pointer.\n */\n\nimport { layoutTextPose } from '@weasel-js/text';\nimport type { LaidOutCell, TextPose } from '@weasel-js/text';\n\n/**\n * Merge neighboring cells drawn from one source character — the two `S`s an\n * uppercased `ß` becomes — into one cell spanning both, so no caret stop falls\n * between them.\n */\nfunction sourceClusters(cells: readonly LaidOutCell[]): LaidOutCell[] {\n  const out: LaidOutCell[] = [];\n  for (const c of cells) {\n    const prev = out[out.length - 1];\n    if (prev && prev.srcIndex === c.srcIndex && prev.srcEnd === c.srcEnd) {\n      const x0 = Math.min(prev.x, c.x);\n      const x1 = Math.max(prev.x + prev.advance, c.x + c.advance);\n      out[out.length - 1] = { ...prev, x: x0, advance: x1 - x0 };\n    } else {\n      out.push(c);\n    }\n  }\n  return out;\n}\n\n/** Options for `pointInTextPose`. */\nexport interface PointInTextPoseOpts {\n  /** Extra padding (world units) added to the rect on all sides. Default 0. */\n  padding?: number;\n}\n\n/** Coarse pose-rect hit-test for a text node — suitable for click-to-edit dispatch. */\nexport function pointInTextPose(\n  x: number,\n  y: number,\n  pose: TextPose,\n  opts: PointInTextPoseOpts = {},\n): boolean {\n  const p = opts.padding ?? 0;\n  return (\n    x >= pose.x - p &&\n    x <= pose.x + pose.width + p &&\n    y >= pose.y - p &&\n    y <= pose.y + pose.height + p\n  );\n}\n\n/**\n * Map a world-space point inside `pose` to a character offset into the pose's\n * text (0..length). Clicks above the first line clamp to 0; clicks below the\n * last line clamp to the end. Within a line, the caret lands between two\n * glyphs at whichever side of the advance cell's midpoint `x` falls on — the\n * standard \"snap caret to nearest character boundary\" rule.\n *\n * Honors `pose.runs` (a mixed-size line snaps on the cells each run actually\n * produced) and `pose.verticalAlign`. The offset is into the runs'\n * concatenated text, which `TextPose` requires to equal `pose.text`.\n */\nexport function caretIndexAt(x: number, y: number, pose: TextPose): number {\n  const { laid, x: dx, y: dy } = layoutTextPose(pose);\n  const lines = laid.lines;\n  if (lines.length === 0) return 0;\n\n  const last = lines[lines.length - 1];\n  if (y < dy + lines[0].y0) return lines[0].cells[0]?.srcIndex ?? lines[0].srcEnd;\n  if (y >= dy + last.y1) return last.srcEnd;\n\n  let line = last;\n  for (const candidate of lines) {\n    if (y < dy + candidate.y1) { line = candidate; break; }\n  }\n\n  // Cells are in logical order and their x values need not ascend, so the\n  // sweep has to be in visual order and each cell's own extent is what it is\n  // tested against — the next cell along is not its right edge.\n  if (line.cells.length === 0) return line.srcEnd;\n  const cells = sourceClusters(line.cells);\n  const visual = cells.map((_, i) => i).sort((a, b) => cells[a].x - cells[b].x);\n\n  for (const i of visual) {\n    const c = cells[i];\n    if (x >= dx + c.x + c.advance / 2) continue;\n    // A right-to-left cell reads the other way, so its visually-leading half\n    // is the character's logical end.\n    return c.level % 2 === 1 ? c.srcEnd : c.srcIndex;\n  }\n  const trailing = cells[visual[visual.length - 1]];\n  return trailing.level % 2 === 1 ? trailing.srcIndex : trailing.srcEnd;\n}\n"],"mappings":";;AAuBA,SAASA,EAAe,GAA8C;CACpE,IAAMC,IAAqB,CAAC;CAC5B,KAAK,IAAMC,KAAKC,GAAO;EACrB,IAAMC,IAAOH,EAAIA,EAAI,SAAS;EAC9B,IAAIG,KAAQA,EAAK,aAAaF,EAAE,YAAYE,EAAK,WAAWF,EAAE,QAAQ;GACpE,IAAMG,IAAK,KAAK,IAAID,EAAK,GAAGF,EAAE,CAAC,GACzBI,IAAK,KAAK,IAAIF,EAAK,IAAIA,EAAK,SAASF,EAAE,IAAIA,EAAE,OAAO;GAC1D,EAAID,EAAI,SAAS,KAAK;IAAE,GAAGG;IAAM,GAAGC;IAAI,SAASC,IAAKD;GAAG;EAC3D,OACE,EAAI,KAAKH,CAAC;CAEd;CACA,OAAOD;AACT;AASA,SAAgBM,EACd,GACA,GACA,GACA,IAA4B,CAAC,GACpB;CACT,IAAMC,IAAIC,EAAK,WAAW;CAC1B,OACEC,KAAKC,EAAK,IAAIH,KACdE,KAAKC,EAAK,IAAIA,EAAK,QAAQH,KAC3BI,KAAKD,EAAK,IAAIH,KACdI,KAAKD,EAAK,IAAIA,EAAK,SAASH;AAEhC;AAaA,SAAgBK,EAAa,GAAW,GAAW,GAAwB;CACzE,IAAM,EAAE,SAAM,GAAGC,GAAI,GAAGC,MAAOC,EAAeL,CAAI,GAC5CM,IAAQC,EAAK;CACnB,IAAID,EAAM,WAAW,GAAG,OAAO;CAE/B,IAAME,IAAOF,EAAMA,EAAM,SAAS;CAClC,IAAIL,IAAIG,IAAKE,EAAM,EAAE,CAAC,IAAI,OAAOA,EAAM,EAAE,CAAC,MAAM,EAAE,EAAE,YAAYA,EAAM,EAAE,CAAC;CACzE,IAAIL,KAAKG,IAAKI,EAAK,IAAI,OAAOA,EAAK;CAEnC,IAAIC,IAAOD;CACX,KAAK,IAAME,KAAaJ,GACtB,IAAIL,IAAIG,IAAKM,EAAU,IAAI;EAAE,IAAOA;EAAW;CAAO;CAMxD,IAAID,EAAK,MAAM,WAAW,GAAG,OAAOA,EAAK;CACzC,IAAMjB,IAAQH,EAAeoB,EAAK,KAAK,GACjCE,IAASnB,EAAM,KAAK,GAAG,MAAMoB,CAAC,CAAC,CAAC,MAAM,GAAG,MAAMpB,EAAMqB,EAAE,CAAC,IAAIrB,EAAMsB,EAAE,CAAC,CAAC;CAE5E,KAAK,IAAMF,KAAKD,GAAQ;EACtB,IAAMpB,IAAIC,EAAMoB;EAChB,IAAI,OAAKT,IAAKZ,EAAE,IAAIA,EAAE,UAAU,IAGhC,OAAOA,EAAE,QAAQ,KAAM,IAAIA,EAAE,SAASA,EAAE;CAC1C;CACA,IAAMwB,IAAWvB,EAAMmB,EAAOA,EAAO,SAAS;CAC9C,OAAOI,EAAS,QAAQ,KAAM,IAAIA,EAAS,WAAWA,EAAS;AACjE"}

package/dist/features/text/renderLabel.js

@@ -1,14 +0,0 @@
-//#region src/features/text/renderLabel.ts
-function e(e, n, r, i, a = {}) {
-	let { align: o = "center", fontSize: s = 13, renderText: c, width: l, height: u, padX: d = 4, padY: f = 1, cornerRadius: p = 3 } = a;
-	e.save(), e.font = `${s}px sans-serif`, e.textBaseline = "top";
-	let m = l ?? e.measureText(n).width, h = u ?? s, g = m + d * 2, _ = h + f * 2, v = o === "center" ? r - g / 2 : r - d;
-	e.fillStyle = "rgba(0, 0, 0, 0.75)", e.beginPath(), e.roundRect(v, i - f, g, _, p), e.fill(), e.textAlign = o === "center" ? "center" : "left", (c ?? t)(e, n, r, i), e.restore();
-}
-var t = (e, t, n, r) => {
-	e.fillStyle = "#FFFFFF", e.fillText(t, n, r);
-};
-//#endregion
-export { t as defaultLabelTextRenderer, e as renderLabel };
-
-//# sourceMappingURL=renderLabel.js.map

package/dist/features/text/renderLabel.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"renderLabel.js","names":["renderLabel","options","ctx","fontSize","contentW","width","text","contentH","height","w","padX","h","padY","rx","align","x","y","cornerRadius","renderText","defaultLabelTextRenderer"],"sources":["../../../src/features/text/renderLabel.ts"],"sourcesContent":["import type { TextRenderer } from '@weasel-js/text';\n\n\n/** Visual options for `renderLabel`. */\nexport interface LabelOptions {\n  align?: 'center' | 'left';\n  fontSize?: number;\n  renderText?: TextRenderer;\n  /** Override the pill width (content width, excluding padding). */\n  width?: number;\n  /** Override the pill height (content height, excluding padding). */\n  height?: number;\n  /** Horizontal padding inside the pill. Default 4 (screen-pixel default). */\n  padX?: number;\n  /** Vertical padding inside the pill. Default 1 (screen-pixel default). */\n  padY?: number;\n  /** Corner radius of the pill background. Default 3 (screen-pixel default). */\n  cornerRadius?: number;\n}\n\n/** Render a text label with a 75%-opaque black pill background and white text. */\nexport function renderLabel(\n  ctx: CanvasRenderingContext2D,\n  text: string,\n  x: number,\n  y: number,\n  options: LabelOptions = {},\n): void {\n  const {\n    align = 'center',\n    fontSize = 13,\n    renderText,\n    width,\n    height,\n    padX = 4,\n    padY = 1,\n    cornerRadius = 3,\n  } = options;\n\n  ctx.save();\n  ctx.font = `${fontSize}px sans-serif`;\n  ctx.textBaseline = 'top';\n  const contentW = width ?? ctx.measureText(text).width;\n  const contentH = height ?? fontSize;\n  const w = contentW + padX * 2;\n  const h = contentH + padY * 2;\n  const rx = align === 'center' ? x - w / 2 : x - padX;\n\n  ctx.fillStyle = 'rgba(0, 0, 0, 0.75)';\n  ctx.beginPath();\n  ctx.roundRect(rx, y - padY, w, h, cornerRadius);\n  ctx.fill();\n\n  ctx.textAlign = align === 'center' ? 'center' : 'left';\n  const tx = align === 'center' ? x : x;\n  (renderText ?? defaultLabelTextRenderer)(ctx, text, tx, y);\n  ctx.restore();\n}\n\n/** Default `TextRenderer` used by `renderLabel`: white fill, no styling. */\nexport const defaultLabelTextRenderer: TextRenderer = (ctx, text, x, y) => {\n  ctx.fillStyle = '#FFFFFF';\n  ctx.fillText(text, x, y);\n};\n"],"mappings":";AAqBA,SAAgBA,EACd,GACA,GACA,GACA,GACA,IAAwB,CAAC,GACnB;CACN,IAAM,EACJ,WAAQ,UACR,cAAW,IACX,eACA,UACA,WACA,UAAO,GACP,UAAO,GACP,kBAAe,MACbC;CAIJ,AAFAC,EAAI,KAAK,GACT,EAAI,OAAO,GAAGC,EAAS,gBACvB,EAAI,eAAe;CACnB,IAAMC,IAAWC,KAASH,EAAI,YAAYI,CAAI,CAAC,CAAC,OAC1CC,IAAWC,KAAUL,GACrBM,IAAIL,IAAWM,IAAO,GACtBC,IAAIJ,IAAWK,IAAO,GACtBC,IAAKC,MAAU,WAAWC,IAAIN,IAAI,IAAIM,IAAIL;CAUhD,AARA,EAAI,YAAY,uBAChBR,EAAI,UAAU,GACdA,EAAI,UAAUW,GAAIG,IAAIJ,GAAMH,GAAGE,GAAGM,CAAY,GAC9Cf,EAAI,KAAK,GAET,EAAI,YAAYY,MAAU,WAAW,WAAW,SAE/CI,KAAcC,EAAA,CAA0BjB,GAAKI,GADdS,GACwBC,CAAC,GACzDd,EAAI,QAAQ;AACd;AAGA,IAAaiB,KAA0C,GAAK,GAAM,GAAG,MAAM;CAEzE,AADA,EAAI,YAAY,WAChBjB,EAAI,SAASI,GAAMS,GAAGC,CAAC;AACzB"}

package/dist/features/text/runs/effectiveRangeStyle.js

@@ -1,66 +0,0 @@
-import { MIXED as e } from "../../../core/mixed.js";
-import { nodeHasFlag as t } from "./flagRange.js";
-import { isBoldWeight as n, numericWeight as r, resolveTextStyle as i } from "@weasel-js/text";
-//#region src/features/text/runs/effectiveRangeStyle.ts
-var a = [
-	"italic",
-	"underline",
-	"strikethrough",
-	"overline"
-];
-function o(t, i) {
-	let a = r(i?.fontWeight ?? 400), o = t?.fontWeight;
-	if (o === e) return {
-		fontWeight: e,
-		bold: e
-	};
-	if (o !== void 0) return {
-		fontWeight: o,
-		bold: n(o)
-	};
-	let s = t?.bold;
-	if (s === e) return a === 700 ? {
-		fontWeight: 700,
-		bold: !0
-	} : {
-		fontWeight: e,
-		bold: n(a) ? !0 : e
-	};
-	let c = s === !0 ? 700 : a;
-	return {
-		fontWeight: c,
-		bold: n(c)
-	};
-}
-var s = [
-	"fontFamily",
-	"fontSize",
-	"letterSpacing",
-	"fill",
-	"script",
-	"baselineShift",
-	"fontScale",
-	"textTransform",
-	"fontVariantCaps"
-];
-function c(e, n, r) {
-	let c = i(n, r), l = n ?? {}, u = {
-		fontFamily: c.fontFamily,
-		fontSize: c.fontSize,
-		letterSpacing: c.letterSpacing,
-		textTransform: c.textTransform,
-		fontVariantCaps: c.fontVariantCaps
-	};
-	c.fill !== null && (u.fill = c.fill), Object.assign(u, o(e, n));
-	for (let n of a) {
-		let r = t(l, n), i = e?.[n];
-		u[n] = r || i === void 0 ? r : i;
-	}
-	if (e === null) return u;
-	for (let t of s) e[t] !== void 0 && (u[t] = e[t]);
-	return u;
-}
-//#endregion
-export { c as effectiveRangeStyle, o as rangeWeight };
-
-//# sourceMappingURL=effectiveRangeStyle.js.map

package/dist/features/text/runs/effectiveRangeStyle.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"effectiveRangeStyle.js","names":["FLAGS","rangeWeight","node","numericWeight","style","own","range","MIXED","isBoldWeight","flag","weight","OVERRIDES","effectiveRangeStyle","resolved","resolveTextStyle","paint","out","key","on","nodeHasFlag","run"],"sources":["../../../../src/features/text/runs/effectiveRangeStyle.ts"],"sourcesContent":["import { isBoldWeight, numericWeight, resolveTextStyle } from '@weasel-js/text';\nimport type { TextPaint, TextStyle } from '@weasel-js/text';\nimport { nodeHasFlag } from './flagRange';\nimport { MIXED } from './rangeStyle';\nimport type { Mixed, RangeStyle } from './rangeStyle';\n\nconst FLAGS = ['italic', 'underline', 'strikethrough', 'overline'] as const;\n\n/**\n * The weight a range renders at, and whether that reads as bold, resolved as\n * `resolveRuns` resolves a run: its own `fontWeight`, else 700 for `bold`,\n * else the node's weight.\n */\nexport function rangeWeight(\n  range: RangeStyle | null,\n  style: TextStyle | undefined,\n): { fontWeight: number | Mixed; bold: boolean | Mixed } {\n  const node = numericWeight(style?.fontWeight ?? 400);\n  const own = range?.fontWeight;\n  if (own === MIXED) return { fontWeight: MIXED, bold: MIXED };\n  if (own !== undefined) return { fontWeight: own, bold: isBoldWeight(own) };\n  const flag = range?.bold;\n  if (flag === MIXED) {\n    // Flagged runs draw at 700, the rest at the node's weight.\n    if (node === 700) return { fontWeight: 700, bold: true };\n    return { fontWeight: MIXED, bold: isBoldWeight(node) ? true : MIXED };\n  }\n  const weight = flag === true ? 700 : node;\n  return { fontWeight: weight, bold: isBoldWeight(weight) };\n}\n\n/** Keys a run overrides outright. `script` and the two primitives it presets\n *  have no node-level counterpart, so they only ever come from the range. */\nconst OVERRIDES = [\n  'fontFamily', 'fontSize', 'letterSpacing', 'fill', 'script', 'baselineShift', 'fontScale',\n  'textTransform', 'fontVariantCaps',\n] as const;\n\n/**\n * What is actually rendering across a range: `range` (from `styleAtRange`,\n * or `useTextEdit`'s `rangeStyle`) resolved against the node's own `style`\n * and `paint`, as the canvas resolves runs. `null` reads the node alone.\n *\n * Flags are additive — a run can turn one on, never off — so a node flag\n * makes the flag `true` across the range, `MIXED` runs included. Every other\n * key is the run's value where the range sets one, otherwise the node's.\n * The node level is resolved first, so the result has a value for every\n * key but the run-only ones, and for `fill` unless the node is unfilled.\n * Bold is read off the weight that renders (see {@link rangeWeight}), since\n * a run's own `fontWeight` can take a bold node's text back to regular.\n */\nexport function effectiveRangeStyle(\n  range: RangeStyle | null,\n  style: TextStyle | undefined,\n  paint?: TextPaint,\n): RangeStyle {\n  const resolved = resolveTextStyle(style, paint);\n  const node = style ?? {};\n  const out: RangeStyle = {\n    fontFamily: resolved.fontFamily,\n    fontSize: resolved.fontSize,\n    letterSpacing: resolved.letterSpacing,\n    textTransform: resolved.textTransform,\n    fontVariantCaps: resolved.fontVariantCaps,\n  };\n  if (resolved.fill !== null) out.fill = resolved.fill;\n  Object.assign(out, rangeWeight(range, style));\n  for (const key of FLAGS) {\n    const on = nodeHasFlag(node, key);\n    const run = range?.[key];\n    out[key] = on || run === undefined ? on : run;\n  }\n  if (range === null) return out;\n  for (const key of OVERRIDES) {\n    if (range[key] !== undefined) (out as Record<string, unknown>)[key] = range[key];\n  }\n  return out;\n}\n"],"mappings":";;;;AAMA,IAAMA,IAAQ;CAAC;CAAU;CAAa;CAAiB;AAAU;AAOjE,SAAgBC,EACd,GACA,GACuD;CACvD,IAAMC,IAAOC,EAAcC,GAAO,cAAc,GAAG,GAC7CC,IAAMC,GAAO;CACnB,IAAID,MAAQE,GAAO,OAAO;EAAE,YAAYA;EAAO,MAAMA;CAAM;CAC3D,IAAIF,MAAQ,KAAA,GAAW,OAAO;EAAE,YAAYA;EAAK,MAAMG,EAAaH,CAAG;CAAE;CACzE,IAAMI,IAAOH,GAAO;CACpB,IAAIG,MAASF,GAGX,OADIL,MAAS,MAAY;EAAE,YAAY;EAAK,MAAM;CAAK,IAChD;EAAE,YAAYK;EAAO,MAAMC,EAAaN,CAAI,IAAI,KAAOK;CAAM;CAEtE,IAAMG,IAASD,MAAS,KAAO,MAAMP;CACrC,OAAO;EAAE,YAAYQ;EAAQ,MAAMF,EAAaE,CAAM;CAAE;AAC1D;AAIA,IAAMC,IAAY;CAChB;CAAc;CAAY;CAAiB;CAAQ;CAAU;CAAiB;CAC9E;CAAiB;AACnB;AAeA,SAAgBC,EACd,GACA,GACA,GACY;CACZ,IAAMC,IAAWC,EAAiBV,GAAOW,CAAK,GACxCb,IAAOE,KAAS,CAAC,GACjBY,IAAkB;EACtB,YAAYH,EAAS;EACrB,UAAUA,EAAS;EACnB,eAAeA,EAAS;EACxB,eAAeA,EAAS;EACxB,iBAAiBA,EAAS;CAC5B;CAEA,AADIA,EAAS,SAAS,SAAM,EAAI,OAAOA,EAAS,OAChD,OAAO,OAAOG,GAAKf,EAAYK,GAAOF,CAAK,CAAC;CAC5C,KAAK,IAAMa,KAAOjB,GAAO;EACvB,IAAMkB,IAAKC,EAAYjB,GAAMe,CAAG,GAC1BG,IAAMd,IAAQW;EACpB,EAAIA,KAAOC,KAAME,MAAQ,KAAA,IAAYF,IAAKE;CAC5C;CACA,IAAId,MAAU,MAAM,OAAOU;CAC3B,KAAK,IAAMC,KAAON,GAChB,AAAIL,EAAMW,OAAS,KAAA,MAAW,EAAiCA,KAAOX,EAAMW;CAE9E,OAAOD;AACT"}

package/dist/features/text/runs/flagRange.js

@@ -1,53 +0,0 @@
-import { applyStyleToRange as e } from "./rangeStyle.js";
-import { isBoldWeight as t } from "@weasel-js/text";
-//#region src/features/text/runs/flagRange.ts
-function n(e, n) {
-	switch (n) {
-		case "bold": return e.fontWeight !== void 0 && t(e.fontWeight);
-		case "italic": return e.fontStyle === "italic";
-		case "underline": return e.underline === !0;
-		case "strikethrough": return e.strikethrough === !0;
-		case "overline": return e.overline === !0;
-	}
-}
-function r(e) {
-	return n(e, "bold") ? {
-		bold: !1,
-		fontWeight: 400
-	} : { bold: !1 };
-}
-function i(e, t) {
-	let n = { ...e };
-	switch (t) {
-		case "italic":
-			n.fontStyle = "normal";
-			break;
-		case "underline":
-			delete n.underline;
-			break;
-		case "strikethrough":
-			delete n.strikethrough;
-			break;
-		case "overline": delete n.overline;
-	}
-	return n;
-}
-function a(t, a, o, s, c, l) {
-	if (l || !n(a, c)) return {
-		runs: e(t, o, s, { [c]: l }),
-		style: a
-	};
-	if (c === "bold") return {
-		runs: e(t, o, s, r(a)),
-		style: a
-	};
-	let u = t.reduce((e, t) => e + t.text.length, 0), d = Math.max(0, o), f = Math.min(u, s), p = e(t, 0, u, { [c]: !0 });
-	return d < f && (p = e(p, d, f, { [c]: !1 })), {
-		runs: p,
-		style: i(a, c)
-	};
-}
-//#endregion
-export { n as nodeHasFlag, a as setFlagOverRange, r as unboldPatch };
-
-//# sourceMappingURL=flagRange.js.map

package/dist/features/text/runs/flagRange.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"flagRange.js","names":["nodeHasFlag","key","style","isBoldWeight","unboldPatch","clearNodeFlag","next","setFlagOverRange","value","applyStyleToRange","runs","start","end","total","n","r","lo","hi"],"sources":["../../../../src/features/text/runs/flagRange.ts"],"sourcesContent":["/**\n * Turning a run-level flag **off** inside a node that sets it.\n *\n * Run flags are additive over the node's `TextStyle` — a run turns `bold` /\n * `italic` / `underline` / `strikethrough` on, never off (see the contract at\n * the top of `rangeStyle.ts`). So \"select a word inside an underlined node and\n * hit U\" is unrepresentable by the stored shape, and the character bar can\n * only refuse.\n *\n * This resolves it by rewriting rather than by widening the model: clear the\n * flag on the node, and set it on every run *outside* the range. The rendered\n * result is identical and the edit becomes expressible, with `StyledRun`\n * unchanged — so nothing a document can already contain changes meaning, which\n * matters while the flags are heading for a persisted format.\n *\n * The alternative was a tri-state run flag (`true` / `false` / inherit). It\n * cannot cover `italic`: that is a boolean on a run but `fontStyle` on the\n * node, so a run's `false` has no node-level boolean to override.\n *\n * `bold` needs neither: a run carries a numeric `fontWeight`, which overrides\n * the node's outright, so lowering bold writes a regular weight over the\n * range and leaves the node and the rest of the text alone.\n */\n\nimport { isBoldWeight } from '@weasel-js/text';\nimport type { StyledRun } from '@weasel-js/text';\nimport type { TextStyle } from '@weasel-js/text';\nimport { applyStyleToRange } from './rangeStyle';\nimport type { RunStylePatch } from './rangeStyle';\n\n/** The additive run flags. */\nexport type FlagKey = 'bold' | 'italic' | 'underline' | 'strikethrough' | 'overline';\n\n/** The result of toggling a style flag over a text range: the rewritten runs\n *  and node style, and whether the change could be made at all. */\nexport interface SetFlagResult {\n  runs: StyledRun[];\n  style: TextStyle;\n}\n\n/** Does the node style carry this flag? */\nexport function nodeHasFlag(style: TextStyle, key: FlagKey): boolean {\n  switch (key) {\n    case 'bold': return style.fontWeight !== undefined && isBoldWeight(style.fontWeight);\n    case 'italic': return style.fontStyle === 'italic';\n    case 'underline': return style.underline === true;\n    case 'strikethrough': return style.strikethrough === true;\n    case 'overline': return style.overline === true;\n  }\n}\n\n/** The patch that takes bold off a range: the flag, and — in a node that is\n *  itself bold — a regular weight to override the node's. */\nexport function unboldPatch(style: TextStyle): RunStylePatch {\n  return nodeHasFlag(style, 'bold') ? { bold: false, fontWeight: 400 } : { bold: false };\n}\n\n/** The node style with `key` cleared. */\nfunction clearNodeFlag(style: TextStyle, key: Exclude<FlagKey, 'bold'>): TextStyle {\n  const next = { ...style };\n  switch (key) {\n    case 'italic': next.fontStyle = 'normal'; break;\n    case 'underline': delete next.underline; break;\n    case 'strikethrough': delete next.strikethrough; break;\n    case 'overline': delete next.overline; break;\n  }\n  return next;\n}\n\n/**\n * Set `key` to `value` over `[start, end)`.\n *\n * Turning a flag **on**, or off in a node that doesn't set it, is the ordinary\n * additive write and leaves `style` alone. Turning it off in a node that *does*\n * set it takes the rewrite: the node flag is cleared and the flag is written\n * onto the complement of the range. Bold is the exception, written as a\n * weight over the range alone (see {@link unboldPatch}).\n *\n * `runs` is normalized on every path, so the complement collapses back to one\n * run when the range is empty and the whole array coalesces as usual.\n */\nexport function setFlagOverRange(\n  runs: readonly StyledRun[],\n  style: TextStyle,\n  start: number,\n  end: number,\n  key: FlagKey,\n  value: boolean,\n): SetFlagResult {\n  if (value || !nodeHasFlag(style, key)) {\n    return { runs: applyStyleToRange(runs, start, end, { [key]: value }), style };\n  }\n\n  if (key === 'bold') {\n    return { runs: applyStyleToRange(runs, start, end, unboldPatch(style)), style };\n  }\n\n  const total = runs.reduce((n, r) => n + r.text.length, 0);\n  const lo = Math.max(0, start);\n  const hi = Math.min(total, end);\n\n  // Raise the flag on everything, then lower it over the range. Doing it in\n  // that order rather than patching the two complement spans keeps one code\n  // path for a range at either edge, where one span is empty.\n  let next = applyStyleToRange(runs, 0, total, { [key]: true });\n  if (lo < hi) next = applyStyleToRange(next, lo, hi, { [key]: false });\n\n  return { runs: next, style: clearNodeFlag(style, key) };\n}\n"],"mappings":";;;AAyCA,SAAgBA,EAAY,GAAkB,GAAuB;CACnE,QAAQC,GAAR;EACE,KAAK,QAAQ,OAAOC,EAAM,eAAe,KAAA,KAAaC,EAAaD,EAAM,UAAU;EACnF,KAAK,UAAU,OAAOA,EAAM,cAAc;EAC1C,KAAK,aAAa,OAAOA,EAAM,cAAc;EAC7C,KAAK,iBAAiB,OAAOA,EAAM,kBAAkB;EACrD,KAAK,YAAY,OAAOA,EAAM,aAAa;CAC7C;AACF;AAIA,SAAgBE,EAAY,GAAiC;CAC3D,OAAOJ,EAAYE,GAAO,MAAM,IAAI;EAAE,MAAM;EAAO,YAAY;CAAI,IAAI,EAAE,MAAM,GAAM;AACvF;AAGA,SAASG,EAAc,GAAkB,GAA0C;CACjF,IAAMC,IAAO,EAAE,GAAGJ,EAAM;CACxB,QAAQD,GAAR;EACE,KAAK;GAAU,EAAK,YAAY;GAAU;EAC1C,KAAK;GAAa,OAAOK,EAAK;GAAW;EACzC,KAAK;GAAiB,OAAOA,EAAK;GAAe;EACjD,KAAK,YAAY,OAAOA,EAAK;CAC/B;CACA,OAAOA;AACT;AAcA,SAAgBC,EACd,GACA,GACA,GACA,GACA,GACA,GACe;CACf,IAAIC,KAAS,CAACR,EAAYE,GAAOD,CAAG,GAClC,OAAO;EAAE,MAAMQ,EAAkBC,GAAMC,GAAOC,GAAK,GAAGX,IAAMO,EAAM,CAAC;EAAG;CAAM;CAG9E,IAAIP,MAAQ,QACV,OAAO;EAAE,MAAMQ,EAAkBC,GAAMC,GAAOC,GAAKR,EAAYF,CAAK,CAAC;EAAG;CAAM;CAGhF,IAAMW,IAAQH,EAAK,QAAQ,GAAG,MAAMI,IAAIC,EAAE,KAAK,QAAQ,CAAC,GAClDC,IAAK,KAAK,IAAI,GAAGL,CAAK,GACtBM,IAAK,KAAK,IAAIJ,GAAOD,CAAG,GAK1BN,IAAOG,EAAkBC,GAAM,GAAGG,GAAO,GAAGZ,IAAM,GAAK,CAAC;CAG5D,OAFIe,IAAKC,MAAI,IAAOR,EAAkBH,GAAMU,GAAIC,GAAI,GAAGhB,IAAM,GAAM,CAAC,IAE7D;EAAE,MAAMK;EAAM,OAAOD,EAAcH,GAAOD,CAAG;CAAE;AACxD"}

package/dist/features/text/runs/rangeStyle.js

@@ -1,135 +0,0 @@
-import { MIXED as e } from "../../../core/mixed.js";
-//#region src/features/text/runs/rangeStyle.ts
-var t = [
-	"bold",
-	"fontWeight",
-	"italic",
-	"underline",
-	"strikethrough",
-	"overline",
-	"fontFamily",
-	"fontSize",
-	"letterSpacing",
-	"fill",
-	"stroke",
-	"script",
-	"baselineShift",
-	"fontScale",
-	"textTransform",
-	"fontVariantCaps"
-], n = /* @__PURE__ */ new Set([
-	"bold",
-	"italic",
-	"underline",
-	"strikethrough",
-	"overline"
-]);
-function r(e) {
-	return typeof e == "object" && !!e && !Array.isArray(e);
-}
-function i(e, t) {
-	if (Object.is(e, t)) return !0;
-	if (Array.isArray(e) && Array.isArray(t)) return e.length === t.length && e.every((e, n) => i(e, t[n]));
-	if (r(e) && r(t)) {
-		let n = Object.keys(e);
-		return n.length === Object.keys(t).length && n.every((n) => n in t && i(e[n], t[n]));
-	}
-	return !1;
-}
-function a(e, t) {
-	let r = e[t];
-	return n.has(t) ? r ?? !1 : r;
-}
-var o = /* @__PURE__ */ new Set(["fill", "stroke"]);
-function s(e, t, n) {
-	return o.has(e) ? i(t, n) : Object.is(t, n);
-}
-function c(e, n) {
-	return t.every((t) => s(t, a(e, t), a(n, t)));
-}
-function l(e) {
-	let t = 0;
-	for (let n of e) t += n.text.length;
-	return t;
-}
-function u(n, r, i) {
-	let o = Math.max(0, r), c = i;
-	if (!(o < c)) return {};
-	let l = /* @__PURE__ */ new Map(), u = /* @__PURE__ */ new Set(), d = !1, f = 0;
-	for (let e of n) {
-		let n = f + e.text.length, r = Math.max(f, o), i = Math.min(n, c);
-		if (f = n, r < i) {
-			for (let n of t) {
-				let t = a(e, n);
-				d ? !u.has(n) && !s(n, l.get(n), t) && u.add(n) : l.set(n, t);
-			}
-			d = !0;
-		}
-	}
-	if (!d) return {};
-	let p = {};
-	for (let n of t) if (u.has(n)) p[n] = e;
-	else {
-		let e = l.get(n);
-		e !== void 0 && (p[n] = e);
-	}
-	return p;
-}
-function d(e) {
-	return e.some((e) => t.some((t) => {
-		let n = e[t];
-		return n !== void 0 && n !== !1;
-	}));
-}
-function f(e) {
-	if ("bold" in e && !("fontWeight" in e)) return "fontWeight";
-	if (e.fontWeight !== void 0 && !("bold" in e)) return "bold";
-}
-function p(e, t) {
-	let n = { ...e }, r = f(t);
-	r !== void 0 && delete n[r];
-	for (let [e, r] of Object.entries(t)) r !== void 0 && (n[e] = r);
-	return n;
-}
-function m(e, n) {
-	let r = { ...e }, i = f(n);
-	i !== void 0 && delete r[i];
-	for (let e of t) {
-		if (!(e in n)) continue;
-		let t = n[e];
-		t === void 0 || t === !1 ? delete r[e] : r[e] = t;
-	}
-	return r;
-}
-function h(e) {
-	let t = [];
-	for (let n of e) {
-		if (n.text.length === 0) continue;
-		let e = t[t.length - 1];
-		e && c(e, n) ? e.text += n.text : t.push({ ...n });
-	}
-	return t;
-}
-function g(e, t, n, r) {
-	let i = Math.max(0, t), a = Math.min(l(e), n);
-	if (!(i < a)) return h(e);
-	let o = [], s = 0;
-	for (let t of e) {
-		let e = s + t.text.length, n = Math.max(s, i), c = Math.min(e, a);
-		n < c ? (s < n && o.push({
-			...t,
-			text: t.text.slice(0, n - s)
-		}), o.push(m({
-			...t,
-			text: t.text.slice(n - s, c - s)
-		}, r)), c < e && o.push({
-			...t,
-			text: t.text.slice(c - s)
-		})) : o.push({ ...t }), s = e;
-	}
-	return h(o);
-}
-//#endregion
-export { e as MIXED, g as applyStyleToRange, p as patchRangeStyle, d as runsCarryStyling, u as styleAtRange, f as supersededKey };
-
-//# sourceMappingURL=rangeStyle.js.map

package/dist/features/text/runs/rangeStyle.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"rangeStyle.js","names":["STYLE_KEYS","FLAG_KEYS","isPlainObject","v","deepEqual","a","b","item","i","keys","k","valueAt","value","run","key","STRUCTURAL_KEYS","sameValue","sameStyle","totalLength","n","runs","styleAtRange","lo","start","hi","end","first","mixed","seen","pos","runEnd","style","MIXED","runsCarryStyling","supersededKey","patch","patchRangeStyle","out","range","superseded","patchRun","next","coalesceRuns","prev","applyStyleToRange"],"sources":["../../../../src/features/text/runs/rangeStyle.ts"],"sourcesContent":["/**\n * Range-addressed styling over `StyledRun[]`. The panel addresses node paths;\n * a caret addresses a character range — these are the functions for the\n * second case. Pure and React-free so the semantics are unit-testable, the\n * same split `SelectionPanel` makes between `model.ts` and its component.\n *\n * Character offsets index the concatenated run text (`runsToPlainText`), and\n * a range is half-open: `[start, end)`. Ranges are clamped, never wrapped —\n * a negative `start` clamps to 0, an `end` past the text clamps to its\n * length, and a collapsed or inverted range (`start >= end`) is empty.\n * Offsets are UTF-16 code units, as everywhere else in this feature, so a\n * boundary can bisect a surrogate pair (`[1, 2)` over `'a👍b'` splits the\n * thumbs-up into lone surrogates). A caret-derived range never does this.\n *\n * **Run-level flags are additive over the node's `TextStyle`: a run can\n * turn `bold` / `italic` / `underline` / `strikethrough` on, never off.**\n * So a flag is stored only when true, and absent reads as `false`. A run\n * that must be lighter than a bold node says so with its own numeric\n * `fontWeight`, which `bold` is a preset over (see {@link supersededKey}).\n * For the boolean decorations there is no such primitive: both levels are\n * booleans, so a tri-state\n * (`true` / `false` / inherit) is expressible and we are collapsing it by\n * choice, to keep one canonical form per styling. Resolution must therefore\n * read decorations as `run.underline || style.underline` — a `??` would\n * make \"select a word in an underlined node, hit U to turn it off\" look\n * supported by the type while this file discards the `false` that expresses it.\n *\n * Copies here are shallow: a `fill` object is shared by reference between\n * the input runs, the patch, every run the patch touched, and the value\n * `styleAtRange` reports. Treat `fill` values as immutable.\n */\n\nimport { MIXED } from 'core/mixed';\nimport type { Mixed } from 'core/mixed';\nimport type { StyledRun } from '@weasel-js/text';\n\nexport { MIXED };\nexport type { Mixed };\n\n/** Every styleable key of a run, each either a concrete value or MIXED (the\n *  runs in the range disagree at that key). */\nexport type RangeStyle = {\n  [K in Exclude<keyof StyledRun, 'text'>]?: StyledRun[K] | Mixed;\n};\n\n/**\n * What `applyStyleToRange` writes. `text` is deliberately not part of it —\n * this is a styling operation, not an edit.\n */\nexport type RunStylePatch = Partial<Omit<StyledRun, 'text'>>;\n\n/** Every key of a run that carries styling — i.e. everything but `text`. */\nexport type StyleKey = Exclude<keyof StyledRun, 'text'>;\n\nconst STYLE_KEYS = [\n  'bold',\n  'fontWeight',\n  'italic',\n  'underline',\n  'strikethrough',\n  'overline',\n  'fontFamily',\n  'fontSize',\n  'letterSpacing',\n  'fill',\n  'stroke',\n  'script',\n  'baselineShift',\n  'fontScale',\n  'textTransform',\n  'fontVariantCaps',\n] as const satisfies readonly StyleKey[];\n\n// Every function here iterates STYLE_KEYS, so a key missing from the list is\n// invisible: `applyStyleToRange` would drop it when patching a run and\n// `sameStyle` would merge two runs that differ in it, silently discarding\n// one value. `satisfies` only checks the entries that ARE listed, so this\n// assertion checks the other direction — adding a key to `StyledRun`\n// without adding it here is a compile error.\ntype MissingStyleKey = Exclude<StyleKey, (typeof STYLE_KEYS)[number]>;\ntype AssertNoMissingStyleKey = [MissingStyleKey] extends [never] ? true : never;\nconst STYLE_KEYS_ARE_EXHAUSTIVE: AssertNoMissingStyleKey = true;\nvoid STYLE_KEYS_ARE_EXHAUSTIVE;\n\n/** The additive flags: absent and `false` mean the same thing, so both read as `false`. */\nconst FLAG_KEYS: ReadonlySet<StyleKey> = new Set<StyleKey>([\n  'bold',\n  'italic',\n  'underline',\n  'strikethrough',\n  'overline',\n]);\n\nfunction isPlainObject(v: unknown): v is Record<string, unknown> {\n  return typeof v === 'object' && v !== null && !Array.isArray(v);\n}\n\n/**\n * Structural equality over the JSON-ish values a run can hold. This assumes\n * `FillStyle` stays acyclic and plain — every member of the union is data\n * (`TextureHandle` is `{ id }`, so patterns compare by id, which is right).\n * A fill that grew a cyclic or class-valued field would recurse forever.\n */\nfunction deepEqual(a: unknown, b: unknown): boolean {\n  if (Object.is(a, b)) return true;\n  if (Array.isArray(a) && Array.isArray(b)) {\n    return a.length === b.length && a.every((item, i) => deepEqual(item, b[i]));\n  }\n  if (isPlainObject(a) && isPlainObject(b)) {\n    const keys = Object.keys(a);\n    if (keys.length !== Object.keys(b).length) return false;\n    return keys.every((k) => k in b && deepEqual(a[k], b[k]));\n  }\n  return false;\n}\n\n/** A run's value at `key`, with flags normalized so absent reads as `false`. */\nfunction valueAt(run: StyledRun, key: StyleKey): StyledRun[StyleKey] {\n  const value = run[key];\n  if (FLAG_KEYS.has(key)) return (value as boolean | undefined) ?? false;\n  return value;\n}\n\n/** The structural values. Everything else is a primitive, and\n *  `applyStyleToRange` spreads runs, so reference identity isn't reliable. */\nconst STRUCTURAL_KEYS: ReadonlySet<StyleKey> = new Set<StyleKey>(['fill', 'stroke']);\n\nfunction sameValue(key: StyleKey, a: unknown, b: unknown): boolean {\n  return STRUCTURAL_KEYS.has(key) ? deepEqual(a, b) : Object.is(a, b);\n}\n\n/** Do two runs carry the same styling (their `text` aside)? */\nfunction sameStyle(a: StyledRun, b: StyledRun): boolean {\n  return STYLE_KEYS.every((key) => sameValue(key, valueAt(a, key), valueAt(b, key)));\n}\n\n/** Total character length of a run array — the domain of its offsets. */\nfunction totalLength(runs: readonly StyledRun[]): number {\n  let n = 0;\n  for (const run of runs) n += run.text.length;\n  return n;\n}\n\n/**\n * The styling shared by every run overlapping `[start, end)`: a concrete\n * value where the range agrees, `MIXED` where it doesn't. Keys no run\n * in range sets are absent (they inherit the node's `TextStyle`) — except\n * the additive flags, which read as `false` rather than `undefined` since a\n * run cannot un-set them. An empty range reads as `{}`. A reported `fill`\n * is the run's own object, not a copy — treat it as immutable.\n */\nexport function styleAtRange(\n  runs: readonly StyledRun[],\n  start: number,\n  end: number,\n): RangeStyle {\n  const lo = Math.max(0, start);\n  const hi = end;\n  // Negated `<` rather than `>=` so a non-numeric offset reads as empty\n  // instead of matching every run.\n  if (!(lo < hi)) return {};\n\n  const first = new Map<StyleKey, unknown>();\n  const mixed = new Set<StyleKey>();\n  let seen = false;\n  let pos = 0;\n\n  for (const run of runs) {\n    const runEnd = pos + run.text.length;\n    const a = Math.max(pos, lo);\n    const b = Math.min(runEnd, hi);\n    pos = runEnd;\n    if (!(a < b)) continue;\n\n    for (const key of STYLE_KEYS) {\n      const value = valueAt(run, key);\n      if (!seen) first.set(key, value);\n      else if (!mixed.has(key) && !sameValue(key, first.get(key), value)) {\n        mixed.add(key);\n      }\n    }\n    seen = true;\n  }\n\n  if (!seen) return {};\n\n  const style: Record<string, unknown> = {};\n  for (const key of STYLE_KEYS) {\n    if (mixed.has(key)) style[key] = MIXED;\n    else {\n      const value = first.get(key);\n      if (value !== undefined) style[key] = value;\n    }\n  }\n  return style as RangeStyle;\n}\n\n/**\n * Does any run carry styling of its own? Per the additive-flags contract\n * above, absent and `false` are the same state — \"no run-level override\" —\n * so an array that is nothing but text reads as `false`, whether it came\n * from a plain-text edit or from styling that was toggled back off.\n *\n * This is how the commit path tells \"the edit produced run styling\" from\n * \"the edit produced text\", which is the question that decides whether a\n * node grows a `runs` array. Iterating `STYLE_KEYS` rather than the run's\n * own keys is what keeps it honest as `StyledRun` grows: a new styleable\n * key is a compile error at `STYLE_KEYS` until it's listed, and then this\n * sees it for free.\n */\nexport function runsCarryStyling(runs: readonly StyledRun[]): boolean {\n  return runs.some((run) =>\n    STYLE_KEYS.some((key) => {\n      const value = run[key];\n      return value !== undefined && value !== false;\n    }),\n  );\n}\n\n/**\n * The key a patch clears without naming it. `bold` is a preset over\n * `fontWeight`, and a run keeps at most one of the two: writing either drops\n * the other, so a Bold toggle is not hidden under a weight it cannot beat and\n * a picked weight is not shadowed by a stale flag. Naming both writes both.\n */\nexport function supersededKey(patch: RunStylePatch): 'bold' | 'fontWeight' | undefined {\n  if ('bold' in patch && !('fontWeight' in patch)) return 'fontWeight';\n  if (patch.fontWeight !== undefined && !('bold' in patch)) return 'bold';\n  return undefined;\n}\n\n/**\n * `range` with `patch` laid over it, keyed as a write of `patch` would leave\n * the runs — for showing styling armed for the next keystroke over the\n * styling at the caret. A key the patch leaves `undefined` keeps the range's\n * value; the key it supersedes is dropped.\n */\nexport function patchRangeStyle(range: RangeStyle, patch: RunStylePatch): RangeStyle {\n  const out: Record<string, unknown> = { ...range };\n  const superseded = supersededKey(patch);\n  if (superseded !== undefined) delete out[superseded];\n  for (const [key, value] of Object.entries(patch)) {\n    if (value !== undefined) out[key] = value;\n  }\n  return out as RangeStyle;\n}\n\n/** Apply `patch` to one run, deleting rather than storing \"no override\". */\nfunction patchRun(run: StyledRun, patch: RunStylePatch): StyledRun {\n  const next: StyledRun = { ...run };\n  const superseded = supersededKey(patch);\n  if (superseded !== undefined) delete next[superseded];\n  for (const key of STYLE_KEYS) {\n    if (!(key in patch)) continue;\n    const value = patch[key];\n    // Per the additive-flags contract at the top of the file, `false` is not\n    // a storable state — it means \"no run-level override\", same as\n    // `undefined`. Deleting keeps one canonical form (coalescing already\n    // treats absent and `false` as equal, so this isn't what makes runs\n    // merge — it's what keeps the stored shape from drifting).\n    if (value === undefined || value === false) delete next[key];\n    else (next as unknown as Record<string, unknown>)[key] = value;\n  }\n  return next;\n}\n\n/** Merge neighbors that ended up styled identically; drop empty runs. */\nfunction coalesceRuns(runs: readonly StyledRun[]): StyledRun[] {\n  const out: StyledRun[] = [];\n  for (const run of runs) {\n    if (run.text.length === 0) continue;\n    const prev = out[out.length - 1];\n    if (prev && sameStyle(prev, run)) prev.text += run.text;\n    else out.push({ ...run });\n  }\n  return out;\n}\n\n/**\n * Write `patch` over `[start, end)`, splitting runs at the boundaries and\n * coalescing neighbors that end up identical. A patch value of `undefined`\n * or `false` deletes the key instead of storing it — see the additive-flags\n * contract at the top of the file.\n *\n * Returns a new array of new runs; neither the input array nor its runs are\n * mutated (though a nested `fill` is shared by reference). Normalization —\n * merging identical neighbors, dropping empty runs — applies to the whole\n * array, not just the patched span, and to every call, including one whose\n * range is empty and so patches nothing.\n */\nexport function applyStyleToRange(\n  runs: readonly StyledRun[],\n  start: number,\n  end: number,\n  patch: RunStylePatch,\n): StyledRun[] {\n  const lo = Math.max(0, start);\n  const hi = Math.min(totalLength(runs), end);\n  // A collapsed caret is the common call, so it takes the same normalization\n  // as any other range rather than a laxer copy-only path.\n  if (!(lo < hi)) return coalesceRuns(runs);\n\n  const out: StyledRun[] = [];\n  let pos = 0;\n  for (const run of runs) {\n    const runEnd = pos + run.text.length;\n    const a = Math.max(pos, lo);\n    const b = Math.min(runEnd, hi);\n    if (a < b) {\n      if (pos < a) out.push({ ...run, text: run.text.slice(0, a - pos) });\n      out.push(patchRun({ ...run, text: run.text.slice(a - pos, b - pos) }, patch));\n      if (b < runEnd) out.push({ ...run, text: run.text.slice(b - pos) });\n    } else {\n      out.push({ ...run });\n    }\n    pos = runEnd;\n  }\n\n  return coalesceRuns(out);\n}\n"],"mappings":"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"}

package/dist/features/text/textCommand.js

@@ -1,59 +0,0 @@
-import { fillInPoseFrame as e } from "../../core/fillInPoseFrame.js";
-import { resolveFillPattern as t } from "../patterns/resolveSpec.js";
-import { resolveAlign as n, resolveRuns as r, resolveTextStyle as i, textPoseLayoutInput as a } from "@weasel-js/text";
-//#region src/features/text/textCommand.ts
-function o(e, t, a, o, s, c, l, u, d, f = 1) {
-	let p = i(o, u, f);
-	return {
-		kind: "text",
-		x: e,
-		y: t,
-		runs: r(a, p, f),
-		align: n(p.align, p.direction),
-		justify: p.align === "justify",
-		maxWidth: s,
-		style: o ?? {},
-		height: c,
-		verticalAlign: l,
-		width: d
-	};
-}
-function s(e, t, n, r, i, a, s, c, l, u = 1) {
-	return o(e, t, [{ text: n }], r, i, a, s, c, l, u);
-}
-function c(e, t = 1) {
-	let { runs: n, opts: r } = a(e, t);
-	return {
-		kind: "text",
-		x: e.x,
-		y: e.y,
-		runs: l(n, e),
-		align: r.align,
-		justify: r.justify,
-		maxWidth: r.maxWidth,
-		width: r.alignWidth,
-		style: e.style ?? {},
-		height: e.height,
-		verticalAlign: e.verticalAlign
-	};
-}
-function l(n, r) {
-	return n.every((e) => u(e.fill) && u(e.stroke?.paint)) ? n : n.map((n) => {
-		let i = n.fill && t(e(n.fill, r)), a = n.stroke?.paint && t(e(n.stroke.paint, r));
-		return {
-			...n,
-			fill: i,
-			stroke: n.stroke && {
-				...n.stroke,
-				paint: a || void 0
-			}
-		};
-	});
-}
-function u(e) {
-	return e == null || (e.fill ?? "solid") === "solid";
-}
-//#endregion
-export { s as textCommand, c as textCommandFromPose, o as textCommandFromRuns };
-
-//# sourceMappingURL=textCommand.js.map

package/dist/features/text/textCommand.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"textCommand.js","names":["textCommandFromRuns","resolved","resolveTextStyle","style","paint","scale","resolveRuns","runs","resolveAlign","textCommand","x","y","maxWidth","height","verticalAlign","width","textCommandFromPose","textPoseLayoutInput","pose","runsInPoseFrame","opts","isSolid","r","fill","resolveFillPattern","fillInPoseFrame","box"],"sources":["../../../src/features/text/textCommand.ts"],"sourcesContent":["/**\n * Build a `TextDrawCommand`. `textCommandFromPose` is the command for a text\n * node — what `kit:text` and `createTextLayer` both emit. `textCommand` takes\n * a plain string and wraps it in one run; `textCommandFromRuns` takes the\n * styled runs directly, for text that has no pose. All three\n * resolve through `resolveTextStyle` + `resolveRuns`, so every emitter of a\n * text command derives `align` and per-run resolution the same way — a\n * caller that assembles the command by hand is one field away from a\n * silently different result.\n *\n * `paint` is the node's `data.fill` / `data.stroke`. A caller with no node —\n * a HUD widget, a debug overlay — states its color on the run instead.\n *\n * `scale` is the view scale a `{ px }` `fontSize` or `letterSpacing` resolves\n * against — for a world-space layer, the mean of `view.scale.x` and\n * `view.scale.y`. It has to be applied here and not at draw time, because a\n * screen-pixel size moves the glyph advances and so the wrap points.\n */\n\nimport type { DrawCommand, TextDrawCommand } from '../../renderer';\nimport type { TextPaint, TextPose, TextStyle } from '@weasel-js/text';\nimport { resolveAlign, resolveTextStyle, textPoseLayoutInput } from '@weasel-js/text';\nimport { resolveRuns } from '@weasel-js/text';\nimport type { StyledRun } from '@weasel-js/text';\nimport type { TextVerticalAlign, ResolvedRun } from '@weasel-js/text';\nimport type { FillStyle } from '@weasel-js/paint';\nimport { fillInPoseFrame, type FillPoseBox } from '../../core/fillInPoseFrame';\nimport { resolveFillPattern } from '../patterns/resolveSpec';\n\n/** Build a draw command from styled runs, for text with no pose. `style`\n *  supplies the defaults each run inherits; the rest match `textCommand`. */\nexport function textCommandFromRuns(\n  x: number,\n  y: number,\n  runs: readonly StyledRun[],\n  style?: TextStyle,\n  maxWidth?: number,\n  height?: number,\n  verticalAlign?: TextVerticalAlign,\n  paint?: TextPaint,\n  width?: number,\n  scale = 1,\n): DrawCommand {\n  const resolved = resolveTextStyle(style, paint, scale);\n  return {\n    kind: 'text',\n    x,\n    y,\n    runs: resolveRuns(runs, resolved, scale),\n    align: resolveAlign(resolved.align, resolved.direction),\n    justify: resolved.align === 'justify',\n    maxWidth,\n    style: style ?? {},\n    height,\n    verticalAlign,\n    width,\n  };\n}\n\n/** Build a draw command for a single unstyled string. Text is laid out with\n *  the registered font's metrics, wrapped at `maxWidth`, aligned across\n *  `width` (default `maxWidth`) and within `height` when `verticalAlign` is\n *  given. */\nexport function textCommand(\n  x: number,\n  y: number,\n  text: string,\n  style?: TextStyle,\n  maxWidth?: number,\n  height?: number,\n  verticalAlign?: TextVerticalAlign,\n  paint?: TextPaint,\n  width?: number,\n  scale = 1,\n): DrawCommand {\n  return textCommandFromRuns(\n    x, y, [{ text }], style, maxWidth, height, verticalAlign, paint, width, scale,\n  );\n}\n\n/**\n * The draw command for a text pose. Its wrap width, alignment box and runs\n * come from `textPoseLayoutInput`, so the renderer lays it out into exactly\n * the lines `layoutTextPose` reports for the same pose.\n *\n * Each run's paints are resolved against the pose box the way every other\n * node's are — a `'bounds'` paint mapped onto it, a pattern spec swapped for\n * its texture — since the renderer can do neither.\n */\nexport function textCommandFromPose(pose: TextPose, scale = 1): TextDrawCommand {\n  const { runs, opts } = textPoseLayoutInput(pose, scale);\n  return {\n    kind: 'text',\n    x: pose.x,\n    y: pose.y,\n    runs: runsInPoseFrame(runs, pose),\n    align: opts.align,\n    justify: opts.justify,\n    maxWidth: opts.maxWidth,\n    width: opts.alignWidth,\n    style: pose.style ?? {},\n    height: pose.height,\n    verticalAlign: pose.verticalAlign,\n  };\n}\n\nfunction runsInPoseFrame(runs: ResolvedRun[], box: FillPoseBox): ResolvedRun[] {\n  if (runs.every((r) => isSolid(r.fill) && isSolid(r.stroke?.paint))) return runs;\n  return runs.map((r) => {\n    const fill = r.fill && resolveFillPattern(fillInPoseFrame(r.fill, box));\n    const paint = r.stroke?.paint && resolveFillPattern(fillInPoseFrame(r.stroke.paint, box));\n    return { ...r, fill, stroke: r.stroke && { ...r.stroke, paint: paint || undefined } };\n  });\n}\n\nfunction isSolid(paint: FillStyle | null | undefined): boolean {\n  return paint == null || (paint.fill ?? 'solid') === 'solid';\n}\n"],"mappings":";;;;AA+BA,SAAgBA,EACd,GACA,GACA,GACA,GACA,GACA,GACA,GACA,GACA,GACA,IAAQ,GACK;CACb,IAAMC,IAAWC,EAAiBC,GAAOC,GAAOC,CAAK;CACrD,OAAO;EACL,MAAM;EACN;EACA;EACA,MAAMC,EAAYC,GAAMN,GAAUI,CAAK;EACvC,OAAOG,EAAaP,EAAS,OAAOA,EAAS,SAAS;EACtD,SAASA,EAAS,UAAU;EAC5B;EACA,OAAOE,KAAS,CAAC;EACjB;EACA;EACA;CACF;AACF;AAMA,SAAgBM,EACd,GACA,GACA,GACA,GACA,GACA,GACA,GACA,GACA,GACA,IAAQ,GACK;CACb,OAAOT,EACLU,GAAGC,GAAG,CAAC,EAAE,QAAK,CAAC,GAAGR,GAAOS,GAAUC,GAAQC,GAAeV,GAAOW,GAAOV,CAC1E;AACF;AAWA,SAAgBW,EAAoB,GAAgB,IAAQ,GAAoB;CAC9E,IAAM,EAAE,SAAM,YAASC,EAAoBC,GAAMb,CAAK;CACtD,OAAO;EACL,MAAM;EACN,GAAGa,EAAK;EACR,GAAGA,EAAK;EACR,MAAMC,EAAgBZ,GAAMW,CAAI;EAChC,OAAOE,EAAK;EACZ,SAASA,EAAK;EACd,UAAUA,EAAK;EACf,OAAOA,EAAK;EACZ,OAAOF,EAAK,SAAS,CAAC;EACtB,QAAQA,EAAK;EACb,eAAeA,EAAK;CACtB;AACF;AAEA,SAASC,EAAgB,GAAqB,GAAiC;CAE7E,OADIZ,EAAK,OAAO,MAAMc,EAAQC,EAAE,IAAI,KAAKD,EAAQC,EAAE,QAAQ,KAAK,CAAC,IAAUf,IACpEA,EAAK,KAAK,MAAM;EACrB,IAAMgB,IAAOD,EAAE,QAAQE,EAAmBC,EAAgBH,EAAE,MAAMI,CAAG,CAAC,GAChEtB,IAAQkB,EAAE,QAAQ,SAASE,EAAmBC,EAAgBH,EAAE,OAAO,OAAOI,CAAG,CAAC;EACxF,OAAO;GAAE,GAAGJ;GAAG;GAAM,QAAQA,EAAE,UAAU;IAAE,GAAGA,EAAE;IAAQ,OAAOlB,KAAS,KAAA;GAAU;EAAE;CACtF,CAAC;AACH;AAEA,SAASiB,EAAQ,GAA8C;CAC7D,OAAOjB,KAAS,SAASA,EAAM,QAAQ,aAAa;AACtD"}