@weasel-js/text 1.13.0 → 1.14.0

package/dist/index.js

@@ -1,10 +1,10 @@
-import { lazy, DEFAULT_TAB_SIZE, resolveTextStyle, cachedLayoutRuns, blankGlyph, LineBox, doubles, graphemeCount, wrapLines, hangs, layoutRuns, tabAdvance, widthWithTabs } from './chunk-DOTR55MR.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-DOTR55MR.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,93 +376,33 @@ 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 } : {}
-    });
-  }
-  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 })
+      ...relative ? { strutSize: style.fontSize } : NOTHING,
+      ...run.rotate && Number.isFinite(run.rotate) ? { rotate: run.rotate } : NOTHING,
+      ...fontFeatures ? { fontFeatures } : NOTHING,
+      ...lang ? { lang } : NOTHING
     });
-    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(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 });
-    }
-  };
-  return {
-    add(g) {
-      const style = runs[g.run];
-      const paint = style.underline || style.strikethrough || style.overline ? paintOf(g.run) : null;
-      if (paint === null) {
-        if (open !== null) close();
-        return;
-      }
-      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 };
-      }
-    },
-    end() {
-      close();
-      return rules;
-    }
-  };
-}
 
 // src/measure/verticalAlign.ts
 function verticalAlignOffset(align, boxHeight, textHeight) {
@@ -469,260 +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);
-}
-var QUAD_STRIDE = 9;
-function hasGlyphQuad(g) {
-  const { font, glyph } = g;
-  return font !== null && glyph !== null && glyph.width !== 0 && glyph.page >= 0;
-}
-function writeGlyphQuad(g, out, at) {
-  const font = g.font, glyph = g.glyph;
-  const scale = g.fontSize / g.metrics.size;
-  const x0 = g.x + glyph.xoffset * scale;
-  const y0 = g.baselineY + (glyph.yoffset - g.metrics.base) * scale;
-  out[at] = x0;
-  out[at + 1] = y0;
-  out[at + 2] = x0 + glyph.width * scale;
-  out[at + 3] = y0 + glyph.height * scale;
-  out[at + 4] = glyph.x / font.common.scaleW;
-  out[at + 5] = glyph.y / font.common.scaleH;
-  out[at + 6] = (glyph.x + glyph.width) / font.common.scaleW;
-  out[at + 7] = (glyph.y + glyph.height) / font.common.scaleH;
-  out[at + 8] = g.baselineY;
-}
-var groupViews = {
-  quads: lazy("quads", (group) => {
-    const d = group.quadData;
-    const out = [];
-    for (let at = 0, k = 0; at < d.length; at += QUAD_STRIDE, k++) {
-      const q = {
-        x0: d[at],
-        y0: d[at + 1],
-        x1: d[at + 2],
-        y1: d[at + 3],
-        u0: d[at + 4],
-        v0: d[at + 5],
-        u1: d[at + 6],
-        v1: d[at + 7],
-        baselineY: d[at + 8]
-      };
-      if (group.colorGlyphs) q.colorGlyph = group.colorGlyphs[k];
-      out.push(q);
-    }
-    return out;
-  })
-};
-function runFaces(runs) {
-  const faces = runs.map((r) => faceMetricsOf(resolveFontVariant(r.fontFamily, r.fontWeight, r.fontStyle)));
-  return (run) => faces[run];
-}
-var isDecorated = (r) => r.underline || r.strikethrough || r.overline;
-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 } : {},
-      quadData: [],
-      ...source === "color" ? { colorGlyphs: [] } : {},
-      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 = runs.some(isDecorated) ? runFaces(runs) : null;
-  const rulePaint = (run) => fillHasInk(runs[run].fill) ? paintKey(runs[run].fill.paint) : null;
-  const cursor = blankGlyph();
-  let glyphCount = 0;
-  for (const line of laid.lines) glyphCount += LineBox.count(line);
-  let sized = null;
-  let sizedAt = 0;
-  for (const line of laid.lines) {
-    const span = LineBox.span(line);
-    const count = LineBox.count(line);
-    const rules = faceOf && lineDecorations(runs, faceOf, rulePaint);
-    for (let slot = 0; slot < count; slot++) {
-      const g = span ? span.cols.glyph(span.start, span.cols.visual(span.start, slot), cursor) : line.glyphs[slot];
-      rules?.add(g);
-      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;
-      }
-      if (!hasGlyphQuad(g)) continue;
-      const group = groupFor(groups, g, run, g.glyph.color ? "color" : g.resolved.source, last);
-      if (sized === null) {
-        sized = group;
-        group.quadData = doubles(glyphCount * QUAD_STRIDE);
-      }
-      const quads = group.quadData;
-      if (group === sized) {
-        writeGlyphQuad(g, quads, sizedAt);
-        sizedAt += QUAD_STRIDE;
-      } else {
-        writeGlyphQuad(g, quads, quads.length);
-      }
-      group.colorGlyphs?.push(g.glyph);
-    }
-    if (!rules) continue;
-    for (const rule of rules.end()) {
-      const { run, ...rect } = rule;
-      decorations.push({ ...rect, fill: runs[run].fill });
-    }
-  }
-  if (sized !== null) sized.quadData.length = sizedAt;
-  const out = [];
-  for (const group of groups.values()) out.push(Object.defineProperties(group, groupViews));
-  return { groups: out, 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) {
@@ -764,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 };
 }
 
@@ -799,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,
@@ -914,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;
@@ -922,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;
@@ -1127,7 +845,9 @@ var STYLE_KEYS = [
   "baselineShift",
   "fontScale",
   "textTransform",
-  "fontVariantCaps"
+  "fontVariantCaps",
+  "rotate",
+  "lang"
 ];
 var FLAG_KEYS = /* @__PURE__ */ new Set([
   "bold",
@@ -1308,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 };
@@ -1328,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);
@@ -1356,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;
@@ -1437,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) {
@@ -1452,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) => {
@@ -1501,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) {
@@ -1531,14 +1257,14 @@ function walkOutlines(data, pose, opts) {
   }
   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);
@@ -1561,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 = [];
@@ -1588,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, QUAD_STRIDE, 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