@weasel-js/text 1.13.0-rc.0 → 1.14.0

package/dist/index.js

@@ -1,10 +1,10 @@
-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, 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 { DEFAULT_TAB_SIZE, shapesWithFeature, resolveTextStyle, cachedLayoutRuns, graphemeCount, wrapLines, hangs, emboldenGlyph, layoutRuns, lineDecorations, runFaces, tabAdvance, widthWithTabs, DECORATION_KINDS, decorationRule, faceOutlineD, hasGlyphQuad } from './chunk-FODNMBHI.js';
+export { BREAK_ALLOWED, BREAK_MANDATORY, DEFAULT_DECORATION_METRICS, DEFAULT_TEXT_FILL, DEFAULT_TEXT_STYLE, LAYOUT_CACHE_STRUCTURAL_LIMIT, LAYOUT_CACHE_VARIANT_LIMIT, NO_BREAK, QUAD_STRIDE, cachedLayoutRuns, cachedPaintRuns, decorationMetrics, dropRuns, emboldenGlyphD, fontString, isHardLineBreak, layoutRuns, lineBreakOpportunities, paintRuns, paragraphDirection, registerBidi, registerShaper, resolveAlign, resolveTextStyle, syntheticBoldOffset } from './chunk-FODNMBHI.js';
+import { resolveScreenLength, paintKey, strokeKey } from '@weasel-js/paint';
+import { faceMetricsOf, resolveFontVariant, loadFontOutlines, glyphGeneration, faceMetricsFor, outlineStatus, cssFamilyName } from '@weasel-js/font';
 import { MIXED, deepEqual } from '@weasel-js/registry';
 export { MIXED } from '@weasel-js/registry';
+import { transformPath, joinPaths, pathFromD, pathSignedArea, reversePath, poseFrameOf, originFor, coordsFrom, PATH_M, PATH_L, PATH_Z } from '@weasel-js/geom';
 
 // src/runs.ts
 function toRuns(input) {
@@ -173,10 +173,18 @@ var TITLE = /* @__PURE__ */ new Map([
   [8180, "\u038F\u0345"],
   [8183, "\u03A9\u0342\u0345"]
 ]);
-function titlecase(ch) {
+function titlecase(ch, locale) {
   const cp = ch.codePointAt(0);
   if (cp >= 8064 && cp <= 8111) return String.fromCodePoint(cp | 8);
-  return TITLE.get(cp) ?? ch.toUpperCase();
+  return TITLE.get(cp) ?? ch.toLocaleUpperCase(locale);
+}
+function caseLocale(lang) {
+  if (!lang) return void 0;
+  try {
+    return Intl.getCanonicalLocales(lang)[0];
+  } catch {
+    return void 0;
+  }
 }
 var WORD_FALLBACK = /[\p{L}\p{N}][\p{L}\p{N}\p{M}\p{Pc}'’]*/gu;
 function wordStarts(text) {
@@ -194,13 +202,15 @@ function alignsPerCodePoint(texts, whole, map) {
   for (const t of texts) for (const ch of t) n += map(ch).length;
   return n === whole.length;
 }
-var upper = (ch) => ch.toUpperCase();
-var lower = (ch) => ch.toLowerCase();
-function transformRunTexts(texts, transforms) {
+function transformRunTexts(texts, transforms, langs = []) {
   if (transforms.every((t) => t === "none")) return texts.map((text) => ({ text }));
+  const locales = texts.map((_, i) => caseLocale(langs[i]));
+  const shared = locales.every((l) => l === locales[0]) ? locales[0] : void 0;
+  const upper = (ch, l = shared) => ch.toLocaleUpperCase(l);
+  const lower = (ch, l = shared) => ch.toLocaleLowerCase(l);
   const full = texts.join("");
-  const wholeUpper = transforms.includes("uppercase") ? full.toUpperCase() : "";
-  const wholeLower = transforms.includes("lowercase") ? full.toLowerCase() : "";
+  const wholeUpper = transforms.includes("uppercase") ? full.toLocaleUpperCase(shared) : "";
+  const wholeLower = transforms.includes("lowercase") ? full.toLocaleLowerCase(shared) : "";
   const upperAligned = wholeUpper !== "" && alignsPerCodePoint(texts, wholeUpper, upper);
   const lowerAligned = wholeLower !== "" && alignsPerCodePoint(texts, wholeLower, lower);
   const starts = transforms.includes("capitalize") ? wordStarts(full) : null;
@@ -211,6 +221,8 @@ function transformRunTexts(texts, transforms) {
   for (let i = 0; i < texts.length; i++) {
     const source = texts[i];
     const t = transforms[i] ?? "none";
+    const locale = locales[i];
+    const own = locale === shared;
     let text = "";
     const srcStarts = [];
     const srcEnds = [];
@@ -221,11 +233,11 @@ function transformRunTexts(texts, transforms) {
       const lo = lower(ch);
       let piece = ch;
       if (t === "uppercase") {
-        piece = upperAligned ? wholeUpper.slice(upOff, upOff + up.length) : up;
+        piece = upperAligned && own ? wholeUpper.slice(upOff, upOff + up.length) : upper(ch, locale);
       } else if (t === "lowercase") {
-        piece = lowerAligned ? wholeLower.slice(lowOff, lowOff + lo.length) : lo;
-      } else if (t === "capitalize" && starts.has(base + local) && up !== ch) {
-        piece = titlecase(ch);
+        piece = lowerAligned && own ? wholeLower.slice(lowOff, lowOff + lo.length) : lower(ch, locale);
+      } else if (t === "capitalize" && starts.has(base + local) && upper(ch, locale) !== ch) {
+        piece = titlecase(ch, locale);
       }
       upOff += up.length;
       lowOff += lo.length;
@@ -252,10 +264,11 @@ function smallCapsScale(face) {
 function smallCapsScaleFor(family, weight, style) {
   return smallCapsScale(faceMetricsOf(resolveFontVariant(family, weight, style)));
 }
-function isSmallCapsLetter(ch) {
-  return ch.toUpperCase() !== ch;
+function isSmallCapsLetter(ch, lang) {
+  return ch.toLocaleUpperCase(caseLocale(lang)) !== ch;
 }
-function smallCapsText(text, srcMap) {
+function smallCapsText(text, srcMap, lang) {
+  const locale = caseLocale(lang);
   let out = "";
   const small = [];
   const starts = [];
@@ -264,8 +277,9 @@ function smallCapsText(text, srcMap) {
   let anySmall = false;
   let at = 0;
   for (const ch of text) {
-    const shrink = isSmallCapsLetter(ch);
-    const piece = shrink ? ch.toUpperCase() : ch;
+    const capital = ch.toLocaleUpperCase(locale);
+    const shrink = capital !== ch;
+    const piece = shrink ? capital : ch;
     if (piece.length !== ch.length) resized = true;
     anySmall ||= shrink;
     const start = srcMap ? srcMap.starts[at] : at;
@@ -284,6 +298,7 @@ function smallCapsText(text, srcMap) {
 }
 
 // src/runs/resolveRuns.ts
+var SMALL_CAPS_FEATURES = Object.freeze(["smcp"]);
 var SCRIPT_METRICS = Object.freeze({
   super: Object.freeze({ size: 0.583, shift: 0.333 }),
   sub: Object.freeze({ size: 0.583, shift: -0.333 })
@@ -304,6 +319,11 @@ function scriptMetrics(face) {
 function scriptMetricsFor(family, weight, style) {
   return scriptMetrics(faceMetricsOf(resolveFontVariant(family, weight, style)));
 }
+function halfLeadingFor(family, weight, style, fontSize, lineHeight) {
+  const m = faceMetricsOf(resolveFontVariant(family, weight, style));
+  if (m?.ascent === void 0 || m.descent === void 0) return void 0;
+  return (lineHeight - m.ascent - m.descent) / 2 * fontSize;
+}
 function numericWeight(w) {
   if (typeof w === "number") return w;
   if (w === "bold" || w === "bolder") return 700;
@@ -321,15 +341,20 @@ function resolveRunFace(run, style) {
     fontStyle: run.italic ? "italic" : style.fontStyle
   };
 }
+var NOTHING = Object.freeze({});
 function resolveRuns(runs, style, viewScale = 1) {
   const out = [];
-  const shown = transformRunTexts(
+  let transformed = false;
+  for (const r of runs) if ((r.textTransform ?? style.textTransform) !== "none") transformed = true;
+  const shown = transformed ? transformRunTexts(
     runs.map((r) => r.text),
-    runs.map((r) => r.textTransform ?? style.textTransform)
-  );
+    runs.map((r) => r.textTransform ?? style.textTransform),
+    runs.map((r) => r.lang ?? style.lang)
+  ) : null;
   for (let i = 0; i < runs.length; i++) {
     const run = runs[i];
-    let { text, srcMap } = shown[i];
+    let text = shown ? shown[i].text : run.text;
+    let srcMap = shown?.[i].srcMap;
     const scriptKey = run.script ?? style.script;
     const { fontFamily, fontWeight, fontStyle } = resolveRunFace(run, style);
     const script = scriptKey ? scriptMetricsFor(fontFamily, fontWeight, fontStyle)[scriptKey] : void 0;
@@ -338,8 +363,12 @@ function resolveRuns(runs, style, viewScale = 1) {
     const relative = run.fontSize === void 0 && scale !== 1;
     const fontSize = run.fontSize !== void 0 ? resolveScreenLength(run.fontSize, viewScale) : style.fontSize * scale;
     let sizeMap;
-    if ((run.fontVariantCaps ?? style.fontVariantCaps) === "small-caps") {
-      const caps = smallCapsText(text, srcMap);
+    let fontFeatures;
+    const smallCaps = (run.fontVariantCaps ?? style.fontVariantCaps) === "small-caps";
+    if (smallCaps && shapesWithFeature(fontFamily, fontWeight, fontStyle, "smcp")) {
+      fontFeatures = SMALL_CAPS_FEATURES;
+    } else if (smallCaps) {
+      const caps = smallCapsText(text, srcMap, run.lang ?? style.lang);
       text = caps.text;
       srcMap = caps.srcMap;
       if (caps.small) {
@@ -347,90 +376,34 @@ function resolveRuns(runs, style, viewScale = 1) {
         sizeMap = caps.small.map((s) => s ? small : fontSize);
       }
     }
+    const lang = run.lang ?? style.lang;
     out.push({
       text,
-      ...srcMap ? { srcMap } : {},
+      ...srcMap ? { srcMap } : NOTHING,
       fontFamily,
       fontSize,
-      ...sizeMap ? { sizeMap } : {},
+      ...sizeMap ? { sizeMap } : NOTHING,
       fontWeight,
       fontStyle,
       fill: run.fill !== void 0 ? run.fill : style.fill,
       // Unlike the decorations below, a run's stroke *replaces* the node's
       // rather than adding to it — there is only one outline to paint.
-      ...(run.stroke ?? style.stroke) !== void 0 ? { stroke: run.stroke ?? style.stroke } : {},
+      ...(run.stroke ?? style.stroke) !== void 0 ? { stroke: run.stroke ?? style.stroke } : NOTHING,
       letterSpacing: run.letterSpacing !== void 0 ? resolveScreenLength(run.letterSpacing, viewScale) : style.letterSpacing,
       // `||`, not `??`: run-level decorations are additive over the node style.
       underline: run.underline || style.underline,
       strikethrough: run.strikethrough || style.strikethrough,
       overline: run.overline || style.overline,
       baselineShift: shiftEm * style.fontSize,
-      ...relative ? { strutSize: style.fontSize } : {}
+      ...relative ? { strutSize: style.fontSize } : NOTHING,
+      ...run.rotate && Number.isFinite(run.rotate) ? { rotate: run.rotate } : NOTHING,
+      ...fontFeatures ? { fontFeatures } : NOTHING,
+      ...lang ? { lang } : NOTHING
     });
   }
   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 = style.underline || style.strikethrough || style.overline ? paintOf(g.run) : null;
-    if (paint === null) {
-      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;
@@ -465,210 +438,6 @@ 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) {
-  const outlineOnly = g.resolved.source === "outline";
-  if (!outlineOnly) {
-    if (minSize === void 0) return null;
-    if (run.fontSize < minSize && !strokeHasInk(run.stroke)) return null;
-  }
-  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;
-  const { family, weight, style } = g.resolved.resolved;
-  if (g.resolved.source !== "outline" && g.glyph === null) 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, 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);
-  if (!group) {
-    group = {
-      family,
-      weight,
-      style,
-      synthetic: { ...synthetic },
-      source,
-      page,
-      fill: run.fill,
-      ...stroke ? { stroke } : {},
-      quads: [],
-      glyphs: []
-    };
-    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 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
-        });
-        continue;
-      }
-      const quad = glyphQuad(g);
-      if (!quad) continue;
-      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;
-      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) {
@@ -710,15 +479,15 @@ function measureText(ctx, text, maxWidth, style) {
 
 // src/measure/measureTextBounds.ts
 function measureTextBounds(text, style, opts) {
-  const resolved2 = resolveTextStyle(style, void 0, opts?.scale);
-  const runs = resolveRuns([{ text }], resolved2, opts?.scale);
+  const resolved = resolveTextStyle(style, void 0, opts?.scale);
+  const runs = resolveRuns([{ text }], resolved, opts?.scale);
   const { bounds } = cachedLayoutRuns(runs, {
     maxWidth: opts?.maxWidth ?? Infinity,
-    lineHeight: opts?.lineHeight ?? resolved2.lineHeight,
-    align: resolved2.align,
-    direction: resolved2.direction,
-    tabSize: resolved2.tabSize
-  });
+    lineHeight: opts?.lineHeight ?? resolved.lineHeight,
+    align: resolved.align,
+    direction: resolved.direction,
+    tabSize: resolved.tabSize
+  }, "read");
   return { width: bounds.width, height: bounds.height };
 }
 
@@ -745,8 +514,7 @@ function caretCells(cells) {
   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);
+      const [x0, x1] = c.advance === 0 ? [prev.x, prev.x + prev.advance] : prev.advance === 0 ? [c.x, c.x + c.advance] : [Math.min(prev.x, c.x), Math.max(prev.x + prev.advance, c.x + c.advance)];
       out[out.length - 1] = {
         ...prev,
         x: x0,
@@ -860,7 +628,11 @@ function runMetrics(run, fontSize, face) {
 }
 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 shown = transformRunTexts(
+    runs.map((r) => r.text),
+    runs.map((r) => r.textTransform ?? "none"),
+    runs.map((r) => r.lang)
+  );
   const segs = [];
   runs.forEach((r, i) => {
     const text = shown[i].text;
@@ -868,7 +640,7 @@ function layoutMarkdown(runs, maxWidth, fontSize, measure, lineHeightFactor = 1.
       segs.push(text === r.text ? r : { ...r, text });
       return;
     }
-    const caps = smallCapsText(text);
+    const caps = smallCapsText(text, void 0, r.lang);
     if (!caps.small) {
       segs.push({ ...r, text: caps.text });
       return;
@@ -1073,7 +845,9 @@ var STYLE_KEYS = [
   "baselineShift",
   "fontScale",
   "textTransform",
-  "fontVariantCaps"
+  "fontVariantCaps",
+  "rotate",
+  "lang"
 ];
 var FLAG_KEYS = /* @__PURE__ */ new Set([
   "bold",
@@ -1254,9 +1028,9 @@ function setFlagOverRange(runs, style, start, end, key, value) {
 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 own = range?.fontWeight;
+  if (own === MIXED) return { fontWeight: MIXED, bold: MIXED };
+  if (own !== void 0) return { fontWeight: own, bold: isBoldWeight(own) };
   const flag = range?.bold;
   if (flag === MIXED) {
     if (node === 700) return { fontWeight: 700, bold: true };
@@ -1274,19 +1048,22 @@ var OVERRIDES = [
   "baselineShift",
   "fontScale",
   "textTransform",
-  "fontVariantCaps"
+  "fontVariantCaps",
+  "rotate",
+  "lang"
 ];
 function effectiveRangeStyle(range, style, paint) {
-  const resolved2 = resolveTextStyle(style, paint);
+  const resolved = resolveTextStyle(style, paint);
   const node = style ?? {};
   const out = {
-    fontFamily: resolved2.fontFamily,
-    fontSize: resolved2.fontSize,
-    letterSpacing: resolved2.letterSpacing,
-    textTransform: resolved2.textTransform,
-    fontVariantCaps: resolved2.fontVariantCaps
+    fontFamily: resolved.fontFamily,
+    fontSize: resolved.fontSize,
+    letterSpacing: resolved.letterSpacing,
+    textTransform: resolved.textTransform,
+    fontVariantCaps: resolved.fontVariantCaps
   };
-  if (resolved2.fill !== null) out.fill = resolved2.fill;
+  if (resolved.fill !== null) out.fill = resolved.fill;
+  if (resolved.lang !== void 0) out.lang = resolved.lang;
   Object.assign(out, rangeWeight(range, style));
   for (const key of FLAGS) {
     const on = nodeHasFlag(node, key);
@@ -1302,6 +1079,14 @@ function effectiveRangeStyle(range, style, paint) {
 
 // src/syntheticItalic.ts
 var SYNTHETIC_ITALIC_RADIANS = 0.2094;
+
+// src/glyphTurn.ts
+function glyphTurn(rotate) {
+  if (!rotate) return UPRIGHT;
+  const rad = rotate * Math.PI / 180;
+  return [Math.cos(rad), Math.sin(rad)];
+}
+var UPRIGHT = [1, 0];
 var TextOutlinesError = class extends Error {
   reason;
   family;
@@ -1370,7 +1155,7 @@ function emGlyph(d) {
 function placedGlyphOutline(g, dx, dy, caller, blankFallback = false) {
   const d = faceOutlineD(g);
   if (d === null) {
-    if (!blankFallback && glyphQuad(g) !== null) {
+    if (!blankFallback && hasGlyphQuad(g)) {
       const { family, weight, style } = g.resolved.resolved;
       throw new TextOutlinesError(
         "no-outlines",
@@ -1383,9 +1168,20 @@ function placedGlyphOutline(g, dx, dy, caller, blankFallback = false) {
     }
     return null;
   }
+  return glyphOutlineAt(d, g, dx, dy);
+}
+function glyphOutlineAt(d, g, dx, dy) {
   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];
+  const [cos, sin] = glyphTurn(g.rotate);
+  const m = [
+    cos * s,
+    sin * s,
+    -(cos * shear + sin) * s,
+    (cos - sin * shear) * s,
+    g.x + dx,
+    g.baselineY + dy
+  ];
   return transformPath(emboldenGlyph(emGlyph(d), d, g.resolved), m);
 }
 function colorGlyphError(run, caller) {
@@ -1398,25 +1194,6 @@ function colorGlyphError(run, caller) {
     caller
   );
 }
-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" };
-}
-
-// src/textToPath.ts
 function facesOf(runs) {
   const out = /* @__PURE__ */ new Map();
   const add = (family, weight, style) => {
@@ -1447,11 +1224,14 @@ function outlineLayoutInput(data, box, opts, caller) {
   return input;
 }
 function ruleContour(x0, y0, x1, y1) {
+  const xy = [x0, y0, x1, y0, x1, y1, x0, y1];
+  const origin = originFor(xy);
   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"
+    coords: coordsFrom(origin, xy),
+    fillRule: "nonzero",
+    ...origin ? { origin } : {}
   };
 }
 function walkOutlines(data, pose, opts) {
@@ -1464,25 +1244,27 @@ function walkOutlines(data, pose, opts) {
   const rules = paints.map(() => []);
   const faceOf = runFaces(runs);
   for (const line of laid.lines) {
+    const deco = lineDecorations(runs, faceOf, (run) => String(paintOf[run]));
     for (const g of line.glyphs) {
+      deco.add(g);
       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]))) {
+    for (const r of deco.end()) {
       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]]);
+    const path = joinPaths([...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);
+  return joinPaths(walkOutlines(data, pose, opts).paths);
 }
 function textToPathsByPaint(data, pose, opts = {}) {
   const { paints, paths } = walkOutlines(data, pose, opts);
@@ -1505,11 +1287,26 @@ async function loadTextOutlines(data, opts = {}) {
 }
 var MIDDLE_FALLBACK = 0.25;
 function textClusters(data, opts = {}) {
-  const box = { x: 0, y: 0, width: opts.width ?? Infinity, height: 0 };
+  const width = opts.width ?? Infinity;
+  const scale = opts.scale ?? 1;
+  const generation = glyphGeneration();
+  const hit = remembered.get(data);
+  if (hit && hit.width === width && hit.scale === scale && hit.generation === generation) return hit.clusters;
+  const clusters = clustersOf(data, width, scale);
+  remembered.set(data, { width, scale, generation, clusters });
+  return clusters;
+}
+var remembered = /* @__PURE__ */ new WeakMap();
+function clustersOf(data, width, scale) {
+  const opts = { scale };
+  const box = { x: 0, y: 0, width, 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 deco = lineDecorations(runs, runFaces(runs), (run) => String(paintOf[run]));
+  for (const g of line.glyphs) deco.add(g);
+  const lineRules = deco.end();
   const glyphOf = new Array(line.cells.length);
   for (const g of line.glyphs) glyphOf[g.cell] = g;
   const groups = [];
@@ -1532,19 +1329,36 @@ function textClusters(data, opts = {}) {
     }
     const paths = [];
     parts.forEach((p, k) => {
-      if (p.length > 0) paths.push({ ...paints[k], path: concat(p) });
+      if (p.length > 0) paths.push({ ...paints[k], path: joinPaths(p) });
     });
+    const rules = [];
+    for (const r of lineRules) {
+      const x0 = Math.max(r.x0, left);
+      const x1 = Math.min(r.x1, right);
+      if (!(x1 > x0)) continue;
+      const { fill, stroke } = paints[paintOf[r.run]];
+      rules.push({
+        kind: r.kind,
+        x0: x0 - left,
+        x1: x1 - left,
+        y0: r.y0 - line.baselineY,
+        y1: r.y1 - line.baselineY,
+        fill,
+        ...stroke ? { stroke } : {}
+      });
+    }
     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
+      middle: (xHeight === void 0 ? MIDDLE_FALLBACK : xHeight / 2) * first.fontSize,
+      rules
     };
   });
 }
 
-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 };
+export { MARKDOWN_RUN_GRAMMAR, SCRIPT_METRICS, SMALL_CAPS_SCALE, SYNTHETIC_ITALIC_RADIANS, TextOutlinesError, applyStyleToRange, caretIndexAt, createMarkdownRenderer, defaultLabelTextRenderer, effectiveRangeStyle, fitTextPose, glyphOutlineAt, glyphTurn, halfLeadingFor, isBoldWeight, isSmallCapsLetter, isTextData, layoutMarkdown, layoutTextPose, loadTextOutlines, markdownToRuns, measureText, measureTextBounds, measuredWidth, nodeHasFlag, numericWeight, patchRangeStyle, pointInTextPose, rangeWeight, renderLabel, resolveRunFace, resolveRuns, runsCarryStyling, runsToMarkdown, runsToPlainText, scriptMetrics, scriptMetricsFor, setFlagOverRange, smallCapsScale, smallCapsScaleFor, smallCapsText, styleAtRange, supersededKey, textClusters, textLineBoxes, textPoseLayoutInput, textToPath, textToPathsByPaint, toRuns, transformRunTexts, unboldPatch, verticalAlignOffset };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map