@weasel-js/text 1.14.1 → 1.15.0

package/dist/{chunk-FODNMBHI.js → chunk-ZNSU5C43.js}

@@ -1,5 +1,5 @@
 import { isSolidPaint, resolveFill, resolveScreenLength, fillHasInk, strokeHasInk, paintKey, strokeKey } from '@weasel-js/paint';
-import { cssFamilyName, resolveFontVariant, syntheticBoldGrowth, glyphOutline, faceMetricsOf, glyphGeneration, faceGeneration, metricsOf, warnNoMetrics, resolveColorCluster, glyphIn, resolveGlyph } from '@weasel-js/font';
+import { cssFamilyName, cachedFontVariant, syntheticBoldGrowth, glyphOutline, faceMetricsOf, glyphGeneration, faceGeneration, metricsOf, warnNoMetrics, resolveColorCluster, glyphIn, resolveGlyph } from '@weasel-js/font';
 import { mergeRegion, growRegion, pathToD, pathFromD } from '@weasel-js/geom';
 
 var __defProp = Object.defineProperty;
@@ -15,16 +15,16 @@ function tabAdvance(x, stop, min) {
   const toNext = (Math.floor(x / stop) + 1) * stop - x;
   return toNext < min ? toNext + stop : toNext;
 }
-function widthWithTabs(start, end, tabs2, stopOf2, flatWidth2, piece) {
+function widthWithTabs(start2, end, tabs2, stopOf2, flatWidth2, piece) {
   let x = 0;
-  let from = start;
+  let from = start2;
   const lay = (to) => {
     if (to <= from) return;
     piece?.(from, to, x);
     x += flatWidth2(from, to);
   };
   for (const t of tabs2) {
-    if (t < start) continue;
+    if (t < start2) continue;
     if (t >= end) break;
     lay(t);
     const { stop, min } = stopOf2(t);
@@ -76,53 +76,51 @@ var DEFAULT_TEXT_STYLE = {
   textTransform: "none",
   fontVariantCaps: "normal"
 };
-var NOTHING = Object.freeze({});
 function resolveTextStyle(style, paint, scale = 1) {
+  if (!style && resolveFill(paint?.fill) === null && (paint?.stroke ?? void 0) === void 0) {
+    return DEFAULT_TEXT_STYLE;
+  }
+  return resolveTextStyleInto({ ...DEFAULT_TEXT_STYLE }, style, paint, scale);
+}
+function resolveTextStyleInto(out, style, paint, scale = 1) {
+  const s = style ?? NO_STYLE;
   const fill2 = resolveFill(paint?.fill);
   const stroke = paint?.stroke ?? void 0;
-  if (!style) {
-    return fill2 === null && stroke === void 0 ? DEFAULT_TEXT_STYLE : {
-      ...DEFAULT_TEXT_STYLE,
-      fill: fill2,
-      caretColor: paintColor(fill2?.paint ?? null),
-      selectionBackground: defaultSelectionBackground(paintColor(fill2?.paint ?? null)),
-      ...stroke !== void 0 ? { stroke } : NOTHING
-    };
-  }
-  const caretColor = style.caretColor ?? paintColor(fill2?.paint ?? null);
+  const caretColor = s.caretColor ?? paintColor(fill2?.paint ?? null);
   let selectionBackground;
-  if (style.selectionBackground === "none") {
+  if (s.selectionBackground === "none") {
     selectionBackground = null;
-  } else if (style.selectionBackground != null) {
-    selectionBackground = style.selectionBackground;
+  } else if (s.selectionBackground != null) {
+    selectionBackground = s.selectionBackground;
   } else {
     selectionBackground = defaultSelectionBackground(caretColor);
   }
-  return {
-    fontSize: resolveScreenLength(style.fontSize ?? DEFAULT_TEXT_STYLE.fontSize, scale),
-    fontFamily: style.fontFamily ?? DEFAULT_TEXT_STYLE.fontFamily,
-    fontWeight: style.fontWeight ?? DEFAULT_TEXT_STYLE.fontWeight,
-    fontStyle: style.fontStyle ?? DEFAULT_TEXT_STYLE.fontStyle,
-    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: fill2,
-    caretColor,
-    selectionBackground,
-    selectionColor: style.selectionColor ?? null,
-    letterSpacing: resolveScreenLength(style.letterSpacing ?? DEFAULT_TEXT_STYLE.letterSpacing, scale),
-    underline: style.underline ?? DEFAULT_TEXT_STYLE.underline,
-    strikethrough: style.strikethrough ?? DEFAULT_TEXT_STYLE.strikethrough,
-    overline: style.overline ?? DEFAULT_TEXT_STYLE.overline,
-    textTransform: style.textTransform ?? DEFAULT_TEXT_STYLE.textTransform,
-    fontVariantCaps: style.fontVariantCaps ?? DEFAULT_TEXT_STYLE.fontVariantCaps,
-    ...style.script !== void 0 ? { script: style.script } : NOTHING,
-    ...style.lang ? { lang: style.lang } : NOTHING,
-    ...stroke !== void 0 ? { stroke } : NOTHING
-  };
+  out.fontSize = resolveScreenLength(s.fontSize ?? DEFAULT_TEXT_STYLE.fontSize, scale);
+  out.fontFamily = s.fontFamily ?? DEFAULT_TEXT_STYLE.fontFamily;
+  out.fontWeight = s.fontWeight ?? DEFAULT_TEXT_STYLE.fontWeight;
+  out.fontStyle = s.fontStyle ?? DEFAULT_TEXT_STYLE.fontStyle;
+  out.align = s.align ?? DEFAULT_TEXT_STYLE.align;
+  out.direction = s.direction ?? DEFAULT_TEXT_STYLE.direction;
+  out.lineHeight = s.lineHeight ?? DEFAULT_TEXT_STYLE.lineHeight;
+  out.tabSize = s.tabSize ?? DEFAULT_TEXT_STYLE.tabSize;
+  out.wrap = s.wrap ?? DEFAULT_TEXT_STYLE.wrap;
+  out.fill = fill2;
+  out.caretColor = caretColor;
+  out.selectionBackground = selectionBackground;
+  out.selectionColor = s.selectionColor ?? null;
+  out.letterSpacing = resolveScreenLength(s.letterSpacing ?? DEFAULT_TEXT_STYLE.letterSpacing, scale);
+  out.underline = s.underline ?? DEFAULT_TEXT_STYLE.underline;
+  out.strikethrough = s.strikethrough ?? DEFAULT_TEXT_STYLE.strikethrough;
+  out.overline = s.overline ?? DEFAULT_TEXT_STYLE.overline;
+  out.textTransform = s.textTransform ?? DEFAULT_TEXT_STYLE.textTransform;
+  out.fontVariantCaps = s.fontVariantCaps ?? DEFAULT_TEXT_STYLE.fontVariantCaps;
+  if (s.script !== void 0 || out.script !== void 0) out.script = s.script;
+  const lang = s.lang || void 0;
+  if (lang !== void 0 || out.lang !== void 0) out.lang = lang;
+  if (stroke !== void 0 || out.stroke !== void 0) out.stroke = stroke;
+  return out;
 }
+var NO_STYLE = Object.freeze({});
 function fontString(s) {
   return `${s.fontStyle} ${s.fontWeight} ${s.fontSize}px ${cssFamilyName(s.fontFamily)}`;
 }
@@ -149,7 +147,7 @@ function shapeableBytes(resolved2) {
 }
 function shapesWithFeature(family, weight, style, tag, shaper = registered) {
   if (shaper === null) return false;
-  const bytes = shapeableBytes(resolveFontVariant(family, weight, style));
+  const bytes = shapeableBytes(cachedFontVariant(family, weight, style));
   return bytes !== null && shaper.hasFeature(bytes, tag);
 }
 
@@ -333,7 +331,7 @@ function decode() {
   const values = new Uint8Array(RUNS);
   const slot = new Uint8Array(128);
   for (let i = 0; i < ALPHABET.length; i++) slot[ALPHABET.charCodeAt(i)] = PALETTE[i];
-  let cp = 0;
+  let cp2 = 0;
   let run = 0;
   let len = 0;
   for (let i = 0; i < PACKED.length; i++) {
@@ -341,11 +339,11 @@ function decode() {
     if (code <= 57 && code >= 48) len = len * 10 + code - 48;
     else {
       const v = slot[code];
-      starts[run] = cp;
+      starts[run] = cp2;
       values[run] = v;
-      if (cp < 65536) direct.fill(v, cp, Math.min(cp + len, 65536));
+      if (cp2 < 65536) direct.fill(v, cp2, Math.min(cp2 + len, 65536));
       run++;
-      cp += len;
+      cp2 += len;
       len = 0;
     }
   }
@@ -353,16 +351,16 @@ function decode() {
   astralStarts = starts;
   astralValues = values;
 }
-function lineBreakPropsOf(cp) {
+function lineBreakPropsOf(cp2) {
   if (bmp === null) decode();
-  if (cp < 65536) return bmp[cp];
-  if (cp > 1114111) return AL;
+  if (cp2 < 65536) return bmp[cp2];
+  if (cp2 > 1114111) return AL;
   const starts = astralStarts;
   let lo = 0;
   let hi = starts.length - 1;
   while (lo < hi) {
     const mid = lo + hi + 1 >> 1;
-    if (starts[mid] <= cp) lo = mid;
+    if (starts[mid] <= cp2) lo = mid;
     else hi = mid - 1;
   }
   return astralValues[lo];
@@ -427,8 +425,8 @@ var HYPHEN = 8208;
 var DOTTED_CIRCLE = 9676;
 var isQU = (c) => c === QU2 || c === QU_PI2 || c === QU_PF2;
 var isHard = (c) => c === BK2 || c === CR2 || c === LF2 || c === NL2;
-function isHardLineBreak(cp) {
-  return isHard(lineBreakPropsOf2(cp) & CLASS_MASK2);
+function isHardLineBreak(cp2) {
+  return isHard(lineBreakPropsOf2(cp2) & CLASS_MASK2);
 }
 var isAlpha = (c) => c === AL2 || c === HL2;
 var isKorean = (c) => c === JL2 || c === JV2 || c === JT2 || c === H22 || c === H32;
@@ -446,14 +444,28 @@ function growScratch(n) {
   if (shared.cls.length < n) shared = newScratch(Math.min(SCRATCH_MAX, Math.max(n, shared.cls.length * 2)));
   return shared;
 }
+var NO_INPUT = [];
+var input = NO_INPUT;
+var cls = shared.cls;
+var ea = shared.ea;
+var pict = shared.pict;
+var cp = shared.cp;
+var start = shared.start;
+var units = 0;
 function lineBreakOpportunities(cps) {
+  return lineBreakOpportunitiesInto(cps, new Uint8Array(cps.length + 1));
+}
+function lineBreakOpportunitiesInto(cps, out) {
   const n = cps.length;
-  const out = new Uint8Array(n + 1);
-  if (n === 0) return out;
+  for (let i = 0; i < n; i++) out[i] = NO_BREAK;
+  if (n === 0) {
+    out[0] = NO_BREAK;
+    return out;
+  }
   out[n] = BREAK_MANDATORY;
   const scratch2 = n <= SCRATCH_MAX ? growScratch(n) : newScratch(n);
-  const { cls, ea, pict, cp } = scratch2;
-  const start = scratch2.start;
+  input = cps;
+  ({ cls, ea, pict, cp, start } = scratch2);
   let u = 0;
   for (let i = 0; i < n; i++) {
     const props = lineBreakPropsOf2(cps[i]);
@@ -475,111 +487,113 @@ function lineBreakOpportunities(cps) {
     start[u] = i;
     u++;
   }
-  const units = u;
-  const prevIsZWJ = (b) => (lineBreakPropsOf2(cps[start[b] - 1]) & CLASS_MASK2) === ZWJ2;
-  const beforeSpaces = (k) => {
-    while (k >= 0 && cls[k] === SP2) k--;
-    return k;
-  };
+  units = u;
   for (let b = 1; b < units; b++) {
     out[start[b]] = decide(b);
   }
+  input = NO_INPUT;
+  if (scratch2 !== shared) ({ cls, ea, pict, cp, start } = shared);
   return out;
-  function decide(b) {
-    const a = b - 1;
-    const A = cls[a];
-    const B = cls[b];
-    if (A === CR2 && B === LF2) return NO_BREAK;
-    if (isHard(A)) return BREAK_MANDATORY;
-    if (isHard(B) || B === SP2 || B === ZW2) return NO_BREAK;
-    const s = beforeSpaces(a);
-    if (s >= 0 && cls[s] === ZW2) return BREAK_ALLOWED;
-    if (prevIsZWJ(b)) return NO_BREAK;
-    if (A === WJ2 || B === WJ2 || A === GL2) return NO_BREAK;
-    if (B === GL2 && A !== SP2 && A !== BA2 && A !== HY2) return NO_BREAK;
-    if (B === CL2 || B === CP2 || B === EX2 || B === SY2) return NO_BREAK;
-    const S = s >= 0 ? cls[s] : -1;
-    if (S === OP2) return NO_BREAK;
-    if (S === QU_PI2) {
-      const p = s - 1;
-      if (p < 0) return NO_BREAK;
-      const P = cls[p];
-      if (isHard(P) || P === OP2 || isQU(P) || P === GL2 || P === SP2 || P === ZW2) return NO_BREAK;
-    }
-    if (B === QU_PF2) {
-      if (b + 1 >= units) return NO_BREAK;
+}
+var prevIsZWJ = (b) => (lineBreakPropsOf2(input[start[b] - 1]) & CLASS_MASK2) === ZWJ2;
+function beforeSpaces(k) {
+  while (k >= 0 && cls[k] === SP2) k--;
+  return k;
+}
+function decide(b) {
+  const a = b - 1;
+  const A = cls[a];
+  const B = cls[b];
+  if (A === CR2 && B === LF2) return NO_BREAK;
+  if (isHard(A)) return BREAK_MANDATORY;
+  if (isHard(B) || B === SP2 || B === ZW2) return NO_BREAK;
+  const s = beforeSpaces(a);
+  if (s >= 0 && cls[s] === ZW2) return BREAK_ALLOWED;
+  if (prevIsZWJ(b)) return NO_BREAK;
+  if (A === WJ2 || B === WJ2 || A === GL2) return NO_BREAK;
+  if (B === GL2 && A !== SP2 && A !== BA2 && A !== HY2) return NO_BREAK;
+  if (B === CL2 || B === CP2 || B === EX2 || B === SY2) return NO_BREAK;
+  const S = s >= 0 ? cls[s] : -1;
+  if (S === OP2) return NO_BREAK;
+  if (S === QU_PI2) {
+    const p = s - 1;
+    if (p < 0) return NO_BREAK;
+    const P = cls[p];
+    if (isHard(P) || P === OP2 || isQU(P) || P === GL2 || P === SP2 || P === ZW2) return NO_BREAK;
+  }
+  if (B === QU_PF2) {
+    if (b + 1 >= units) return NO_BREAK;
+    const N = cls[b + 1];
+    if (N === SP2 || N === GL2 || N === WJ2 || N === CL2 || isQU(N) || N === CP2 || N === EX2 || N === IS2 || N === SY2 || isHard(N) || N === ZW2) return NO_BREAK;
+  }
+  if (A === SP2 && B === IS2 && b + 1 < units && cls[b + 1] === NU2) return BREAK_ALLOWED;
+  if (B === IS2) return NO_BREAK;
+  if ((S === CL2 || S === CP2) && B === NS2) return NO_BREAK;
+  if (S === B22 && B === B22) return NO_BREAK;
+  if (A === SP2) return BREAK_ALLOWED;
+  if (B === QU2 || B === QU_PF2) return NO_BREAK;
+  if (A === QU2 || A === QU_PI2) return NO_BREAK;
+  if (isQU(B)) {
+    if (!ea[a]) return NO_BREAK;
+    if (b + 1 >= units || !ea[b + 1]) return NO_BREAK;
+  }
+  if (isQU(A)) {
+    if (!ea[b]) return NO_BREAK;
+    if (a === 0 || !ea[a - 1]) return NO_BREAK;
+  }
+  if (A === CB2 || B === CB2) return BREAK_ALLOWED;
+  if ((A === HY2 || cp[a] === HYPHEN) && B === AL2) {
+    if (a === 0) return NO_BREAK;
+    const P = cls[a - 1];
+    if (isHard(P) || P === SP2 || P === ZW2 || P === CB2 || P === GL2) return NO_BREAK;
+  }
+  if (B === BA2 || B === HY2 || B === NS2 || A === BB2) return NO_BREAK;
+  if (a > 0 && cls[a - 1] === HL2 && (A === HY2 || A === BA2 && !ea[a]) && B !== HL2) return NO_BREAK;
+  if (A === SY2 && B === HL2) return NO_BREAK;
+  if (B === IN2) return NO_BREAK;
+  if (isAlpha(A) && B === NU2 || A === NU2 && isAlpha(B)) return NO_BREAK;
+  if (A === PR2 && isIdeoLike(B) || isIdeoLike(A) && B === PO2) return NO_BREAK;
+  if ((A === PR2 || A === PO2) && isAlpha(B) || isAlpha(A) && (B === PR2 || B === PO2)) return NO_BREAK;
+  if (B === PO2 || B === PR2) {
+    let k = A === CL2 || A === CP2 ? a - 1 : a;
+    while (k >= 0 && (cls[k] === SY2 || cls[k] === IS2)) k--;
+    if (k >= 0 && cls[k] === NU2) return NO_BREAK;
+  }
+  if (A === PO2 || A === PR2) {
+    if (B === NU2) return NO_BREAK;
+    if (B === OP2 && b + 1 < units) {
       const N = cls[b + 1];
-      if (N === SP2 || N === GL2 || N === WJ2 || N === CL2 || isQU(N) || N === CP2 || N === EX2 || N === IS2 || N === SY2 || isHard(N) || N === ZW2) return NO_BREAK;
-    }
-    if (A === SP2 && B === IS2 && b + 1 < units && cls[b + 1] === NU2) return BREAK_ALLOWED;
-    if (B === IS2) return NO_BREAK;
-    if ((S === CL2 || S === CP2) && B === NS2) return NO_BREAK;
-    if (S === B22 && B === B22) return NO_BREAK;
-    if (A === SP2) return BREAK_ALLOWED;
-    if (B === QU2 || B === QU_PF2) return NO_BREAK;
-    if (A === QU2 || A === QU_PI2) return NO_BREAK;
-    if (isQU(B)) {
-      if (!ea[a]) return NO_BREAK;
-      if (b + 1 >= units || !ea[b + 1]) return NO_BREAK;
-    }
-    if (isQU(A)) {
-      if (!ea[b]) return NO_BREAK;
-      if (a === 0 || !ea[a - 1]) return NO_BREAK;
-    }
-    if (A === CB2 || B === CB2) return BREAK_ALLOWED;
-    if ((A === HY2 || cp[a] === HYPHEN) && B === AL2) {
-      if (a === 0) return NO_BREAK;
-      const P = cls[a - 1];
-      if (isHard(P) || P === SP2 || P === ZW2 || P === CB2 || P === GL2) return NO_BREAK;
-    }
-    if (B === BA2 || B === HY2 || B === NS2 || A === BB2) return NO_BREAK;
-    if (a > 0 && cls[a - 1] === HL2 && (A === HY2 || A === BA2 && !ea[a]) && B !== HL2) return NO_BREAK;
-    if (A === SY2 && B === HL2) return NO_BREAK;
-    if (B === IN2) return NO_BREAK;
-    if (isAlpha(A) && B === NU2 || A === NU2 && isAlpha(B)) return NO_BREAK;
-    if (A === PR2 && isIdeoLike(B) || isIdeoLike(A) && B === PO2) return NO_BREAK;
-    if ((A === PR2 || A === PO2) && isAlpha(B) || isAlpha(A) && (B === PR2 || B === PO2)) return NO_BREAK;
-    if (B === PO2 || B === PR2) {
-      let k = A === CL2 || A === CP2 ? a - 1 : a;
-      while (k >= 0 && (cls[k] === SY2 || cls[k] === IS2)) k--;
-      if (k >= 0 && cls[k] === NU2) return NO_BREAK;
-    }
-    if (A === PO2 || A === PR2) {
-      if (B === NU2) return NO_BREAK;
-      if (B === OP2 && b + 1 < units) {
-        const N = cls[b + 1];
-        if (N === NU2) return NO_BREAK;
-        if (N === IS2 && b + 2 < units && cls[b + 2] === NU2) return NO_BREAK;
-      }
-    }
-    if ((A === HY2 || A === IS2) && B === NU2) return NO_BREAK;
-    if (B === NU2) {
-      let k = a;
-      while (k >= 0 && (cls[k] === SY2 || cls[k] === IS2)) k--;
-      if (k >= 0 && cls[k] === NU2) return NO_BREAK;
+      if (N === NU2) return NO_BREAK;
+      if (N === IS2 && b + 2 < units && cls[b + 2] === NU2) return NO_BREAK;
     }
-    if (A === JL2 && (B === JL2 || B === JV2 || B === H22 || B === H32)) return NO_BREAK;
-    if ((A === JV2 || A === H22) && (B === JV2 || B === JT2)) return NO_BREAK;
-    if ((A === JT2 || A === H32) && B === JT2) return NO_BREAK;
-    if (isKorean(A) && B === PO2 || A === PR2 && isKorean(B)) return NO_BREAK;
-    if (isAlpha(A) && isAlpha(B)) return NO_BREAK;
-    const aksaraA = A === AK2 || A === AS2 || cp[a] === DOTTED_CIRCLE;
-    const aksaraB = B === AK2 || B === AS2 || cp[b] === DOTTED_CIRCLE;
-    if (A === AP2 && aksaraB) return NO_BREAK;
-    if (aksaraA && (B === VF2 || B === VI2)) return NO_BREAK;
-    if (A === VI2 && a > 0 && (cls[a - 1] === AK2 || cls[a - 1] === AS2 || cp[a - 1] === DOTTED_CIRCLE) && (B === AK2 || cp[b] === DOTTED_CIRCLE)) return NO_BREAK;
-    if (aksaraA && aksaraB && b + 1 < units && cls[b + 1] === VF2) return NO_BREAK;
-    if (A === IS2 && isAlpha(B)) return NO_BREAK;
-    if ((isAlpha(A) || A === NU2) && B === OP2 && !ea[b]) return NO_BREAK;
-    if (A === CP2 && !ea[a] && (isAlpha(B) || B === NU2)) return NO_BREAK;
-    if (A === RI2 && B === RI2) {
-      let k = a;
-      while (k >= 0 && cls[k] === RI2) k--;
-      if ((a - k) % 2 === 1) return NO_BREAK;
-    }
-    if (B === EM2 && (A === EB2 || pict[a])) return NO_BREAK;
-    return BREAK_ALLOWED;
   }
+  if ((A === HY2 || A === IS2) && B === NU2) return NO_BREAK;
+  if (B === NU2) {
+    let k = a;
+    while (k >= 0 && (cls[k] === SY2 || cls[k] === IS2)) k--;
+    if (k >= 0 && cls[k] === NU2) return NO_BREAK;
+  }
+  if (A === JL2 && (B === JL2 || B === JV2 || B === H22 || B === H32)) return NO_BREAK;
+  if ((A === JV2 || A === H22) && (B === JV2 || B === JT2)) return NO_BREAK;
+  if ((A === JT2 || A === H32) && B === JT2) return NO_BREAK;
+  if (isKorean(A) && B === PO2 || A === PR2 && isKorean(B)) return NO_BREAK;
+  if (isAlpha(A) && isAlpha(B)) return NO_BREAK;
+  const aksaraA = A === AK2 || A === AS2 || cp[a] === DOTTED_CIRCLE;
+  const aksaraB = B === AK2 || B === AS2 || cp[b] === DOTTED_CIRCLE;
+  if (A === AP2 && aksaraB) return NO_BREAK;
+  if (aksaraA && (B === VF2 || B === VI2)) return NO_BREAK;
+  if (A === VI2 && a > 0 && (cls[a - 1] === AK2 || cls[a - 1] === AS2 || cp[a - 1] === DOTTED_CIRCLE) && (B === AK2 || cp[b] === DOTTED_CIRCLE)) return NO_BREAK;
+  if (aksaraA && aksaraB && b + 1 < units && cls[b + 1] === VF2) return NO_BREAK;
+  if (A === IS2 && isAlpha(B)) return NO_BREAK;
+  if ((isAlpha(A) || A === NU2) && B === OP2 && !ea[b]) return NO_BREAK;
+  if (A === CP2 && !ea[a] && (isAlpha(B) || B === NU2)) return NO_BREAK;
+  if (A === RI2 && B === RI2) {
+    let k = a;
+    while (k >= 0 && cls[k] === RI2) k--;
+    if ((a - k) % 2 === 1) return NO_BREAK;
+  }
+  if (B === EM2 && (A === EB2 || pict[a])) return NO_BREAK;
+  return BREAK_ALLOWED;
 }
 
 // src/layout/bidiRegistry.ts
@@ -601,9 +615,9 @@ function paragraphDirection(text, direction = "auto", engine = registered2) {
   if (engine === null) return "ltr";
   const cps = [];
   for (const ch of text) {
-    const cp = ch.codePointAt(0);
-    if (isHardLineBreak(cp)) break;
-    cps.push(cp);
+    const cp2 = ch.codePointAt(0);
+    if (isHardLineBreak(cp2)) break;
+    cps.push(cp2);
   }
   return directionOfLevel(engine.baseLevel(engine.analyze(cps, "auto")));
 }
@@ -630,21 +644,21 @@ var RTL_BLOCK_NEUTRALS = [
   [64830, 64831],
   [65279, 65279]
 ];
-function within(ranges, cp) {
-  for (let i = 0; i < ranges.length; i++) if (cp >= ranges[i][0] && cp <= ranges[i][1]) return true;
+function within(ranges, cp2) {
+  for (let i = 0; i < ranges.length; i++) if (cp2 >= ranges[i][0] && cp2 <= ranges[i][1]) return true;
   return false;
 }
 var warnedLogicalRtl = false;
-function warnRtlWithoutEngine(codePoints) {
+function warnRtlWithoutEngine(codePoints, who = "weasel layoutRuns") {
   if (warnedLogicalRtl) return;
   for (let i = 0; i < codePoints.length; i++) {
-    const cp = codePoints[i];
-    if (!within(RTL_BLOCKS, cp) || within(RTL_BLOCK_NUMBERS, cp) || within(RTL_BLOCK_NEUTRALS, cp)) continue;
+    const cp2 = codePoints[i];
+    if (!within(RTL_BLOCKS, cp2) || within(RTL_BLOCK_NUMBERS, cp2) || within(RTL_BLOCK_NEUTRALS, cp2)) 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."
+      `${who}: 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;
   }
@@ -656,13 +670,13 @@ function _resetBidiWarningForTests() {
 // src/layout/bidiLines.ts
 function analyzeParagraphs(engine, codePoints, isBreak, direction) {
   const paragraphs = [];
-  let start = 0;
+  let start2 = 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) });
+    if (i > start2) {
+      paragraphs.push({ start: start2, end: i, analysis: engine.analyze(codePoints.slice(start2, i), direction) });
     }
-    start = i + 1;
+    start2 = i + 1;
   }
   const holding = (at) => {
     let lo = 0;
@@ -729,17 +743,20 @@ function logicalOrder(count) {
   if (count <= SHARED_ORDER_LIMIT) logicalOrders[count] = order;
   return order;
 }
-function orderLine(paragraphs, start, count) {
+function orderLine(paragraphs, start2, count) {
   if (paragraphs === null || count === 0) return logicalOrder(count);
+  return reorderedLine(paragraphs, start2, count);
+}
+function reorderedLine(paragraphs, start2, count) {
   const levels = new Array(count).fill(0);
-  const r = paragraphs.reorder(start, start + count);
+  const r = paragraphs.reorder(start2, start2 + 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;
+    const pos = at - start2;
     if (Number.isInteger(pos) && pos >= 0 && pos < count) kept.add(pos);
   }
   return { visual: restoreRemoved([...kept], count, (pos) => levels[pos] % 2 === 1), levels };
@@ -785,6 +802,9 @@ function giveDoubles(a) {
 function giveRefs(a) {
   give(refs, a);
 }
+function truncate(a, n) {
+  while (a.length > n) a.pop();
+}
 
 // src/layout/layoutColumns.ts
 var NUM = 13;
@@ -808,12 +828,21 @@ var EMPTY_NUM = [];
 var EMPTY_REF = [];
 var spare = [];
 var SPARE_MAX = 1024;
+var stamps = 0;
 var LayoutColumns = class _LayoutColumns {
   num;
   ref;
   /** The layout's line boxes, its `lines`. A recycled layout's are refilled
    *  by the next layout to take its columns. */
   boxes = [];
+  /** The layout's `bounds`, refilled like its boxes. */
+  bounds = { width: 0.5, height: 0.5 };
+  /** The layout itself, `{ lines: boxes, bounds }`, handed to every layout
+   *  that takes these columns. */
+  laid = null;
+  /** Which of those layouts this is, new each time the columns are taken:
+   *  what tells a layout apart from the one these columns held before. */
+  stamp = 0;
   /** The paint cache's paintings of this layout, kept here rather than in a
    *  map keyed by the layout, so that recycling one deletes no map entry. */
   paintings = [];
@@ -831,15 +860,20 @@ var LayoutColumns = class _LayoutColumns {
   /** Columns for `size` code points: a recycled layout's, refilled, when the
    *  pool holds one. */
   static take(size) {
-    const cols = spare.pop();
-    if (cols === void 0) return new _LayoutColumns(size);
-    cols.num = takeDoubles(size * NUM);
-    cols.ref = takeRefs(size * REF);
+    let cols = spare.pop();
+    if (cols === void 0) {
+      cols = new _LayoutColumns(size);
+    } else {
+      cols.num = takeDoubles(size * NUM);
+      cols.ref = takeRefs(size * REF);
+    }
+    cols.stamp = ++stamps;
     return cols;
   }
   /** Give the arrays back to the pool, and these columns with their line
-   *  boxes to the next layout. A line box still held afterwards reads that
-   *  layout's code points, so only a layout nobody holds is recycled. */
+   *  boxes and result to the next layout. A line box or result still held
+   *  afterwards reads that layout's code points, so only a layout nobody holds
+   *  is recycled. */
   recycle() {
     giveDoubles(this.num);
     const { ref } = this;
@@ -847,7 +881,7 @@ var LayoutColumns = class _LayoutColumns {
     giveRefs(ref);
     this.num = EMPTY_NUM;
     this.ref = EMPTY_REF;
-    this.paintings.length = 0;
+    truncate(this.paintings, 0);
     this.owners = 0;
     this.listed = false;
     this.pinned = false;
@@ -882,17 +916,17 @@ var LayoutColumns = class _LayoutColumns {
   }
   /** Record that the `slot`-th code point the pen reaches on the line starting
    *  at `start` is the line's `pos`-th in logical order. */
-  setVisual(start, slot, pos) {
-    this.num[(start + slot) * NUM + VISUAL] = pos;
+  setVisual(start2, slot, pos) {
+    this.num[(start2 + slot) * NUM + VISUAL] = pos;
   }
   /** Logical index, within its line, of the glyph at visual `slot`. */
-  visual(start, slot) {
-    return this.num[(start + slot) * NUM + VISUAL];
+  visual(start2, slot) {
+    return this.num[(start2 + slot) * NUM + VISUAL];
   }
   /** Fill `out` with code point `start + pos`'s placed glyph and return it.
    *  Every field is overwritten, so one object can walk a whole layout. */
-  glyph(start, pos, out) {
-    const i = start + pos;
+  glyph(start2, pos, out) {
+    const i = start2 + pos;
     const n = i * NUM, r = i * REF;
     const { num, ref } = this;
     out.run = num[n + RUN];
@@ -912,12 +946,12 @@ var LayoutColumns = class _LayoutColumns {
     return out;
   }
   /** Code point `start + pos`'s `LaidOutCell.drawsInk`, without building the cell. */
-  drawsInk(start, pos) {
-    return (this.num[(start + pos) * NUM + FLAGS] & DRAWS_INK) !== 0;
+  drawsInk(start2, pos) {
+    return (this.num[(start2 + pos) * NUM + FLAGS] & DRAWS_INK) !== 0;
   }
   /** Code point `start + pos`'s cell, as a new object. */
-  cell(start, pos) {
-    const n = (start + pos) * NUM;
+  cell(start2, pos) {
+    const n = (start2 + pos) * NUM;
     const { num } = this;
     const flags = num[n + FLAGS];
     return {
@@ -951,19 +985,12 @@ function blankGlyph() {
   };
 }
 var LineBox = class _LineBox {
-  x0;
-  y0;
-  x1;
-  y1;
-  baselineY;
-  srcEnd;
-  justified;
   #cols;
   #start;
   #count;
   /** Whether a view was built, replacing its accessor with a value. */
   #viewed = false;
-  constructor(x0, y0, x1, y1, baselineY, srcEnd, justified, cols, start, count) {
+  constructor(x0, y0, x1, y1, baselineY, srcEnd, justified, cols, start2, count) {
     this.x0 = x0;
     this.y0 = y0;
     this.x1 = x1;
@@ -972,13 +999,13 @@ var LineBox = class _LineBox {
     this.srcEnd = srcEnd;
     this.justified = justified;
     this.#cols = cols;
-    this.#start = start;
+    this.#start = start2;
     this.#count = count;
     Object.defineProperties(this, _LineBox.#views);
   }
   /** Set this box to another line of the same columns, as the constructor
    *  would, its views unbuilt again. */
-  refill(x0, y0, x1, y1, baselineY, srcEnd, justified, start, count) {
+  refill(x0, y0, x1, y1, baselineY, srcEnd, justified, start2, count) {
     this.x0 = x0;
     this.y0 = y0;
     this.x1 = x1;
@@ -986,7 +1013,7 @@ var LineBox = class _LineBox {
     this.baselineY = baselineY;
     this.srcEnd = srcEnd;
     this.justified = justified;
-    this.#start = start;
+    this.#start = start2;
     this.#count = count;
     if (this.#viewed) {
       this.#viewed = false;
@@ -1052,7 +1079,7 @@ function graphemeEnds(text, into) {
   } else {
     const seg = graphemeSegmenter();
     if (seg) {
-      for (const s of seg.segment(text)) out[n++] = s.index + s.segment.length;
+      n = segmentedEnds(seg, text, out);
     } else {
       let at = 0;
       for (const ch of text) out[n++] = at += ch.length;
@@ -1061,6 +1088,32 @@ function graphemeEnds(text, into) {
   out.length = n;
   return out;
 }
+var plain = (u) => u < 768 && u !== 13;
+function segmentedEnds(seg, text, out) {
+  const len = text.length;
+  let segments = null;
+  let n = 0;
+  let i = 0;
+  while (i < len) {
+    if (plain(text.charCodeAt(i)) && (i + 1 === len || plain(text.charCodeAt(i + 1)))) {
+      out[n++] = ++i;
+      continue;
+    }
+    let end = i + 1;
+    for (; ; ) {
+      while (end < len && !plain(text.charCodeAt(end))) end++;
+      if (end === len) break;
+      end++;
+      if (end === len || plain(text.charCodeAt(end))) break;
+    }
+    segments ??= seg.segment(text);
+    while (i < end) {
+      const s = segments.containing(i);
+      out[n++] = i = s.index + s.segment.length;
+    }
+  }
+  return n;
+}
 function graphemeCount(text) {
   return graphemeEnds(text).length;
 }
@@ -1087,20 +1140,20 @@ function slotsFor(shaper, face, text, glyphs) {
   let g = 0;
   let i = 0;
   while (i < glyphs.length) {
-    const start = glyphs[i].cluster;
+    const start2 = glyphs[i].cluster;
     let j = i;
-    while (j < glyphs.length && glyphs[j].cluster === start) j++;
+    while (j < glyphs.length && glyphs[j].cluster === start2) j++;
     const end = j < glyphs.length ? glyphs[j].cluster : text.length;
-    while (g < ends.length && ends[g] <= start) g++;
+    while (g < ends.length && ends[g] <= start2) g++;
     let inner = 0;
     for (let k = g; k < ends.length && ends[k] < end; k++) inner++;
     if (!holdsNotdef(glyphs, i, j)) {
       const total = advanceOf(glyphs, i, j);
       const share = total / (inner + 1);
       const shift = glyphs[i].rtl ? share - total : 0;
-      slots2[start] = clusterSlot(shaper, face, glyphs, i, j, text.slice(start, end), shift, share);
+      slots2[start2] = clusterSlot(shaper, face, glyphs, i, j, text.slice(start2, end), shift, share);
       const opens = share === 0 ? COVERED : { cluster: NOTHING_DRAWN, advance: share };
-      for (let at = start + 1, k = g; at < end; at++) {
+      for (let at = start2 + 1, k = g; at < end; at++) {
         const opening = k < ends.length && ends[k] === at;
         if (opening) k++;
         slots2[at] = opening ? opens : COVERED;
@@ -1138,13 +1191,13 @@ function clusterSlot(shaper, face, glyphs, from, to, text, shift, advance) {
 // src/layout/layoutEntries.ts
 var NONSPACING_MARK = /^[\p{Mn}\p{Me}]$/u;
 function measureRuns(runs, tabSize, pool, into, shaper = null) {
-  const entries = into ?? [];
+  const entries2 = into ?? [];
   let n = 0;
   let prev;
   let srcIndex = 0;
   for (let runIndex = 0; runIndex < runs.length; runIndex++) {
     const run = runs[runIndex];
-    const resolved2 = resolveFontVariant(run.fontFamily, run.fontWeight, run.fontStyle);
+    const resolved2 = cachedFontVariant(run.fontFamily, run.fontWeight, run.fontStyle);
     const metrics = metricsOf(resolved2);
     if (!metrics) {
       warnNoMetrics(run.fontFamily, run.fontWeight, run.fontStyle);
@@ -1162,8 +1215,8 @@ function measureRuns(runs, tabSize, pool, into, shaper = null) {
     let at = 0;
     const text = run.text;
     while (at < text.length) {
-      const cp = text.codePointAt(at);
-      const len = cp > 65535 ? 2 : 1;
+      const cp2 = text.codePointAt(at);
+      const len = cp2 > 65535 ? 2 : 1;
       const slot = shaped?.[at];
       const fontSize = run.sizeMap ? run.sizeMap[at] : run.fontSize;
       if (at === clusterStart) {
@@ -1182,72 +1235,69 @@ function measureRuns(runs, tabSize, pool, into, shaper = null) {
       const srcEnd = map ? runBase + map.ends[at] : runBase + at + len;
       at += len;
       srcIndex = map ? runBase + map.length : srcEnd;
-      const mark = isNonspacingMark(cp);
-      const kerningBefore = prev && !mark ? prev.metrics.kernOf(prev.cp, cp) * (prev.fontSize / prev.metrics.size) : 0;
-      const blank = blankEntry(
-        pool,
-        n,
-        runIndex,
-        cp,
-        fontSize,
-        Math.max(run.fontSize, run.strutSize ?? 0),
-        // Optional on the authored run type; absent, every y would go NaN.
-        run.baselineShift ?? 0,
-        run.rotate ?? 0,
-        srcStart,
-        srcEnd,
-        clusterEnd,
-        resolved2,
-        metrics
-      );
+      const mark = isNonspacingMark(cp2);
+      const kerningBefore = prev && !mark ? prev.metrics.kernOf(prev.cp, cp2) * (prev.fontSize / prev.metrics.size) : 0;
+      const blank = blankEntry(pool, n, runIndex, run, cp2, fontSize, srcStart, srcEnd, clusterEnd, resolved2, metrics);
       if (color) {
-        entries[n++] = clusterEnd ? ink(blank, color, 0, tracking) : blank;
+        if (clusterEnd) {
+          blank.tracking = tracking;
+          ink(blank, color);
+        }
+        entries2[n++] = blank;
         prev = void 0;
-      } else if (isHardLineBreak(cp)) {
-        entries[n++] = blank;
+      } else if (isHardLineBreak(cp2)) {
+        entries2[n++] = blank;
         prev = void 0;
-      } else if (cp === 9 || cp === 32) {
+      } else if (cp2 === 9 || cp2 === 32) {
         const space = metrics.advanceOf(32);
         const advance = space !== null ? space * (fontSize / metrics.size) : fontSize * 0.25;
-        if (cp === 9) {
-          entries[n++] = { ...blank, tab: { stop: tabSize * (advance + run.letterSpacing), min: advance / 2 } };
+        if (cp2 === 9) {
+          entries2[n++] = { ...blank, tab: { stop: tabSize * (advance + run.letterSpacing), min: advance / 2 } };
           prev = void 0;
         } else {
-          const own2 = glyphIn(resolved2, 32, HIT);
-          blank.font = own2?.font ?? null;
-          blank.glyph = own2?.glyph ?? null;
+          const own = glyphIn(resolved2, 32, HIT);
+          blank.font = own?.font ?? null;
+          blank.glyph = own?.glyph ?? null;
           blank.advance = advance;
           blank.tracking = tracking;
           blank.kerningBefore = kerningBefore;
           prev = blank;
-          entries[n++] = prev;
+          entries2[n++] = prev;
         }
       } else if (slot !== void 0) {
-        entries[n++] = shape(blank, slot, tracking);
+        blank.tracking = tracking;
+        entries2[n++] = shape(blank, slot);
         prev = void 0;
       } else {
-        const hit = resolveGlyph(resolved2, run.fontFamily, run.fontWeight, run.fontStyle, cp, true, HIT);
-        const entry = hit ? ink(blank, hit, kerningBefore, tracking) : blank;
-        entries[n++] = entry;
-        if (!mark) prev = entry;
+        const hit = resolveGlyph(resolved2, run.fontFamily, run.fontWeight, run.fontStyle, cp2, true, HIT);
+        if (hit) {
+          blank.kerningBefore = kerningBefore;
+          blank.tracking = tracking;
+          ink(blank, hit);
+        }
+        entries2[n++] = blank;
+        if (!mark) prev = blank;
       }
     }
   }
-  entries.length = n;
-  return entries;
+  entries2.length = n;
+  return entries2;
 }
-function isNonspacingMark(cp) {
-  return cp >= 768 && NONSPACING_MARK.test(String.fromCodePoint(cp));
+function isNonspacingMark(cp2) {
+  return cp2 >= 768 && NONSPACING_MARK.test(String.fromCodePoint(cp2));
 }
 var CLUSTER_ENDS = [];
 var HIT = { resolved: null, metrics: null, advance: 0, font: null, glyph: null };
 var POOL_MAX = 4096;
-function blankEntry(pool, i, run, cp, fontSize, lineSize, baselineShift, rotate, srcIndex, srcEnd, clusterEnd, resolved2, metrics) {
+function blankEntry(pool, i, run, r, cp2, fontSize, srcIndex, srcEnd, clusterEnd, resolved2, metrics) {
+  const lineSize = Math.max(r.fontSize, r.strutSize ?? 0);
+  const baselineShift = r.baselineShift ?? 0;
+  const rotate = r.rotate ?? 0;
   const e = pool?.[i];
   if (!e) {
     const made = {
       run,
-      cp,
+      cp: cp2,
       fontSize,
       lineSize,
       baselineShift,
@@ -1270,7 +1320,7 @@ function blankEntry(pool, i, run, cp, fontSize, lineSize, baselineShift, rotate,
     return made;
   }
   e.run = run;
-  e.cp = cp;
+  e.cp = cp2;
   e.fontSize = fontSize;
   e.lineSize = lineSize;
   e.baselineShift = baselineShift;
@@ -1290,26 +1340,22 @@ function blankEntry(pool, i, run, cp, fontSize, lineSize, baselineShift, rotate,
   e.drawsInk = false;
   return e;
 }
-function ink(e, hit, kerning, tracking) {
+function ink(e, hit) {
   e.resolved = hit.resolved;
   e.metrics = hit.metrics;
   e.font = hit.font;
   e.glyph = hit.glyph;
   e.advance = hit.advance * (e.fontSize / hit.metrics.size);
-  e.tracking = tracking;
-  e.kerningBefore = kerning;
   e.drawsInk = true;
-  return e;
 }
-function shape(e, slot, tracking) {
+function shape(e, slot) {
   e.shaped = slot.cluster;
   e.advance = slot.advance * e.fontSize;
-  e.tracking = tracking;
   e.drawsInk = slot.cluster.d !== null;
   return e;
 }
-function mirrorEntries(entries, levels, mirror, runs) {
-  return entries.map((entry, pos) => {
+function mirrorEntries(entries2, levels, mirror, runs) {
+  return entries2.map((entry, pos) => {
     const odd = levels[pos] % 2 === 1;
     if (entry.shaped !== null && entry.shaped.rtl !== odd) {
       const flipped = mirror(entry.cp);
@@ -1317,39 +1363,57 @@ function mirrorEntries(entries, levels, mirror, runs) {
     }
     if (!odd) return entry;
     if (entry.shaped !== null) return entry;
-    const cp = mirror(entry.cp);
-    if (cp === null || cp === entry.cp) return entry;
-    if (entry.font === null) return { ...entry, cp };
+    const cp2 = mirror(entry.cp);
+    if (cp2 === null || cp2 === entry.cp) return entry;
+    if (entry.font === null) return { ...entry, cp: cp2 };
     const run = runs[entry.run];
-    const hit = resolveGlyph(entry.resolved, run.fontFamily, run.fontWeight, run.fontStyle, cp, false);
+    const hit = resolveGlyph(entry.resolved, run.fontFamily, run.fontWeight, run.fontStyle, cp2, false);
     if (!hit) return entry;
-    return { ...entry, cp, resolved: hit.resolved, metrics: hit.metrics, font: hit.font, glyph: hit.glyph };
+    return { ...entry, cp: cp2, resolved: hit.resolved, metrics: hit.metrics, font: hit.font, glyph: hit.glyph };
   });
 }
 
 // src/layout/lineBreak/wrapLines.ts
-var hangs = (cp) => cp === 32 || cp === 9;
+var hangs = (cp2) => cp2 === 32 || cp2 === 9;
 function wrapLines(cps, maxWidth, widthOf) {
   const lines = [];
-  wrapSpans(cps, maxWidth, widthOf, (start, end, wrapped) => {
-    lines.push({ start, end, wrapped });
+  wrapSpans(cps, { maxWidth }, widthOf, (start2, end, wrapped) => {
+    lines.push({ start: start2, end, wrapped });
   });
   return lines;
 }
-function wrapSpans(cps, maxWidth, widthOf, emit) {
+var breakScratch = new Uint8Array(64);
+var breakScratchTaken = false;
+var BREAK_SCRATCH_MAX = 1 << 16;
+function wrapSpans(cps, box, widthOf, emit) {
   const n = cps.length;
-  const breaks = Number.isFinite(maxWidth) ? lineBreakOpportunities(cps) : null;
-  let start = 0;
+  if (!Number.isFinite(box.maxWidth)) {
+    wrapAt(cps, box, widthOf, emit, null);
+  } else if (breakScratchTaken || n >= BREAK_SCRATCH_MAX) {
+    wrapAt(cps, box, widthOf, emit, lineBreakOpportunities(cps));
+  } else {
+    if (breakScratch.length < n + 1) breakScratch = new Uint8Array(Math.max(n + 1, breakScratch.length * 2));
+    breakScratchTaken = true;
+    try {
+      wrapAt(cps, box, widthOf, emit, lineBreakOpportunitiesInto(cps, breakScratch));
+    } finally {
+      breakScratchTaken = false;
+    }
+  }
+}
+function wrapAt(cps, box, widthOf, emit, breaks) {
+  const n = cps.length;
+  let start2 = 0;
   let i = 0;
   while (i < n) {
-    const cp = cps[i];
-    if (isHardLineBreak(cp)) {
-      emit(start, i, false);
-      i += cp === 13 && cps[i + 1] === 10 ? 2 : 1;
-      start = i;
+    const cp2 = cps[i];
+    if (isHardLineBreak(cp2)) {
+      emit(start2, i, false);
+      i += cp2 === 13 && cps[i + 1] === 10 ? 2 : 1;
+      start2 = i;
       continue;
     }
-    if (hangs(cp)) {
+    if (hangs(cp2)) {
       i++;
       continue;
     }
@@ -1359,13 +1423,13 @@ function wrapSpans(cps, maxWidth, widthOf, emit) {
       if (!hangs(cps[j])) ink2 = j + 1;
       j++;
     }
-    if (breaks && i > start && widthOf(start, ink2) > maxWidth) {
-      emit(start, i, true);
-      start = i;
+    if (breaks && i > start2 && widthOf(start2, ink2) > box.maxWidth) {
+      emit(start2, i, true);
+      start2 = i;
     }
     i = j;
   }
-  if (start < n) emit(start, n, false);
+  if (start2 < n) emit(start2, n, false);
 }
 
 // src/layout/layoutLines.ts
@@ -1383,21 +1447,21 @@ var broken = [];
 var brokenCount = 0;
 var linePool = [];
 var LINE_POOL_MAX = 64;
-function flatWidth(start, end) {
-  return cur[start].advance + cur[start].tracking + sum[end] - sum[start + 1];
+function flatWidth(start2, end) {
+  return cur[start2].advance + cur[start2].tracking + sum[end] - sum[start2 + 1];
 }
 var stopOf = (k) => cur[k].tab;
-function tabbedWidth(start, end) {
-  return widthWithTabs(start, end, tabs, stopOf, flatWidth);
+function tabbedWidth(start2, end) {
+  return widthWithTabs(start2, end, tabs, stopOf, flatWidth);
 }
-function pushSpan(start, end, wrapped) {
+function pushSpan(start2, end, wrapped) {
   const i = brokenCount++;
   let line = linePool[i];
   if (line === void 0) {
     line = { start: 0, entries: [], width: 0.5, height: 0.5, ascent: 0.5, wrapped: false, srcEnd: 0, end: 0 };
     if (i < LINE_POOL_MAX) linePool[i] = line;
   }
-  line.start = start;
+  line.start = start2;
   line.end = end;
   line.wrapped = wrapped;
   line.width = 0;
@@ -1406,34 +1470,35 @@ function pushSpan(start, end, wrapped) {
   line.srcEnd = 0;
   broken[i] = line;
 }
-function breakLines(entries, cps, maxWidth, lineHeight) {
-  if (sum.length < entries.length + 1) sum = doubles(entries.length + 1);
+function breakLines(entries2, cps, opts) {
+  const { lineHeight } = opts;
+  if (sum.length < entries2.length + 1) sum = doubles(entries2.length + 1);
   sum[0] = 0;
   let tabCount = 0;
   brokenCount = 0;
-  for (let k = 0; k < entries.length; k++) {
-    const e = entries[k];
+  for (let k = 0; k < entries2.length; k++) {
+    const e = entries2[k];
     sum[k + 1] = sum[k] + e.kerningBefore + e.advance + e.tracking;
     if (e.tab) tabs[tabCount++] = k;
   }
   tabs.length = tabCount;
-  cur = entries;
-  wrapSpans(cps, maxWidth, tabCount === 0 ? flatWidth : tabbedWidth, pushSpan);
+  cur = entries2;
+  wrapSpans(cps, opts, tabCount === 0 ? flatWidth : tabbedWidth, pushSpan);
   cur = NONE;
   broken.length = brokenCount;
   for (let i = 0; i < broken.length; i++) {
     const line = broken[i];
     if (line.start === line.end) {
-      const brk = entries[line.end];
+      const brk = entries2[line.end];
       line.height = brk.lineSize * lineHeight;
       line.ascent = aboveBaseline(brk, lineHeight);
       line.srcEnd = brk.srcIndex;
-      line.entries.length = 0;
+      truncate(line.entries, 0);
       continue;
     }
     const out = line.entries;
     for (let k = line.start; k < line.end; k++) {
-      const e = entries[k];
+      const e = entries2[k];
       if (k === line.start) e.kerningBefore = 0;
       if (e.tab) e.advance = tabAdvance(line.width, e.tab.stop, e.tab.min);
       out[k - line.start] = e;
@@ -1442,25 +1507,25 @@ function breakLines(entries, cps, maxWidth, lineHeight) {
       line.ascent = Math.max(line.ascent, aboveBaseline(e, lineHeight));
     }
     out.length = line.end - line.start;
-    line.srcEnd = entries[line.end - 1].srcEnd;
+    line.srcEnd = entries2[line.end - 1].srcEnd;
   }
   return broken;
 }
-function hungWidth(entries) {
+function hungWidth(entries2) {
   let hung = 0;
-  for (let k = entries.length - 1; k >= 0 && hangs(entries[k].cp); k--) {
-    const e = entries[k];
+  for (let k = entries2.length - 1; k >= 0 && hangs(entries2[k].cp); k--) {
+    const e = entries2[k];
     hung += e.kerningBefore + e.advance + e.tracking;
   }
   return hung;
 }
-function wordGaps(entries) {
+function wordGaps(entries2) {
   const gaps = /* @__PURE__ */ new Set();
   let first = 0;
-  while (first < entries.length && entries[first].cp === 32) first++;
-  let last2 = entries.length - 1;
-  while (last2 > first && entries[last2].cp === 32) last2--;
-  for (let k = first + 1; k < last2; k++) if (entries[k].cp === 32) gaps.add(k);
+  while (first < entries2.length && entries2[first].cp === 32) first++;
+  let last2 = entries2.length - 1;
+  while (last2 > first && entries2[last2].cp === 32) last2--;
+  for (let k = first + 1; k < last2; k++) if (entries2[k].cp === 32) gaps.add(k);
   return gaps;
 }
 function alignOffset(align, alignWidth, inkWidth) {
@@ -1471,16 +1536,17 @@ function alignOffset(align, alignWidth, inkWidth) {
 }
 var NO_GAPS = /* @__PURE__ */ new Set();
 var placed = { box: null, inkWidth: 0.5 };
-function placeLine(line, y, order, align, alignWidth, justify, cols, start, at) {
-  const { entries } = line;
-  const hung = hungWidth(entries);
+function placeLine(line, y, order, align, opts, cols, start2, at) {
+  const { alignWidth, justify } = opts;
+  const { entries: entries2 } = line;
+  const hung = hungWidth(entries2);
   const inkWidth = line.width - hung;
   const slack = alignWidth - inkWidth;
-  const gaps = justify && line.wrapped && Number.isFinite(alignWidth) && slack > 0 ? wordGaps(entries) : NO_GAPS;
+  const gaps = justify && line.wrapped && Number.isFinite(alignWidth) && slack > 0 ? wordGaps(entries2) : NO_GAPS;
   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 hangsLeft = hung > 0 && order.levels[entries2.length - 1] % 2 === 1;
   const left = hangsLeft ? inkLeft - hung : inkLeft;
   const lineBaselineY = y + line.ascent;
   let penX = left;
@@ -1490,21 +1556,21 @@ function placeLine(line, y, order, align, alignWidth, justify, cols, start, at)
   const { visual } = order;
   for (let v = 0; v < visual.length; v++) {
     const pos = visual[v];
-    const e = entries[pos];
-    const kern = prevPos < 0 ? 0 : pos === prevPos + 1 ? e.kerningBefore : prevPos === pos + 1 ? entries[prevPos].kerningBefore : 0;
-    if (kern !== 0) cols.widen(start + (wide >= 0 ? wide : prevPos), kern);
+    const e = entries2[pos];
+    const kern = prevPos < 0 ? 0 : pos === prevPos + 1 ? e.kerningBefore : prevPos === pos + 1 ? entries2[prevPos].kerningBefore : 0;
+    if (kern !== 0) cols.widen(start2 + (wide >= 0 ? wide : prevPos), kern);
     penX += kern;
     prevPos = pos;
     const step = e.advance + e.tracking + (gaps.has(pos) ? gapExtra : 0);
     if (step !== 0) wide = pos;
-    cols.set(start + pos, e, order.levels[pos], penX, step, lineBaselineY - e.baselineShift);
-    cols.setVisual(start, slot++, pos);
+    cols.set(start2 + pos, e, order.levels[pos], penX, step, lineBaselineY - e.baselineShift);
+    cols.setVisual(start2, slot++, pos);
     penX += step;
   }
   const x1 = left + line.width + spread;
   const y1 = y + line.height;
   const prior = cols.boxes[at];
-  placed.box = prior !== void 0 ? prior.refill(left, y, x1, y1, lineBaselineY, line.srcEnd, spread > 0, start, entries.length) : cols.boxes[at] = new LineBox(left, y, x1, y1, lineBaselineY, line.srcEnd, spread > 0, cols, start, entries.length);
+  placed.box = prior !== void 0 ? prior.refill(left, y, x1, y1, lineBaselineY, line.srcEnd, spread > 0, start2, entries2.length) : cols.boxes[at] = new LineBox(left, y, x1, y1, lineBaselineY, line.srcEnd, spread > 0, cols, start2, entries2.length);
   placed.inkWidth = inkWidth + spread;
   return placed;
 }
@@ -1522,7 +1588,7 @@ function resolveLayoutOpts(opts, out = {
   tabSize: 0
 }) {
   out.maxWidth = opts.maxWidth;
-  out.alignWidth = opts.alignWidth ?? opts.maxWidth;
+  storeAlignWidth(out, opts);
   out.lineHeight = opts.lineHeight;
   out.align = opts.align;
   out.justify = opts.justify === true || opts.align === "justify";
@@ -1532,6 +1598,10 @@ function resolveLayoutOpts(opts, out = {
   out.tabSize = opts.tabSize ?? DEFAULT_TAB_SIZE;
   return out;
 }
+function storeAlignWidth(out, opts) {
+  if (opts.alignWidth === void 0) out.alignWidth = opts.maxWidth;
+  else out.alignWidth = opts.alignWidth;
+}
 function layoutBidi(opts) {
   return opts.bidi ?? registeredBidi();
 }
@@ -1544,6 +1614,11 @@ var ENTRY_POOL = [];
 var ENTRIES = [];
 var CPS = [];
 var OPTS = resolveLayoutOpts({ maxWidth: 0, lineHeight: 0, align: "left" });
+var LINE_OPTS = { maxWidth: 0.5, alignWidth: 0.5, lineHeight: 0.5, justify: false };
+var hardBreakAt = (i) => isHardLineBreak(CPS[i]);
+function mirrorLine(bidi, entries2, levels, runs) {
+  return mirrorEntries(entries2, levels, (cp2) => bidi.mirror(cp2), runs);
+}
 function layoutRuns(runs, opts) {
   const {
     maxWidth,
@@ -1556,42 +1631,49 @@ function layoutRuns(runs, opts) {
     direction,
     tabSize
   } = resolveLayoutOpts(opts, OPTS);
-  const entries = measureRuns(runs, tabSize, ENTRY_POOL, ENTRIES, shaper);
+  const entries2 = measureRuns(runs, tabSize, ENTRY_POOL, ENTRIES, shaper);
   const cps = CPS;
-  cps.length = entries.length;
-  for (let k = 0; k < entries.length; k++) cps[k] = entries[k].cp;
-  const paragraphs = bidi ? analyzeParagraphs(bidi, cps, (i) => isHardLineBreak(cps[i]), direction) : null;
+  cps.length = entries2.length;
+  for (let k = 0; k < entries2.length; k++) cps[k] = entries2[k].cp;
+  const paragraphs = bidi ? analyzeParagraphs(bidi, cps, hardBreakAt, direction) : null;
   if (!bidi) warnRtlWithoutEngine(cps);
-  const broken2 = breakLines(entries, cps, maxWidth, lineHeight);
+  const lineOpts = LINE_OPTS;
+  lineOpts.maxWidth = maxWidth;
+  lineOpts.alignWidth = alignWidth;
+  lineOpts.lineHeight = lineHeight;
+  lineOpts.justify = justify;
+  const broken2 = breakLines(entries2, cps, lineOpts);
   let size = 0;
   for (let i = 0; i < broken2.length; i++) size += broken2[i].entries.length;
   const cols = broken2.length > 0 ? LayoutColumns.take(size) : null;
   const lines = cols !== null ? cols.boxes : [];
   let y = 0;
   let width = 0;
-  let start = 0;
+  let start2 = 0;
   for (let i = 0; i < broken2.length; i++) {
     const line = broken2[i];
     const order = orderLine(paragraphs, line.start, line.entries.length);
-    if (bidi) line.entries = mirrorEntries(line.entries, order.levels, (cp) => bidi.mirror(cp), runs);
+    if (bidi) line.entries = mirrorLine(bidi, line.entries, order.levels, runs);
     const reads = direction !== "auto" ? direction : directionOfLevel(line.entries.length > 0 ? paragraphs?.baseLevel(line.start) ?? 0 : 0);
     const placed2 = placeLine(
       line,
       y,
       order,
       resolveAlign(align, reads),
-      alignWidth,
-      justify,
+      lineOpts,
       cols,
-      start,
+      start2,
       i
     );
-    start += line.entries.length;
+    start2 += line.entries.length;
     width = Math.max(width, placed2.inkWidth);
     y += line.height;
   }
   lines.length = broken2.length;
-  return { lines, bounds: { width, height: y } };
+  if (cols === null) return { lines, bounds: { width, height: y } };
+  cols.bounds.width = width;
+  cols.bounds.height = y;
+  return cols.laid ??= { lines, bounds: cols.bounds };
 }
 
 // src/layout/glyphQuads.ts
@@ -1767,7 +1849,7 @@ var SPARE_GROUPS_MAX = 1024;
 function giveGroup(group) {
   if (spareGroups.length >= SPARE_GROUPS_MAX || group.stroke !== void 0 || group.colorGlyphs !== void 0 || quadsViewed.has(group)) return;
   group.quadData = NO_QUADS;
-  group.glyphs.length = 0;
+  truncate(group.glyphs, 0);
   spareGroups.push(group);
 }
 var slots = [];
@@ -1789,7 +1871,7 @@ function takeGroups(out) {
     out.push(slots[i].group);
     slots[i].group = null;
   }
-  slots.length = 0;
+  truncate(slots, 0);
   last.group = null;
 }
 
@@ -1816,10 +1898,13 @@ function faceOutlineD(g) {
   return glyphOutline(family, weight, style, g.cp);
 }
 function runFaces(runs) {
-  const faces = runs.map((r) => faceMetricsOf(resolveFontVariant(r.fontFamily, r.fontWeight, r.fontStyle)));
+  const faces = runs.map((r) => faceMetricsOf(cachedFontVariant(r.fontFamily, r.fontWeight, r.fontStyle)));
   return (run) => faces[run];
 }
 var isDecorated = (r) => r.underline || r.strikethrough || r.overline;
+function rulePaintOf(runs) {
+  return (run) => fillHasInk(runs[run].fill) ? paintKey(runs[run].fill.paint) : null;
+}
 var cursor = blankGlyph();
 var scratch = [];
 var SCRATCH_MAX2 = 1 << 14;
@@ -1828,10 +1913,10 @@ function paintRuns(laid, runs, opts = {}) {
 }
 function paintRunsInto(laid, runs, opts, out) {
   const { groups, decorations } = out;
-  groups.length = 0;
-  decorations.length = 0;
+  truncate(groups, 0);
+  truncate(decorations, 0);
   const faceOf = runs.some(isDecorated) ? runFaces(runs) : null;
-  const rulePaint = faceOf && ((run) => fillHasInk(runs[run].fill) ? paintKey(runs[run].fill.paint) : null);
+  const rulePaint = faceOf && rulePaintOf(runs);
   let glyphCount = 0;
   const { lines } = laid;
   for (let i = 0; i < lines.length; i++) glyphCount += LineBox.count(lines[i]);
@@ -1843,15 +1928,15 @@ function paintRunsInto(laid, runs, opts, out) {
   for (let li = 0; li < lines.length; li++) {
     const line = lines[li];
     const cols = LineBox.columns(line);
-    const start = cols !== null ? LineBox.start(line) : 0;
+    const start2 = cols !== null ? LineBox.start(line) : 0;
     const count = LineBox.count(line);
     const rules = faceOf && lineDecorations(runs, faceOf, rulePaint);
     for (let slot = 0; slot < count; slot++) {
-      const pos = cols !== null ? cols.visual(start, slot) : -1;
-      const g = cols !== null ? cols.glyph(start, pos, cursor) : line.glyphs[slot];
+      const pos = cols !== null ? cols.visual(start2, slot) : -1;
+      const g = cols !== null ? cols.glyph(start2, pos, cursor) : line.glyphs[slot];
       rules?.add(g);
       const run = runs[g.run];
-      const inks = cols !== null ? cols.drawsInk(start, pos) : line.cells[g.cell].drawsInk;
+      const inks = cols !== null ? cols.drawsInk(start2, pos) : line.cells[g.cell].drawsInk;
       const outline = inks ? glyphOutlineD(g, run, opts.outlineMinSize) : null;
       if (!fillHasInk(run.fill) && !(outline !== null && strokeHasInk(run.stroke))) continue;
       if (outline !== null) {
@@ -1892,9 +1977,56 @@ function paintRunsInto(laid, runs, opts, out) {
   takeGroups(groups);
   return out;
 }
+
+// src/layout/runsEntries.ts
+var entries = /* @__PURE__ */ new WeakMap();
+var spare2 = [];
+var SPARE_MAX2 = 1024;
+function entryOf(runs) {
+  return entries.get(runs);
+}
+function entryFor(runs) {
+  let e = entries.get(runs);
+  if (e === void 0) {
+    e = spare2.pop() ?? {
+      generation: -1,
+      variants: [],
+      painting: null,
+      paintedOn: null,
+      paintedStamp: 0,
+      paintMin: void 0,
+      listed: null
+    };
+    entries.set(runs, e);
+  }
+  return e;
+}
+function dropEntry(runs) {
+  const e = entries.get(runs);
+  if (e !== void 0) entries.delete(runs);
+  return e;
+}
+function emptyEntry(e) {
+  e.generation = -1;
+  e.painting = null;
+  e.paintedOn = null;
+  e.paintMin = void 0;
+  e.listed = null;
+}
+function giveEntry(e) {
+  emptyEntry(e);
+  if (spare2.length < SPARE_MAX2) spare2.push(e);
+}
+function _resetRunsEntriesForTests() {
+  entries = /* @__PURE__ */ new WeakMap();
+}
+
+// src/layout/paintCache.ts
 var PAINT_CACHE_VARIANT_LIMIT = 32;
-var own = /* @__PURE__ */ new WeakMap();
 var shared2 = /* @__PURE__ */ new WeakMap();
+function stampOf(laid) {
+  return laid.lines.length > 0 ? LineBox.columns(laid.lines[0])?.stamp ?? 0 : 0;
+}
 function listOf(laid) {
   const cols = laid.lines.length > 0 ? LineBox.columns(laid.lines[0]) : null;
   if (cols !== null) return cols.paintings;
@@ -1902,10 +2034,10 @@ function listOf(laid) {
   if (list === void 0) shared2.set(laid, list = []);
   return list;
 }
-var spare2 = [];
-var SPARE_MAX2 = 1024;
+var spare3 = [];
+var SPARE_MAX3 = 1024;
 function painting(laid, runs, opts, generation, key, bucket) {
-  const p = spare2.pop();
+  const p = spare3.pop();
   if (p === void 0) {
     return {
       generation,
@@ -1953,13 +2085,15 @@ function keyOf(p) {
 function cachedPaintRuns(laid, runs, opts = {}, use = "keep") {
   const generation = glyphGeneration();
   const min = opts.outlineMinSize;
-  const mine = own.get(runs);
-  const mineHere = mine !== void 0 && mine.laid === laid && mine.painting.generation === generation;
-  if (mineHere && mine.min === min) return handOut(mine.painting, use);
+  const mine = entryOf(runs);
+  const stamp = stampOf(laid);
+  const own = mine !== void 0 && mine.paintedOn === laid && mine.paintedStamp === stamp ? mine.painting : null;
+  const mineHere = own !== null && own.generation === generation;
+  if (mineHere && mine.paintMin === min) return handOut(own, use);
   const bucket = outlineBucket(runs, min);
-  if (mineHere && mine.painting.bucket === bucket) {
-    mine.min = min;
-    return handOut(mine.painting, use);
+  if (mineHere && own.bucket === bucket) {
+    mine.paintMin = min;
+    return handOut(own, use);
   }
   const list = listOf(laid);
   let p = null;
@@ -1978,34 +2112,21 @@ function cachedPaintRuns(laid, runs, opts = {}, use = "keep") {
   }
   if (list.length >= PAINT_CACHE_VARIANT_LIMIT) list.shift();
   list.push(p);
-  if (mine !== void 0) {
-    mine.laid = laid;
-    mine.painting = p;
-    mine.min = min;
-  } else {
-    const o = spareOwn.pop();
-    if (o === void 0) {
-      own.set(runs, { laid, painting: p, min });
-    } else {
-      o.laid = laid;
-      o.painting = p;
-      o.min = min;
-      own.set(runs, o);
-    }
-  }
+  const e = mine ?? entryFor(runs);
+  if (e.painting !== null && e.painting !== p) settlePainting(e.painting, runs);
+  e.paintedOn = laid;
+  e.paintedStamp = stamp;
+  e.painting = p;
+  e.paintMin = min;
   return handOut(p, use);
 }
+function settlePainting(p, runs) {
+  if (p.runs === runs) keyOf(p);
+}
 function handOut(p, use) {
   if (use === "keep") p.pinned = true;
   return p.painted;
 }
-function forgetPaintRuns(runs) {
-  const mine = own.get(runs);
-  if (mine === void 0) return;
-  own.delete(runs);
-  if (spareOwn.length < SPARE_MAX2) spareOwn.push(mine);
-}
-var spareOwn = [];
 function recyclePaintings(laid) {
   const cols = laid.lines.length > 0 ? LineBox.columns(laid.lines[0]) : null;
   let list;
@@ -2026,17 +2147,16 @@ function recyclePaintings(laid) {
       group.quadData = NO_QUADS;
       giveGroup(group);
     }
-    groups.length = 0;
-    p.painted.decorations.length = 0;
+    truncate(groups, 0);
+    truncate(p.painted.decorations, 0);
     p.runs = null;
     p.key = null;
-    if (spare2.length < SPARE_MAX2) spare2.push(p);
+    if (spare3.length < SPARE_MAX3) spare3.push(p);
   }
-  list.length = 0;
+  truncate(list, 0);
 }
 var LAYOUT_CACHE_VARIANT_LIMIT = 8;
 var LAYOUT_CACHE_STRUCTURAL_LIMIT = 64;
-var cache2 = /* @__PURE__ */ new WeakMap();
 var structural = [];
 var structuralGeneration = -1;
 var clock = 0;
@@ -2058,9 +2178,8 @@ function release(laid) {
   recyclePaintings(laid);
   cols.recycle();
 }
-var spareEntries = [];
 var spareVariants = [];
-var SPARE_MAX3 = 1024;
+var SPARE_MAX4 = 1024;
 function disown(vs) {
   for (let i = 0; i < vs.length; i++) {
     const v = vs[i];
@@ -2070,14 +2189,14 @@ function disown(vs) {
       release(v.laid);
     }
     v.laid = NO_LAYOUT;
-    if (spareVariants.length < SPARE_MAX3) spareVariants.push(v);
+    if (spareVariants.length < SPARE_MAX4) spareVariants.push(v);
   }
-  vs.length = 0;
+  truncate(vs, 0);
 }
 var NO_LAYOUT = { lines: [], bounds: { width: 0, height: 0 } };
 function fill(v, opts, bidi, laid) {
   v.maxWidth = opts.maxWidth;
-  v.alignWidth = opts.alignWidth ?? opts.maxWidth;
+  storeAlignWidth(v, opts);
   v.lineHeight = opts.lineHeight;
   v.align = opts.align;
   v.justify = opts.justify === true || opts.align === "justify";
@@ -2089,11 +2208,11 @@ function fill(v, opts, bidi, laid) {
   return v;
 }
 function variant(opts, bidi, laid) {
-  const spare3 = spareVariants.pop();
-  if (spare3 !== void 0) return fill(spare3, opts, bidi, laid);
-  return {
+  const spare4 = spareVariants.pop();
+  if (spare4 !== void 0) return fill(spare4, opts, bidi, laid);
+  const v = {
     maxWidth: opts.maxWidth,
-    alignWidth: opts.alignWidth ?? opts.maxWidth,
+    alignWidth: opts.maxWidth,
     lineHeight: opts.lineHeight,
     align: opts.align,
     justify: opts.justify === true || opts.align === "justify",
@@ -2103,6 +2222,8 @@ function variant(opts, bidi, laid) {
     shaper: layoutShaper(opts),
     laid
   };
+  storeAlignWidth(v, opts);
+  return v;
 }
 function mix(h, n) {
   return Math.imul(h ^ n, 16777619);
@@ -2131,7 +2252,7 @@ function runsHash(runs) {
     h = mix(h, r.fontFeatures?.length ?? 0);
     h = mixStr(h, r.lang ?? "");
   }
-  return h;
+  return h & 1073741823;
 }
 function sameNums(a, b) {
   if (a === b) return true;
@@ -2159,12 +2280,8 @@ function sameRuns(a, b) {
 function cachedLayoutRuns(runs, opts, use = "keep") {
   const fonts = faceGeneration();
   const bidi = layoutBidi(opts);
-  let entry = cache2.get(runs);
-  if (entry === void 0) {
-    entry = spareEntries.pop() ?? { generation: fonts, variants: [] };
-    entry.generation = fonts;
-    cache2.set(runs, entry);
-  } else if (entry.generation !== fonts) {
+  const entry = entryFor(runs);
+  if (entry.generation !== fonts) {
     entry.generation = fonts;
     disown(entry.variants);
   } else {
@@ -2177,7 +2294,7 @@ function cachedLayoutRuns(runs, opts, use = "keep") {
       return handOut2(v.laid, use);
     }
   }
-  const laid = structuralLayout(runs, opts, bidi, fonts);
+  const laid = structuralLayout(runs, opts, bidi, fonts, entry);
   const vs = entry.variants;
   if (vs.length >= LAYOUT_CACHE_VARIANT_LIMIT) disown(vs);
   vs.unshift(variant(opts, bidi, laid));
@@ -2186,16 +2303,17 @@ function cachedLayoutRuns(runs, opts, use = "keep") {
   return handOut2(laid, use);
 }
 function dropRuns(runs) {
-  const entry = cache2.get(runs);
-  forgetPaintRuns(runs);
+  const entry = dropEntry(runs);
   if (entry === void 0) return;
-  cache2.delete(runs);
   disown(entry.variants);
-  if (spareEntries.length < SPARE_MAX3) spareEntries.push(entry);
+  giveEntry(entry);
 }
-function structuralLayout(runs, opts, bidi, fonts) {
+function structuralLayout(runs, opts, bidi, fonts, entry) {
   if (structuralGeneration !== fonts) {
-    for (const s of structural) unlist(s);
+    for (const s of structural) {
+      unlist(s);
+      s.runs = NO_RUNS;
+    }
     structural = [];
     structuralGeneration = fonts;
   }
@@ -2216,11 +2334,29 @@ function structuralLayout(runs, opts, bidi, fonts) {
   filled.hash = hash;
   filled.runs = runs;
   filled.used = ++clock;
+  entry.listed = filled;
   const cols = columnsOf(laid);
   if (cols !== null) cols.listed = true;
   if (!full) structural.push(filled);
   return laid;
 }
+function clearRuns(runs) {
+  const entry = entryOf(runs);
+  if (entry === void 0) return;
+  const s = entry.listed;
+  if (s !== null && s.runs === runs) {
+    unlist(s);
+    s.laid = NO_LAYOUT;
+    s.runs = NO_RUNS;
+    s.hash = -1;
+    s.used = 0;
+  }
+  const p = entry.painting;
+  disown(entry.variants);
+  if (p !== null) settlePainting(p, runs);
+  emptyEntry(entry);
+}
+var NO_RUNS = [];
 function structuralEntry(opts, bidi, laid) {
   return fill({
     maxWidth: 0,
@@ -2245,12 +2381,12 @@ function unlist(s) {
   release(s.laid);
 }
 function _resetLayoutCacheForTests() {
-  cache2 = /* @__PURE__ */ new WeakMap();
+  _resetRunsEntriesForTests();
   structural = [];
   structuralGeneration = -1;
   clock = 0;
 }
 
-export { BREAK_ALLOWED, BREAK_MANDATORY, DECORATION_KINDS, DEFAULT_DECORATION_METRICS, DEFAULT_TAB_SIZE, DEFAULT_TEXT_FILL, DEFAULT_TEXT_STYLE, LAYOUT_CACHE_STRUCTURAL_LIMIT, LAYOUT_CACHE_VARIANT_LIMIT, NO_BREAK, QUAD_STRIDE, _resetBidiWarningForTests, _resetLayoutCacheForTests, cachedLayoutRuns, cachedPaintRuns, decorationMetrics, decorationRule, dropRuns, emboldenGlyph, emboldenGlyphD, faceOutlineD, fontString, graphemeCount, hangs, hasGlyphQuad, isHardLineBreak, layoutRuns, lineBreakOpportunities, lineDecorations, paintRuns, paragraphDirection, registerBidi, registerShaper, resolveAlign, resolveTextStyle, runFaces, shapesWithFeature, syntheticBoldOffset, tabAdvance, widthWithTabs, wrapLines };
-//# sourceMappingURL=chunk-FODNMBHI.js.map
-//# sourceMappingURL=chunk-FODNMBHI.js.map
+export { BREAK_ALLOWED, BREAK_MANDATORY, DECORATION_KINDS, DEFAULT_DECORATION_METRICS, DEFAULT_TAB_SIZE, DEFAULT_TEXT_FILL, DEFAULT_TEXT_STYLE, LAYOUT_CACHE_STRUCTURAL_LIMIT, LAYOUT_CACHE_VARIANT_LIMIT, NO_BREAK, QUAD_STRIDE, _resetBidiWarningForTests, _resetLayoutCacheForTests, cachedLayoutRuns, cachedPaintRuns, clearRuns, decorationMetrics, decorationRule, dropRuns, emboldenGlyph, emboldenGlyphD, faceOutlineD, fontString, graphemeCount, hangs, hasGlyphQuad, isHardLineBreak, layoutRuns, lineBreakOpportunities, lineDecorations, paintRuns, paragraphDirection, registerBidi, registerShaper, registeredBidi, resolveAlign, resolveTextStyle, resolveTextStyleInto, runFaces, shapesWithFeature, syntheticBoldOffset, tabAdvance, warnRtlWithoutEngine, widthWithTabs, wrapLines };
+//# sourceMappingURL=chunk-ZNSU5C43.js.map
+//# sourceMappingURL=chunk-ZNSU5C43.js.map