@weasel-js/text 1.11.0 → 1.12.0

package/dist/index.d.ts

@@ -1,8 +1,8 @@
-import { S as StyledRun, T as TextStyle, L as LaidOutRuns, R as ResolvedTextStyle, a as ResolvedRun, b as LayoutRunsOpts, c as TextPaint } from './test-seams-BypGSlZj.js';
-export { B as BidiAnalysis, d as BidiReordering, e as BidiResolver, D as DEFAULT_TEXT_STYLE, F as FontVariantCaps, f as LAYOUT_CACHE_STRUCTURAL_LIMIT, g as LAYOUT_CACHE_VARIANT_LIMIT, h as LaidOutCell, i as LaidOutLineBox, M as MARKDOWN_RUN_GRAMMAR, P as PlacedGlyph, j as RunFlag, k as RunGrammar, l as RunMarker, m as RunSourceMap, n as SCRIPT_METRICS, o as SMALL_CAPS_SCALE, p as ScriptPreset, q as SmallCapsText, r as TextAlign, s as TextDirection, t as TextTransform, u as TransformedRunText, v as cachedLayoutRuns, w as fontString, x as isBoldWeight, y as isSmallCapsLetter, z as layoutRuns, A as markdownToRuns, C as numericWeight, E as paragraphDirection, G as registerBidi, H as resolveAlign, I as resolveRunFace, J as resolveRuns, K as resolveTextStyle, N as runsToMarkdown, O as runsToPlainText, Q as scriptMetrics, U as scriptMetricsFor, V as smallCapsScale, W as smallCapsScaleFor, X as smallCapsText, Y as toRuns, Z as transformRunTexts } from './test-seams-BypGSlZj.js';
-import { FaceRuleMetrics, FaceMetrics, FontStyle, BmFontChar } from '@weasel-js/font';
+import { S as StyledRun, T as TextStyle, L as LaidOutRuns, R as ResolvedTextStyle, a as ResolvedRun, b as LayoutRunsOpts, c as TextPaint } from './test-seams-B0BDm36M.js';
+export { B as BidiAnalysis, d as BidiReordering, e as BidiResolver, D as DEFAULT_TEXT_FILL, f as DEFAULT_TEXT_STYLE, F as FontVariantCaps, g as LAYOUT_CACHE_STRUCTURAL_LIMIT, h as LAYOUT_CACHE_VARIANT_LIMIT, i as LaidOutCell, j as LaidOutLineBox, M as MARKDOWN_RUN_GRAMMAR, P as PlacedGlyph, k as RunFlag, l as RunGrammar, m as RunMarker, n as RunSourceMap, o as SCRIPT_METRICS, p as SMALL_CAPS_SCALE, q as ScriptPreset, r as SmallCapsText, s as TextAlign, t as TextDirection, u as TextTransform, v as TransformedRunText, w as cachedLayoutRuns, x as fontString, y as isBoldWeight, z as isSmallCapsLetter, A as layoutRuns, C as markdownToRuns, E as numericWeight, G as paragraphDirection, H as registerBidi, I as resolveAlign, J as resolveRunFace, K as resolveRuns, N as resolveTextStyle, O as runsToMarkdown, Q as runsToPlainText, U as scriptMetrics, V as scriptMetricsFor, W as smallCapsScale, X as smallCapsScaleFor, Y as smallCapsText, Z as toRuns, _ as transformRunTexts } from './test-seams-B0BDm36M.js';
+import { FaceRuleMetrics, FaceMetrics, FontStyle, BmFontChar, ResolveResult } from '@weasel-js/font';
 import { Fill, Stroke } from '@weasel-js/paint';
-import { Rect, PathInWorldPose, PolygonPath } from '@weasel-js/geom';
+import { Rect, PolygonPath, PathInWorldPose } from '@weasel-js/geom';
 import { Mixed } from '@weasel-js/registry';
 export { MIXED, Mixed } from '@weasel-js/registry';
 
@@ -162,9 +162,10 @@ interface LaidOutQuad {
  * One glyph the renderer should tessellate rather than sample.
  *
  * `d` is em-space SVG path data — 1 unit is 1 em, y grows down, origin on the
- * baseline at the pen. Placing it is therefore a uniform scale by `scale`
+ * baseline at the pen — with any synthetic bold already grown into it. Placing it is therefore a uniform scale by `scale`
  * followed by a translate to `(x, baselineY)`. `key` identifies the cached
- * tessellation — face identity plus codepoint.
+ * tessellation — face identity plus codepoint, plus the growth of a synthetic
+ * bold.
  */
 interface LaidOutOutlineGlyph {
     d: string;
@@ -189,7 +190,8 @@ interface LaidOutGroup {
     /** Resolved variant — matches the registered atlas and the texture-cache key. */
     weight: number;
     style: FontStyle;
-    /** Gap between the request and the resolved match, for the renderer to fake. */
+    /** Gap between the request and the resolved match, for the renderer to fake.
+     *  An `'outline'` group's bold is already grown into its glyphs. */
     synthetic: {
         bold: boolean;
         italic: boolean;
@@ -209,7 +211,7 @@ interface LaidOutGroup {
     /** Outline painted over the glyphs. Only ever set on an `'outline'` group —
      *  the SDF tiers have no geometry to stroke, which is why a stroke pulls its
      *  run onto the outline tier at any size. A run the tier cannot serve at all
-     *  (no registered outlines, synthetic bold) stays on the atlas, unstroked. */
+     *  (no registered outlines) stays on the atlas, unstroked. */
     stroke?: Stroke;
     /** Textured glyph quads. Always empty for an `'outline'` group. */
     quads: LaidOutQuad[];
@@ -659,6 +661,62 @@ declare function setFlagOverRange(runs: readonly StyledRun[], style: TextStyle,
  */
 declare const SYNTHETIC_ITALIC_RADIANS = 0.2094;
 
+/**
+ * Synthetic bold as geometry. The renderer fakes a missing bold face by
+ * dropping the distance-field threshold, which moves every edge of the glyph
+ * outward by `syntheticBoldGrowth`; outlining it is the glyph's own outline
+ * grown by that distance.
+ */
+
+/**
+ * How far synthetic bold grows a glyph served as `resolved`, in em per side,
+ * and how its corners turn; `null` when the renderer draws it unshifted.
+ * An MSDF atlas keeps sharp corners, so its shifted edge meets in a miter; a
+ * canvas bake is a true distance field, whose shifted edge rounds them.
+ */
+declare function syntheticBoldOffset(resolved: ResolveResult): {
+    growth: number;
+    join: 'miter' | 'round';
+} | null;
+/**
+ * {@link emboldenGlyph} for the renderer's outline tier, which takes outline
+ * data: `d` grown as the field draws it, and a tag naming the growth for the
+ * glyph's tessellation key. `null` when the renderer draws `resolved` unshifted.
+ */
+declare function emboldenGlyphD(d: string, resolved: ResolveResult): {
+    d: string;
+    tag: string;
+} | null;
+
+/**
+ * The per-glyph half of text-as-geometry, shared by `textToPath` and
+ * `textClusters`: checking a run's face can give outlines, finding a placed
+ * glyph's outline, and setting it where the renderer's outline tier puts it.
+ */
+
+/**
+ * Why a text node has no outline geometry to give:
+ *
+ * - `'no-outlines'` — the face that serves it has no outlines registered
+ *   (`registerFontOutlines`), so there is no geometry to read.
+ * - `'outlines-loading'` — registered but not parsed yet. `loadTextOutlines`
+ *   waits for it; the call has already started the load.
+ * - `'outlines-failed'` — registered, and the bytes did not load or parse.
+ * - `'color-glyph'` — the text holds an emoji, which is a picture in its own
+ *   colors with no outline. Nothing a caller registers changes that.
+ */
+type TextOutlinesFailure = 'no-outlines' | 'color-glyph' | 'outlines-loading' | 'outlines-failed';
+/** Thrown by `textToPath`, `textToPathsByPaint` and `textClusters` when some
+ *  run of the text has no outline geometry. Names the run's requested face and
+ *  the function that was asked. */
+declare class TextOutlinesError extends Error {
+    readonly reason: TextOutlinesFailure;
+    readonly family: string;
+    readonly weight: number;
+    readonly style: FontStyle;
+    constructor(reason: TextOutlinesFailure, family: string, weight: number, style: FontStyle, detail: string, caller?: string);
+}
+
 /**
  * Text as path geometry: the glyph outlines a text node draws, placed in
  * world space and composed into one `Path`. The glyphs are the ones
@@ -699,27 +757,6 @@ interface TextToPathOptions {
      *  against, as for `textCommandFromPose`. Default 1. */
     scale?: number;
 }
-/**
- * Why a text node has no outline geometry to give:
- *
- * - `'no-outlines'` — the face that serves it has no outlines registered
- *   (`registerFontOutlines`), so there is no geometry to read.
- * - `'outlines-loading'` — registered but not parsed yet. `loadTextOutlines`
- *   waits for it; the call has already started the load.
- * - `'outlines-failed'` — registered, and the bytes did not load or parse.
- * - `'color-glyph'` — the text holds an emoji, which is a picture in its own
- *   colors with no outline. Nothing a caller registers changes that.
- */
-type TextOutlinesFailure = 'no-outlines' | 'color-glyph' | 'outlines-loading' | 'outlines-failed';
-/** Thrown by {@link textToPath} when some run of the text has no outline
- *  geometry. Names the run's requested face. */
-declare class TextOutlinesError extends Error {
-    readonly reason: TextOutlinesFailure;
-    readonly family: string;
-    readonly weight: number;
-    readonly style: FontStyle;
-    constructor(reason: TextOutlinesFailure, family: string, weight: number, style: FontStyle, detail: string);
-}
 /**
  * The outline geometry of a text node, in world space: every glyph and every
  * underline, strikethrough and overline rule it draws, as one `'nonzero'`
@@ -752,4 +789,37 @@ declare function textToPathsByPaint(data: TextOutlineSource, pose: PathInWorldPo
  */
 declare function loadTextOutlines(data: TextOutlineSource, opts?: TextToPathOptions): Promise<void>;
 
-export { BREAK_ALLOWED, BREAK_MANDATORY, DEFAULT_DECORATION_METRICS, type DecorationKind, type FaceMetricsFn, type FitTextPoseOptions, type FlagKey, type LabelOptions, type LaidOutDecoration, type LaidOutGroup, type LaidOutOutlineGlyph, type LaidOutQuad, LaidOutRuns, type LayoutLine, type LayoutResult, LayoutRunsOpts, type MarkdownFontOptions, type MeasureFn, type MeasureTextBoundsOpts, type MeasuredSpan, type MeasuredText, NO_BREAK, type PaintRunsOpts, type PaintedRuns, type PointInTextPoseOpts, type PositionedRun, type RangeStyle, ResolvedRun, ResolvedTextStyle, type RunStylePatch, SYNTHETIC_ITALIC_RADIANS, type SetFlagResult, type StyleKey, StyledRun, type TextLineBoxesOpts, type TextNodeSource, type TextOutlineSource, TextOutlinesError, type TextOutlinesFailure, TextPaint, type TextPaintPath, type TextPose, type TextPoseLayout, type TextPoseLayoutInput, type TextRenderer, TextStyle, type TextToPathOptions, type TextVerticalAlign, applyStyleToRange, cachedPaintRuns, caretIndexAt, createMarkdownRenderer, decorationMetrics, defaultLabelTextRenderer, effectiveRangeStyle, fitTextPose, isHardLineBreak, isTextData, layoutMarkdown, layoutTextPose, lineBreakOpportunities, loadTextOutlines, measureText, measureTextBounds, measuredWidth, nodeHasFlag, paintRuns, patchRangeStyle, pointInTextPose, rangeWeight, renderLabel, runsCarryStyling, setFlagOverRange, styleAtRange, supersededKey, textLineBoxes, textPoseLayoutInput, textToPath, textToPathsByPaint, unboldPatch, verticalAlignOffset };
+/** One grapheme cluster of a text line: its slot and its outlines. */
+interface TextCluster {
+    /** Its slot's leading edge, from the line's left, in visual order. */
+    x: number;
+    /** The slot's width: its cells' advances, kerning and tracking included. */
+    advance: number;
+    /** Outlines with the slot's left edge at x = 0 and the baseline at y = 0, y down, one per paint; empty for a
+     *  space or a color glyph. */
+    paths: TextPaintPath[];
+    /** Height of the x-height's middle above the baseline. */
+    middle: number;
+}
+/** Options for {@link textClusters}. */
+interface TextClustersOptions extends TextToPathOptions {
+    /** The node's box width, which a `wrap` style wraps at and `align` aligns
+     *  in, as the node's own layout does. Default `Infinity`: one line per
+     *  paragraph. */
+    width?: number;
+}
+/**
+ * The first laid line of `data` as its grapheme clusters, in visual order,
+ * laid at the node's box origin with no pose applied; the lines after it are
+ * dropped. The slots tile the
+ * line: each cluster's `advance` runs to the next one's `x`, so the kerning
+ * between two clusters belongs to the left one. Decoration rules are left out.
+ *
+ * Throws `TextOutlinesError` as `textToPath` does, except that a color
+ * glyph, or one drawn by a fallback face with no outlines, keeps its slot
+ * with no `paths`. Only a code point that inks its slot is drawn, so a color
+ * cluster's leading code points stay blank too.
+ */
+declare function textClusters(data: TextOutlineSource, opts?: TextClustersOptions): TextCluster[];
+
+export { BREAK_ALLOWED, BREAK_MANDATORY, DEFAULT_DECORATION_METRICS, type DecorationKind, type FaceMetricsFn, type FitTextPoseOptions, type FlagKey, type LabelOptions, type LaidOutDecoration, type LaidOutGroup, type LaidOutOutlineGlyph, type LaidOutQuad, LaidOutRuns, type LayoutLine, type LayoutResult, LayoutRunsOpts, type MarkdownFontOptions, type MeasureFn, type MeasureTextBoundsOpts, type MeasuredSpan, type MeasuredText, NO_BREAK, type PaintRunsOpts, type PaintedRuns, type PointInTextPoseOpts, type PositionedRun, type RangeStyle, ResolvedRun, ResolvedTextStyle, type RunStylePatch, SYNTHETIC_ITALIC_RADIANS, type SetFlagResult, type StyleKey, StyledRun, type TextCluster, type TextClustersOptions, type TextLineBoxesOpts, type TextNodeSource, type TextOutlineSource, TextOutlinesError, type TextOutlinesFailure, TextPaint, type TextPaintPath, type TextPose, type TextPoseLayout, type TextPoseLayoutInput, type TextRenderer, TextStyle, type TextToPathOptions, type TextVerticalAlign, applyStyleToRange, cachedPaintRuns, caretIndexAt, createMarkdownRenderer, decorationMetrics, defaultLabelTextRenderer, effectiveRangeStyle, emboldenGlyphD, fitTextPose, isHardLineBreak, isTextData, layoutMarkdown, layoutTextPose, lineBreakOpportunities, loadTextOutlines, measureText, measureTextBounds, measuredWidth, nodeHasFlag, paintRuns, patchRangeStyle, pointInTextPose, rangeWeight, renderLabel, runsCarryStyling, setFlagOverRange, styleAtRange, supersededKey, syntheticBoldOffset, textClusters, textLineBoxes, textPoseLayoutInput, textToPath, textToPathsByPaint, unboldPatch, verticalAlignOffset };

package/dist/index.js

@@ -1,10 +1,10 @@
-import { DEFAULT_TAB_SIZE, resolveTextStyle, cachedLayoutRuns, graphemeCount, wrapLines, hangs, tabAdvance, widthWithTabs, layoutRuns } from './chunk-HI4VEOYP.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-HI4VEOYP.js';
+import { DEFAULT_TAB_SIZE, resolveTextStyle, cachedLayoutRuns, graphemeCount, wrapLines, hangs, layoutRuns, tabAdvance, widthWithTabs } from './chunk-ADRQIIHS.js';
+export { BREAK_ALLOWED, BREAK_MANDATORY, DEFAULT_TEXT_FILL, DEFAULT_TEXT_STYLE, LAYOUT_CACHE_STRUCTURAL_LIMIT, LAYOUT_CACHE_VARIANT_LIMIT, NO_BREAK, cachedLayoutRuns, fontString, isHardLineBreak, layoutRuns, lineBreakOpportunities, paragraphDirection, registerBidi, resolveAlign, resolveTextStyle } from './chunk-ADRQIIHS.js';
 import { resolveScreenLength, fillHasInk, strokeHasInk, paintKey, strokeKey } from '@weasel-js/paint';
-import { faceMetricsOf, resolveFontVariant, glyphGeneration, loadFontOutlines, faceMetricsFor, glyphOutline, outlineStatus, cssFamilyName, syntheticBoldGrowth } from '@weasel-js/font';
+import { faceMetricsOf, resolveFontVariant, syntheticBoldGrowth, glyphGeneration, loadFontOutlines, faceMetricsFor, glyphOutline, outlineStatus, cssFamilyName } from '@weasel-js/font';
+import { pathToD, pathFromD, mergeRegion, growRegion, poseFrameOf, transformPath, PATH_M, PATH_L, PATH_Z, pathSignedArea, reversePath } from '@weasel-js/geom';
 import { MIXED, deepEqual } from '@weasel-js/registry';
 export { MIXED } from '@weasel-js/registry';
-import { transformPath, poseFrameOf, growRegion, pathFromD, pathSignedArea, reversePath, PATH_M, PATH_L, PATH_Z } from '@weasel-js/geom';
 
 // src/runs.ts
 function toRuns(input) {
@@ -413,8 +413,8 @@ function lineDecorations(glyphs, runs, faceOf, paintOf) {
   };
   for (const g of glyphs) {
     const style = runs[g.run];
-    const paint = paintOf(g.run);
-    if (paint === null || !DECORATION_KINDS.some((kind) => style[kind])) {
+    const paint = style.underline || style.strikethrough || style.overline ? paintOf(g.run) : null;
+    if (paint === null) {
       close();
       continue;
     }
@@ -465,13 +465,61 @@ function layoutTextPose(pose, scale = 1) {
     y: pose.y + verticalAlignOffset(pose.verticalAlign, pose.height, laid.bounds.height)
   };
 }
+var SYNTHETIC_BOLD_TOLERANCE = 5e-4;
+var CACHE_LIMIT = 4096;
+var cache = /* @__PURE__ */ new Map();
+var dCache = /* @__PURE__ */ new Map();
+function syntheticBoldOffset(resolved2) {
+  if (!resolved2.synthetic.bold) return null;
+  const { source } = resolved2;
+  if (source !== "atlas" && source !== "canvas") return null;
+  const { family, weight, style } = resolved2.resolved;
+  const growth = syntheticBoldGrowth(source, family, weight, style);
+  if (growth === void 0 || !(growth > 0)) return null;
+  return { growth, join: source === "atlas" ? "miter" : "round" };
+}
+function emboldenGlyph(em, d, resolved2) {
+  const offset = syntheticBoldOffset(resolved2);
+  if (offset === null) return em;
+  const key = `${offset.growth}|${offset.join}|${d}`;
+  let grown = cache.get(key);
+  if (grown) return grown;
+  grown = mergeRegion(
+    growRegion(em, offset.growth, { join: offset.join, tolerance: SYNTHETIC_BOLD_TOLERANCE }),
+    { tolerance: SYNTHETIC_BOLD_TOLERANCE }
+  );
+  if (cache.size >= CACHE_LIMIT) cache.clear();
+  cache.set(key, grown);
+  return grown;
+}
+function emboldenGlyphD(d, resolved2) {
+  const offset = syntheticBoldOffset(resolved2);
+  if (offset === null) return null;
+  const tag = `bold:${offset.growth}:${offset.join}`;
+  const key = `${tag}|${d}`;
+  let grown = dCache.get(key);
+  if (grown === void 0) {
+    grown = pathToD(emboldenGlyph(pathFromD(d), d, resolved2));
+    if (dCache.size >= CACHE_LIMIT) dCache.clear();
+    dCache.set(key, grown);
+  }
+  return { d: grown, tag };
+}
+
+// src/layout/paintRuns.ts
 function glyphOutlineD(g, run, minSize) {
-  if (g.resolved.source !== "outline") {
+  const outlineOnly = g.resolved.source === "outline";
+  if (!outlineOnly) {
     if (minSize === void 0) return null;
     if (run.fontSize < minSize && !strokeHasInk(run.stroke)) return null;
-    if (g.resolved.synthetic.bold) return null;
   }
-  return faceOutlineD(g);
+  const d = faceOutlineD(g);
+  if (d === null) return null;
+  const { family, weight, style } = g.resolved.resolved;
+  const key = `${family}|${weight}|${style}|${g.cp}`;
+  if (outlineOnly || !g.resolved.synthetic.bold) return { d, key };
+  const bold = emboldenGlyphD(d, g.resolved);
+  return bold && { d: bold.d, key: `${key}|${bold.tag}` };
 }
 function faceOutlineD(g) {
   if (g.glyph?.color) return null;
@@ -501,10 +549,13 @@ 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) {
+function groupFor(groups, g, run, source, last) {
   const { family, weight, style } = g.resolved.resolved;
   const { synthetic } = g.resolved;
   const page = source === "outline" ? 0 : g.glyph.page;
+  if (last.group !== null && last.run === g.run && last.source === source && last.page === page && last.family === family && last.weight === weight && last.style === style && last.bold === synthetic.bold && last.italic === synthetic.italic) {
+    return last.group;
+  }
   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);
@@ -523,23 +574,41 @@ function groupFor(groups, g, run, source) {
     };
     groups.set(key, group);
   }
+  last.group = group;
+  last.run = g.run;
+  last.family = family;
+  last.weight = weight;
+  last.style = style;
+  last.bold = synthetic.bold;
+  last.italic = synthetic.italic;
+  last.source = source;
+  last.page = page;
   return group;
 }
 function paintRuns(laid, runs, opts = {}) {
   const groups = /* @__PURE__ */ new Map();
+  const last = {
+    group: null,
+    run: -1,
+    family: "",
+    weight: 0,
+    style: "normal",
+    bold: false,
+    italic: false,
+    source: "atlas",
+    page: 0
+  };
   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}`,
+      const outline = glyphOutlineD(g, run, opts.outlineMinSize);
+      if (!fillHasInk(run.fill) && !(outline !== null && strokeHasInk(run.stroke))) continue;
+      if (outline !== null) {
+        groupFor(groups, g, run, "outline", last).glyphs.push({
+          ...outline,
           x: g.x,
           baselineY: g.baselineY,
           scale: g.fontSize
@@ -548,8 +617,8 @@ function paintRuns(laid, runs, opts = {}) {
       }
       const quad = glyphQuad(g);
       if (!quad) continue;
-      if (g.glyph?.color) groupFor(groups, g, run, "color").quads.push({ ...quad, colorGlyph: g.glyph });
-      else groupFor(groups, g, run, g.resolved.source).quads.push(quad);
+      if (g.glyph?.color) groupFor(groups, g, run, "color", last).quads.push({ ...quad, colorGlyph: g.glyph });
+      else groupFor(groups, g, run, g.resolved.source, last).quads.push(quad);
     }
     for (const rule of lineDecorations(line.glyphs, runs, faceOf, rulePaint)) {
       const { run, ...rect } = rule;
@@ -1233,41 +1302,13 @@ function effectiveRangeStyle(range, style, paint) {
 
 // src/syntheticItalic.ts
 var SYNTHETIC_ITALIC_RADIANS = 0.2094;
-var SYNTHETIC_BOLD_TOLERANCE = 5e-4;
-var CACHE_LIMIT = 4096;
-var cache = /* @__PURE__ */ new Map();
-function syntheticBoldOffset(resolved2) {
-  if (!resolved2.synthetic.bold) return null;
-  const { source } = resolved2;
-  if (source !== "atlas" && source !== "canvas") return null;
-  const { family, weight, style } = resolved2.resolved;
-  const growth = syntheticBoldGrowth(source, family, weight, style);
-  if (growth === void 0 || !(growth > 0)) return null;
-  return { growth, join: source === "atlas" ? "miter" : "round" };
-}
-function emboldenGlyph(em, d, resolved2) {
-  const offset = syntheticBoldOffset(resolved2);
-  if (offset === null) return em;
-  const key = `${offset.growth}|${offset.join}|${d}`;
-  let grown = cache.get(key);
-  if (grown) return grown;
-  grown = growRegion(em, offset.growth, {
-    join: offset.join,
-    tolerance: SYNTHETIC_BOLD_TOLERANCE
-  });
-  if (cache.size >= CACHE_LIMIT) cache.clear();
-  cache.set(key, grown);
-  return grown;
-}
-
-// src/textToPath.ts
 var TextOutlinesError = class extends Error {
   reason;
   family;
   weight;
   style;
-  constructor(reason, family, weight, style, detail) {
-    super(`textToPath: "${family}" ${weight}/${style} \u2014 ${detail}`);
+  constructor(reason, family, weight, style, detail, caller = "textToPath") {
+    super(`${caller}: "${family}" ${weight}/${style} \u2014 ${detail}`);
     this.name = "TextOutlinesError";
     this.reason = reason;
     this.family = family;
@@ -1275,22 +1316,10 @@ var TextOutlinesError = class extends Error {
     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) {
+function assertOutlinable(run, caller) {
   const { fontFamily, fontWeight, fontStyle } = run;
   const fail = (reason, detail) => {
-    throw new TextOutlinesError(reason, fontFamily, fontWeight, fontStyle, detail);
+    throw new TextOutlinesError(reason, fontFamily, fontWeight, fontStyle, detail, caller);
   };
   const requested = outlineStatus(fontFamily, fontWeight, fontStyle);
   if (requested === "idle" || requested === "loading") {
@@ -1312,6 +1341,21 @@ function assertOutlinable(run) {
     fail("outlines-failed", `the outlines registered for ${family} ${weight}/${style} failed to load.`);
   }
 }
+function paintsOf(runs) {
+  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;
+  });
+  return { paints, paintOf };
+}
 var EM_CACHE_LIMIT = 4096;
 var emCache = /* @__PURE__ */ new Map();
 function emGlyph(d) {
@@ -1323,6 +1367,37 @@ function emGlyph(d) {
   emCache.set(d, p);
   return p;
 }
+function placedGlyphOutline(g, dx, dy, caller, blankFallback = false) {
+  const d = faceOutlineD(g);
+  if (d === null) {
+    if (!blankFallback && 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.",
+        caller
+      );
+    }
+    return null;
+  }
+  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];
+  return transformPath(emboldenGlyph(emGlyph(d), d, g.resolved), m);
+}
+function colorGlyphError(run, caller) {
+  return new TextOutlinesError(
+    "color-glyph",
+    run.fontFamily,
+    run.fontWeight,
+    run.fontStyle,
+    "the text holds an emoji, which is drawn in its own colors and has no outline.",
+    caller
+  );
+}
 function concat(parts) {
   let nc = 0, nk = 0;
   for (const p of parts) {
@@ -1340,20 +1415,26 @@ function concat(parts) {
   }
   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"
+
+// src/textToPath.ts
+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 walkOutlines(data, pose, opts) {
+function outlineLayoutInput(data, box, opts, caller) {
   const textPose = {
-    x: pose.x,
-    y: pose.y,
-    width: pose.width,
-    height: pose.height,
+    x: box.x,
+    y: box.y,
+    width: box.width,
+    height: box.height,
     text: data.text,
     runs: data.runs,
     style: data.style,
@@ -1361,20 +1442,21 @@ function walkOutlines(data, pose, opts) {
     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 input = textPoseLayoutInput(textPose, opts.scale ?? 1);
+  for (const run of input.runs) assertOutlinable(run, caller);
+  return input;
+}
+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 { runs, opts: layoutOpts } = outlineLayoutInput(data, pose, opts, "textToPath");
+  const { paints, paintOf } = paintsOf(runs);
   const laid = layoutRuns(runs, layoutOpts);
   const dx = pose.x;
   const dy = pose.y + verticalAlignOffset(data.verticalAlign, pose.height, laid.bounds.height);
@@ -1383,34 +1465,9 @@ function walkOutlines(data, pose, opts) {
   const faceOf = runFaces(runs);
   for (const line of laid.lines) {
     for (const g of line.glyphs) {
-      if (g.glyph?.color) {
-        const { fontFamily, fontWeight, fontStyle } = runs[g.run];
-        throw new TextOutlinesError(
-          "color-glyph",
-          fontFamily,
-          fontWeight,
-          fontStyle,
-          "the text holds an emoji, which is drawn in its own colors and has no outline."
-        );
-      }
-      const d = faceOutlineD(g);
-      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(emboldenGlyph(emGlyph(d), d, g.resolved), m));
+      if (g.glyph?.color) throw colorGlyphError(runs[g.run], "textToPath");
+      const glyph = placedGlyphOutline(g, dx, dy, "textToPath");
+      if (glyph) parts[paintOf[g.run]].push(glyph);
     }
     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));
@@ -1446,7 +1503,48 @@ async function loadTextOutlines(data, opts = {}) {
   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 })));
 }
+var MIDDLE_FALLBACK = 0.25;
+function textClusters(data, opts = {}) {
+  const box = { x: 0, y: 0, width: opts.width ?? Infinity, height: 0 };
+  const { runs, opts: layoutOpts } = outlineLayoutInput(data, box, opts, "textClusters");
+  const line = layoutRuns(runs, layoutOpts).lines[0];
+  if (!line || line.cells.length === 0) return [];
+  const { paints, paintOf } = paintsOf(runs);
+  const glyphOf = new Array(line.cells.length);
+  for (const g of line.glyphs) glyphOf[g.cell] = g;
+  const groups = [];
+  let open = [];
+  line.cells.forEach((cell, i) => {
+    open.push(glyphOf[i]);
+    if (cell.clusterEnd || i === line.cells.length - 1) {
+      groups.push(open);
+      open = [];
+    }
+  });
+  const slots = groups.map((glyphs) => ({ glyphs, left: Math.min(...glyphs.map((g) => g.x)) })).sort((a, b) => a.left - b.left);
+  return slots.map(({ glyphs, left }, i) => {
+    const right = i + 1 < slots.length ? slots[i + 1].left : line.x1;
+    const parts = paints.map(() => []);
+    for (const g of glyphs) {
+      if (g.glyph?.color || !line.cells[g.cell].drawsInk) continue;
+      const outline = placedGlyphOutline(g, -left, -line.baselineY, "textClusters", true);
+      if (outline) parts[paintOf[g.run]].push(outline);
+    }
+    const paths = [];
+    parts.forEach((p, k) => {
+      if (p.length > 0) paths.push({ ...paints[k], path: concat(p) });
+    });
+    const first = glyphs[0];
+    const xHeight = faceMetricsOf(first.resolved)?.xHeight;
+    return {
+      x: left - line.x0,
+      advance: right - left,
+      paths,
+      middle: (xHeight === void 0 ? MIDDLE_FALLBACK : xHeight / 2) * first.fontSize
+    };
+  });
+}
 
-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 };
+export { DEFAULT_DECORATION_METRICS, MARKDOWN_RUN_GRAMMAR, SCRIPT_METRICS, SMALL_CAPS_SCALE, SYNTHETIC_ITALIC_RADIANS, TextOutlinesError, applyStyleToRange, cachedPaintRuns, caretIndexAt, createMarkdownRenderer, decorationMetrics, defaultLabelTextRenderer, effectiveRangeStyle, emboldenGlyphD, 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, syntheticBoldOffset, textClusters, textLineBoxes, textPoseLayoutInput, textToPath, textToPathsByPaint, toRuns, transformRunTexts, unboldPatch, verticalAlignOffset };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map