@weasel-js/text 1.9.3 → 1.10.0

package/dist/{chunk-L6UJ4RQK.js → chunk-Z6YRJ33J.js}

@@ -1,19 +1,48 @@
-import { resolveScreenLength } from '@weasel-js/paint';
-import { cssFamilyName, resolveFontVariant, faceMetricsOf, fontPending, glyphGeneration, glyphOutline, resolveGlyphFallback } from '@weasel-js/font';
+import { isSolidPaint, resolveScreenLength } from '@weasel-js/paint';
+import { cssFamilyName, faceGeneration, resolveFontVariant, metricsOf, warnNoMetrics, resolveColorCluster, glyphIn, resolveGlyph } from '@weasel-js/font';
 
 var __defProp = Object.defineProperty;
 var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, { get: all[name], enumerable: true });
 };
+
+// src/layout/tabStops.ts
+var DEFAULT_TAB_SIZE = 8;
+function tabAdvance(x, stop, min) {
+  if (!(stop > 0)) return 0;
+  const toNext = (Math.floor(x / stop) + 1) * stop - x;
+  return toNext < min ? toNext + stop : toNext;
+}
+function widthWithTabs(start, end, tabs, stopOf, flatWidth, piece) {
+  let x = 0;
+  let from = start;
+  const lay = (to) => {
+    if (to <= from) return;
+    piece?.(from, to, x);
+    x += flatWidth(from, to);
+  };
+  for (const t of tabs) {
+    if (t < start) continue;
+    if (t >= end) break;
+    lay(t);
+    const { stop, min } = stopOf(t);
+    x += tabAdvance(x, stop, min);
+    from = t + 1;
+  }
+  lay(end);
+  return x;
+}
+
+// src/textStyle.ts
 function resolveAlign(align, direction) {
   if (align === "start" || align === "justify") return direction === "rtl" ? "right" : "left";
   if (align === "end") return direction === "rtl" ? "left" : "right";
   return align;
 }
-var DEFAULT_FILL = { fill: "solid", color: "#000" };
+var DEFAULT_FILL = { kind: "solid", color: "#000" };
 function paintColor(p) {
-  return p !== null && "color" in p ? p.color : "#000";
+  return isSolidPaint(p) ? p.color : "#000";
 }
 function defaultSelectionBackground(textColor) {
   return `color-mix(in srgb, ${textColor} 25%, transparent)`;
@@ -24,10 +53,11 @@ var DEFAULT_TEXT_STYLE = {
   fontWeight: 400,
   fontStyle: "normal",
   align: "left",
-  direction: "ltr",
+  direction: "auto",
   lineHeight: 1.2,
+  tabSize: DEFAULT_TAB_SIZE,
   wrap: false,
-  fill: DEFAULT_FILL,
+  fill: { paint: DEFAULT_FILL },
   caretColor: paintColor(DEFAULT_FILL),
   selectionBackground: defaultSelectionBackground(paintColor(DEFAULT_FILL)),
   selectionColor: null,
@@ -45,12 +75,12 @@ function resolveTextStyle(style, paint, scale = 1) {
     return fill === DEFAULT_TEXT_STYLE.fill && stroke === void 0 ? DEFAULT_TEXT_STYLE : {
       ...DEFAULT_TEXT_STYLE,
       fill,
-      caretColor: paintColor(fill),
-      selectionBackground: defaultSelectionBackground(paintColor(fill)),
+      caretColor: paintColor(fill?.paint ?? null),
+      selectionBackground: defaultSelectionBackground(paintColor(fill?.paint ?? null)),
       ...stroke !== void 0 ? { stroke } : {}
     };
   }
-  const caretColor = style.caretColor ?? paintColor(fill);
+  const caretColor = style.caretColor ?? paintColor(fill?.paint ?? null);
   let selectionBackground;
   if (style.selectionBackground === "none") {
     selectionBackground = null;
@@ -67,6 +97,7 @@ function resolveTextStyle(style, paint, scale = 1) {
     align: style.align ?? DEFAULT_TEXT_STYLE.align,
     direction: style.direction ?? DEFAULT_TEXT_STYLE.direction,
     lineHeight: style.lineHeight ?? DEFAULT_TEXT_STYLE.lineHeight,
+    tabSize: style.tabSize ?? DEFAULT_TEXT_STYLE.tabSize,
     wrap: style.wrap ?? DEFAULT_TEXT_STYLE.wrap,
     fill,
     caretColor,
@@ -86,34 +117,6 @@ function fontString(s) {
   return `${s.fontStyle} ${s.fontWeight} ${s.fontSize}px ${cssFamilyName(s.fontFamily)}`;
 }
 
-// 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 };
-}
-
 // src/layout/lineBreak/lineBreakTable.ts
 var lineBreakTable_exports = {};
 __export(lineBreakTable_exports, {
@@ -468,8 +471,156 @@ function lineBreakOpportunities(cps) {
   }
 }
 
+// src/layout/bidiRegistry.ts
+var registered = null;
+function registerBidi(engine) {
+  registered = engine;
+  return () => {
+    if (registered === engine) registered = null;
+  };
+}
+function registeredBidi() {
+  return registered;
+}
+function directionOfLevel(level) {
+  return level % 2 === 1 ? "rtl" : "ltr";
+}
+function paragraphDirection(text, direction = "auto", engine = registered) {
+  if (direction !== "auto") return direction;
+  if (engine === null) return "ltr";
+  const cps = [];
+  for (const ch of text) {
+    const cp = ch.codePointAt(0);
+    if (isHardLineBreak(cp)) break;
+    cps.push(cp);
+  }
+  return directionOfLevel(engine.baseLevel(engine.analyze(cps, "auto")));
+}
+var RTL_BLOCKS = [
+  [1424, 1535],
+  [1536, 1983],
+  [2144, 2303],
+  [64285, 65023],
+  [65136, 65279],
+  [67584, 69631],
+  [124928, 126975]
+];
+var RTL_BLOCK_NUMBERS = [
+  [1536, 1541],
+  [1632, 1644],
+  [1757, 1757],
+  [1776, 1785],
+  [2274, 2274],
+  [68912, 68921],
+  [69216, 69246]
+];
+var RTL_BLOCK_NEUTRALS = [
+  [1548, 1548],
+  [64830, 64831],
+  [65279, 65279]
+];
+var within = (ranges, cp) => ranges.some(([lo, hi]) => cp >= lo && cp <= hi);
+var warnedLogicalRtl = false;
+function warnRtlWithoutEngine(codePoints) {
+  if (warnedLogicalRtl) return;
+  for (const cp of codePoints) {
+    if (!within(RTL_BLOCKS, cp) || within(RTL_BLOCK_NUMBERS, cp) || within(RTL_BLOCK_NEUTRALS, cp)) continue;
+    warnedLogicalRtl = true;
+    console.warn(
+      // Naming the import in `from "<pkg>"` form would trip labkit's
+      // consumer smoke test, which greps dist for that exact shape.
+      "weasel layoutRuns: this text contains right-to-left characters but no `bidi` engine is registered, so it is being laid out in logical order \u2014 the glyphs will appear reversed. Import `bidi` out of the `@weasel-js/bidi` package and call `registerBidi(bidi)` once at startup."
+    );
+    return;
+  }
+}
+function _resetBidiWarningForTests() {
+  warnedLogicalRtl = false;
+}
+
+// src/layout/bidiLines.ts
+function analyzeParagraphs(engine, codePoints, isBreak, direction) {
+  const paragraphs = [];
+  let start = 0;
+  for (let i = 0; i <= codePoints.length; i++) {
+    if (i < codePoints.length && !isBreak(i)) continue;
+    if (i > start) {
+      paragraphs.push({ start, end: i, analysis: engine.analyze(codePoints.slice(start, i), direction) });
+    }
+    start = i + 1;
+  }
+  const holding = (at) => {
+    let lo = 0;
+    let hi = paragraphs.length - 1;
+    while (lo < hi) {
+      const mid = lo + hi >> 1;
+      if (paragraphs[mid].end <= at) lo = mid + 1;
+      else hi = mid;
+    }
+    const p = paragraphs[lo];
+    return p !== void 0 && at >= p.start && at < p.end ? p : void 0;
+  };
+  return {
+    reorder(from, to) {
+      const p = holding(from);
+      if (p === void 0 || to > p.end) return { order: [], levels: [] };
+      const r = engine.reorder(p.analysis, from - p.start, to - p.start);
+      return { order: r.order.map((i) => i + p.start), levels: r.levels };
+    },
+    baseLevel(at) {
+      const p = holding(at);
+      return p === void 0 ? 0 : engine.baseLevel(p.analysis);
+    }
+  };
+}
+function restoreRemoved(order, count, rtl) {
+  if (order.length === count) return [...order];
+  const kept = new Set(order);
+  const leading = [];
+  const following = /* @__PURE__ */ new Map();
+  let anchor = -1;
+  let firstKept = -1;
+  for (let k = 0; k < count; k++) {
+    if (kept.has(k)) {
+      anchor = k;
+      if (firstKept < 0) firstKept = k;
+    } else if (anchor < 0) {
+      leading.push(k);
+    } else {
+      const list = following.get(anchor);
+      if (list) list.push(k);
+      else following.set(anchor, [k]);
+    }
+  }
+  if (firstKept < 0) return leading;
+  const out = [];
+  for (const p of order) {
+    const after = following.get(p) ?? [];
+    const before = p === firstKept ? leading : [];
+    if (rtl(p)) out.push(...[...after].reverse(), p, ...[...before].reverse());
+    else out.push(...before, p, ...after);
+  }
+  return out;
+}
+function orderLine(paragraphs, start, count) {
+  const levels = new Array(count).fill(0);
+  if (paragraphs === null || count === 0) return { visual: levels.map((_, pos) => pos), levels };
+  const r = paragraphs.reorder(start, start + count);
+  for (let pos = 0; pos < count; pos++) {
+    const level = r.levels[pos];
+    if (typeof level === "number" && level >= 0) levels[pos] = level;
+  }
+  const kept = /* @__PURE__ */ new Set();
+  for (const at of r.order) {
+    const pos = at - start;
+    if (Number.isInteger(pos) && pos >= 0 && pos < count) kept.add(pos);
+  }
+  return { visual: restoreRemoved([...kept], count, (pos) => levels[pos] % 2 === 1), levels };
+}
+
 // src/measure/graphemes.ts
 var segmenter;
+var NEEDS_SEGMENTING = /[\r\u0300-\uffff]/;
 function graphemeSegmenter() {
   if (segmenter === void 0) {
     segmenter = typeof Intl !== "undefined" && "Segmenter" in Intl ? new Intl.Segmenter(void 0, { granularity: "grapheme" }) : null;
@@ -478,6 +629,10 @@ function graphemeSegmenter() {
 }
 function graphemeEnds(text) {
   const out = [];
+  if (!NEEDS_SEGMENTING.test(text)) {
+    for (let i = 1; i <= text.length; i++) out.push(i);
+    return out;
+  }
   const seg = graphemeSegmenter();
   if (seg) {
     for (const s of seg.segment(text)) out.push(s.index + s.segment.length);
@@ -491,8 +646,125 @@ function graphemeCount(text) {
   return graphemeEnds(text).length;
 }
 
+// src/layout/layoutEntries.ts
+function measureRuns(runs, tabSize) {
+  const entries = [];
+  let prev;
+  let srcIndex = 0;
+  runs.forEach((run, runIndex) => {
+    const resolved = resolveFontVariant(run.fontFamily, run.fontWeight, run.fontStyle);
+    const metrics = metricsOf(resolved);
+    if (!metrics) {
+      warnNoMetrics(run.fontFamily, run.fontWeight, run.fontStyle);
+      srcIndex += run.srcMap?.length ?? run.text.length;
+      prev = void 0;
+      return;
+    }
+    const runBase = srcIndex;
+    const map = run.srcMap;
+    const clusterEnds = graphemeEnds(run.text);
+    let cluster = 0;
+    let clusterStart = 0;
+    let color = null;
+    let at = 0;
+    for (const ch of run.text) {
+      const cp = ch.codePointAt(0);
+      const fontSize = run.sizeMap ? run.sizeMap[at] : run.fontSize;
+      if (at === clusterStart) {
+        color = resolveColorCluster(
+          resolved,
+          run.fontFamily,
+          run.fontWeight,
+          run.fontStyle,
+          run.text.slice(at, clusterEnds[cluster])
+        );
+      }
+      const clusterEnd = at + ch.length === clusterEnds[cluster];
+      if (clusterEnd) clusterStart = clusterEnds[cluster++];
+      const tracking = clusterEnd ? run.letterSpacing : 0;
+      const srcStart = map ? runBase + map.starts[at] : runBase + at;
+      const srcEnd = map ? runBase + map.ends[at] : runBase + at + ch.length;
+      at += ch.length;
+      srcIndex = map ? runBase + map.length : srcEnd;
+      const kerningBefore = prev ? prev.metrics.kernOf(prev.cp, cp) * (prev.fontSize / prev.metrics.size) : 0;
+      const blank = {
+        run: runIndex,
+        cp,
+        fontSize,
+        lineSize: Math.max(run.fontSize, run.strutSize ?? 0),
+        // Optional on the authored run type; absent, every y would go NaN.
+        baselineShift: run.baselineShift ?? 0,
+        srcIndex: srcStart,
+        srcEnd,
+        clusterEnd,
+        resolved,
+        metrics,
+        font: null,
+        glyph: null,
+        advance: 0,
+        tracking: 0,
+        kerningBefore: 0,
+        drawsInk: false
+      };
+      const inked = (hit, kerning) => ({
+        ...blank,
+        resolved: hit.resolved,
+        metrics: hit.metrics,
+        font: hit.font,
+        glyph: hit.glyph,
+        advance: hit.advance * (fontSize / hit.metrics.size),
+        tracking,
+        kerningBefore: kerning,
+        drawsInk: true
+      });
+      if (color) {
+        entries.push(clusterEnd ? inked(color, 0) : blank);
+        prev = void 0;
+      } else if (isHardLineBreak(cp)) {
+        entries.push(blank);
+        prev = void 0;
+      } else if (cp === 9 || cp === 32) {
+        const space = metrics.advanceOf(32);
+        const advance = space !== null ? space * (fontSize / metrics.size) : fontSize * 0.25;
+        if (cp === 9) {
+          entries.push({ ...blank, tab: { stop: tabSize * (advance + run.letterSpacing), min: advance / 2 } });
+          prev = void 0;
+        } else {
+          const own = glyphIn(resolved, 32);
+          prev = {
+            ...blank,
+            font: own?.font ?? null,
+            glyph: own?.glyph ?? null,
+            advance,
+            tracking,
+            kerningBefore
+          };
+          entries.push(prev);
+        }
+      } else {
+        const hit = resolveGlyph(resolved, run.fontFamily, run.fontWeight, run.fontStyle, cp);
+        prev = hit ? inked(hit, kerningBefore) : blank;
+        entries.push(prev);
+      }
+    }
+  });
+  return entries;
+}
+function mirrorEntries(entries, levels, mirror, runs) {
+  return entries.map((entry, pos) => {
+    if (levels[pos] % 2 === 0) return entry;
+    const cp = mirror(entry.cp);
+    if (cp === null || cp === entry.cp) return entry;
+    if (entry.font === null) return { ...entry, cp };
+    const run = runs[entry.run];
+    const hit = resolveGlyph(entry.resolved, run.fontFamily, run.fontWeight, run.fontStyle, cp, false);
+    if (!hit) return entry;
+    return { ...entry, cp, resolved: hit.resolved, metrics: hit.metrics, font: hit.font, glyph: hit.glyph };
+  });
+}
+
 // src/layout/lineBreak/wrapLines.ts
-var SPACE = 32;
+var hangs = (cp) => cp === 32 || cp === 9;
 function wrapLines(cps, maxWidth, widthOf) {
   const n = cps.length;
   const breaks = Number.isFinite(maxWidth) ? lineBreakOpportunities(cps) : null;
@@ -507,14 +779,14 @@ function wrapLines(cps, maxWidth, widthOf) {
       start = i;
       continue;
     }
-    if (cp === SPACE) {
+    if (hangs(cp)) {
       i++;
       continue;
     }
     let j = i + 1;
     let ink = i + 1;
     while (j < n && !isHardLineBreak(cps[j]) && (!breaks || breaks[j] === NO_BREAK)) {
-      if (cps[j] !== SPACE) ink = j + 1;
+      if (!hangs(cps[j])) ink = j + 1;
       j++;
     }
     if (breaks && i > start && widthOf(start, ink) > maxWidth) {
@@ -527,609 +799,175 @@ function wrapLines(cps, maxWidth, widthOf) {
   return lines;
 }
 
-// src/layout/layoutRuns.ts
-function atlasMetrics(font) {
-  const size = font.info.size;
-  const { ascent, descent } = font.faceMetrics ?? {};
-  return {
-    size,
-    base: font.common.base,
-    ...ascent !== void 0 && descent !== void 0 ? { ascent: ascent * size, descent: descent * size } : { ascent: font.common.base },
-    advanceOf: (cp) => font.charMap.get(cp)?.xadvance ?? null,
-    kernOf: (l, r) => font.kerningMap.get(l)?.get(r) ?? 0
-  };
-}
-function fillKey(p) {
-  if (p === null) return "none";
-  if ("color" in p) return `s:${p.color}:${p.opacity ?? 1}`;
-  return `nx:${Math.random()}`;
-}
-function sameFill(a, b) {
-  if (a === b) return true;
-  if (a !== null && b !== null && "color" in a && "color" in b) {
-    return a.color === b.color && (a.opacity ?? 1) === (b.opacity ?? 1);
-  }
-  return false;
-}
-function strokePaints(s) {
-  if (s?.paint === void 0) return false;
-  const w = s.width ?? 1;
-  return (typeof w === "number" ? w : w.px) > 0;
-}
-function strokeKey(s) {
-  if (!strokePaints(s)) return "-";
-  const width = s.width ?? 1;
-  return [
-    // A screen-pixel width keys apart from the equal world-unit number: the two
-    // resolve to different ribbons, so they must not share a draw call.
-    fillKey(s.paint),
-    typeof width === "number" ? width : `px${width.px}`,
-    s.join ?? "miter",
-    s.cap ?? "butt",
-    s.miterLimit ?? "",
-    s.align ?? "center",
-    (s.dash ?? []).join(",")
-  ].join(":");
-}
-function groupKey(family, weight, style, synthetic, fill, stroke, source, page) {
-  return `${family}|${weight}|${style}|${synthetic.bold ? 1 : 0}${synthetic.italic ? 1 : 0}|${fillKey(fill)}|${strokeKey(stroke)}|${source}|${page}`;
-}
-function getOrCreateGroup(ctx, run, resolved2, page, sourceOverride) {
-  const atlasFamily = resolved2.resolved.family;
-  const resolvedWeight = resolved2.resolved.weight;
-  const resolvedStyle = resolved2.resolved.style;
-  const source = sourceOverride ?? resolved2.source;
-  const key = groupKey(
-    atlasFamily,
-    resolvedWeight,
-    resolvedStyle,
-    resolved2.synthetic,
-    run.fill,
-    source === "outline" && strokePaints(run.stroke) ? run.stroke : void 0,
-    source,
-    page
-  );
-  let g = ctx.groups.get(key);
-  if (!g) {
-    g = {
-      family: atlasFamily,
-      weight: resolvedWeight,
-      style: resolvedStyle,
-      synthetic: { ...resolved2.synthetic },
-      source,
-      page,
-      fill: run.fill,
-      // Only the outline tier can paint it, and carrying it on an SDF group
-      // would be a promise the renderer cannot keep.
-      ...source === "outline" && strokePaints(run.stroke) ? { stroke: run.stroke } : {},
-      quads: [],
-      glyphs: []
-    };
-    ctx.groups.set(key, g);
-  }
-  return g;
-}
-function resolveGlyph(run, font, resolved2, cp) {
-  const direct = font.charMap.get(cp);
-  if (direct) return { glyph: direct, font, resolved: resolved2 };
-  const fallback = resolveGlyphFallback(run.fontFamily, run.fontWeight, run.fontStyle);
-  const face = fallback?.dynamicFace;
-  if (fallback && face) {
-    const glyph = face.requestGlyph(cp);
-    if (glyph.xadvance > 0 || glyph.width > 0) {
-      return { glyph, font: face.font, resolved: fallback };
-    }
-  }
-  warnMissingGlyphOnce(resolved2.resolved.family, cp);
-  return null;
-}
-var RTL_BLOCKS = [
-  [1424, 1535],
-  [1536, 1983],
-  [2144, 2303],
-  [64285, 65023],
-  [65136, 65279],
-  [67584, 69631],
-  [124928, 126975]
-];
-var warnedLogicalRtl = false;
-function warnLogicalRtlOnce() {
-  if (warnedLogicalRtl) return;
-  warnedLogicalRtl = true;
-  console.warn(
-    // Naming the import in `from "<pkg>"` form would trip labkit's
-    // consumer smoke test, which greps dist for that exact shape.
-    "weasel layoutRuns: this text contains right-to-left characters but no `bidi` engine was supplied, so it is being laid out in logical order \u2014 the glyphs will appear reversed. Import `bidi` out of the `@weasel-js/bidi` package and add it to the layout options."
-  );
-}
-var warnedMissingGlyphs = /* @__PURE__ */ new Set();
-function warnMissingGlyphOnce(family, cp) {
-  const key = `${family}|${cp}`;
-  if (warnedMissingGlyphs.has(key)) return;
-  warnedMissingGlyphs.add(key);
-  const ch = String.fromCodePoint(cp);
-  console.warn(
-    `weasel layoutRuns: no glyph for U+${cp.toString(16).toUpperCase().padStart(4, "0")} (${JSON.stringify(ch)}) in "${family}", and the dynamic tier could not rasterize it \u2014 skipping the character. Bake it into the atlas, or call registerCanvasFont("${family}") to serve missing codepoints from installed fonts.`
-  );
+// src/layout/layoutLines.ts
+function aboveBaseline(e, lineHeight) {
+  const k = e.lineSize / e.metrics.size;
+  const ascent = e.metrics.ascent * k;
+  if (e.metrics.descent === void 0) return ascent;
+  return (e.lineSize * lineHeight - ascent - e.metrics.descent * k) / 2 + ascent;
 }
-var warnedNoMetrics = /* @__PURE__ */ new Set();
-function warnNoMetricsOnce(family, weight, style) {
-  const key = `${family}|${weight}|${style}`;
-  if (warnedNoMetrics.has(key)) return;
-  warnedNoMetrics.add(key);
-  console.warn(
-    `weasel layoutRuns: no metrics for "${family}" ${weight}/${style} \u2014 neither an atlas nor an outline face resolved, so every run set in it lays out as nothing. Register it with registerFont / registerCanvasFont / registerFontOutlines. If you did, check for a duplicated @weasel-js/font in node_modules \u2014 its registry is module state, so a second copy is a second, empty one.`
-  );
-}
-function layoutRuns(runs, opts) {
-  const ctx = { groups: /* @__PURE__ */ new Map() };
-  const align = resolveAlign(opts.align, opts.direction ?? "ltr");
-  const justify = opts.justify === true || opts.align === "justify";
-  const lineSize = (e) => Math.max(e.run.fontSize, e.run.strutSize ?? 0);
-  const aboveBaseline = (e) => {
-    const k = lineSize(e) / e.metrics.size;
-    const ascent = e.metrics.ascent * k;
-    if (e.metrics.descent === void 0) return ascent;
-    return (lineSize(e) * opts.lineHeight - ascent - e.metrics.descent * k) / 2 + ascent;
-  };
-  const entries = [];
-  const runFaces = /* @__PURE__ */ new Map();
-  let prevCp;
-  let prevMetrics;
-  let prevFontSize;
-  let srcIndex = 0;
-  for (const run of runs) {
-    const resolved2 = resolveFontVariant(run.fontFamily, run.fontWeight, run.fontStyle);
-    runFaces.set(run, faceMetricsOf(resolved2));
-    const outlineFace = resolved2.outlineFace;
-    const font = resolved2.entry?.font ?? resolved2.dynamicFace?.font ?? null;
-    const metrics = outlineFace ? {
-      size: 1,
-      base: outlineFace.ascender,
-      ascent: outlineFace.faceMetrics?.ascent ?? outlineFace.ascender,
-      ...outlineFace.faceMetrics?.descent !== void 0 ? { descent: outlineFace.faceMetrics.descent } : {},
-      advanceOf: (cp) => outlineFace.advanceOf(cp),
-      kernOf: (l, r) => outlineFace.kernOf(l, r)
-    } : font ? atlasMetrics(font) : void 0;
-    if (!metrics) {
-      if (!fontPending(run.fontFamily, run.fontWeight, run.fontStyle)) {
-        warnNoMetricsOnce(run.fontFamily, run.fontWeight, run.fontStyle);
-      }
-      srcIndex += run.srcMap?.length ?? run.text.length;
-      prevCp = void 0;
-      prevMetrics = void 0;
-      prevFontSize = void 0;
-      continue;
-    }
-    const runBase = srcIndex;
-    const map = run.srcMap;
-    const sizes = run.sizeMap;
-    let at = 0;
-    const runTracking = run.letterSpacing;
-    const clusterEnds = runTracking === 0 ? null : new Set(graphemeEnds(run.text));
-    for (const ch of [...run.text]) {
-      const cp = ch.codePointAt(0);
-      const fontSize = sizes ? sizes[at] : run.fontSize;
-      const scale = fontSize / metrics.size;
-      const tracking = clusterEnds === null || clusterEnds.has(at + ch.length) ? runTracking : 0;
-      const isNewline = isHardLineBreak(cp);
-      const isSpace = cp === 32;
-      const srcStart = map ? runBase + map.starts[at] : runBase + at;
-      const srcEnd = map ? runBase + map.ends[at] : runBase + at + ch.length;
-      at += ch.length;
-      srcIndex = map ? runBase + map.length : srcEnd;
-      if (isNewline) {
-        entries.push({
-          run,
-          font,
-          metrics,
-          glyph: { id: cp, x: 0, y: 0, width: 0, height: 0, xoffset: 0, yoffset: 0, xadvance: 0, page: 0 },
-          // A newline consumes no advance, so it takes no tracking either.
-          cp,
-          advance: 0,
-          tracking: 0,
-          kerningBefore: 0,
-          isSpace: false,
-          isNewline: true,
-          drawsInk: false,
-          resolved: resolved2,
-          fontSize,
-          srcIndex: srcStart,
-          srcEnd,
-          flat: 0
-        });
-        prevCp = void 0;
-        prevMetrics = void 0;
-        prevFontSize = void 0;
-        continue;
-      }
-      if (isSpace) {
-        const spaceGlyph = resolved2.dynamicFace ? resolved2.dynamicFace.requestGlyph(32) : font?.charMap.get(32) ?? null;
-        const spaceAdvance = spaceGlyph ? spaceGlyph.xadvance : metrics.advanceOf(32);
-        const advance = spaceAdvance !== null ? spaceAdvance * scale : fontSize * 0.25;
-        let kerningBefore2 = 0;
-        if (prevCp !== void 0 && prevMetrics !== void 0 && prevFontSize !== void 0) {
-          kerningBefore2 = prevMetrics.kernOf(prevCp, cp) * (prevFontSize / prevMetrics.size);
-        }
-        entries.push({
-          run,
-          font,
-          metrics,
-          glyph: spaceGlyph ?? { id: 32, x: 0, y: 0, width: 0, height: 0, xoffset: 0, yoffset: 0, xadvance: 0, page: 0 },
-          cp,
-          advance,
-          tracking,
-          kerningBefore: kerningBefore2,
-          isSpace: true,
-          isNewline: false,
-          drawsInk: false,
-          resolved: resolved2,
-          fontSize,
-          srcIndex: srcStart,
-          srcEnd,
-          flat: 0
-        });
-        prevCp = cp;
-        prevMetrics = metrics;
-        prevFontSize = fontSize;
-        continue;
-      }
-      if (outlineFace) {
-        const adv = metrics.advanceOf(cp);
-        if (adv === null) {
-          entries.push({
-            run,
-            font: null,
-            metrics,
-            glyph: null,
-            cp,
-            advance: 0,
-            tracking: 0,
-            kerningBefore: 0,
-            isSpace,
-            isNewline: false,
-            drawsInk: false,
-            resolved: resolved2,
-            fontSize,
-            srcIndex: srcStart,
-            srcEnd,
-            flat: 0
-          });
-          prevCp = cp;
-          prevMetrics = metrics;
-          prevFontSize = fontSize;
-          continue;
-        }
-        let kerningBefore2 = 0;
-        if (prevCp !== void 0 && prevMetrics !== void 0 && prevFontSize !== void 0) {
-          kerningBefore2 = prevMetrics.kernOf(prevCp, cp) * (prevFontSize / prevMetrics.size);
-        }
-        entries.push({
-          run,
-          font: null,
-          metrics,
-          glyph: null,
-          cp,
-          advance: adv * scale,
-          tracking,
-          kerningBefore: kerningBefore2,
-          isSpace,
-          isNewline: false,
-          drawsInk: !isSpace,
-          resolved: resolved2,
-          fontSize,
-          srcIndex: srcStart,
-          srcEnd,
-          flat: 0
-        });
-        prevCp = cp;
-        prevMetrics = metrics;
-        prevFontSize = fontSize;
-        continue;
-      }
-      const hit = resolved2.dynamicFace ? { glyph: resolved2.dynamicFace.requestGlyph(cp), font, resolved: resolved2 } : resolveGlyph(run, font, resolved2, cp);
-      if (!hit) {
-        entries.push({
-          run,
-          font: null,
-          metrics,
-          glyph: null,
-          cp,
-          advance: 0,
-          tracking: 0,
-          kerningBefore: 0,
-          isSpace,
-          isNewline: false,
-          drawsInk: false,
-          resolved: resolved2,
-          fontSize,
-          srcIndex: srcStart,
-          srcEnd,
-          flat: 0
-        });
-        prevCp = cp;
-        prevMetrics = metrics;
-        prevFontSize = fontSize;
-        continue;
-      }
-      const glyphFont = hit.font;
-      const glyphMetrics = glyphFont === font ? metrics : atlasMetrics(glyphFont);
-      const glyphScale = fontSize / glyphFont.info.size;
-      let kerningBefore = 0;
-      if (prevCp !== void 0 && prevMetrics !== void 0 && prevFontSize !== void 0) {
-        kerningBefore = prevMetrics.kernOf(prevCp, cp) * (prevFontSize / prevMetrics.size);
-      }
-      entries.push({
-        run,
-        font: glyphFont,
-        metrics: glyphMetrics,
-        glyph: hit.glyph,
-        cp,
-        advance: hit.glyph.xadvance * glyphScale,
-        tracking,
-        kerningBefore,
-        isSpace,
-        isNewline: false,
-        drawsInk: !isSpace,
-        resolved: hit.resolved,
-        fontSize,
-        srcIndex: srcStart,
-        srcEnd,
-        flat: 0
-      });
-      prevCp = cp;
-      prevMetrics = glyphMetrics;
-      prevFontSize = fontSize;
-    }
-  }
-  for (let i = 0; i < entries.length; i++) entries[i].flat = i;
-  const analysis = opts.bidi ? opts.bidi.analyze(entries.map((e) => e.cp), opts.direction ?? "auto") : null;
-  if (!opts.bidi && entries.some((e) => RTL_BLOCKS.some(([lo, hi]) => e.cp >= lo && e.cp <= hi))) {
-    warnLogicalRtlOnce();
-  }
-  const openingWidth = (e) => e.isSpace ? 0 : e.advance + e.tracking;
+function breakLines(entries, maxWidth, lineHeight) {
   const sum = new Float64Array(entries.length + 1);
-  for (let k = 0; k < entries.length; k++) {
-    const e = entries[k];
+  const tabs = [];
+  entries.forEach((e, k) => {
     sum[k + 1] = sum[k] + e.kerningBefore + e.advance + e.tracking;
-  }
-  const widthOf = (start, end) => openingWidth(entries[start]) + sum[end] - sum[start + 1];
-  const lines = [];
-  for (const span2 of wrapLines(entries.map((e) => e.cp), opts.maxWidth, widthOf)) {
-    const line = { entries: [], width: 0, height: 0, ...span2.wrapped ? { wrapped: true } : {} };
-    if (span2.start === span2.end) {
-      const brk = entries[span2.end];
-      line.height = lineSize(brk) * opts.lineHeight;
-      line.blank = brk;
+    if (e.tab) tabs.push(k);
+  });
+  const flatWidth = (start, end) => entries[start].advance + entries[start].tracking + sum[end] - sum[start + 1];
+  const widthOf = tabs.length === 0 ? flatWidth : (start, end) => widthWithTabs(start, end, tabs, (k) => entries[k].tab, flatWidth);
+  return wrapLines(entries.map((e) => e.cp), maxWidth, widthOf).map((span) => {
+    const line = {
+      start: span.start,
+      entries: [],
+      width: 0,
+      height: 0,
+      ascent: 0,
+      wrapped: span.wrapped,
+      srcEnd: 0
+    };
+    if (span.start === span.end) {
+      const brk = entries[span.end];
+      line.height = brk.lineSize * lineHeight;
+      line.ascent = aboveBaseline(brk, lineHeight);
+      line.srcEnd = brk.srcIndex;
+      return line;
     }
-    for (let k = span2.start; k < span2.end; k++) {
+    for (let k = span.start; k < span.end; k++) {
       const e = entries[k];
-      const placed = k > span2.start ? e : e.isSpace ? { ...e, kerningBefore: 0, advance: 0, tracking: 0 } : { ...e, kerningBefore: 0 };
+      const opened = k > span.start ? e : { ...e, kerningBefore: 0 };
+      const placed = e.tab ? { ...opened, advance: tabAdvance(line.width, e.tab.stop, e.tab.min) } : opened;
       line.entries.push(placed);
       line.width += placed.kerningBefore + placed.advance + placed.tracking;
-      line.height = Math.max(line.height, lineSize(e) * opts.lineHeight);
-    }
-    lines.push(line);
-  }
-  function outlineFor(e) {
-    const r0 = e.resolved.resolved;
-    if (e.resolved.source === "outline") {
-      return glyphOutline(r0.family, r0.weight, r0.style, e.cp);
-    }
-    const min = opts.outlineMinSize;
-    if (min === void 0) return null;
-    if (e.run.fontSize < min && !strokePaints(e.run.stroke)) return null;
-    if (e.resolved.synthetic.bold) return null;
-    const r = e.resolved.resolved;
-    return glyphOutline(r.family, r.weight, r.style, e.cp);
-  }
-  const decorations = [];
-  let span = null;
-  function flushSpan() {
-    const s = span;
-    span = null;
-    if (!s || s.x1 <= s.x0) return;
-    for (const kind of DECORATION_KINDS) {
-      if (!s[kind]) continue;
-      const { y0, y1 } = decorationRule(kind, s.baselineY, s.fontSize, s.face);
-      decorations.push({ kind, x0: s.x0, y0, x1: s.x1, y1, fill: s.fill });
+      line.height = Math.max(line.height, e.lineSize * lineHeight);
+      line.ascent = Math.max(line.ascent, aboveBaseline(placed, lineHeight));
     }
+    line.srcEnd = entries[span.end - 1].srcEnd;
+    return line;
+  });
+}
+function hungWidth(entries) {
+  let hung = 0;
+  for (let k = entries.length - 1; k >= 0 && hangs(entries[k].cp); k--) {
+    const e = entries[k];
+    hung += e.kerningBefore + e.advance + e.tracking;
   }
-  const lineBoxes = [];
-  let penY = 0;
-  let maxLineWidth = 0;
-  const alignWidth = opts.alignWidth ?? opts.maxWidth;
-  for (const line of lines) {
-    let hung = 0;
-    for (let k = line.entries.length - 1; k >= 0; k--) {
-      const e = line.entries[k];
-      if (!e.isSpace) break;
-      hung += e.kerningBefore + e.advance + e.tracking;
-    }
-    const inkWidth = line.width - hung;
-    const gaps = /* @__PURE__ */ new Set();
-    let gapExtra = 0;
-    if (justify && line.wrapped && Number.isFinite(alignWidth) && alignWidth > inkWidth) {
-      let first = 0;
-      while (first < line.entries.length && line.entries[first].isSpace) first++;
-      let last = line.entries.length - 1;
-      while (last > first && line.entries[last].isSpace) last--;
-      for (let k = first + 1; k < last; k++) if (line.entries[k].isSpace) gaps.add(k);
-      if (gaps.size > 0) gapExtra = (alignWidth - inkWidth) / gaps.size;
-    }
-    const spread = gapExtra * gaps.size;
-    const alignShift = (() => {
-      if (spread > 0) return 0;
-      if (align === "left") return 0;
-      if (!Number.isFinite(alignWidth)) {
-        return align === "center" ? -inkWidth / 2 : -inkWidth;
-      }
-      const slack = alignWidth - inkWidth;
-      return align === "center" ? slack / 2 : slack;
-    })();
-    const lineX0 = alignShift;
-    let lineAscent = 0;
-    for (const e of line.entries) lineAscent = Math.max(lineAscent, aboveBaseline(e));
-    if (line.entries.length === 0 && line.blank) lineAscent = aboveBaseline(line.blank);
-    const lineBaselineY = penY + lineAscent;
-    const cells = new Array(line.entries.length);
-    const flatOf = line.entries.map((e) => e.flat);
-    const posOfFlat = /* @__PURE__ */ new Map();
-    flatOf.forEach((f, pos) => posOfFlat.set(f, pos));
-    let visual = line.entries.map((_, k) => k);
-    let levelOf = () => 0;
-    if (opts.bidi && analysis !== null && line.entries.length > 0) {
-      const from = flatOf[0];
-      const to = flatOf[flatOf.length - 1] + 1;
-      const r = opts.bidi.reorder(analysis, from, to);
-      const seen = /* @__PURE__ */ new Set();
-      const ordered = [];
-      for (const f of r.order) {
-        const pos = posOfFlat.get(f);
-        if (pos !== void 0 && !seen.has(pos)) {
-          ordered.push(pos);
-          seen.add(pos);
-        }
-      }
-      for (let k = 0; k < line.entries.length; k++) if (!seen.has(k)) ordered.push(k);
-      visual = ordered;
-      levelOf = (pos) => {
-        const l = r.levels[flatOf[pos] - from];
-        return typeof l === "number" && l >= 0 ? l : 0;
-      };
-    }
-    if (opts.bidi) {
-      for (let pos = 0; pos < line.entries.length; pos++) {
-        if (levelOf(pos) % 2 === 0) continue;
-        const e = line.entries[pos];
-        const m = opts.bidi.mirror(e.cp);
-        if (m === null || m === e.cp) continue;
-        if (e.font !== null) {
-          const hit = resolveGlyph(e.run, e.font, e.resolved, m);
-          if (!hit) continue;
-          e.glyph = hit.glyph;
-        }
-        e.cp = m;
-      }
-    }
-    let penX = lineX0;
-    let prevPos = -1;
-    for (const pos of visual) {
-      const e = line.entries[pos];
-      penX += prevPos < 0 ? 0 : pos === prevPos + 1 ? e.kerningBefore : prevPos === pos + 1 ? line.entries[prevPos].kerningBefore : 0;
-      prevPos = pos;
-      const step = e.advance + e.tracking + (gaps.has(pos) ? gapExtra : 0);
-      const cell = {
-        srcIndex: e.srcIndex,
-        srcEnd: e.srcEnd,
-        cp: e.cp,
-        x: penX,
-        advance: step,
-        level: levelOf(pos),
-        drawsInk: e.drawsInk
-      };
-      cells[pos] = cell;
-      const scale = e.fontSize / e.metrics.size;
-      const baselineY = lineBaselineY - (e.run.baselineShift ?? 0);
-      const decoFill = e.run.fill;
-      if (decoFill !== null && (e.run.underline || e.run.strikethrough || e.run.overline)) {
-        const face = runFaces.get(e.run);
-        if (span !== null && span.underline === e.run.underline && span.strikethrough === e.run.strikethrough && span.overline === e.run.overline && span.fontSize === e.run.fontSize && span.face === face && span.baselineY === baselineY && sameFill(span.fill, e.run.fill)) {
-          span.x1 = penX + step;
-        } else {
-          flushSpan();
-          span = {
-            underline: e.run.underline,
-            strikethrough: e.run.strikethrough,
-            overline: e.run.overline,
-            fill: decoFill,
-            // The run's size, not the glyph's: a small-caps word is one rule.
-            fontSize: e.run.fontSize,
-            face,
-            baselineY,
-            x0: penX,
-            x1: penX + step
-          };
-        }
-      } else {
-        flushSpan();
-      }
-      const outlineD = outlineFor(e);
-      if (e.run.fill === null && !(outlineD !== null && strokePaints(e.run.stroke))) {
-        penX += step;
-        continue;
-      }
-      if (outlineD !== null) {
-        const group2 = getOrCreateGroup(ctx, e.run, e.resolved, 0, "outline");
-        group2.glyphs.push({
-          d: outlineD,
-          key: `${e.resolved.resolved.family}|${e.resolved.resolved.weight}|${e.resolved.resolved.style}|${e.cp}`,
-          x: penX,
-          baselineY,
-          // Em space is unit-scale, so world units per em is just the size.
-          scale: e.fontSize
-        });
-        penX += step;
-        continue;
-      }
-      if (e.font === null || e.glyph === null || e.advance === 0 || e.glyph.width === 0 || e.glyph.page < 0) {
-        penX += step;
-        continue;
-      }
-      const group = getOrCreateGroup(ctx, e.run, e.resolved, e.glyph.page);
-      const atlasW = e.font.common.scaleW;
-      const atlasH = e.font.common.scaleH;
-      const qx0 = penX + e.glyph.xoffset * scale;
-      const qy0 = baselineY + (e.glyph.yoffset - e.metrics.base) * scale;
-      const qx1 = qx0 + e.glyph.width * scale;
-      const qy1 = qy0 + e.glyph.height * scale;
-      const u0 = e.glyph.x / atlasW;
-      const v0 = e.glyph.y / atlasH;
-      const u1 = (e.glyph.x + e.glyph.width) / atlasW;
-      const v1 = (e.glyph.y + e.glyph.height) / atlasH;
-      group.quads.push({ x0: qx0, y0: qy0, x1: qx1, y1: qy1, u0, v0, u1, v1, baselineY });
-      penX += step;
-    }
-    flushSpan();
-    const lastCell = line.entries[line.entries.length - 1];
-    const srcEnd = lastCell ? lastCell.srcEnd : line.blank?.srcIndex ?? 0;
-    lineBoxes.push({
-      x0: lineX0,
-      y0: penY,
-      x1: lineX0 + line.width + spread,
-      y1: penY + line.height,
-      baselineY: lineBaselineY,
-      cells,
-      srcEnd
+  return hung;
+}
+function wordGaps(entries) {
+  const gaps = /* @__PURE__ */ new Set();
+  let first = 0;
+  while (first < entries.length && entries[first].cp === 32) first++;
+  let last = entries.length - 1;
+  while (last > first && entries[last].cp === 32) last--;
+  for (let k = first + 1; k < last; k++) if (entries[k].cp === 32) gaps.add(k);
+  return gaps;
+}
+function alignOffset(align, alignWidth, inkWidth) {
+  if (align === "left") return 0;
+  if (!Number.isFinite(alignWidth)) return align === "center" ? -inkWidth / 2 : -inkWidth;
+  const slack = alignWidth - inkWidth;
+  return align === "center" ? slack / 2 : slack;
+}
+function placeLine(line, y, order, align, alignWidth, justify) {
+  const { entries } = line;
+  const hung = hungWidth(entries);
+  const inkWidth = line.width - hung;
+  const slack = alignWidth - inkWidth;
+  const gaps = justify && line.wrapped && Number.isFinite(alignWidth) && slack > 0 ? wordGaps(entries) : /* @__PURE__ */ new Set();
+  const gapExtra = gaps.size > 0 ? slack / gaps.size : 0;
+  const spread = gapExtra * gaps.size;
+  const inkLeft = spread > 0 ? 0 : alignOffset(align, alignWidth, inkWidth);
+  const hangsLeft = hung > 0 && order.levels[entries.length - 1] % 2 === 1;
+  const left = hangsLeft ? inkLeft - hung : inkLeft;
+  const lineBaselineY = y + line.ascent;
+  const cells = new Array(entries.length);
+  const glyphs = [];
+  let penX = left;
+  let prevPos = -1;
+  for (const pos of order.visual) {
+    const e = entries[pos];
+    penX += prevPos < 0 ? 0 : pos === prevPos + 1 ? e.kerningBefore : prevPos === pos + 1 ? entries[prevPos].kerningBefore : 0;
+    prevPos = pos;
+    const step = e.advance + e.tracking + (gaps.has(pos) ? gapExtra : 0);
+    cells[pos] = {
+      srcIndex: e.srcIndex,
+      srcEnd: e.srcEnd,
+      cp: e.cp,
+      x: penX,
+      advance: step,
+      level: order.levels[pos],
+      drawsInk: e.drawsInk,
+      clusterEnd: e.clusterEnd
+    };
+    glyphs.push({
+      run: e.run,
+      cp: e.cp,
+      fontSize: e.fontSize,
+      resolved: e.resolved,
+      metrics: e.metrics,
+      font: e.font,
+      glyph: e.glyph,
+      x: penX,
+      // Positive raises, and y grows down, so the shift subtracts.
+      baselineY: lineBaselineY - e.baselineShift,
+      advance: e.advance,
+      step
     });
-    maxLineWidth = Math.max(maxLineWidth, inkWidth + spread);
-    penY += line.height;
+    penX += step;
   }
   return {
-    groups: [...ctx.groups.values()],
-    decorations,
-    lines: lineBoxes,
-    bounds: { width: maxLineWidth, height: penY }
+    box: {
+      x0: left,
+      y0: y,
+      x1: left + line.width + spread,
+      y1: y + line.height,
+      baselineY: lineBaselineY,
+      cells,
+      glyphs,
+      srcEnd: line.srcEnd
+    },
+    inkWidth: inkWidth + spread
   };
 }
-var LAYOUT_CACHE_VARIANT_LIMIT = 8;
-var LAYOUT_CACHE_STRUCTURAL_LIMIT = 64;
-var cache = /* @__PURE__ */ new WeakMap();
-var structural = /* @__PURE__ */ new Map();
-var structuralGeneration = -1;
-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;
+
+// src/layout/layoutOpts.ts
+function resolveLayoutOpts(opts) {
+  return {
+    maxWidth: opts.maxWidth,
+    alignWidth: opts.alignWidth ?? opts.maxWidth,
+    lineHeight: opts.lineHeight,
+    align: opts.align,
+    justify: opts.justify === true || opts.align === "justify",
+    bidi: opts.bidi ?? registeredBidi(),
+    direction: opts.direction ?? "auto",
+    tabSize: opts.tabSize ?? DEFAULT_TAB_SIZE
+  };
 }
-function variantKey(runs, opts) {
-  const alignWidth = opts.alignWidth ?? opts.maxWidth;
-  const justify = opts.justify === true || opts.align === "justify";
-  return `${opts.maxWidth}|${alignWidth}|${opts.lineHeight}|${opts.align}|${justify ? "j" : ""}|${outlineBucket(runs, opts.outlineMinSize)}`;
+
+// src/layout/layoutRuns.ts
+function layoutRuns(runs, opts) {
+  const o = resolveLayoutOpts(opts);
+  const entries = measureRuns(runs, o.tabSize);
+  const cps = entries.map((e) => e.cp);
+  const { bidi } = o;
+  const paragraphs = bidi ? analyzeParagraphs(bidi, cps, (i) => isHardLineBreak(cps[i]), o.direction) : null;
+  if (!bidi) warnRtlWithoutEngine(cps);
+  const lines = [];
+  let y = 0;
+  let width = 0;
+  for (const line of breakLines(entries, o.maxWidth, o.lineHeight)) {
+    const order = orderLine(paragraphs, line.start, line.entries.length);
+    if (bidi) line.entries = mirrorEntries(line.entries, order.levels, (cp) => bidi.mirror(cp), runs);
+    const reads = o.direction !== "auto" ? o.direction : directionOfLevel(line.entries.length > 0 ? paragraphs?.baseLevel(line.start) ?? 0 : 0);
+    const placed = placeLine(line, y, order, resolveAlign(o.align, reads), o.alignWidth, o.justify);
+    lines.push(placed.box);
+    width = Math.max(width, placed.inkWidth);
+    y += line.height;
+  }
+  return { lines, bounds: { width, height: y } };
 }
+
+// src/layout/refId.ts
 var nextRefId = 1;
 var refIds = /* @__PURE__ */ new WeakMap();
 function refId(o) {
@@ -1140,32 +978,26 @@ function refId(o) {
   }
   return id;
 }
-function paintKey(p) {
-  if (p === null) return "none";
-  return "color" in p ? `s${p.color}:${p.opacity ?? 1}` : `#${refId(p)}`;
-}
-function strokeKey2(s) {
-  if (!s?.paint) return "-";
-  const width = s.width ?? 1;
-  return [
-    paintKey(s.paint),
-    typeof width === "number" ? width : `px${width.px}`,
-    s.join ?? "miter",
-    s.cap ?? "butt",
-    s.miterLimit ?? "",
-    s.align ?? "center",
-    (s.dash ?? []).join(",")
-  ].join(":");
+
+// src/layout/layoutCache.ts
+var LAYOUT_CACHE_VARIANT_LIMIT = 8;
+var LAYOUT_CACHE_STRUCTURAL_LIMIT = 64;
+var cache = /* @__PURE__ */ new WeakMap();
+var structural = /* @__PURE__ */ new Map();
+var structuralGeneration = -1;
+function variantKey(opts) {
+  const o = resolveLayoutOpts(opts);
+  return `${o.maxWidth}|${o.alignWidth}|${o.lineHeight}|${o.align}|${o.justify ? "j" : ""}|${o.direction}|${o.bidi ? refId(o.bidi) : ""}|${o.tabSize}`;
 }
 function runsKey(runs) {
   let out = "";
   for (const r of runs) {
-    out += `${r.text.length}:${r.text}|${r.fontFamily.length}:${r.fontFamily}|${r.fontSize}|${r.fontWeight}|${r.fontStyle}|${r.letterSpacing}|${r.underline ? 1 : 0}${r.strikethrough ? 1 : 0}${r.overline ? 1 : 0}|${r.baselineShift}|${paintKey(r.fill)}|${strokeKey2(r.stroke)}|${r.srcMap ? `${r.srcMap.length}:${r.srcMap.starts.join(",")}` : ""}|${r.sizeMap ? r.sizeMap.join(",") : ""}|`;
+    out += `${r.text.length}:${r.text}|${r.fontFamily.length}:${r.fontFamily}|${r.fontSize}|${r.fontWeight}|${r.fontStyle}|${r.letterSpacing}|${r.baselineShift}|${r.strutSize ?? ""}|${r.srcMap ? `${r.srcMap.length}:${r.srcMap.starts.join(",")}` : ""}|${r.sizeMap ? r.sizeMap.join(",") : ""}|`;
   }
   return out;
 }
 function cachedLayoutRuns(runs, opts) {
-  const fonts = glyphGeneration();
+  const fonts = faceGeneration();
   let entry = cache.get(runs);
   if (entry === void 0) {
     entry = { generation: fonts, byVariant: /* @__PURE__ */ new Map() };
@@ -1174,7 +1006,7 @@ function cachedLayoutRuns(runs, opts) {
     entry.generation = fonts;
     entry.byVariant.clear();
   }
-  const key = variantKey(runs, opts);
+  const key = variantKey(opts);
   const hit = entry.byVariant.get(key);
   if (hit !== void 0) return hit;
   if (structuralGeneration !== fonts) {
@@ -1202,6 +1034,6 @@ function _resetLayoutCacheForTests() {
   structuralGeneration = -1;
 }
 
-export { BREAK_ALLOWED, BREAK_MANDATORY, DECORATION_KINDS, DEFAULT_DECORATION_METRICS, DEFAULT_TEXT_STYLE, LAYOUT_CACHE_STRUCTURAL_LIMIT, LAYOUT_CACHE_VARIANT_LIMIT, NO_BREAK, _resetLayoutCacheForTests, cachedLayoutRuns, decorationMetrics, decorationRule, fontString, graphemeCount, isHardLineBreak, layoutRuns, lineBreakOpportunities, resolveAlign, resolveTextStyle, wrapLines };
-//# sourceMappingURL=chunk-L6UJ4RQK.js.map
-//# sourceMappingURL=chunk-L6UJ4RQK.js.map
+export { BREAK_ALLOWED, BREAK_MANDATORY, DEFAULT_TAB_SIZE, DEFAULT_TEXT_STYLE, LAYOUT_CACHE_STRUCTURAL_LIMIT, LAYOUT_CACHE_VARIANT_LIMIT, NO_BREAK, _resetBidiWarningForTests, _resetLayoutCacheForTests, cachedLayoutRuns, fontString, graphemeCount, hangs, isHardLineBreak, layoutRuns, lineBreakOpportunities, paragraphDirection, registerBidi, resolveAlign, resolveTextStyle, tabAdvance, widthWithTabs, wrapLines };
+//# sourceMappingURL=chunk-Z6YRJ33J.js.map
+//# sourceMappingURL=chunk-Z6YRJ33J.js.map