@weasel-js/text 1.9.4 → 1.10.0

package/dist/index.js

@@ -1,7 +1,10 @@
-import { resolveTextStyle, cachedLayoutRuns, graphemeCount, wrapLines, hangs, DECORATION_KINDS, decorationRule } from './chunk-VZNK3C6F.js';
-export { BREAK_ALLOWED, BREAK_MANDATORY, DEFAULT_DECORATION_METRICS, DEFAULT_TEXT_STYLE, LAYOUT_CACHE_STRUCTURAL_LIMIT, LAYOUT_CACHE_VARIANT_LIMIT, NO_BREAK, cachedLayoutRuns, decorationMetrics, fontString, isHardLineBreak, layoutRuns, lineBreakOpportunities, paragraphDirection, registerBidi, resolveAlign, resolveTextStyle } from './chunk-VZNK3C6F.js';
-import { resolveScreenLength } from '@weasel-js/paint';
-import { faceMetricsOf, resolveFontVariant, faceMetricsFor, cssFamilyName } from '@weasel-js/font';
+import { DEFAULT_TAB_SIZE, resolveTextStyle, cachedLayoutRuns, graphemeCount, wrapLines, hangs, tabAdvance, widthWithTabs, layoutRuns } from './chunk-Z6YRJ33J.js';
+export { BREAK_ALLOWED, BREAK_MANDATORY, DEFAULT_TEXT_STYLE, LAYOUT_CACHE_STRUCTURAL_LIMIT, LAYOUT_CACHE_VARIANT_LIMIT, NO_BREAK, cachedLayoutRuns, fontString, isHardLineBreak, layoutRuns, lineBreakOpportunities, paragraphDirection, registerBidi, resolveAlign, resolveTextStyle } from './chunk-Z6YRJ33J.js';
+import { resolveScreenLength, fillHasInk, strokeHasInk, paintKey, strokeKey } from '@weasel-js/paint';
+import { faceMetricsOf, resolveFontVariant, glyphGeneration, loadFontOutlines, faceMetricsFor, glyphOutline, outlineStatus, cssFamilyName } from '@weasel-js/font';
+import { MIXED, isPlainObject } from '@weasel-js/registry';
+export { MIXED } from '@weasel-js/registry';
+import { transformPath, poseFrameOf, pathFromD, pathSignedArea, reversePath, PATH_M, PATH_L, PATH_Z } from '@weasel-js/geom';
 
 // src/runs.ts
 function toRuns(input) {
@@ -368,6 +371,66 @@ function resolveRuns(runs, style, viewScale = 1) {
   return out;
 }
 
+// src/layout/decorationMetrics.ts
+var DECORATION_KINDS = ["underline", "strikethrough", "overline"];
+var DEFAULT_DECORATION_METRICS = Object.freeze({
+  underline: Object.freeze({ offset: 0.1, thickness: 0.05 }),
+  strikethrough: Object.freeze({ offset: -0.3, thickness: 0.05 }),
+  overline: Object.freeze({ offset: -0.9, thickness: 0.05 })
+});
+var resolved = /* @__PURE__ */ new WeakMap();
+function decorationMetrics(face) {
+  if (!face) return DEFAULT_DECORATION_METRICS;
+  let out = resolved.get(face);
+  if (!out) {
+    const underline = face.underline ?? DEFAULT_DECORATION_METRICS.underline;
+    out = Object.freeze({
+      underline,
+      strikethrough: face.strikethrough ?? DEFAULT_DECORATION_METRICS.strikethrough,
+      overline: Object.freeze({ offset: DEFAULT_DECORATION_METRICS.overline.offset, thickness: underline.thickness })
+    });
+    resolved.set(face, out);
+  }
+  return out;
+}
+function decorationRule(kind, baselineY, fontSize, face) {
+  const m = decorationMetrics(face)[kind];
+  const y0 = baselineY + fontSize * m.offset;
+  return { y0, y1: y0 + fontSize * m.thickness };
+}
+function lineDecorations(glyphs, runs, faceOf, paintOf) {
+  const rules = [];
+  let open = null;
+  const close = () => {
+    const s = open;
+    open = null;
+    if (!s || s.x1 <= s.x0) return;
+    for (const kind of DECORATION_KINDS) {
+      if (!s.style[kind]) continue;
+      const { y0, y1 } = decorationRule(kind, s.baselineY, s.style.fontSize, s.face);
+      rules.push({ kind, x0: s.x0, y0, x1: s.x1, y1, run: s.run });
+    }
+  };
+  for (const g of glyphs) {
+    const style = runs[g.run];
+    const paint = paintOf(g.run);
+    if (paint === null || !DECORATION_KINDS.some((kind) => style[kind])) {
+      close();
+      continue;
+    }
+    const face = faceOf(g.run);
+    const joins = open !== null && DECORATION_KINDS.every((kind) => open.style[kind] === style[kind]) && open.style.fontSize === style.fontSize && open.face === face && open.baselineY === g.baselineY && open.paint === paint;
+    if (joins) {
+      open.x1 = g.x + g.step;
+    } else {
+      close();
+      open = { run: g.run, style, face, paint, baselineY: g.baselineY, x0: g.x, x1: g.x + g.step };
+    }
+  }
+  close();
+  return rules;
+}
+
 // src/measure/verticalAlign.ts
 function verticalAlignOffset(align, boxHeight, textHeight) {
   if (align === void 0 || align === "top" || boxHeight === void 0) return 0;
@@ -402,6 +465,135 @@ function layoutTextPose(pose, scale = 1) {
     y: pose.y + verticalAlignOffset(pose.verticalAlign, pose.height, laid.bounds.height)
   };
 }
+function glyphOutlineD(g, run, minSize) {
+  if (g.glyph?.color) return null;
+  const { family, weight, style } = g.resolved.resolved;
+  if (g.resolved.source === "outline") return glyphOutline(family, weight, style, g.cp);
+  if (g.glyph === null) return null;
+  if (minSize === void 0) return null;
+  if (run.fontSize < minSize && !strokeHasInk(run.stroke)) return null;
+  if (g.resolved.synthetic.bold) return null;
+  return glyphOutline(family, weight, style, g.cp);
+}
+function glyphQuad(g) {
+  const { font, glyph } = g;
+  if (font === null || glyph === null || glyph.width === 0 || glyph.page < 0) return null;
+  const scale = g.fontSize / g.metrics.size;
+  const x0 = g.x + glyph.xoffset * scale;
+  const y0 = g.baselineY + (glyph.yoffset - g.metrics.base) * scale;
+  return {
+    x0,
+    y0,
+    x1: x0 + glyph.width * scale,
+    y1: y0 + glyph.height * scale,
+    u0: glyph.x / font.common.scaleW,
+    v0: glyph.y / font.common.scaleH,
+    u1: (glyph.x + glyph.width) / font.common.scaleW,
+    v1: (glyph.y + glyph.height) / font.common.scaleH,
+    baselineY: g.baselineY
+  };
+}
+function runFaces(runs) {
+  const faces = runs.map((r) => faceMetricsOf(resolveFontVariant(r.fontFamily, r.fontWeight, r.fontStyle)));
+  return (run) => faces[run];
+}
+function groupFor(groups, g, run, source) {
+  const { family, weight, style } = g.resolved.resolved;
+  const { synthetic } = g.resolved;
+  const page = source === "outline" ? 0 : g.glyph.page;
+  const stroke = source === "outline" && strokeHasInk(run.stroke) ? run.stroke : void 0;
+  const key = `${family}|${weight}|${style}|${synthetic.bold ? 1 : 0}${synthetic.italic ? 1 : 0}|${paintKey(run.fill?.paint)}|${strokeKey(stroke)}|${source}|${page}`;
+  let group = groups.get(key);
+  if (!group) {
+    group = {
+      family,
+      weight,
+      style,
+      synthetic: { ...synthetic },
+      source,
+      page,
+      fill: run.fill,
+      ...stroke ? { stroke } : {},
+      quads: [],
+      glyphs: []
+    };
+    groups.set(key, group);
+  }
+  return group;
+}
+function paintRuns(laid, runs, opts = {}) {
+  const groups = /* @__PURE__ */ new Map();
+  const decorations = [];
+  const faceOf = runFaces(runs);
+  const rulePaint = (run) => fillHasInk(runs[run].fill) ? paintKey(runs[run].fill.paint) : null;
+  for (const line of laid.lines) {
+    for (const g of line.glyphs) {
+      const run = runs[g.run];
+      const d = glyphOutlineD(g, run, opts.outlineMinSize);
+      if (!fillHasInk(run.fill) && !(d !== null && strokeHasInk(run.stroke))) continue;
+      if (d !== null) {
+        const { family, weight, style } = g.resolved.resolved;
+        groupFor(groups, g, run, "outline").glyphs.push({
+          d,
+          key: `${family}|${weight}|${style}|${g.cp}`,
+          x: g.x,
+          baselineY: g.baselineY,
+          scale: g.fontSize
+        });
+        continue;
+      }
+      const quad = glyphQuad(g);
+      if (quad) groupFor(groups, g, run, g.glyph?.color ? "color" : g.resolved.source).quads.push(quad);
+    }
+    for (const rule of lineDecorations(line.glyphs, runs, faceOf, rulePaint)) {
+      const { run, ...rect } = rule;
+      decorations.push({ ...rect, fill: runs[run].fill });
+    }
+  }
+  return { groups: [...groups.values()], decorations };
+}
+var PAINT_CACHE_VARIANT_LIMIT = 32;
+var own = /* @__PURE__ */ new WeakMap();
+var shared = /* @__PURE__ */ new WeakMap();
+function outlineBucket(runs, min) {
+  if (min === void 0) return -1;
+  const sizes = /* @__PURE__ */ new Set();
+  for (const r of runs) sizes.add(r.fontSize);
+  let n = 0;
+  for (const size of sizes) if (size >= min) n++;
+  return n;
+}
+function variantKey(runs, opts) {
+  let out = `${outlineBucket(runs, opts.outlineMinSize)}`;
+  for (const r of runs) {
+    out += `|${r.underline ? 1 : 0}${r.strikethrough ? 1 : 0}${r.overline ? 1 : 0}${paintKey(r.fill?.paint)}|${strokeKey(r.stroke)}`;
+  }
+  return out;
+}
+function cachedPaintRuns(laid, runs, opts = {}) {
+  const generation = glyphGeneration();
+  const key = variantKey(runs, opts);
+  const fresh = (p) => p !== void 0 && p.generation === generation && p.key === key;
+  let byLayout = own.get(runs);
+  if (byLayout === void 0) {
+    byLayout = /* @__PURE__ */ new WeakMap();
+    own.set(runs, byLayout);
+  }
+  const mine = byLayout.get(laid);
+  if (fresh(mine)) return mine.painted;
+  let byKey = shared.get(laid);
+  if (byKey === void 0) {
+    byKey = /* @__PURE__ */ new Map();
+    shared.set(laid, byKey);
+  }
+  let painting = byKey.get(key);
+  byKey.delete(key);
+  if (!fresh(painting)) painting = { generation, key, painted: paintRuns(laid, runs, opts) };
+  if (byKey.size >= PAINT_CACHE_VARIANT_LIMIT) byKey.delete(byKey.keys().next().value);
+  byKey.set(key, painting);
+  byLayout.set(laid, painting);
+  return painting.painted;
+}
 
 // src/measure/measureText.ts
 function measuredWidth(ctx, text, style) {
@@ -417,27 +609,40 @@ function measureText(ctx, text, maxWidth, style) {
     u += ch.length;
   }
   at.push(u);
-  const wrapped = wrapLines(cps, maxWidth, (start, end) => measuredWidth(ctx, text.slice(at[start], at[end]), style));
-  const lines = wrapped.map((l) => {
+  const flatWidth = (start, end) => measuredWidth(ctx, text.slice(at[start], at[end]), style);
+  const tabs = [];
+  cps.forEach((cp, k) => {
+    if (cp === 9) tabs.push(k);
+  });
+  const space = tabs.length === 0 ? 0 : ctx.measureText(" ").width;
+  const tab = { stop: style.tabSize * (space + style.letterSpacing), min: space / 2 };
+  const widthOf = (start, end, piece) => widthWithTabs(start, end, tabs, () => tab, flatWidth, piece);
+  const wrapped = wrapLines(cps, maxWidth, (start, end) => widthOf(start, end));
+  const lines = [];
+  const spans = [];
+  for (const l of wrapped) {
     let end = l.end;
     while (end > l.start && hangs(cps[end - 1])) end--;
-    return text.slice(at[l.start], at[end]);
-  });
+    lines.push(text.slice(at[l.start], at[end]));
+    const row = [];
+    widthOf(l.start, end, (from, to, x) => row.push({ text: text.slice(at[from], at[to]), x }));
+    spans.push(row);
+  }
   const lineStarts = wrapped.map((l) => at[l.start]);
   const height = lines.length * style.fontSize * style.lineHeight;
-  return { lines, lineStarts, height };
+  return { lines, spans, lineStarts, height };
 }
 
 // src/measure/measureTextBounds.ts
 function measureTextBounds(text, style, opts) {
-  const resolved = resolveTextStyle(style, void 0, opts?.scale);
-  const runs = resolveRuns([{ text }], resolved, opts?.scale);
+  const resolved2 = resolveTextStyle(style, void 0, opts?.scale);
+  const runs = resolveRuns([{ text }], resolved2, opts?.scale);
   const { bounds } = cachedLayoutRuns(runs, {
     maxWidth: opts?.maxWidth ?? Infinity,
-    lineHeight: opts?.lineHeight ?? resolved.lineHeight,
-    align: resolved.align,
-    direction: resolved.direction,
-    tabSize: resolved.tabSize
+    lineHeight: opts?.lineHeight ?? resolved2.lineHeight,
+    align: resolved2.align,
+    direction: resolved2.direction,
+    tabSize: resolved2.tabSize
   });
   return { width: bounds.width, height: bounds.height };
 }
@@ -458,6 +663,115 @@ function textLineBoxes(pose, opts = {}) {
   }
   return out;
 }
+
+// src/hitTest.ts
+function caretCells(cells) {
+  const out = [];
+  for (const c of cells) {
+    const prev = out[out.length - 1];
+    if (prev && (!prev.clusterEnd || prev.srcIndex === c.srcIndex && prev.srcEnd === c.srcEnd)) {
+      const x0 = Math.min(prev.x, c.x);
+      const x1 = Math.max(prev.x + prev.advance, c.x + c.advance);
+      out[out.length - 1] = {
+        ...prev,
+        x: x0,
+        advance: x1 - x0,
+        srcIndex: Math.min(prev.srcIndex, c.srcIndex),
+        srcEnd: Math.max(prev.srcEnd, c.srcEnd),
+        clusterEnd: c.clusterEnd
+      };
+    } else {
+      out.push(c);
+    }
+  }
+  return out;
+}
+function pointInTextPose(x, y, pose, opts = {}) {
+  const p = opts.padding ?? 0;
+  return x >= pose.x - p && x <= pose.x + pose.width + p && y >= pose.y - p && y <= pose.y + pose.height + p;
+}
+function caretIndexAt(x, y, pose) {
+  const { laid, x: dx, y: dy } = layoutTextPose(pose);
+  const lines = laid.lines;
+  if (lines.length === 0) return 0;
+  const last = lines[lines.length - 1];
+  if (y < dy + lines[0].y0) return lines[0].cells[0]?.srcIndex ?? lines[0].srcEnd;
+  if (y >= dy + last.y1) return last.srcEnd;
+  let line = last;
+  for (const candidate of lines) {
+    if (y < dy + candidate.y1) {
+      line = candidate;
+      break;
+    }
+  }
+  if (line.cells.length === 0) return line.srcEnd;
+  const cells = caretCells(line.cells);
+  const visual = cells.map((_, i) => i).sort((a, b) => cells[a].x - cells[b].x);
+  for (const i of visual) {
+    const c = cells[i];
+    if (x >= dx + c.x + c.advance / 2) continue;
+    return c.level % 2 === 1 ? c.srcEnd : c.srcIndex;
+  }
+  const trailing = cells[visual[visual.length - 1]];
+  return trailing.level % 2 === 1 ? trailing.srcIndex : trailing.srcEnd;
+}
+
+// src/fitTextPose.ts
+function fitTextPose(pose, opts = {}) {
+  const axis = opts.axis ?? "height";
+  const { padX, padY } = resolvePadding(opts.padding);
+  const { bounds } = layoutTextPose(axis === "height" ? { ...pose, width: pose.width - padX * 2 } : { ...pose, style: { ...pose.style, wrap: false } }).laid;
+  if (axis === "height") return { ...pose, height: bounds.height + padY * 2 };
+  return {
+    ...pose,
+    width: bounds.width + padX * 2,
+    height: bounds.height + padY * 2
+  };
+}
+function resolvePadding(p) {
+  if (p == null) return { padX: 0, padY: 0 };
+  if (typeof p === "number") return { padX: p, padY: p };
+  return { padX: p.x ?? 0, padY: p.y ?? 0 };
+}
+
+// src/renderLabel.ts
+function renderLabel(ctx, text, x, y, options = {}) {
+  const {
+    align = "center",
+    fontSize = 13,
+    renderText,
+    width,
+    height,
+    padX = 4,
+    padY = 1,
+    cornerRadius = 3
+  } = options;
+  ctx.save();
+  ctx.font = `${fontSize}px sans-serif`;
+  ctx.textBaseline = "top";
+  const contentW = width ?? ctx.measureText(text).width;
+  const contentH = height ?? fontSize;
+  const w = contentW + padX * 2;
+  const h = contentH + padY * 2;
+  const rx = align === "center" ? x - w / 2 : x - padX;
+  ctx.fillStyle = "rgba(0, 0, 0, 0.75)";
+  ctx.beginPath();
+  ctx.roundRect(rx, y - padY, w, h, cornerRadius);
+  ctx.fill();
+  ctx.textAlign = align === "center" ? "center" : "left";
+  const tx = align === "center" ? x : x;
+  (renderText ?? defaultLabelTextRenderer)(ctx, text, tx, y);
+  ctx.restore();
+}
+var defaultLabelTextRenderer = (ctx, text, x, y) => {
+  ctx.fillStyle = "#FFFFFF";
+  ctx.fillText(text, x, y);
+};
+
+// src/isTextData.ts
+function isTextData(data) {
+  return typeof data === "object" && data !== null && typeof data.text === "string";
+}
 function runMetrics(run, fontSize, face) {
   const script = run.script ? scriptMetrics(face)[run.script] : void 0;
   const scale = run.fontScale ?? script?.size ?? 1;
@@ -469,7 +783,7 @@ function runMetrics(run, fontSize, face) {
     y: shiftEm === 0 ? 0 : -shiftEm * fontSize
   };
 }
-function layoutMarkdown(runs, maxWidth, fontSize, measure, lineHeightFactor = 1.3, faceOf) {
+function layoutMarkdown(runs, maxWidth, fontSize, measure, lineHeightFactor = 1.3, faceOf, tabSize = DEFAULT_TAB_SIZE) {
   if (runs.length === 0) return { lines: [], width: 0, height: 0 };
   const shown = transformRunTexts(runs.map((r) => r.text), runs.map((r) => r.textTransform ?? "none"));
   const segs = [];
@@ -520,7 +834,7 @@ function layoutMarkdown(runs, maxWidth, fontSize, measure, lineHeightFactor = 1.
     const out = [];
     for (let k = from; k < to; k++) {
       const last = out[out.length - 1];
-      if (last && last.run === runOf[k] && last.end === startOf[k]) {
+      if (last && last.run === runOf[k] && last.end === startOf[k] && cps[k] !== 9 && cps[k - 1] !== 9) {
         out[out.length - 1] = { ...last, end: endOf[k] };
       } else {
         out.push({ run: runOf[k], start: startOf[k], end: endOf[k] });
@@ -535,14 +849,25 @@ function layoutMarkdown(runs, maxWidth, fontSize, measure, lineHeightFactor = 1.
     const positioned = [];
     for (const p of line) {
       const { run, face, size, y, runSize } = placed[p.run];
-      const width2 = pieceWidth(p);
+      const tab = run.text[p.start] === "	" ? stopOf(p.run) : null;
+      const width2 = tab ? tabAdvance(x, tab.stop, tab.min) : pieceWidth(p);
       positioned.push({ ...run, text: run.text.slice(p.start, p.end), x, width: width2, y, size, ...face ? { face } : {} });
       x += width2;
       maxSize = Math.max(maxSize, runSize);
     }
     lines.push({ runs: positioned, width: x, height: (maxSize > 0 ? maxSize : fontSize) * lineHeightFactor });
   }
-  const widthOf = (start, end) => piecesOf(start, end).reduce((w, p) => w + pieceWidth(p), 0);
+  const stopOf = (run) => {
+    const { run: r, size } = placed[run];
+    const space = measure(" ", size, r.bold ?? false, r.italic ?? false);
+    return { stop: tabSize * space, min: space / 2 };
+  };
+  const tabs = [];
+  cps.forEach((cp, k) => {
+    if (cp === 9) tabs.push(k);
+  });
+  const flatWidth = (start, end) => piecesOf(start, end).reduce((w, p) => w + pieceWidth(p), 0);
+  const widthOf = (start, end) => widthWithTabs(start, end, tabs, (k) => stopOf(runOf[k]), flatWidth);
   for (const line of wrapLines(cps, maxWidth, widthOf)) {
     let end = line.end;
     if (line.wrapped) while (end > line.start && hangs(cps[end - 1])) end--;
@@ -599,7 +924,7 @@ function createMarkdownRenderer(ctx, text, fontSize, maxWidth = Infinity, fontOp
   const family = fontOpts.family ?? "sans-serif";
   const weight = numericWeight(fontOpts.weight ?? 400);
   const faceOf = (bold, italic) => faceMetricsFor(family, bold ? 700 : weight, italic ? "italic" : "normal");
-  const layout = layoutMarkdown(parsed, maxWidth, fontSize, measure, fontOpts.lineHeight, faceOf);
+  const layout = layoutMarkdown(parsed, maxWidth, fontSize, measure, fontOpts.lineHeight, faceOf, fontOpts.tabSize);
   function walk(c, x, y, drawRun) {
     const align = c.textAlign;
     const left = blockLeft(c, x, layout.width);
@@ -657,7 +982,442 @@ function createMarkdownRenderer(ctx, text, fontSize, maxWidth = Infinity, fontOp
   };
   return { renderer, strokeRenderer, width: layout.width, height: layout.height };
 }
+var STYLE_KEYS = [
+  "bold",
+  "fontWeight",
+  "italic",
+  "underline",
+  "strikethrough",
+  "overline",
+  "fontFamily",
+  "fontSize",
+  "letterSpacing",
+  "fill",
+  "stroke",
+  "script",
+  "baselineShift",
+  "fontScale",
+  "textTransform",
+  "fontVariantCaps"
+];
+var FLAG_KEYS = /* @__PURE__ */ new Set([
+  "bold",
+  "italic",
+  "underline",
+  "strikethrough",
+  "overline"
+]);
+function deepEqual(a, b) {
+  if (Object.is(a, b)) return true;
+  if (Array.isArray(a) && Array.isArray(b)) {
+    return a.length === b.length && a.every((item, i) => deepEqual(item, b[i]));
+  }
+  if (isPlainObject(a) && isPlainObject(b)) {
+    const keys = Object.keys(a);
+    if (keys.length !== Object.keys(b).length) return false;
+    return keys.every((k) => k in b && deepEqual(a[k], b[k]));
+  }
+  return false;
+}
+function valueAt(run, key) {
+  const value = run[key];
+  if (FLAG_KEYS.has(key)) return value ?? false;
+  return value;
+}
+var STRUCTURAL_KEYS = /* @__PURE__ */ new Set(["fill", "stroke"]);
+function sameValue(key, a, b) {
+  return STRUCTURAL_KEYS.has(key) ? deepEqual(a, b) : Object.is(a, b);
+}
+function sameStyle(a, b) {
+  return STYLE_KEYS.every((key) => sameValue(key, valueAt(a, key), valueAt(b, key)));
+}
+function totalLength(runs) {
+  let n = 0;
+  for (const run of runs) n += run.text.length;
+  return n;
+}
+function styleAtRange(runs, start, end) {
+  const lo = Math.max(0, start);
+  const hi = end;
+  if (!(lo < hi)) return {};
+  const first = /* @__PURE__ */ new Map();
+  const mixed = /* @__PURE__ */ new Set();
+  let seen = false;
+  let pos = 0;
+  for (const run of runs) {
+    const runEnd = pos + run.text.length;
+    const a = Math.max(pos, lo);
+    const b = Math.min(runEnd, hi);
+    pos = runEnd;
+    if (!(a < b)) continue;
+    for (const key of STYLE_KEYS) {
+      const value = valueAt(run, key);
+      if (!seen) first.set(key, value);
+      else if (!mixed.has(key) && !sameValue(key, first.get(key), value)) {
+        mixed.add(key);
+      }
+    }
+    seen = true;
+  }
+  if (!seen) return {};
+  const style = {};
+  for (const key of STYLE_KEYS) {
+    if (mixed.has(key)) style[key] = MIXED;
+    else {
+      const value = first.get(key);
+      if (value !== void 0) style[key] = value;
+    }
+  }
+  return style;
+}
+function runsCarryStyling(runs) {
+  return runs.some(
+    (run) => STYLE_KEYS.some((key) => {
+      const value = run[key];
+      return value !== void 0 && value !== false;
+    })
+  );
+}
+function supersededKey(patch) {
+  if ("bold" in patch && !("fontWeight" in patch)) return "fontWeight";
+  if (patch.fontWeight !== void 0 && !("bold" in patch)) return "bold";
+  return void 0;
+}
+function patchRangeStyle(range, patch) {
+  const out = { ...range };
+  const superseded = supersededKey(patch);
+  if (superseded !== void 0) delete out[superseded];
+  for (const [key, value] of Object.entries(patch)) {
+    if (value !== void 0) out[key] = value;
+  }
+  return out;
+}
+function patchRun(run, patch) {
+  const next = { ...run };
+  const superseded = supersededKey(patch);
+  if (superseded !== void 0) delete next[superseded];
+  for (const key of STYLE_KEYS) {
+    if (!(key in patch)) continue;
+    const value = patch[key];
+    if (value === void 0 || value === false) delete next[key];
+    else next[key] = value;
+  }
+  return next;
+}
+function coalesceRuns(runs) {
+  const out = [];
+  for (const run of runs) {
+    if (run.text.length === 0) continue;
+    const prev = out[out.length - 1];
+    if (prev && sameStyle(prev, run)) prev.text += run.text;
+    else out.push({ ...run });
+  }
+  return out;
+}
+function applyStyleToRange(runs, start, end, patch) {
+  const lo = Math.max(0, start);
+  const hi = Math.min(totalLength(runs), end);
+  if (!(lo < hi)) return coalesceRuns(runs);
+  const out = [];
+  let pos = 0;
+  for (const run of runs) {
+    const runEnd = pos + run.text.length;
+    const a = Math.max(pos, lo);
+    const b = Math.min(runEnd, hi);
+    if (a < b) {
+      if (pos < a) out.push({ ...run, text: run.text.slice(0, a - pos) });
+      out.push(patchRun({ ...run, text: run.text.slice(a - pos, b - pos) }, patch));
+      if (b < runEnd) out.push({ ...run, text: run.text.slice(b - pos) });
+    } else {
+      out.push({ ...run });
+    }
+    pos = runEnd;
+  }
+  return coalesceRuns(out);
+}
+
+// src/runs/flagRange.ts
+function nodeHasFlag(style, key) {
+  switch (key) {
+    case "bold":
+      return style.fontWeight !== void 0 && isBoldWeight(style.fontWeight);
+    case "italic":
+      return style.fontStyle === "italic";
+    case "underline":
+      return style.underline === true;
+    case "strikethrough":
+      return style.strikethrough === true;
+    case "overline":
+      return style.overline === true;
+  }
+}
+function unboldPatch(style) {
+  return nodeHasFlag(style, "bold") ? { bold: false, fontWeight: 400 } : { bold: false };
+}
+function clearNodeFlag(style, key) {
+  const next = { ...style };
+  switch (key) {
+    case "italic":
+      next.fontStyle = "normal";
+      break;
+    case "underline":
+      delete next.underline;
+      break;
+    case "strikethrough":
+      delete next.strikethrough;
+      break;
+    case "overline":
+      delete next.overline;
+      break;
+  }
+  return next;
+}
+function setFlagOverRange(runs, style, start, end, key, value) {
+  if (value || !nodeHasFlag(style, key)) {
+    return { runs: applyStyleToRange(runs, start, end, { [key]: value }), style };
+  }
+  if (key === "bold") {
+    return { runs: applyStyleToRange(runs, start, end, unboldPatch(style)), style };
+  }
+  const total = runs.reduce((n, r) => n + r.text.length, 0);
+  const lo = Math.max(0, start);
+  const hi = Math.min(total, end);
+  let next = applyStyleToRange(runs, 0, total, { [key]: true });
+  if (lo < hi) next = applyStyleToRange(next, lo, hi, { [key]: false });
+  return { runs: next, style: clearNodeFlag(style, key) };
+}
+
+// src/runs/effectiveRangeStyle.ts
+var FLAGS = ["italic", "underline", "strikethrough", "overline"];
+function rangeWeight(range, style) {
+  const node = numericWeight(style?.fontWeight ?? 400);
+  const own2 = range?.fontWeight;
+  if (own2 === MIXED) return { fontWeight: MIXED, bold: MIXED };
+  if (own2 !== void 0) return { fontWeight: own2, bold: isBoldWeight(own2) };
+  const flag = range?.bold;
+  if (flag === MIXED) {
+    if (node === 700) return { fontWeight: 700, bold: true };
+    return { fontWeight: MIXED, bold: isBoldWeight(node) ? true : MIXED };
+  }
+  const weight = flag === true ? 700 : node;
+  return { fontWeight: weight, bold: isBoldWeight(weight) };
+}
+var OVERRIDES = [
+  "fontFamily",
+  "fontSize",
+  "letterSpacing",
+  "fill",
+  "script",
+  "baselineShift",
+  "fontScale",
+  "textTransform",
+  "fontVariantCaps"
+];
+function effectiveRangeStyle(range, style, paint) {
+  const resolved2 = resolveTextStyle(style, paint);
+  const node = style ?? {};
+  const out = {
+    fontFamily: resolved2.fontFamily,
+    fontSize: resolved2.fontSize,
+    letterSpacing: resolved2.letterSpacing,
+    textTransform: resolved2.textTransform,
+    fontVariantCaps: resolved2.fontVariantCaps
+  };
+  if (resolved2.fill !== null) out.fill = resolved2.fill;
+  Object.assign(out, rangeWeight(range, style));
+  for (const key of FLAGS) {
+    const on = nodeHasFlag(node, key);
+    const run = range?.[key];
+    out[key] = on || run === void 0 ? on : run;
+  }
+  if (range === null) return out;
+  for (const key of OVERRIDES) {
+    if (range[key] !== void 0) out[key] = range[key];
+  }
+  return out;
+}
+
+// src/syntheticItalic.ts
+var SYNTHETIC_ITALIC_RADIANS = 0.2094;
+var TextOutlinesError = class extends Error {
+  reason;
+  family;
+  weight;
+  style;
+  constructor(reason, family, weight, style, detail) {
+    super(`textToPath: "${family}" ${weight}/${style} \u2014 ${detail}`);
+    this.name = "TextOutlinesError";
+    this.reason = reason;
+    this.family = family;
+    this.weight = weight;
+    this.style = style;
+  }
+};
+function facesOf(runs) {
+  const out = /* @__PURE__ */ new Map();
+  const add = (family, weight, style) => {
+    out.set(`${family}|${weight}|${style}`, { family, weight, style });
+  };
+  for (const r of runs) {
+    add(r.fontFamily, r.fontWeight, r.fontStyle);
+    const { family, weight, style } = resolveFontVariant(r.fontFamily, r.fontWeight, r.fontStyle).resolved;
+    add(family, weight, style);
+  }
+  return [...out.values()];
+}
+function assertOutlinable(run) {
+  const { fontFamily, fontWeight, fontStyle } = run;
+  const fail = (reason, detail) => {
+    throw new TextOutlinesError(reason, fontFamily, fontWeight, fontStyle, detail);
+  };
+  const requested = outlineStatus(fontFamily, fontWeight, fontStyle);
+  if (requested === "idle" || requested === "loading") {
+    void loadFontOutlines(fontFamily, { weight: fontWeight, style: fontStyle });
+    fail("outlines-loading", "its outlines have not loaded yet; await loadTextOutlines first.");
+  }
+  const r = resolveFontVariant(fontFamily, fontWeight, fontStyle);
+  const { family, weight, style } = r.resolved;
+  if (r.synthetic.bold) {
+    fail("synthetic-bold", `drawn as a faux bold of ${family} ${weight}/${style}, which has no geometry to embolden. Register outlines for the real bold face.`);
+  }
+  if (r.source === "outline") return;
+  const status = outlineStatus(family, weight, style);
+  if (status === null) {
+    fail("no-outlines", `served by ${family} ${weight}/${style}, which has no outlines registered. Call registerFontOutlines for it.`);
+  }
+  if (status === "idle" || status === "loading") {
+    void loadFontOutlines(family, { weight, style });
+    fail("outlines-loading", `the outlines of ${family} ${weight}/${style} have not loaded yet; await loadTextOutlines first.`);
+  }
+  if (status === "failed") {
+    fail("outlines-failed", `the outlines registered for ${family} ${weight}/${style} failed to load.`);
+  }
+}
+var EM_CACHE_LIMIT = 4096;
+var emCache = /* @__PURE__ */ new Map();
+function emGlyph(d) {
+  let p = emCache.get(d);
+  if (p) return p;
+  p = pathFromD(d);
+  if (pathSignedArea(p) < 0) p = reversePath(p);
+  if (emCache.size >= EM_CACHE_LIMIT) emCache.clear();
+  emCache.set(d, p);
+  return p;
+}
+function concat(parts) {
+  let nc = 0, nk = 0;
+  for (const p of parts) {
+    nc += p.commands.length;
+    nk += p.coords.length;
+  }
+  const commands = new Uint8Array(nc);
+  const coords = new Float32Array(nk);
+  let ci = 0, ki = 0;
+  for (const p of parts) {
+    commands.set(p.commands, ci);
+    ci += p.commands.length;
+    coords.set(p.coords, ki);
+    ki += p.coords.length;
+  }
+  return { kind: "polygon", commands, coords, fillRule: "nonzero" };
+}
+function ruleContour(x0, y0, x1, y1) {
+  return {
+    kind: "polygon",
+    commands: new Uint8Array([PATH_M, PATH_L, PATH_L, PATH_L, PATH_Z]),
+    coords: new Float32Array([x0, y0, x1, y0, x1, y1, x0, y1]),
+    fillRule: "nonzero"
+  };
+}
+function walkOutlines(data, pose, opts) {
+  const textPose = {
+    x: pose.x,
+    y: pose.y,
+    width: pose.width,
+    height: pose.height,
+    text: data.text,
+    runs: data.runs,
+    style: data.style,
+    verticalAlign: data.verticalAlign,
+    fill: data.fill,
+    stroke: data.stroke
+  };
+  const { runs, opts: layoutOpts } = textPoseLayoutInput(textPose, opts.scale ?? 1);
+  for (const run of runs) assertOutlinable(run);
+  const paints = [];
+  const indexOf = /* @__PURE__ */ new Map();
+  const paintOf = runs.map((run) => {
+    const key = `${paintKey(run.fill?.paint)}|${strokeKey(run.stroke)}`;
+    let i = indexOf.get(key);
+    if (i === void 0) {
+      i = paints.length;
+      indexOf.set(key, i);
+      paints.push(run.stroke !== void 0 ? { fill: run.fill, stroke: run.stroke } : { fill: run.fill });
+    }
+    return i;
+  });
+  const laid = layoutRuns(runs, layoutOpts);
+  const dx = pose.x;
+  const dy = pose.y + verticalAlignOffset(data.verticalAlign, pose.height, laid.bounds.height);
+  const parts = paints.map(() => []);
+  const rules = paints.map(() => []);
+  const faceOf = runFaces(runs);
+  for (const line of laid.lines) {
+    for (const g of line.glyphs) {
+      const d = glyphOutlineD(g, runs[g.run], 0);
+      if (d === null) {
+        if (glyphQuad(g) !== null) {
+          const { family, weight, style } = g.resolved.resolved;
+          throw new TextOutlinesError(
+            "no-outlines",
+            family,
+            weight,
+            style,
+            "a fallback face serving some of the text's characters has no outlines registered."
+          );
+        }
+        continue;
+      }
+      const s = g.fontSize;
+      const shear = g.resolved.synthetic.italic ? Math.tan(SYNTHETIC_ITALIC_RADIANS) : 0;
+      const m = [s, 0, -shear * s, s, g.x + dx, g.baselineY + dy];
+      parts[paintOf[g.run]].push(transformPath(emGlyph(d), m));
+    }
+    for (const r of lineDecorations(line.glyphs, runs, faceOf, (run) => String(paintOf[run]))) {
+      rules[paintOf[r.run]].push(ruleContour(r.x0 + dx, r.y0 + dy, r.x1 + dx, r.y1 + dy));
+    }
+  }
+  const frame = poseFrameOf(pose);
+  const paths = parts.map((glyphs, i) => {
+    const path = concat([...glyphs, ...rules[i]]);
+    if (!frame || path.commands.length === 0) return path;
+    return transformPath(path, frame);
+  });
+  return { paints, paths };
+}
+function textToPath(data, pose, opts = {}) {
+  return concat(walkOutlines(data, pose, opts).paths);
+}
+function textToPathsByPaint(data, pose, opts = {}) {
+  const { paints, paths } = walkOutlines(data, pose, opts);
+  const out = [];
+  paints.forEach((paint, i) => {
+    if (paths[i].commands.length > 0) out.push({ ...paint, path: paths[i] });
+  });
+  return out;
+}
+async function loadTextOutlines(data, opts = {}) {
+  const textPose = {
+    width: 0,
+    text: data.text,
+    runs: data.runs,
+    style: data.style
+  };
+  const { runs } = textPoseLayoutInput(textPose, opts.scale ?? 1);
+  await Promise.all(facesOf(runs).map((f) => loadFontOutlines(f.family, { weight: f.weight, style: f.style })));
+  await Promise.all(facesOf(runs).map((f) => loadFontOutlines(f.family, { weight: f.weight, style: f.style })));
+}
 
-export { MARKDOWN_RUN_GRAMMAR, SCRIPT_METRICS, SMALL_CAPS_SCALE, createMarkdownRenderer, isBoldWeight, isSmallCapsLetter, layoutMarkdown, layoutTextPose, markdownToRuns, measureText, measureTextBounds, measuredWidth, numericWeight, resolveRunFace, resolveRuns, runsToMarkdown, runsToPlainText, scriptMetrics, scriptMetricsFor, smallCapsScale, smallCapsScaleFor, smallCapsText, textLineBoxes, textPoseLayoutInput, toRuns, transformRunTexts, verticalAlignOffset };
+export { DEFAULT_DECORATION_METRICS, MARKDOWN_RUN_GRAMMAR, SCRIPT_METRICS, SMALL_CAPS_SCALE, SYNTHETIC_ITALIC_RADIANS, TextOutlinesError, applyStyleToRange, cachedPaintRuns, caretIndexAt, createMarkdownRenderer, decorationMetrics, defaultLabelTextRenderer, effectiveRangeStyle, fitTextPose, isBoldWeight, isSmallCapsLetter, isTextData, layoutMarkdown, layoutTextPose, loadTextOutlines, markdownToRuns, measureText, measureTextBounds, measuredWidth, nodeHasFlag, numericWeight, paintRuns, patchRangeStyle, pointInTextPose, rangeWeight, renderLabel, resolveRunFace, resolveRuns, runsCarryStyling, runsToMarkdown, runsToPlainText, scriptMetrics, scriptMetricsFor, setFlagOverRange, smallCapsScale, smallCapsScaleFor, smallCapsText, styleAtRange, supersededKey, textLineBoxes, textPoseLayoutInput, textToPath, textToPathsByPaint, toRuns, transformRunTexts, unboldPatch, verticalAlignOffset };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map