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

package/dist/chunk-FODNMBHI.js

@@ -0,0 +1,2256 @@
+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 { mergeRegion, growRegion, pathToD, pathFromD } from '@weasel-js/geom';
+
+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, tabs2, stopOf2, flatWidth2, piece) {
+  let x = 0;
+  let from = start;
+  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 >= end) break;
+    lay(t);
+    const { stop, min } = stopOf2(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 = { kind: "solid", color: "#000" };
+var DEFAULT_TEXT_FILL = { paint: DEFAULT_FILL };
+function paintColor(p) {
+  return isSolidPaint(p) ? p.color : "#000";
+}
+var mixedColor = "";
+var mixed = "";
+function defaultSelectionBackground(textColor) {
+  if (textColor !== mixedColor) {
+    mixed = `color-mix(in srgb, ${textColor} 25%, transparent)`;
+    mixedColor = textColor;
+  }
+  return mixed;
+}
+var DEFAULT_TEXT_STYLE = {
+  fontSize: 16,
+  fontFamily: "sans-serif",
+  fontWeight: 400,
+  fontStyle: "normal",
+  align: "left",
+  direction: "auto",
+  lineHeight: 1.2,
+  tabSize: DEFAULT_TAB_SIZE,
+  wrap: false,
+  fill: null,
+  caretColor: paintColor(DEFAULT_FILL),
+  selectionBackground: defaultSelectionBackground(paintColor(DEFAULT_FILL)),
+  selectionColor: null,
+  letterSpacing: 0,
+  underline: false,
+  strikethrough: false,
+  overline: false,
+  textTransform: "none",
+  fontVariantCaps: "normal"
+};
+var NOTHING = Object.freeze({});
+function resolveTextStyle(style, paint, scale = 1) {
+  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);
+  let selectionBackground;
+  if (style.selectionBackground === "none") {
+    selectionBackground = null;
+  } else if (style.selectionBackground != null) {
+    selectionBackground = style.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
+  };
+}
+function fontString(s) {
+  return `${s.fontStyle} ${s.fontWeight} ${s.fontSize}px ${cssFamilyName(s.fontFamily)}`;
+}
+var registered = null;
+function registerShaper(shaper) {
+  registered = shaper;
+  return () => {
+    if (registered === shaper) registered = null;
+  };
+}
+function registeredShaper() {
+  return registered;
+}
+var bytesOf = /* @__PURE__ */ new WeakMap();
+function shapeableBytes(resolved2) {
+  const face = resolved2.outlineFace;
+  if (!face) return null;
+  let bytes = bytesOf.get(face);
+  if (bytes === void 0) {
+    bytes = face.embedding?.().sfnt ?? null;
+    bytesOf.set(face, bytes);
+  }
+  return bytes;
+}
+function shapesWithFeature(family, weight, style, tag, shaper = registered) {
+  if (shaper === null) return false;
+  const bytes = shapeableBytes(resolveFontVariant(family, weight, style));
+  return bytes !== null && shaper.hasFeature(bytes, tag);
+}
+
+// src/layout/decorationMetrics.ts
+var DECORATION_KINDS = ["underline", "strikethrough", "overline"];
+var DEFAULT_DECORATION_METRICS = Object.freeze({
+  underline: Object.freeze({ offset: 0.1, thickness: 0.05 }),
+  strikethrough: Object.freeze({ offset: -0.3, thickness: 0.05 }),
+  overline: Object.freeze({ offset: -0.9, thickness: 0.05 })
+});
+var resolved = /* @__PURE__ */ new WeakMap();
+function decorationMetrics(face) {
+  if (!face) return DEFAULT_DECORATION_METRICS;
+  let out = resolved.get(face);
+  if (!out) {
+    const underline = face.underline ?? DEFAULT_DECORATION_METRICS.underline;
+    out = Object.freeze({
+      underline,
+      strikethrough: face.strikethrough ?? DEFAULT_DECORATION_METRICS.strikethrough,
+      overline: Object.freeze({ offset: DEFAULT_DECORATION_METRICS.overline.offset, thickness: underline.thickness })
+    });
+    resolved.set(face, out);
+  }
+  return out;
+}
+function decorationRule(kind, baselineY, fontSize, face) {
+  const m = decorationMetrics(face)[kind];
+  const y0 = baselineY + fontSize * m.offset;
+  return { y0, y1: y0 + fontSize * m.thickness };
+}
+function lineDecorations(runs, faceOf, paintOf2) {
+  const rules = [];
+  let open = null;
+  const close = () => {
+    const s = open;
+    open = null;
+    if (!s || s.x1 <= s.x0) return;
+    for (const kind of DECORATION_KINDS) {
+      if (!s.style[kind]) continue;
+      const { y0, y1 } = decorationRule(kind, s.baselineY, s.style.fontSize, s.face);
+      rules.push({ kind, x0: s.x0, y0, x1: s.x1, y1, run: s.run });
+    }
+  };
+  return {
+    add(g) {
+      const style = runs[g.run];
+      const paint = style.underline || style.strikethrough || style.overline ? paintOf2(g.run) : null;
+      if (paint === null) {
+        if (open !== null) close();
+        return;
+      }
+      const face = faceOf(g.run);
+      const joins = open !== null && DECORATION_KINDS.every((kind) => open.style[kind] === style[kind]) && open.style.fontSize === style.fontSize && open.face === face && open.baselineY === g.baselineY && open.paint === paint;
+      if (joins) {
+        open.x1 = g.x + g.step;
+      } else {
+        close();
+        open = { run: g.run, style, face, paint, baselineY: g.baselineY, x0: g.x, x1: g.x + g.step };
+      }
+    },
+    end() {
+      close();
+      return rules;
+    }
+  };
+}
+
+// src/layout/lineBreak/lineBreakTable.ts
+var lineBreakTable_exports = {};
+__export(lineBreakTable_exports, {
+  AK: () => AK,
+  AL: () => AL,
+  AP: () => AP,
+  AS: () => AS,
+  B2: () => B2,
+  BA: () => BA,
+  BB: () => BB,
+  BK: () => BK,
+  CB: () => CB,
+  CL: () => CL,
+  CLASS_MASK: () => CLASS_MASK,
+  CM: () => CM,
+  CP: () => CP,
+  CR: () => CR,
+  EAST_ASIAN: () => EAST_ASIAN,
+  EB: () => EB,
+  EM: () => EM,
+  EX: () => EX,
+  GL: () => GL,
+  H2: () => H2,
+  H3: () => H3,
+  HL: () => HL,
+  HY: () => HY,
+  ID: () => ID,
+  IN: () => IN,
+  IS: () => IS,
+  JL: () => JL,
+  JT: () => JT,
+  JV: () => JV,
+  LF: () => LF,
+  NL: () => NL,
+  NS: () => NS,
+  NU: () => NU,
+  OP: () => OP,
+  PICTOGRAPHIC_CN: () => PICTOGRAPHIC_CN,
+  PO: () => PO,
+  PR: () => PR,
+  QU: () => QU,
+  QU_PF: () => QU_PF,
+  QU_PI: () => QU_PI,
+  RI: () => RI,
+  SP: () => SP,
+  SY: () => SY,
+  UNICODE_VERSION: () => UNICODE_VERSION,
+  VF: () => VF,
+  VI: () => VI,
+  WJ: () => WJ,
+  ZW: () => ZW,
+  ZWJ: () => ZWJ,
+  lineBreakPropsOf: () => lineBreakPropsOf
+});
+var UNICODE_VERSION = "16.0.0";
+var BK = 0;
+var CR = 1;
+var LF = 2;
+var NL = 3;
+var SP = 4;
+var ZW = 5;
+var ZWJ = 6;
+var CM = 7;
+var WJ = 8;
+var GL = 9;
+var BA = 10;
+var BB = 11;
+var B2 = 12;
+var HY = 13;
+var CB = 14;
+var CL = 15;
+var CP = 16;
+var EX = 17;
+var IN = 18;
+var NS = 19;
+var OP = 20;
+var QU = 21;
+var IS = 22;
+var NU = 23;
+var PO = 24;
+var PR = 25;
+var SY = 26;
+var AL = 27;
+var HL = 28;
+var ID = 29;
+var EB = 30;
+var EM = 31;
+var H2 = 32;
+var H3 = 33;
+var JL = 34;
+var JV = 35;
+var JT = 36;
+var RI = 37;
+var AK = 38;
+var AP = 39;
+var AS = 40;
+var VF = 41;
+var VI = 42;
+var QU_PI = 43;
+var QU_PF = 44;
+var CLASS_MASK = 63;
+var EAST_ASIAN = 64;
+var PICTOGRAPHIC_CN = 128;
+var ALPHABET = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz!#$%&()*+,-./:;<=>?@[]^_{|}~";
+var PALETTE = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 71, 73, 74, 79, 81, 82, 83, 84, 88, 89, 91, 93, 94, 95, 96, 97, 98, 155, 157];
+var RUNS = 2787;
+var PACKED = "9H1K1C2A1B18H1E1R1V1b1Z1Y1b1V1U1Q1b1Z1W1N1W1a10X2W3b1R27b1U1Z1Q29b1U1K1P1b6H1D26H1J1U1Y3Z5b1n1b1K2b1Y1Z2b1L6b1o3b1U520b1L3b1L18b1L32b79H1J12H7J13H14b1W260b7H255b1W1K4b1Z1b45H1K1H1b2H1b2H1R1H8b27c4b4c13b6X3b3Y2W2b11H1R1H3R43b21H10X1Y2X3b1H99b1R1b7H1X1b6H2b2H1b4H2b10X23b1H30b27H91b11H15b10X33b9H4b1W1R3b1H2Z22b4H1b9H1b3H1b5H43b3H52b2X5b9H42b24H1X33H54b3H1b18H1b7H10b2H2K10X17b3H56b1H1b7H2b2H2b3H9b1H10b2H2b10X2b2Y5b1Y1b1Z2b1H2b3H56b1H1b5H4b2H2b3H3b1H20b10X2H3b1H11b3H56b1H1b8H1b3H1b3H20b2H2b10X1b1Z8b6H1b3H56b1H1b7H2b2H2b3H7b3H10b2H2b10X18b1H59b5H3b3H1b4H9b1H14b10X9b1Z6b5H55b1H1b7H1b3H1b4H7b2H11b2H2b10X7b1L9b3H1L55b1H1b7H1b3H1b4H7b2H11b2H2b10X3b1H12b4H55b2H1b7H1b3H1b4H9b1H10b2H2b10X9b1Y7b3H70b1H4b6H1b1H1b8H6b10X2b2H61b1H2b7H4b1Z7b8H1b10X2K85b1H2b9H11b7H1b10X39b4L1b2L1J2L1K1J5R1J1b1R3b2H6b10X10b1K1H1b1H1b1H1U1P1U1P2H49b14H1K5H1K2H5b11H1b36H1b2K6b1H9b2L1K1L5b2J80b20H1b10X2K10b4H4b3H1b3H2b7H3b4H13b12H1b1H10X4H98b96(72f88g349b3H1b1K158b1K639b1K26b1U1P78b3K36b4H28b3H2K27b2H30b2H64b32H2K1T1b1K1b1K1Z1b1H2b10X24b2R2K1L1b2R1b3H1J1H10X107b2H34b1H118b12H4b12H8b2R10X128b11X60b5H57b10H1b29H2b1H10X6b10X22b31H49b5H47i16H1m8i1b2K10k2K1d4K10d9H9d3K3H30b13H2b10X6b38k12H2l48b20H3b5K10X6b10X36b2K80b3H1b21H4b1H6b1H2b3H198b13H1J46H1J3H509b1L2b7K1J3K1F1H1G2H1K1J2K1M3b1n1o1U2n1o1U1n4b3S1K2A5H1J8Y1b1n1o1b2T6b1W1U1P3T12b1K1Y4K1b3K1I5b10H13b1U1P14b1U1P17b7Z1Y1Z1y12Z1Y4Z1Y2Z1Y1Z1Y15Z33H18b1Y5b1Y12b1Z251b2Z219b1S24b1U1P1U1P14b2!13b1w1s190b4z3b1!2d1!521b2z1b4d16b2!2b1d1b3d1e2d16b8z1b3d12b12z20b1d22b1!10b6z3b1z13b1z8b2z17b2!5d2!3d4b1d1z3d1b1d1!3b2d2b1d2b3d8b1!6b1d2!1d1!1b2d1e1!2b1!7d1z2b2d2#2e26b1z35b1z1b1z4b3z1b1z3b6V1b2R1d3b1U1P1U1P1U1P1U1P1U1P1U1P1U1P31b3z24b1z14b1z5b1U1P31b1U1P1U1P1U1P1U1P1U1P403b1U1P1U1P1U1P1U1P1U1P1U1P1U1P1U1P1U1P1U1P1U1P63b1U1P1U1P32b1U1P285b2z51b1z4b1z409b3H7b1R3K1b1R1K112b1K14b1H96b32H2V1n1o1n1o3V1n1o1V1n1o8K1b1K1U1K2b1n1o2b1n1o1U1P1U1P1U1P1U1P4K1R1b2K1b2K5b2M3K1b2K1U8K1b1K1b2K3b2R1U1Q1U1Q1U1Q1U1Q1K34b26!1b89!12b214!26b16!1r2s2!1v2!1w1s1w1s1w1s1w1s1w1s2!1w1s1w1s1w1s1w1s1v1w2s10!6p5!1p5!2v2!1d1b1v1!1v1!1v1!1v1!1v25!1v31!1v1!1v1!1v6!1v6!2v2b2p4v1!2v1!1v1!1v1!1v1!1v25!1v31!1v1!1v1!1v6!1v6!2v4!4v1!5b43!1b94!1b86!9b1!16v31!1b40!8b7024!64z21013!1v1143!3b55!55b2K269b1K1R1K16b10X69b4H1b10H32b2H80b2H1b5K266b1H3b1H4b1H23b5H4b1H11b1Y59b2L2R8b2H50b18H8b2K10X6b18H10b1L2b1H10X28b8H2K23b13H12b29(3b4H47i13H1m6d3K4d1b1K10k4b2d5b1H10b10X6b41k14H9b3K1H8K2H2b10k2b1d3K27b3H50b1H1b3H2b2H5b2H1b1H41b5H2K3b2H236b8H1K2H2b10X6b1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&1%27&12b23f4b49g8452b512!29b1c1H10c1b13c1b5c1b1c1b2c1b2c1b10c494b1P1U188b1Y3b16H3s2v2t1w1s1u6b1J1H1J1H1J1H2J1H1J1H1J1H2J1H5!1w1s1w1s1w1s1w1s1w1s1w1s1w1s1w1s2!1w1s7!1s1!1s1b2v2t1!1w1s1w1s1w1s8!1b1!1y1x1!147b1I1b1t2!1y1x2!1w1s2!1s1!1s11!2v3!1t27!1w1!1s29!1w1!1s1!1w2s1w2s1v1!10v45!2v31!3b6!2b6!2b6!2b3!3b1x1y3!2y1b7z10b3H1O259b3K250b1H226b1H149b5H36b1K48b1K207b10X941b1K199b1K225b3H1b2H5b4H40b3H4b1H16b8K141b2H9b6K1S66b7K484b4H8b10X6b10X31b5H1K316b2H1K78b4H70b11H49b4H122b3H2j51i14H1m2K5d4b20d10k1H2i2H1i9b1J3H45b11H2b1X4K1H10b1X34b10X6b3H36b14H1b10X4K1b2H44b1H1b1L10b3H48b14H4b2K1b1K4H1b2H10X1b1L1b3K76b12H2K1b2K1b1H2b1H103b1K53b12H5b10X6b4H1b8i2b2i2b22i1b7i1b2i1b5i1b2H1K7H2b2H2b2H1m2b1k6b1H5b1K2k2i2H2b7H3b5H11b10k1b1k2b1k1b2k36i1b1d9H1b1H2b1H1b4H1b4H1m1j1H3d1b2d8b2H82b18H4b4K1b10X2K2b1H81b20H12b10X213b7H2b9H1L2K2R3b15K4b2H82b17H2K13b10X6b13L62b13H8b10X6b20X57b15H4b10X2b3K237b15H165b10X22b7i2b1i2b8i1b2i1b24i6H1b2H2b3H1m1j1H1j2H3K9b10k119b7H2b7H1b1L1b1H28b10H40b7H1b4H1L1b4K1L1b1H9b11H46b16H3K1b3L2K93b10L230b10X53b8H1b8H1b5K10b10X22b1L1R32b22H1b14H122b6H3b1H1b2H1b7H1b1H8b10X48b5H1b2H1b5H8b10X310b18k1K4H2K7b2H1j1H13i1b34i7H3b4H1m2K11d10k1H130b4Y30b1K1136b5K3555b3U3P36b1P3b1U1P1U1P239b1U2P179b1U7J1U1P3J1U1P1U1P1H6b15H4472b1U1P6960b30k18H10k2342b10X4b2K80b10X38b5H1K58b7H3K10b1K11b10X532b2K10X285b2K182b1H1b55H7b4H77b4v1q11b2p14b6136!8b768!470z41b1z9!8935b4z1b7z1b2z1b291!15b1v29b3v2b1v14b4v8b396!2465b2H1K4H4172b10X518b46H2b23H542b5H3b22H2b7H30b4H148b3H187b87z9b23z1111b50X512b55H4b50H8b1H14b1H2b4K16b5H1b15H1360b7H1b17H2b7H1b2H1b5H100b1H160b7H9b10X356b1H61b4H10X5b1Z492b4H10X244b2H1b10X725b7H109b7H5b10X4b2U844b1Y3b1Y847b4d1!39d4*100d12*15d2*15d1*14d1!1*37d10*142b1z2b10z19b56*26h3!13*44!4*9!7*2!14*6!154*33!12d9!1d70!1d7!1#14!8d2b2d21!2z5!1z5!3#2!1#2!1#2e2d5!12d17!3d1!3d3!5$63!1d1!1d2#2!11#21!19#3!1#4!3#1!3#7!1#1!1#14!1z1!1z1!1z5!1#4!1z1!2z74!2d1!7z16!14z13!12z12b1d4!1d24!12d2e4d1#21d1e4d2#13d1!47d8b24d6b1d74!3#3!5#38b3V3T4b35!1#16!3#9!1#5!6d1#3d3!2d3!4*4!11d2!3*4d9!3*116b3d4*5d85b5d6*12!4*1!15*12b4)56b8)10b6)40b8)30b2)12b4)2b62)12b1#2!1#8!8#6!1#9!10#1!1d3#7!1d48!1#61!2#1!2#1!1#17!3#1!13#34!84b12*14d2*13!3*10!5*52!3#1!7*15!2*11!6*9#7*240b10X6b1022*2b65534!2b65534!655363b1H30b96H128b240H196112b";
+var bmp = null;
+var astralStarts = null;
+var astralValues = null;
+function decode() {
+  const direct = new Uint8Array(65536);
+  const starts = new Int32Array(RUNS);
+  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 run = 0;
+  let len = 0;
+  for (let i = 0; i < PACKED.length; i++) {
+    const code = PACKED.charCodeAt(i);
+    if (code <= 57 && code >= 48) len = len * 10 + code - 48;
+    else {
+      const v = slot[code];
+      starts[run] = cp;
+      values[run] = v;
+      if (cp < 65536) direct.fill(v, cp, Math.min(cp + len, 65536));
+      run++;
+      cp += len;
+      len = 0;
+    }
+  }
+  bmp = direct;
+  astralStarts = starts;
+  astralValues = values;
+}
+function lineBreakPropsOf(cp) {
+  if (bmp === null) decode();
+  if (cp < 65536) return bmp[cp];
+  if (cp > 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;
+    else hi = mid - 1;
+  }
+  return astralValues[lo];
+}
+
+// src/layout/lineBreak/lineBreaks.ts
+var {
+  lineBreakPropsOf: lineBreakPropsOf2,
+  CLASS_MASK: CLASS_MASK2,
+  EAST_ASIAN: EAST_ASIAN2,
+  PICTOGRAPHIC_CN: PICTOGRAPHIC_CN2,
+  BK: BK2,
+  CR: CR2,
+  LF: LF2,
+  NL: NL2,
+  SP: SP2,
+  ZW: ZW2,
+  ZWJ: ZWJ2,
+  CM: CM2,
+  WJ: WJ2,
+  GL: GL2,
+  BA: BA2,
+  BB: BB2,
+  B2: B22,
+  HY: HY2,
+  CB: CB2,
+  CL: CL2,
+  CP: CP2,
+  EX: EX2,
+  IN: IN2,
+  NS: NS2,
+  OP: OP2,
+  QU: QU2,
+  IS: IS2,
+  NU: NU2,
+  PO: PO2,
+  PR: PR2,
+  SY: SY2,
+  AL: AL2,
+  HL: HL2,
+  ID: ID2,
+  EB: EB2,
+  EM: EM2,
+  H2: H22,
+  H3: H32,
+  JL: JL2,
+  JV: JV2,
+  JT: JT2,
+  RI: RI2,
+  AK: AK2,
+  AP: AP2,
+  AS: AS2,
+  VF: VF2,
+  VI: VI2,
+  QU_PI: QU_PI2,
+  QU_PF: QU_PF2
+} = lineBreakTable_exports;
+var NO_BREAK = 0;
+var BREAK_ALLOWED = 1;
+var BREAK_MANDATORY = 2;
+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);
+}
+var isAlpha = (c) => c === AL2 || c === HL2;
+var isKorean = (c) => c === JL2 || c === JV2 || c === JT2 || c === H22 || c === H32;
+var isIdeoLike = (c) => c === ID2 || c === EB2 || c === EM2;
+var newScratch = (n) => ({
+  cls: new Uint8Array(n),
+  ea: new Uint8Array(n),
+  pict: new Uint8Array(n),
+  cp: new Int32Array(n),
+  start: new Int32Array(n)
+});
+var SCRATCH_MAX = 1 << 16;
+var shared = newScratch(64);
+function growScratch(n) {
+  if (shared.cls.length < n) shared = newScratch(Math.min(SCRATCH_MAX, Math.max(n, shared.cls.length * 2)));
+  return shared;
+}
+function lineBreakOpportunities(cps) {
+  const n = cps.length;
+  const out = new Uint8Array(n + 1);
+  if (n === 0) 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;
+  let u = 0;
+  for (let i = 0; i < n; i++) {
+    const props = lineBreakPropsOf2(cps[i]);
+    const c = props & CLASS_MASK2;
+    if ((c === CM2 || c === ZWJ2) && u > 0) {
+      const base = cls[u - 1];
+      if (!isHard(base) && base !== SP2 && base !== ZW2) continue;
+    }
+    if (c === CM2 || c === ZWJ2) {
+      cls[u] = AL2;
+      ea[u] = 0;
+      pict[u] = 0;
+    } else {
+      cls[u] = c;
+      ea[u] = props & EAST_ASIAN2 ? 1 : 0;
+      pict[u] = props & PICTOGRAPHIC_CN2 ? 1 : 0;
+    }
+    cp[u] = cps[i];
+    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;
+  };
+  for (let b = 1; b < units; b++) {
+    out[start[b]] = decide(b);
+  }
+  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;
+      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 (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
+var registered2 = null;
+function registerBidi(engine) {
+  registered2 = engine;
+  return () => {
+    if (registered2 === engine) registered2 = null;
+  };
+}
+function registeredBidi() {
+  return registered2;
+}
+function directionOfLevel(level) {
+  return level % 2 === 1 ? "rtl" : "ltr";
+}
+function paragraphDirection(text, direction = "auto", engine = registered2) {
+  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]
+];
+function within(ranges, cp) {
+  for (let i = 0; i < ranges.length; i++) if (cp >= ranges[i][0] && cp <= ranges[i][1]) return true;
+  return false;
+}
+var warnedLogicalRtl = false;
+function warnRtlWithoutEngine(codePoints) {
+  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;
+    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;
+}
+var SHARED_ORDER_LIMIT = 1024;
+var logicalOrders = [];
+function logicalOrder(count) {
+  const known = logicalOrders[count];
+  if (known !== void 0) return known;
+  const order = {
+    visual: Array.from({ length: count }, (_, pos) => pos),
+    levels: new Array(count).fill(0)
+  };
+  if (count <= SHARED_ORDER_LIMIT) logicalOrders[count] = order;
+  return order;
+}
+function orderLine(paragraphs, start, count) {
+  if (paragraphs === null || count === 0) return logicalOrder(count);
+  const levels = new Array(count).fill(0);
+  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/layout/arrayPool.ts
+var TEMPLATE_LIMIT = 1 << 16;
+var template = [0.5];
+function doubles(n) {
+  if (n > TEMPLATE_LIMIT) return new Array(n).fill(0.5);
+  while (template.length < n) template = template.concat(template);
+  return template.slice(0, n);
+}
+var ARRAY_POOL_LIMIT = 1 << 18;
+var nums = /* @__PURE__ */ new Map();
+var refs = /* @__PURE__ */ new Map();
+var held = 0;
+function take(pool, n) {
+  const b = pool.get(n);
+  if (b === void 0 || b.n === 0) return void 0;
+  held -= n;
+  const a = b.items[--b.n];
+  b.items[b.n] = void 0;
+  return a;
+}
+function give(pool, a) {
+  const n = a.length;
+  if (n === 0 || held + n > ARRAY_POOL_LIMIT) return;
+  let b = pool.get(n);
+  if (b === void 0) pool.set(n, b = { items: [], n: 0 });
+  b.items[b.n++] = a;
+  held += n;
+}
+function takeDoubles(n) {
+  return take(nums, n) ?? doubles(n);
+}
+function takeRefs(n) {
+  return take(refs, n) ?? new Array(n);
+}
+function giveDoubles(a) {
+  give(nums, a);
+}
+function giveRefs(a) {
+  give(refs, a);
+}
+
+// src/layout/layoutColumns.ts
+var NUM = 13;
+var X = 0;
+var STEP = 1;
+var ADVANCE = 2;
+var FONT_SIZE = 3;
+var BASELINE = 4;
+var SRC_INDEX = 5;
+var SRC_END = 6;
+var CP3 = 7;
+var LEVEL = 8;
+var FLAGS = 9;
+var RUN = 10;
+var VISUAL = 11;
+var ROTATE = 12;
+var DRAWS_INK = 1;
+var CLUSTER_END = 2;
+var REF = 5;
+var EMPTY_NUM = [];
+var EMPTY_REF = [];
+var spare = [];
+var SPARE_MAX = 1024;
+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 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 = [];
+  /** The layout cache's record of who can still reach this layout: runs
+   *  arrays it is filed under, whether its structural list holds it, and
+   *  whether any caller was handed it to keep. Only a layout with none of the
+   *  three gives its arrays back. */
+  owners = 0;
+  listed = false;
+  pinned = false;
+  constructor(size) {
+    this.num = takeDoubles(size * NUM);
+    this.ref = takeRefs(size * REF);
+  }
+  /** 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);
+    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. */
+  recycle() {
+    giveDoubles(this.num);
+    const { ref } = this;
+    for (let i = 0; i < ref.length; i++) ref[i] = void 0;
+    giveRefs(ref);
+    this.num = EMPTY_NUM;
+    this.ref = EMPTY_REF;
+    this.paintings.length = 0;
+    this.owners = 0;
+    this.listed = false;
+    this.pinned = false;
+    if (spare.length < SPARE_MAX) spare.push(this);
+  }
+  /** Store code point `i`: entry `e`, set at `x` on a baseline at `baselineY`,
+   *  moving the pen `step`. */
+  set(i, e, level, x, step, baselineY) {
+    const n = i * NUM, r = i * REF;
+    const { num, ref } = this;
+    num[n + X] = x;
+    num[n + STEP] = step;
+    num[n + ADVANCE] = e.advance;
+    num[n + FONT_SIZE] = e.fontSize;
+    num[n + BASELINE] = baselineY;
+    num[n + SRC_INDEX] = e.srcIndex;
+    num[n + SRC_END] = e.srcEnd;
+    num[n + CP3] = e.cp;
+    num[n + LEVEL] = level;
+    num[n + RUN] = e.run;
+    num[n + ROTATE] = e.rotate;
+    num[n + FLAGS] = (e.drawsInk ? DRAWS_INK : 0) | (e.clusterEnd ? CLUSTER_END : 0);
+    ref[r] = e.resolved;
+    ref[r + 1] = e.metrics;
+    ref[r + 2] = e.font;
+    ref[r + 3] = e.glyph;
+    ref[r + 4] = e.shaped;
+  }
+  /** Lengthen code point `i`'s step by `by`: the kerning the pen takes after it. */
+  widen(i, by) {
+    this.num[i * NUM + STEP] += by;
+  }
+  /** 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;
+  }
+  /** Logical index, within its line, of the glyph at visual `slot`. */
+  visual(start, slot) {
+    return this.num[(start + 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;
+    const n = i * NUM, r = i * REF;
+    const { num, ref } = this;
+    out.run = num[n + RUN];
+    out.cell = pos;
+    out.cp = num[n + CP3];
+    out.fontSize = num[n + FONT_SIZE];
+    out.resolved = ref[r];
+    out.metrics = ref[r + 1];
+    out.font = ref[r + 2];
+    out.glyph = ref[r + 3];
+    out.shaped = ref[r + 4];
+    out.x = num[n + X];
+    out.baselineY = num[n + BASELINE];
+    out.advance = num[n + ADVANCE];
+    out.step = num[n + STEP];
+    out.rotate = num[n + ROTATE];
+    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;
+  }
+  /** Code point `start + pos`'s cell, as a new object. */
+  cell(start, pos) {
+    const n = (start + pos) * NUM;
+    const { num } = this;
+    const flags = num[n + FLAGS];
+    return {
+      srcIndex: num[n + SRC_INDEX],
+      srcEnd: num[n + SRC_END],
+      cp: num[n + CP3],
+      x: num[n + X],
+      advance: num[n + STEP],
+      level: num[n + LEVEL],
+      drawsInk: (flags & DRAWS_INK) !== 0,
+      clusterEnd: (flags & CLUSTER_END) !== 0
+    };
+  }
+};
+function blankGlyph() {
+  return {
+    run: 0,
+    cell: 0,
+    cp: 0,
+    fontSize: 0.5,
+    resolved: null,
+    metrics: null,
+    font: null,
+    glyph: null,
+    shaped: null,
+    x: 0.5,
+    baselineY: 0.5,
+    advance: 0.5,
+    step: 0.5,
+    rotate: 0.5
+  };
+}
+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) {
+    this.x0 = x0;
+    this.y0 = y0;
+    this.x1 = x1;
+    this.y1 = y1;
+    this.baselineY = baselineY;
+    this.srcEnd = srcEnd;
+    this.justified = justified;
+    this.#cols = cols;
+    this.#start = start;
+    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) {
+    this.x0 = x0;
+    this.y0 = y0;
+    this.x1 = x1;
+    this.y1 = y1;
+    this.baselineY = baselineY;
+    this.srcEnd = srcEnd;
+    this.justified = justified;
+    this.#start = start;
+    this.#count = count;
+    if (this.#viewed) {
+      this.#viewed = false;
+      Object.defineProperties(this, _LineBox.#views);
+    }
+    return this;
+  }
+  /** The columns a line reads; null for a line built by hand. */
+  static columns(line) {
+    return line instanceof _LineBox ? line.#cols : null;
+  }
+  /** Where a line built by layout starts in its columns; 0 for one built by hand. */
+  static start(line) {
+    return line instanceof _LineBox ? line.#start : 0;
+  }
+  /** How many code points the line holds, without building a view. */
+  static count(line) {
+    return line instanceof _LineBox ? line.#count : line.glyphs.length;
+  }
+  static #views = {
+    cells: lazy("cells", (l) => {
+      l.#viewed = true;
+      const out = new Array(l.#count);
+      for (let pos = 0; pos < l.#count; pos++) out[pos] = l.#cols.cell(l.#start, pos);
+      return out;
+    }),
+    glyphs: lazy("glyphs", (l) => {
+      l.#viewed = true;
+      const out = new Array(l.#count);
+      for (let slot = 0; slot < l.#count; slot++) {
+        out[slot] = l.#cols.glyph(l.#start, l.#cols.visual(l.#start, slot), blankGlyph());
+      }
+      return out;
+    })
+  };
+};
+function lazy(key, build) {
+  return {
+    enumerable: true,
+    configurable: true,
+    get() {
+      const value = build(this);
+      Object.defineProperty(this, key, { value, enumerable: true, configurable: true, writable: false });
+      return value;
+    }
+  };
+}
+
+// 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;
+  }
+  return segmenter;
+}
+function graphemeEnds(text, into) {
+  const out = into ?? [];
+  let n = 0;
+  if (!NEEDS_SEGMENTING.test(text)) {
+    for (let i = 1; i <= text.length; i++) out[n++] = i;
+  } else {
+    const seg = graphemeSegmenter();
+    if (seg) {
+      for (const s of seg.segment(text)) out[n++] = s.index + s.segment.length;
+    } else {
+      let at = 0;
+      for (const ch of text) out[n++] = at += ch.length;
+    }
+  }
+  out.length = n;
+  return out;
+}
+function graphemeCount(text) {
+  return graphemeEnds(text).length;
+}
+
+// src/layout/shapedRuns.ts
+var NOTHING_DRAWN = Object.freeze({ d: null, key: "", glyphs: Object.freeze([]), rtl: false, text: "" });
+var COVERED = Object.freeze({ cluster: NOTHING_DRAWN, advance: 0 });
+var slotsOf = /* @__PURE__ */ new WeakMap();
+var fmt = (v) => String(Math.round(v * 1e5) / 1e5);
+function shapeRun(run, resolved2, shaper) {
+  if (shaper === null) return null;
+  const face = shapeableBytes(resolved2);
+  if (face === null) return null;
+  const glyphs = shaper.shape(face, run.text, run.fontFeatures, run.lang);
+  let slots2 = slotsOf.get(glyphs);
+  if (slots2) return slots2;
+  slots2 = slotsFor(shaper, face, run.text, glyphs);
+  slotsOf.set(glyphs, slots2);
+  return slots2;
+}
+function slotsFor(shaper, face, text, glyphs) {
+  const slots2 = new Array(text.length);
+  const ends = graphemeEnds(text);
+  let g = 0;
+  let i = 0;
+  while (i < glyphs.length) {
+    const start = glyphs[i].cluster;
+    let j = i;
+    while (j < glyphs.length && glyphs[j].cluster === start) j++;
+    const end = j < glyphs.length ? glyphs[j].cluster : text.length;
+    while (g < ends.length && ends[g] <= start) 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);
+      const opens = share === 0 ? COVERED : { cluster: NOTHING_DRAWN, advance: share };
+      for (let at = start + 1, k = g; at < end; at++) {
+        const opening = k < ends.length && ends[k] === at;
+        if (opening) k++;
+        slots2[at] = opening ? opens : COVERED;
+      }
+    }
+    i = j;
+  }
+  return slots2;
+}
+function advanceOf(glyphs, from, to) {
+  let sum2 = 0;
+  for (let k = from; k < to; k++) sum2 += glyphs[k].advance;
+  return sum2;
+}
+function holdsNotdef(glyphs, from, to) {
+  for (let k = from; k < to; k++) if (glyphs[k].gid === 0) return true;
+  return false;
+}
+function clusterSlot(shaper, face, glyphs, from, to, text, shift, advance) {
+  const placed2 = [];
+  let pen = shift;
+  let d = "";
+  let key = "";
+  for (let k = from; k < to; k++) {
+    const g = glyphs[k];
+    const x = pen + g.dx, y = g.dy;
+    placed2.push({ gid: g.gid, x, y });
+    d += shaper.glyphD(face, g.gid, x, y) ?? "";
+    key += `${k === from ? "" : ";"}${g.gid}${x === 0 && y === 0 ? "" : `@${fmt(x)},${fmt(y)}`}`;
+    pen += g.advance;
+  }
+  return { cluster: { d: d.length > 0 ? d : null, key, glyphs: placed2, rtl: glyphs[from].rtl, text }, advance };
+}
+
+// src/layout/layoutEntries.ts
+var NONSPACING_MARK = /^[\p{Mn}\p{Me}]$/u;
+function measureRuns(runs, tabSize, pool, into, shaper = null) {
+  const entries = 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 metrics = metricsOf(resolved2);
+    if (!metrics) {
+      warnNoMetrics(run.fontFamily, run.fontWeight, run.fontStyle);
+      srcIndex += run.srcMap?.length ?? run.text.length;
+      prev = void 0;
+      continue;
+    }
+    const runBase = srcIndex;
+    const map = run.srcMap;
+    const clusterEnds = graphemeEnds(run.text, CLUSTER_ENDS);
+    const shaped = shapeRun(run, resolved2, shaper);
+    let cluster = 0;
+    let clusterStart = 0;
+    let color = null;
+    let at = 0;
+    const text = run.text;
+    while (at < text.length) {
+      const cp = text.codePointAt(at);
+      const len = cp > 65535 ? 2 : 1;
+      const slot = shaped?.[at];
+      const fontSize = run.sizeMap ? run.sizeMap[at] : run.fontSize;
+      if (at === clusterStart) {
+        color = resolveColorCluster(
+          resolved2,
+          run.fontFamily,
+          run.fontWeight,
+          run.fontStyle,
+          run.text.slice(at, clusterEnds[cluster])
+        );
+      }
+      const clusterEnd = at + len === 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 + 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
+      );
+      if (color) {
+        entries[n++] = clusterEnd ? ink(blank, color, 0, tracking) : blank;
+        prev = void 0;
+      } else if (isHardLineBreak(cp)) {
+        entries[n++] = 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[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;
+          blank.advance = advance;
+          blank.tracking = tracking;
+          blank.kerningBefore = kerningBefore;
+          prev = blank;
+          entries[n++] = prev;
+        }
+      } else if (slot !== void 0) {
+        entries[n++] = shape(blank, slot, tracking);
+        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;
+      }
+    }
+  }
+  entries.length = n;
+  return entries;
+}
+function isNonspacingMark(cp) {
+  return cp >= 768 && NONSPACING_MARK.test(String.fromCodePoint(cp));
+}
+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) {
+  const e = pool?.[i];
+  if (!e) {
+    const made = {
+      run,
+      cp,
+      fontSize,
+      lineSize,
+      baselineShift,
+      rotate,
+      srcIndex,
+      srcEnd,
+      clusterEnd,
+      resolved: resolved2,
+      metrics,
+      font: null,
+      glyph: null,
+      advance: 0,
+      tracking: 0,
+      kerningBefore: 0,
+      tab: void 0,
+      shaped: null,
+      drawsInk: false
+    };
+    if (pool && i < POOL_MAX) pool[i] = made;
+    return made;
+  }
+  e.run = run;
+  e.cp = cp;
+  e.fontSize = fontSize;
+  e.lineSize = lineSize;
+  e.baselineShift = baselineShift;
+  e.rotate = rotate;
+  e.srcIndex = srcIndex;
+  e.srcEnd = srcEnd;
+  e.clusterEnd = clusterEnd;
+  e.resolved = resolved2;
+  e.metrics = metrics;
+  e.font = null;
+  e.glyph = null;
+  e.advance = 0;
+  e.tracking = 0;
+  e.kerningBefore = 0;
+  e.tab = void 0;
+  e.shaped = null;
+  e.drawsInk = false;
+  return e;
+}
+function ink(e, hit, kerning, tracking) {
+  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) {
+  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) => {
+    const odd = levels[pos] % 2 === 1;
+    if (entry.shaped !== null && entry.shaped.rtl !== odd) {
+      const flipped = mirror(entry.cp);
+      if (flipped !== null && flipped !== entry.cp) entry = { ...entry, shaped: null };
+    }
+    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 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 hangs = (cp) => cp === 32 || cp === 9;
+function wrapLines(cps, maxWidth, widthOf) {
+  const lines = [];
+  wrapSpans(cps, maxWidth, widthOf, (start, end, wrapped) => {
+    lines.push({ start, end, wrapped });
+  });
+  return lines;
+}
+function wrapSpans(cps, maxWidth, widthOf, emit) {
+  const n = cps.length;
+  const breaks = Number.isFinite(maxWidth) ? lineBreakOpportunities(cps) : null;
+  let start = 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;
+      continue;
+    }
+    if (hangs(cp)) {
+      i++;
+      continue;
+    }
+    let j = i + 1;
+    let ink2 = i + 1;
+    while (j < n && !isHardLineBreak(cps[j]) && (!breaks || breaks[j] === NO_BREAK)) {
+      if (!hangs(cps[j])) ink2 = j + 1;
+      j++;
+    }
+    if (breaks && i > start && widthOf(start, ink2) > maxWidth) {
+      emit(start, i, true);
+      start = i;
+    }
+    i = j;
+  }
+  if (start < n) emit(start, n, false);
+}
+
+// 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 NONE = [];
+var cur = NONE;
+var sum = doubles(64);
+var tabs = [];
+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];
+}
+var stopOf = (k) => cur[k].tab;
+function tabbedWidth(start, end) {
+  return widthWithTabs(start, end, tabs, stopOf, flatWidth);
+}
+function pushSpan(start, 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.end = end;
+  line.wrapped = wrapped;
+  line.width = 0;
+  line.height = 0;
+  line.ascent = 0;
+  line.srcEnd = 0;
+  broken[i] = line;
+}
+function breakLines(entries, cps, maxWidth, lineHeight) {
+  if (sum.length < entries.length + 1) sum = doubles(entries.length + 1);
+  sum[0] = 0;
+  let tabCount = 0;
+  brokenCount = 0;
+  for (let k = 0; k < entries.length; k++) {
+    const e = entries[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 = 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];
+      line.height = brk.lineSize * lineHeight;
+      line.ascent = aboveBaseline(brk, lineHeight);
+      line.srcEnd = brk.srcIndex;
+      line.entries.length = 0;
+      continue;
+    }
+    const out = line.entries;
+    for (let k = line.start; k < line.end; k++) {
+      const e = entries[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;
+      line.width += e.kerningBefore + e.advance + e.tracking;
+      line.height = Math.max(line.height, e.lineSize * lineHeight);
+      line.ascent = Math.max(line.ascent, aboveBaseline(e, lineHeight));
+    }
+    out.length = line.end - line.start;
+    line.srcEnd = entries[line.end - 1].srcEnd;
+  }
+  return broken;
+}
+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;
+  }
+  return hung;
+}
+function wordGaps(entries) {
+  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);
+  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;
+}
+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);
+  const inkWidth = line.width - hung;
+  const slack = alignWidth - inkWidth;
+  const gaps = justify && line.wrapped && Number.isFinite(alignWidth) && slack > 0 ? wordGaps(entries) : 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 left = hangsLeft ? inkLeft - hung : inkLeft;
+  const lineBaselineY = y + line.ascent;
+  let penX = left;
+  let prevPos = -1;
+  let wide = -1;
+  let slot = 0;
+  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);
+    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);
+    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.inkWidth = inkWidth + spread;
+  return placed;
+}
+
+// src/layout/layoutOpts.ts
+function resolveLayoutOpts(opts, out = {
+  maxWidth: 0,
+  alignWidth: 0,
+  lineHeight: 0,
+  align: "left",
+  justify: false,
+  bidi: null,
+  shaper: null,
+  direction: "auto",
+  tabSize: 0
+}) {
+  out.maxWidth = opts.maxWidth;
+  out.alignWidth = opts.alignWidth ?? opts.maxWidth;
+  out.lineHeight = opts.lineHeight;
+  out.align = opts.align;
+  out.justify = opts.justify === true || opts.align === "justify";
+  out.bidi = layoutBidi(opts);
+  out.shaper = layoutShaper(opts);
+  out.direction = opts.direction ?? "auto";
+  out.tabSize = opts.tabSize ?? DEFAULT_TAB_SIZE;
+  return out;
+}
+function layoutBidi(opts) {
+  return opts.bidi ?? registeredBidi();
+}
+function layoutShaper(opts) {
+  return opts.shaper ?? registeredShaper();
+}
+
+// src/layout/layoutRuns.ts
+var ENTRY_POOL = [];
+var ENTRIES = [];
+var CPS = [];
+var OPTS = resolveLayoutOpts({ maxWidth: 0, lineHeight: 0, align: "left" });
+function layoutRuns(runs, opts) {
+  const {
+    maxWidth,
+    alignWidth,
+    lineHeight,
+    align,
+    justify,
+    bidi,
+    shaper,
+    direction,
+    tabSize
+  } = resolveLayoutOpts(opts, OPTS);
+  const entries = 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;
+  if (!bidi) warnRtlWithoutEngine(cps);
+  const broken2 = breakLines(entries, cps, maxWidth, lineHeight);
+  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;
+  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);
+    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,
+      cols,
+      start,
+      i
+    );
+    start += line.entries.length;
+    width = Math.max(width, placed2.inkWidth);
+    y += line.height;
+  }
+  lines.length = broken2.length;
+  return { lines, bounds: { width, height: y } };
+}
+
+// src/layout/glyphQuads.ts
+var QUAD_STRIDE = 11;
+function hasGlyphQuad(g) {
+  const { font, glyph } = g;
+  return font !== null && glyph !== null && glyph.width !== 0 && glyph.page >= 0;
+}
+function writeGlyphQuad(g, out, at) {
+  const font = g.font, glyph = g.glyph;
+  const scale = g.fontSize / g.metrics.size;
+  const x0 = g.x + glyph.xoffset * scale;
+  const y0 = g.baselineY + (glyph.yoffset - g.metrics.base) * scale;
+  out[at] = x0;
+  out[at + 1] = y0;
+  out[at + 2] = x0 + glyph.width * scale;
+  out[at + 3] = y0 + glyph.height * scale;
+  out[at + 4] = glyph.x / font.common.scaleW;
+  out[at + 5] = glyph.y / font.common.scaleH;
+  out[at + 6] = (glyph.x + glyph.width) / font.common.scaleW;
+  out[at + 7] = (glyph.y + glyph.height) / font.common.scaleH;
+  out[at + 8] = g.baselineY;
+  out[at + 9] = g.x;
+  out[at + 10] = g.rotate ?? 0;
+}
+var quadsViewed = /* @__PURE__ */ new WeakSet();
+var quadViews = {
+  quads: lazy("quads", (group) => {
+    quadsViewed.add(group);
+    const d = group.quadData;
+    const out = [];
+    for (let at = 0, k = 0; at < d.length; at += QUAD_STRIDE, k++) {
+      const q = {
+        x0: d[at],
+        y0: d[at + 1],
+        x1: d[at + 2],
+        y1: d[at + 3],
+        u0: d[at + 4],
+        v0: d[at + 5],
+        u1: d[at + 6],
+        v1: d[at + 7],
+        baselineY: d[at + 8],
+        penX: d[at + 9],
+        rotate: d[at + 10]
+      };
+      if (group.colorGlyphs) q.colorGlyph = group.colorGlyphs[k];
+      out.push(q);
+    }
+    return out;
+  })
+};
+var SYNTHETIC_BOLD_TOLERANCE = 5e-4;
+var CACHE_LIMIT = 4096;
+var cache = /* @__PURE__ */ new Map();
+var dCache = /* @__PURE__ */ new Map();
+function syntheticBoldOffset(resolved2) {
+  if (!resolved2.synthetic.bold) return null;
+  const { source } = resolved2;
+  if (source !== "atlas" && source !== "canvas") return null;
+  const { family, weight, style } = resolved2.resolved;
+  const growth = syntheticBoldGrowth(source, family, weight, style);
+  if (growth === void 0 || !(growth > 0)) return null;
+  return { growth, join: source === "atlas" ? "miter" : "round" };
+}
+function emboldenGlyph(em, d, resolved2) {
+  const offset = syntheticBoldOffset(resolved2);
+  if (offset === null) return em;
+  const key = `${offset.growth}|${offset.join}|${d}`;
+  let grown = cache.get(key);
+  if (grown) return grown;
+  grown = mergeRegion(
+    growRegion(em, offset.growth, { join: offset.join, tolerance: SYNTHETIC_BOLD_TOLERANCE }),
+    { tolerance: SYNTHETIC_BOLD_TOLERANCE }
+  );
+  if (cache.size >= CACHE_LIMIT) cache.clear();
+  cache.set(key, grown);
+  return grown;
+}
+function emboldenGlyphD(d, resolved2) {
+  const offset = syntheticBoldOffset(resolved2);
+  if (offset === null) return null;
+  const tag = `bold:${offset.growth}:${offset.join}`;
+  const key = `${tag}|${d}`;
+  let grown = dCache.get(key);
+  if (grown === void 0) {
+    grown = pathToD(emboldenGlyph(pathFromD(d), d, resolved2));
+    if (dCache.size >= CACHE_LIMIT) dCache.clear();
+    dCache.set(key, grown);
+  }
+  return { d: grown, tag };
+}
+function strokeOn(run, source) {
+  return source === "outline" && strokeHasInk(run.stroke) ? run.stroke : void 0;
+}
+function paintOf(run, source) {
+  return `${paintKey(run.fill?.paint)}|${strokeKey(strokeOn(run, source))}`;
+}
+function groupFor(runs, g, source) {
+  const { family, weight, style } = g.resolved.resolved;
+  const { synthetic } = g.resolved;
+  const page = source === "outline" ? 0 : g.glyph.page;
+  if (last.group !== null && last.run === g.run && last.source === source && last.page === page && last.family === family && last.weight === weight && last.style === style && last.bold === synthetic.bold && last.italic === synthetic.italic) {
+    return last.group;
+  }
+  const run = runs[g.run];
+  let group = null;
+  let paint = null;
+  for (let k = 0; k < slots.length; k++) {
+    const slot = slots[k];
+    const c = slot.group;
+    if (c.source !== source || c.page !== page || c.family !== family || c.weight !== weight || c.style !== style || c.synthetic.bold !== synthetic.bold || c.synthetic.italic !== synthetic.italic) continue;
+    if (slot.run !== g.run) {
+      paint ??= paintOf(run, source);
+      slot.paint ??= paintOf(runs[slot.run], source);
+      if (slot.paint !== paint) continue;
+    }
+    group = c;
+    break;
+  }
+  if (group === null) {
+    const stroke = strokeOn(run, source);
+    group = stroke === void 0 && source !== "color" ? spareGroups.pop() ?? null : null;
+    if (group !== null) {
+      group.family = family;
+      group.weight = weight;
+      group.style = style;
+      group.synthetic.bold = synthetic.bold;
+      group.synthetic.italic = synthetic.italic;
+      group.source = source;
+      group.page = page;
+      group.fill = run.fill;
+    } else {
+      group = Object.defineProperties({
+        family,
+        weight,
+        style,
+        synthetic: { bold: synthetic.bold, italic: synthetic.italic },
+        source,
+        page,
+        fill: run.fill,
+        quadData: NO_QUADS,
+        glyphs: []
+      }, quadViews);
+      if (stroke) group.stroke = stroke;
+      if (source === "color") group.colorGlyphs = [];
+    }
+    const i = slots.length;
+    let slot = slotPool[i];
+    if (slot === void 0) {
+      slot = { group, run: g.run, paint };
+      if (i < SLOT_POOL_MAX) slotPool[i] = slot;
+    } else {
+      slot.group = group;
+      slot.run = g.run;
+      slot.paint = paint;
+    }
+    slots.push(slot);
+  }
+  last.group = group;
+  last.run = g.run;
+  last.family = family;
+  last.weight = weight;
+  last.style = style;
+  last.bold = synthetic.bold;
+  last.italic = synthetic.italic;
+  last.source = source;
+  last.page = page;
+  return group;
+}
+var NO_QUADS = [];
+var spareGroups = [];
+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;
+  spareGroups.push(group);
+}
+var slots = [];
+var slotPool = [];
+var SLOT_POOL_MAX = 64;
+var last = {
+  group: null,
+  run: -1,
+  family: "",
+  weight: 0,
+  style: "normal",
+  bold: false,
+  italic: false,
+  source: "atlas",
+  page: 0
+};
+function takeGroups(out) {
+  for (let i = 0; i < slots.length; i++) {
+    out.push(slots[i].group);
+    slots[i].group = null;
+  }
+  slots.length = 0;
+  last.group = null;
+}
+
+// src/layout/paintRuns.ts
+function glyphOutlineD(g, run, minSize) {
+  const outlineOnly = g.resolved.source === "outline";
+  if (!outlineOnly) {
+    if (minSize === void 0) return null;
+    if (run.fontSize < minSize && !strokeHasInk(run.stroke)) return null;
+  }
+  const d = faceOutlineD(g);
+  if (d === null) return null;
+  const { family, weight, style } = g.resolved.resolved;
+  const key = g.shaped ? `${family}|${weight}|${style}|#${g.shaped.key}` : `${family}|${weight}|${style}|${g.cp}`;
+  if (outlineOnly || !g.resolved.synthetic.bold) return { d, key };
+  const bold = emboldenGlyphD(d, g.resolved);
+  return bold && { d: bold.d, key: `${key}|${bold.tag}` };
+}
+function faceOutlineD(g) {
+  if (g.shaped) return g.shaped.d;
+  if (g.glyph?.color) return null;
+  const { family, weight, style } = g.resolved.resolved;
+  if (g.resolved.source !== "outline" && g.glyph === null) return null;
+  return glyphOutline(family, weight, style, g.cp);
+}
+function runFaces(runs) {
+  const faces = runs.map((r) => faceMetricsOf(resolveFontVariant(r.fontFamily, r.fontWeight, r.fontStyle)));
+  return (run) => faces[run];
+}
+var isDecorated = (r) => r.underline || r.strikethrough || r.overline;
+var cursor = blankGlyph();
+var scratch = [];
+var SCRATCH_MAX2 = 1 << 14;
+function paintRuns(laid, runs, opts = {}) {
+  return paintRunsInto(laid, runs, opts, { groups: [], decorations: [] });
+}
+function paintRunsInto(laid, runs, opts, out) {
+  const { groups, decorations } = out;
+  groups.length = 0;
+  decorations.length = 0;
+  const faceOf = runs.some(isDecorated) ? runFaces(runs) : null;
+  const rulePaint = faceOf && ((run) => fillHasInk(runs[run].fill) ? paintKey(runs[run].fill.paint) : null);
+  let glyphCount = 0;
+  const { lines } = laid;
+  for (let i = 0; i < lines.length; i++) glyphCount += LineBox.count(lines[i]);
+  const need = glyphCount * QUAD_STRIDE;
+  if (need <= SCRATCH_MAX2 && scratch.length < need) scratch = doubles(need);
+  const buf = need <= SCRATCH_MAX2 ? scratch : doubles(need);
+  let sized = null;
+  let sizedAt = 0;
+  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 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];
+      rules?.add(g);
+      const run = runs[g.run];
+      const inks = cols !== null ? cols.drawsInk(start, 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) {
+        const placed2 = { ...outline, x: g.x, baselineY: g.baselineY, scale: g.fontSize };
+        if (g.rotate) placed2.rotate = g.rotate;
+        groupFor(runs, g, "outline").glyphs.push(placed2);
+        continue;
+      }
+      if (!hasGlyphQuad(g)) continue;
+      const group = groupFor(runs, g, g.glyph.color ? "color" : g.resolved.source);
+      if (sized === null) {
+        sized = group;
+        group.quadData = buf;
+      }
+      let quads = group.quadData;
+      if (quads === NO_QUADS) group.quadData = quads = [];
+      if (group === sized) {
+        writeGlyphQuad(g, quads, sizedAt);
+        sizedAt += QUAD_STRIDE;
+      } else {
+        writeGlyphQuad(g, quads, quads.length);
+      }
+      group.colorGlyphs?.push(g.glyph);
+    }
+    if (!rules) continue;
+    for (const rule of rules.end()) {
+      const { run, ...rect } = rule;
+      decorations.push({ ...rect, fill: runs[run].fill });
+    }
+  }
+  if (sized !== null && buf !== scratch) {
+    buf.length = sizedAt;
+  } else if (sized !== null) {
+    const quads = takeDoubles(sizedAt);
+    for (let k = 0; k < sizedAt; k++) quads[k] = scratch[k];
+    sized.quadData = quads;
+  }
+  takeGroups(groups);
+  return out;
+}
+var PAINT_CACHE_VARIANT_LIMIT = 32;
+var own = /* @__PURE__ */ new WeakMap();
+var shared2 = /* @__PURE__ */ new WeakMap();
+function listOf(laid) {
+  const cols = laid.lines.length > 0 ? LineBox.columns(laid.lines[0]) : null;
+  if (cols !== null) return cols.paintings;
+  let list = shared2.get(laid);
+  if (list === void 0) shared2.set(laid, list = []);
+  return list;
+}
+var spare2 = [];
+var SPARE_MAX2 = 1024;
+function painting(laid, runs, opts, generation, key, bucket) {
+  const p = spare2.pop();
+  if (p === void 0) {
+    return {
+      generation,
+      key,
+      bucket,
+      runs: key === null ? runs : null,
+      painted: paintRunsInto(laid, runs, opts, { groups: [], decorations: [] }),
+      pinned: false
+    };
+  }
+  p.generation = generation;
+  p.key = key;
+  p.bucket = bucket;
+  p.runs = key === null ? runs : null;
+  p.pinned = false;
+  paintRunsInto(laid, runs, opts, p.painted);
+  return p;
+}
+function outlineBucket(runs, min) {
+  if (min === void 0) return -1;
+  let n = 0;
+  for (let i = 0; i < runs.length; i++) {
+    const size = runs[i].fontSize;
+    if (!(size >= min)) continue;
+    let seen = false;
+    for (let j = 0; j < i && !seen; j++) seen = runs[j].fontSize === size;
+    if (!seen) n++;
+  }
+  return n;
+}
+function variantKey(runs, bucket) {
+  let out = `${bucket}`;
+  for (const r of runs) {
+    out += `|${r.underline ? 1 : 0}${r.strikethrough ? 1 : 0}${r.overline ? 1 : 0}${paintKey(r.fill?.paint)}|${strokeKey(r.stroke)}`;
+  }
+  return out;
+}
+function keyOf(p) {
+  if (p.key === null) {
+    p.key = variantKey(p.runs, p.bucket);
+    p.runs = null;
+  }
+  return p.key;
+}
+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 bucket = outlineBucket(runs, min);
+  if (mineHere && mine.painting.bucket === bucket) {
+    mine.min = min;
+    return handOut(mine.painting, use);
+  }
+  const list = listOf(laid);
+  let p = null;
+  if (list.length > 0) {
+    const key = variantKey(runs, bucket);
+    for (let i = 0; i < list.length; i++) {
+      const held2 = list[i];
+      if (held2.bucket !== bucket || keyOf(held2) !== key) continue;
+      list.splice(i, 1);
+      if (held2.generation === generation) p = held2;
+      break;
+    }
+    p ??= painting(laid, runs, opts, generation, key, bucket);
+  } else {
+    p = painting(laid, runs, opts, generation, null, bucket);
+  }
+  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);
+    }
+  }
+  return handOut(p, use);
+}
+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;
+  if (cols !== null) {
+    list = cols.paintings;
+  } else {
+    list = shared2.get(laid);
+    if (list === void 0) return;
+    shared2.delete(laid);
+  }
+  for (let i = 0; i < list.length; i++) {
+    const p = list[i];
+    if (p.pinned) continue;
+    const { groups } = p.painted;
+    for (let k = 0; k < groups.length; k++) {
+      const group = groups[k];
+      if (group.quadData.length > 0) giveDoubles(group.quadData);
+      group.quadData = NO_QUADS;
+      giveGroup(group);
+    }
+    groups.length = 0;
+    p.painted.decorations.length = 0;
+    p.runs = null;
+    p.key = null;
+    if (spare2.length < SPARE_MAX2) spare2.push(p);
+  }
+  list.length = 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;
+var same = (a, b) => a === b || a !== a && b !== b;
+function matches(v, opts, bidi) {
+  return same(v.maxWidth, opts.maxWidth) && same(v.alignWidth, opts.alignWidth ?? opts.maxWidth) && same(v.lineHeight, opts.lineHeight) && v.align === opts.align && v.justify === (opts.justify === true || opts.align === "justify") && v.direction === (opts.direction ?? "auto") && same(v.tabSize, opts.tabSize ?? DEFAULT_TAB_SIZE) && v.bidi === bidi && v.shaper === layoutShaper(opts);
+}
+var columnsOf = (laid) => laid.lines.length > 0 ? LineBox.columns(laid.lines[0]) : null;
+function handOut2(laid, use) {
+  if (use === "keep") {
+    const cols = columnsOf(laid);
+    if (cols !== null) cols.pinned = true;
+  }
+  return laid;
+}
+function release(laid) {
+  const cols = columnsOf(laid);
+  if (cols === null || cols.owners > 0 || cols.listed || cols.pinned) return;
+  recyclePaintings(laid);
+  cols.recycle();
+}
+var spareEntries = [];
+var spareVariants = [];
+var SPARE_MAX3 = 1024;
+function disown(vs) {
+  for (let i = 0; i < vs.length; i++) {
+    const v = vs[i];
+    const cols = columnsOf(v.laid);
+    if (cols !== null) {
+      cols.owners--;
+      release(v.laid);
+    }
+    v.laid = NO_LAYOUT;
+    if (spareVariants.length < SPARE_MAX3) spareVariants.push(v);
+  }
+  vs.length = 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;
+  v.lineHeight = opts.lineHeight;
+  v.align = opts.align;
+  v.justify = opts.justify === true || opts.align === "justify";
+  v.direction = opts.direction ?? "auto";
+  v.tabSize = opts.tabSize ?? DEFAULT_TAB_SIZE;
+  v.bidi = bidi;
+  v.shaper = layoutShaper(opts);
+  v.laid = laid;
+  return v;
+}
+function variant(opts, bidi, laid) {
+  const spare3 = spareVariants.pop();
+  if (spare3 !== void 0) return fill(spare3, opts, bidi, laid);
+  return {
+    maxWidth: opts.maxWidth,
+    alignWidth: opts.alignWidth ?? opts.maxWidth,
+    lineHeight: opts.lineHeight,
+    align: opts.align,
+    justify: opts.justify === true || opts.align === "justify",
+    direction: opts.direction ?? "auto",
+    tabSize: opts.tabSize ?? DEFAULT_TAB_SIZE,
+    bidi,
+    shaper: layoutShaper(opts),
+    laid
+  };
+}
+function mix(h, n) {
+  return Math.imul(h ^ n, 16777619);
+}
+function mixNum(h, x) {
+  return mix(h, x === (x | 0) ? x : Math.round(x * 4096));
+}
+function mixStr(h, s) {
+  h = mix(h, s.length);
+  for (let i = 0; i < s.length; i++) h = mix(h, s.charCodeAt(i));
+  return h;
+}
+function runsHash(runs) {
+  let h = mix(2166136261, runs.length);
+  for (let i = 0; i < runs.length; i++) {
+    const r = runs[i];
+    h = mixStr(h, r.text);
+    h = mixStr(h, r.fontFamily);
+    h = mixNum(h, r.fontSize);
+    h = mixNum(h, r.fontWeight);
+    h = mix(h, r.fontStyle === "italic" ? 1 : 0);
+    h = mixNum(h, r.letterSpacing);
+    h = mixNum(h, r.baselineShift);
+    h = mixNum(h, r.rotate ?? 0);
+    h = mixNum(h, r.strutSize ?? -1);
+    h = mix(h, r.fontFeatures?.length ?? 0);
+    h = mixStr(h, r.lang ?? "");
+  }
+  return h;
+}
+function sameNums(a, b) {
+  if (a === b) return true;
+  if (a === void 0 || b === void 0 || a.length !== b.length) return false;
+  for (let i = 0; i < a.length; i++) if (!same(a[i], b[i])) return false;
+  return true;
+}
+function sameStrs(a, b) {
+  if (a === b) return true;
+  if ((a?.length ?? 0) !== (b?.length ?? 0)) return false;
+  for (let i = 0; i < (a?.length ?? 0); i++) if (a[i] !== b[i]) return false;
+  return true;
+}
+function sameRuns(a, b) {
+  if (a.length !== b.length) return false;
+  for (let i = 0; i < a.length; i++) {
+    const x = a[i], y = b[i];
+    if (x === y) continue;
+    if (x.text !== y.text || x.fontFamily !== y.fontFamily || !same(x.fontSize, y.fontSize) || !same(x.fontWeight, y.fontWeight) || x.fontStyle !== y.fontStyle || !same(x.letterSpacing, y.letterSpacing) || !same(x.baselineShift, y.baselineShift) || !same(x.strutSize, y.strutSize) || !same(x.rotate ?? 0, y.rotate ?? 0) || !sameNums(x.sizeMap, y.sizeMap) || !sameStrs(x.fontFeatures, y.fontFeatures) || x.lang !== y.lang) return false;
+    const sx = x.srcMap, sy = y.srcMap;
+    if (sx !== sy && (sx === void 0 || sy === void 0 || sx.length !== sy.length || !sameNums(sx.starts, sy.starts))) return false;
+  }
+  return true;
+}
+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) {
+    entry.generation = fonts;
+    disown(entry.variants);
+  } else {
+    const vs2 = entry.variants;
+    for (let i = 0; i < vs2.length; i++) {
+      const v = vs2[i];
+      if (!matches(v, opts, bidi)) continue;
+      for (let k = i; k > 0; k--) vs2[k] = vs2[k - 1];
+      vs2[0] = v;
+      return handOut2(v.laid, use);
+    }
+  }
+  const laid = structuralLayout(runs, opts, bidi, fonts);
+  const vs = entry.variants;
+  if (vs.length >= LAYOUT_CACHE_VARIANT_LIMIT) disown(vs);
+  vs.unshift(variant(opts, bidi, laid));
+  const cols = columnsOf(laid);
+  if (cols !== null) cols.owners++;
+  return handOut2(laid, use);
+}
+function dropRuns(runs) {
+  const entry = cache2.get(runs);
+  forgetPaintRuns(runs);
+  if (entry === void 0) return;
+  cache2.delete(runs);
+  disown(entry.variants);
+  if (spareEntries.length < SPARE_MAX3) spareEntries.push(entry);
+}
+function structuralLayout(runs, opts, bidi, fonts) {
+  if (structuralGeneration !== fonts) {
+    for (const s of structural) unlist(s);
+    structural = [];
+    structuralGeneration = fonts;
+  }
+  const hash = runsHash(runs);
+  let oldest = 0;
+  for (let i = 0; i < structural.length; i++) {
+    const s = structural[i];
+    if (s.hash === hash && matches(s, opts, bidi) && sameRuns(s.runs, runs)) {
+      s.used = ++clock;
+      return s.laid;
+    }
+    if (s.used < structural[oldest].used) oldest = i;
+  }
+  const full = structural.length >= LAYOUT_CACHE_STRUCTURAL_LIMIT;
+  if (full) unlist(structural[oldest]);
+  const laid = layoutRuns(runs, opts);
+  const filled = full ? fill(structural[oldest], opts, bidi, laid) : structuralEntry(opts, bidi, laid);
+  filled.hash = hash;
+  filled.runs = runs;
+  filled.used = ++clock;
+  const cols = columnsOf(laid);
+  if (cols !== null) cols.listed = true;
+  if (!full) structural.push(filled);
+  return laid;
+}
+function structuralEntry(opts, bidi, laid) {
+  return fill({
+    maxWidth: 0,
+    alignWidth: 0,
+    lineHeight: 0,
+    align: "left",
+    justify: false,
+    direction: "auto",
+    tabSize: 0,
+    bidi: null,
+    shaper: null,
+    laid,
+    hash: 0,
+    runs: [],
+    used: 0
+  }, opts, bidi, laid);
+}
+function unlist(s) {
+  const cols = columnsOf(s.laid);
+  if (cols === null) return;
+  cols.listed = false;
+  release(s.laid);
+}
+function _resetLayoutCacheForTests() {
+  cache2 = /* @__PURE__ */ new WeakMap();
+  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