@weasel-js/text 1.7.0 → 1.7.2

package/dist/chunk-JQPOFIGT.js

@@ -0,0 +1,1207 @@
+import { resolveScreenLength } from '@weasel-js/paint';
+import { resolveFontVariant, faceMetricsOf, fontPending, glyphGeneration, glyphOutline, resolveGlyphFallback } from '@weasel-js/font';
+
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+function resolveAlign(align, direction) {
+  if (align === "start" || align === "justify") return direction === "rtl" ? "right" : "left";
+  if (align === "end") return direction === "rtl" ? "left" : "right";
+  return align;
+}
+var DEFAULT_FILL = { fill: "solid", color: "#000" };
+function paintColor(p) {
+  return p !== null && "color" in p ? p.color : "#000";
+}
+function defaultSelectionBackground(textColor) {
+  return `color-mix(in srgb, ${textColor} 25%, transparent)`;
+}
+var DEFAULT_TEXT_STYLE = {
+  fontSize: 16,
+  fontFamily: "sans-serif",
+  fontWeight: 400,
+  fontStyle: "normal",
+  align: "left",
+  direction: "ltr",
+  lineHeight: 1.2,
+  wrap: false,
+  fill: DEFAULT_FILL,
+  caretColor: paintColor(DEFAULT_FILL),
+  selectionBackground: defaultSelectionBackground(paintColor(DEFAULT_FILL)),
+  selectionColor: null,
+  letterSpacing: 0,
+  underline: false,
+  strikethrough: false,
+  overline: false,
+  textTransform: "none",
+  fontVariantCaps: "normal"
+};
+function resolveTextStyle(style, paint, scale = 1) {
+  const fill = paint?.fill === void 0 ? DEFAULT_TEXT_STYLE.fill : paint.fill;
+  const stroke = paint?.stroke ?? void 0;
+  if (!style) {
+    return fill === DEFAULT_TEXT_STYLE.fill && stroke === void 0 ? DEFAULT_TEXT_STYLE : {
+      ...DEFAULT_TEXT_STYLE,
+      fill,
+      caretColor: paintColor(fill),
+      selectionBackground: defaultSelectionBackground(paintColor(fill)),
+      ...stroke !== void 0 ? { stroke } : {}
+    };
+  }
+  const caretColor = style.caretColor ?? paintColor(fill);
+  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,
+    wrap: style.wrap ?? DEFAULT_TEXT_STYLE.wrap,
+    fill,
+    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 } : {},
+    ...stroke !== void 0 ? { stroke } : {}
+  };
+}
+function fontString(s) {
+  return `${s.fontStyle} ${s.fontWeight} ${s.fontSize}px ${s.fontFamily}`;
+}
+
+// src/layout/decorationMetrics.ts
+var DECORATION_KINDS = ["underline", "strikethrough", "overline"];
+var DEFAULT_DECORATION_METRICS = Object.freeze({
+  underline: Object.freeze({ offset: 0.1, thickness: 0.05 }),
+  strikethrough: Object.freeze({ offset: -0.3, thickness: 0.05 }),
+  overline: Object.freeze({ offset: -0.9, thickness: 0.05 })
+});
+var resolved = /* @__PURE__ */ new WeakMap();
+function decorationMetrics(face) {
+  if (!face) return DEFAULT_DECORATION_METRICS;
+  let out = resolved.get(face);
+  if (!out) {
+    const underline = face.underline ?? DEFAULT_DECORATION_METRICS.underline;
+    out = Object.freeze({
+      underline,
+      strikethrough: face.strikethrough ?? DEFAULT_DECORATION_METRICS.strikethrough,
+      overline: Object.freeze({ offset: DEFAULT_DECORATION_METRICS.overline.offset, thickness: underline.thickness })
+    });
+    resolved.set(face, out);
+  }
+  return out;
+}
+function decorationRule(kind, baselineY, fontSize, face) {
+  const m = decorationMetrics(face)[kind];
+  const y0 = baselineY + fontSize * m.offset;
+  return { y0, y1: y0 + fontSize * m.thickness };
+}
+
+// src/layout/lineBreak/lineBreakTable.ts
+var lineBreakTable_exports = {};
+__export(lineBreakTable_exports, {
+  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;
+function lineBreakOpportunities(cps) {
+  const n = cps.length;
+  const out = new Uint8Array(n + 1);
+  if (n === 0) return out;
+  out[n] = BREAK_MANDATORY;
+  const cls = new Uint8Array(n);
+  const ea = new Uint8Array(n);
+  const pict = new Uint8Array(n);
+  const cp = new Int32Array(n);
+  const start = new Int32Array(n);
+  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/measure/graphemes.ts
+var segmenter;
+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) {
+  const out = [];
+  const seg = graphemeSegmenter();
+  if (seg) {
+    for (const s of seg.segment(text)) out.push(s.index + s.segment.length);
+    return out;
+  }
+  let at = 0;
+  for (const ch of text) out.push(at += ch.length);
+  return out;
+}
+function graphemeCount(text) {
+  return graphemeEnds(text).length;
+}
+
+// src/layout/lineBreak/wrapLines.ts
+var SPACE = 32;
+function wrapLines(cps, maxWidth, widthOf) {
+  const n = cps.length;
+  const breaks = Number.isFinite(maxWidth) ? lineBreakOpportunities(cps) : null;
+  const lines = [];
+  let start = 0;
+  let i = 0;
+  while (i < n) {
+    const cp = cps[i];
+    if (isHardLineBreak(cp)) {
+      lines.push({ start, end: i, wrapped: false });
+      i += cp === 13 && cps[i + 1] === 10 ? 2 : 1;
+      start = i;
+      continue;
+    }
+    if (cp === SPACE) {
+      i++;
+      continue;
+    }
+    let j = i + 1;
+    let ink = i + 1;
+    while (j < n && !isHardLineBreak(cps[j]) && (!breaks || breaks[j] === NO_BREAK)) {
+      if (cps[j] !== SPACE) ink = j + 1;
+      j++;
+    }
+    if (breaks && i > start && widthOf(start, ink) > maxWidth) {
+      lines.push({ start, end: i, wrapped: true });
+      start = i;
+    }
+    i = j;
+  }
+  if (start < n) lines.push({ start, end: n, wrapped: false });
+  return lines;
+}
+
+// src/layout/layoutRuns.ts
+function atlasMetrics(font) {
+  const size = font.info.size;
+  const { ascent, descent } = font.faceMetrics ?? {};
+  return {
+    size,
+    base: font.common.base,
+    ...ascent !== void 0 && descent !== void 0 ? { ascent: ascent * size, descent: descent * size } : { ascent: font.common.base },
+    advanceOf: (cp) => font.charMap.get(cp)?.xadvance ?? null,
+    kernOf: (l, r) => font.kerningMap.get(l)?.get(r) ?? 0
+  };
+}
+function fillKey(p) {
+  if (p === null) return "none";
+  if ("color" in p) return `s:${p.color}:${p.opacity ?? 1}`;
+  return `nx:${Math.random()}`;
+}
+function sameFill(a, b) {
+  if (a === b) return true;
+  if (a !== null && b !== null && "color" in a && "color" in b) {
+    return a.color === b.color && (a.opacity ?? 1) === (b.opacity ?? 1);
+  }
+  return false;
+}
+function strokePaints(s) {
+  if (s?.paint === void 0) return false;
+  const w = s.width ?? 1;
+  return (typeof w === "number" ? w : w.px) > 0;
+}
+function strokeKey(s) {
+  if (!strokePaints(s)) return "-";
+  const width = s.width ?? 1;
+  return [
+    // A screen-pixel width keys apart from the equal world-unit number: the two
+    // resolve to different ribbons, so they must not share a draw call.
+    fillKey(s.paint),
+    typeof width === "number" ? width : `px${width.px}`,
+    s.join ?? "miter",
+    s.cap ?? "butt",
+    s.miterLimit ?? "",
+    s.align ?? "center",
+    (s.dash ?? []).join(",")
+  ].join(":");
+}
+function groupKey(family, weight, style, synthetic, fill, stroke, source, page) {
+  return `${family}|${weight}|${style}|${synthetic.bold ? 1 : 0}${synthetic.italic ? 1 : 0}|${fillKey(fill)}|${strokeKey(stroke)}|${source}|${page}`;
+}
+function getOrCreateGroup(ctx, run, resolved2, page, sourceOverride) {
+  const atlasFamily = resolved2.resolved.family;
+  const resolvedWeight = resolved2.resolved.weight;
+  const resolvedStyle = resolved2.resolved.style;
+  const source = sourceOverride ?? resolved2.source;
+  const key = groupKey(
+    atlasFamily,
+    resolvedWeight,
+    resolvedStyle,
+    resolved2.synthetic,
+    run.fill,
+    source === "outline" && strokePaints(run.stroke) ? run.stroke : void 0,
+    source,
+    page
+  );
+  let g = ctx.groups.get(key);
+  if (!g) {
+    g = {
+      family: atlasFamily,
+      weight: resolvedWeight,
+      style: resolvedStyle,
+      synthetic: { ...resolved2.synthetic },
+      source,
+      page,
+      fill: run.fill,
+      // Only the outline tier can paint it, and carrying it on an SDF group
+      // would be a promise the renderer cannot keep.
+      ...source === "outline" && strokePaints(run.stroke) ? { stroke: run.stroke } : {},
+      quads: [],
+      glyphs: []
+    };
+    ctx.groups.set(key, g);
+  }
+  return g;
+}
+function resolveGlyph(run, font, resolved2, cp) {
+  const direct = font.charMap.get(cp);
+  if (direct) return { glyph: direct, font, resolved: resolved2 };
+  const fallback = resolveGlyphFallback(run.fontFamily, run.fontWeight, run.fontStyle);
+  const face = fallback?.dynamicFace;
+  if (fallback && face) {
+    const glyph = face.requestGlyph(cp);
+    if (glyph.xadvance > 0 || glyph.width > 0) {
+      return { glyph, font: face.font, resolved: fallback };
+    }
+  }
+  warnMissingGlyphOnce(resolved2.resolved.family, cp);
+  return null;
+}
+var RTL_BLOCKS = [
+  [1424, 1535],
+  [1536, 1983],
+  [2144, 2303],
+  [64285, 65023],
+  [65136, 65279],
+  [67584, 69631],
+  [124928, 126975]
+];
+var warnedLogicalRtl = false;
+function warnLogicalRtlOnce() {
+  if (warnedLogicalRtl) return;
+  warnedLogicalRtl = true;
+  console.warn(
+    // Naming the import in `from "<pkg>"` form would trip labkit's
+    // consumer smoke test, which greps dist for that exact shape.
+    "weasel layoutRuns: this text contains right-to-left characters but no `bidi` engine was supplied, so it is being laid out in logical order \u2014 the glyphs will appear reversed. Import `bidi` out of the `@weasel-js/bidi` package and add it to the layout options."
+  );
+}
+var warnedMissingGlyphs = /* @__PURE__ */ new Set();
+function warnMissingGlyphOnce(family, cp) {
+  const key = `${family}|${cp}`;
+  if (warnedMissingGlyphs.has(key)) return;
+  warnedMissingGlyphs.add(key);
+  const ch = String.fromCodePoint(cp);
+  console.warn(
+    `weasel layoutRuns: no glyph for U+${cp.toString(16).toUpperCase().padStart(4, "0")} (${JSON.stringify(ch)}) in "${family}", and the dynamic tier could not rasterize it \u2014 skipping the character. Bake it into the atlas, or call registerCanvasFont("${family}") to serve missing codepoints from installed fonts.`
+  );
+}
+var warnedNoMetrics = /* @__PURE__ */ new Set();
+function warnNoMetricsOnce(family, weight, style) {
+  const key = `${family}|${weight}|${style}`;
+  if (warnedNoMetrics.has(key)) return;
+  warnedNoMetrics.add(key);
+  console.warn(
+    `weasel layoutRuns: no metrics for "${family}" ${weight}/${style} \u2014 neither an atlas nor an outline face resolved, so every run set in it lays out as nothing. Register it with registerFont / registerCanvasFont / registerFontOutlines. If you did, check for a duplicated @weasel-js/font in node_modules \u2014 its registry is module state, so a second copy is a second, empty one.`
+  );
+}
+function layoutRuns(runs, opts) {
+  const ctx = { groups: /* @__PURE__ */ new Map() };
+  const align = resolveAlign(opts.align, opts.direction ?? "ltr");
+  const justify = opts.justify === true || opts.align === "justify";
+  const lineSize = (e) => Math.max(e.run.fontSize, e.run.strutSize ?? 0);
+  const aboveBaseline = (e) => {
+    const k = lineSize(e) / e.metrics.size;
+    const ascent = e.metrics.ascent * k;
+    if (e.metrics.descent === void 0) return ascent;
+    return (lineSize(e) * opts.lineHeight - ascent - e.metrics.descent * k) / 2 + ascent;
+  };
+  const entries = [];
+  const runFaces = /* @__PURE__ */ new Map();
+  let prevCp;
+  let prevMetrics;
+  let prevFontSize;
+  let srcIndex = 0;
+  for (const run of runs) {
+    const resolved2 = resolveFontVariant(run.fontFamily, run.fontWeight, run.fontStyle);
+    runFaces.set(run, faceMetricsOf(resolved2));
+    const outlineFace = resolved2.outlineFace;
+    const font = resolved2.entry?.font ?? resolved2.dynamicFace?.font ?? null;
+    const metrics = outlineFace ? {
+      size: 1,
+      base: outlineFace.ascender,
+      ascent: outlineFace.faceMetrics?.ascent ?? outlineFace.ascender,
+      ...outlineFace.faceMetrics?.descent !== void 0 ? { descent: outlineFace.faceMetrics.descent } : {},
+      advanceOf: (cp) => outlineFace.advanceOf(cp),
+      kernOf: (l, r) => outlineFace.kernOf(l, r)
+    } : font ? atlasMetrics(font) : void 0;
+    if (!metrics) {
+      if (!fontPending(run.fontFamily, run.fontWeight, run.fontStyle)) {
+        warnNoMetricsOnce(run.fontFamily, run.fontWeight, run.fontStyle);
+      }
+      srcIndex += run.srcMap?.length ?? run.text.length;
+      prevCp = void 0;
+      prevMetrics = void 0;
+      prevFontSize = void 0;
+      continue;
+    }
+    const runBase = srcIndex;
+    const map = run.srcMap;
+    const sizes = run.sizeMap;
+    let at = 0;
+    const runTracking = run.letterSpacing;
+    const clusterEnds = runTracking === 0 ? null : new Set(graphemeEnds(run.text));
+    for (const ch of [...run.text]) {
+      const cp = ch.codePointAt(0);
+      const fontSize = sizes ? sizes[at] : run.fontSize;
+      const scale = fontSize / metrics.size;
+      const tracking = clusterEnds === null || clusterEnds.has(at + ch.length) ? runTracking : 0;
+      const isNewline = isHardLineBreak(cp);
+      const isSpace = cp === 32;
+      const srcStart = map ? runBase + map.starts[at] : runBase + at;
+      const srcEnd = map ? runBase + map.ends[at] : runBase + at + ch.length;
+      at += ch.length;
+      srcIndex = map ? runBase + map.length : srcEnd;
+      if (isNewline) {
+        entries.push({
+          run,
+          font,
+          metrics,
+          glyph: { id: cp, x: 0, y: 0, width: 0, height: 0, xoffset: 0, yoffset: 0, xadvance: 0, page: 0 },
+          // A newline consumes no advance, so it takes no tracking either.
+          cp,
+          advance: 0,
+          tracking: 0,
+          kerningBefore: 0,
+          isSpace: false,
+          isNewline: true,
+          drawsInk: false,
+          resolved: resolved2,
+          fontSize,
+          srcIndex: srcStart,
+          srcEnd,
+          flat: 0
+        });
+        prevCp = void 0;
+        prevMetrics = void 0;
+        prevFontSize = void 0;
+        continue;
+      }
+      if (isSpace) {
+        const spaceGlyph = resolved2.dynamicFace ? resolved2.dynamicFace.requestGlyph(32) : font?.charMap.get(32) ?? null;
+        const spaceAdvance = spaceGlyph ? spaceGlyph.xadvance : metrics.advanceOf(32);
+        const advance = spaceAdvance !== null ? spaceAdvance * scale : fontSize * 0.25;
+        let kerningBefore2 = 0;
+        if (prevCp !== void 0 && prevMetrics !== void 0 && prevFontSize !== void 0) {
+          kerningBefore2 = prevMetrics.kernOf(prevCp, cp) * (prevFontSize / prevMetrics.size);
+        }
+        entries.push({
+          run,
+          font,
+          metrics,
+          glyph: spaceGlyph ?? { id: 32, x: 0, y: 0, width: 0, height: 0, xoffset: 0, yoffset: 0, xadvance: 0, page: 0 },
+          cp,
+          advance,
+          tracking,
+          kerningBefore: kerningBefore2,
+          isSpace: true,
+          isNewline: false,
+          drawsInk: false,
+          resolved: resolved2,
+          fontSize,
+          srcIndex: srcStart,
+          srcEnd,
+          flat: 0
+        });
+        prevCp = cp;
+        prevMetrics = metrics;
+        prevFontSize = fontSize;
+        continue;
+      }
+      if (outlineFace) {
+        const adv = metrics.advanceOf(cp);
+        if (adv === null) {
+          entries.push({
+            run,
+            font: null,
+            metrics,
+            glyph: null,
+            cp,
+            advance: 0,
+            tracking: 0,
+            kerningBefore: 0,
+            isSpace,
+            isNewline: false,
+            drawsInk: false,
+            resolved: resolved2,
+            fontSize,
+            srcIndex: srcStart,
+            srcEnd,
+            flat: 0
+          });
+          prevCp = cp;
+          prevMetrics = metrics;
+          prevFontSize = fontSize;
+          continue;
+        }
+        let kerningBefore2 = 0;
+        if (prevCp !== void 0 && prevMetrics !== void 0 && prevFontSize !== void 0) {
+          kerningBefore2 = prevMetrics.kernOf(prevCp, cp) * (prevFontSize / prevMetrics.size);
+        }
+        entries.push({
+          run,
+          font: null,
+          metrics,
+          glyph: null,
+          cp,
+          advance: adv * scale,
+          tracking,
+          kerningBefore: kerningBefore2,
+          isSpace,
+          isNewline: false,
+          drawsInk: !isSpace,
+          resolved: resolved2,
+          fontSize,
+          srcIndex: srcStart,
+          srcEnd,
+          flat: 0
+        });
+        prevCp = cp;
+        prevMetrics = metrics;
+        prevFontSize = fontSize;
+        continue;
+      }
+      const hit = resolved2.dynamicFace ? { glyph: resolved2.dynamicFace.requestGlyph(cp), font, resolved: resolved2 } : resolveGlyph(run, font, resolved2, cp);
+      if (!hit) {
+        entries.push({
+          run,
+          font: null,
+          metrics,
+          glyph: null,
+          cp,
+          advance: 0,
+          tracking: 0,
+          kerningBefore: 0,
+          isSpace,
+          isNewline: false,
+          drawsInk: false,
+          resolved: resolved2,
+          fontSize,
+          srcIndex: srcStart,
+          srcEnd,
+          flat: 0
+        });
+        prevCp = cp;
+        prevMetrics = metrics;
+        prevFontSize = fontSize;
+        continue;
+      }
+      const glyphFont = hit.font;
+      const glyphMetrics = glyphFont === font ? metrics : atlasMetrics(glyphFont);
+      const glyphScale = fontSize / glyphFont.info.size;
+      let kerningBefore = 0;
+      if (prevCp !== void 0 && prevMetrics !== void 0 && prevFontSize !== void 0) {
+        kerningBefore = prevMetrics.kernOf(prevCp, cp) * (prevFontSize / prevMetrics.size);
+      }
+      entries.push({
+        run,
+        font: glyphFont,
+        metrics: glyphMetrics,
+        glyph: hit.glyph,
+        cp,
+        advance: hit.glyph.xadvance * glyphScale,
+        tracking,
+        kerningBefore,
+        isSpace,
+        isNewline: false,
+        drawsInk: !isSpace,
+        resolved: hit.resolved,
+        fontSize,
+        srcIndex: srcStart,
+        srcEnd,
+        flat: 0
+      });
+      prevCp = cp;
+      prevMetrics = glyphMetrics;
+      prevFontSize = fontSize;
+    }
+  }
+  for (let i = 0; i < entries.length; i++) entries[i].flat = i;
+  const analysis = opts.bidi ? opts.bidi.analyze(entries.map((e) => e.cp), opts.direction ?? "auto") : null;
+  if (!opts.bidi && entries.some((e) => RTL_BLOCKS.some(([lo, hi]) => e.cp >= lo && e.cp <= hi))) {
+    warnLogicalRtlOnce();
+  }
+  const openingWidth = (e) => e.isSpace ? 0 : e.advance + e.tracking;
+  const sum = new Float64Array(entries.length + 1);
+  for (let k = 0; k < entries.length; k++) {
+    const e = entries[k];
+    sum[k + 1] = sum[k] + e.kerningBefore + e.advance + e.tracking;
+  }
+  const widthOf = (start, end) => openingWidth(entries[start]) + sum[end] - sum[start + 1];
+  const lines = [];
+  for (const span2 of wrapLines(entries.map((e) => e.cp), opts.maxWidth, widthOf)) {
+    const line = { entries: [], width: 0, height: 0, ...span2.wrapped ? { wrapped: true } : {} };
+    if (span2.start === span2.end) {
+      const brk = entries[span2.end];
+      line.height = lineSize(brk) * opts.lineHeight;
+      line.blank = brk;
+    }
+    for (let k = span2.start; k < span2.end; k++) {
+      const e = entries[k];
+      const placed = k > span2.start ? e : e.isSpace ? { ...e, kerningBefore: 0, advance: 0, tracking: 0 } : { ...e, kerningBefore: 0 };
+      line.entries.push(placed);
+      line.width += placed.kerningBefore + placed.advance + placed.tracking;
+      line.height = Math.max(line.height, lineSize(e) * opts.lineHeight);
+    }
+    lines.push(line);
+  }
+  function outlineFor(e) {
+    const r0 = e.resolved.resolved;
+    if (e.resolved.source === "outline") {
+      return glyphOutline(r0.family, r0.weight, r0.style, e.cp);
+    }
+    const min = opts.outlineMinSize;
+    if (min === void 0) return null;
+    if (e.run.fontSize < min && !strokePaints(e.run.stroke)) return null;
+    if (e.resolved.synthetic.bold) return null;
+    const r = e.resolved.resolved;
+    return glyphOutline(r.family, r.weight, r.style, e.cp);
+  }
+  const decorations = [];
+  let span = null;
+  function flushSpan() {
+    const s = span;
+    span = null;
+    if (!s || s.x1 <= s.x0) return;
+    for (const kind of DECORATION_KINDS) {
+      if (!s[kind]) continue;
+      const { y0, y1 } = decorationRule(kind, s.baselineY, s.fontSize, s.face);
+      decorations.push({ kind, x0: s.x0, y0, x1: s.x1, y1, fill: s.fill });
+    }
+  }
+  const lineBoxes = [];
+  let penY = 0;
+  let maxLineWidth = 0;
+  const alignWidth = opts.alignWidth ?? opts.maxWidth;
+  for (const line of lines) {
+    let hung = 0;
+    for (let k = line.entries.length - 1; k >= 0; k--) {
+      const e = line.entries[k];
+      if (!e.isSpace) break;
+      hung += e.kerningBefore + e.advance + e.tracking;
+    }
+    const inkWidth = line.width - hung;
+    const gaps = /* @__PURE__ */ new Set();
+    let gapExtra = 0;
+    if (justify && line.wrapped && Number.isFinite(alignWidth) && alignWidth > inkWidth) {
+      let first = 0;
+      while (first < line.entries.length && line.entries[first].isSpace) first++;
+      let last = line.entries.length - 1;
+      while (last > first && line.entries[last].isSpace) last--;
+      for (let k = first + 1; k < last; k++) if (line.entries[k].isSpace) gaps.add(k);
+      if (gaps.size > 0) gapExtra = (alignWidth - inkWidth) / gaps.size;
+    }
+    const spread = gapExtra * gaps.size;
+    const alignShift = (() => {
+      if (spread > 0) return 0;
+      if (align === "left") return 0;
+      if (!Number.isFinite(alignWidth)) {
+        return align === "center" ? -inkWidth / 2 : -inkWidth;
+      }
+      const slack = alignWidth - inkWidth;
+      return align === "center" ? slack / 2 : slack;
+    })();
+    const lineX0 = alignShift;
+    let lineAscent = 0;
+    for (const e of line.entries) lineAscent = Math.max(lineAscent, aboveBaseline(e));
+    if (line.entries.length === 0 && line.blank) lineAscent = aboveBaseline(line.blank);
+    const lineBaselineY = penY + lineAscent;
+    const cells = new Array(line.entries.length);
+    const flatOf = line.entries.map((e) => e.flat);
+    const posOfFlat = /* @__PURE__ */ new Map();
+    flatOf.forEach((f, pos) => posOfFlat.set(f, pos));
+    let visual = line.entries.map((_, k) => k);
+    let levelOf = () => 0;
+    if (opts.bidi && analysis !== null && line.entries.length > 0) {
+      const from = flatOf[0];
+      const to = flatOf[flatOf.length - 1] + 1;
+      const r = opts.bidi.reorder(analysis, from, to);
+      const seen = /* @__PURE__ */ new Set();
+      const ordered = [];
+      for (const f of r.order) {
+        const pos = posOfFlat.get(f);
+        if (pos !== void 0 && !seen.has(pos)) {
+          ordered.push(pos);
+          seen.add(pos);
+        }
+      }
+      for (let k = 0; k < line.entries.length; k++) if (!seen.has(k)) ordered.push(k);
+      visual = ordered;
+      levelOf = (pos) => {
+        const l = r.levels[flatOf[pos] - from];
+        return typeof l === "number" && l >= 0 ? l : 0;
+      };
+    }
+    if (opts.bidi) {
+      for (let pos = 0; pos < line.entries.length; pos++) {
+        if (levelOf(pos) % 2 === 0) continue;
+        const e = line.entries[pos];
+        const m = opts.bidi.mirror(e.cp);
+        if (m === null || m === e.cp) continue;
+        if (e.font !== null) {
+          const hit = resolveGlyph(e.run, e.font, e.resolved, m);
+          if (!hit) continue;
+          e.glyph = hit.glyph;
+        }
+        e.cp = m;
+      }
+    }
+    let penX = lineX0;
+    let prevPos = -1;
+    for (const pos of visual) {
+      const e = line.entries[pos];
+      penX += prevPos < 0 ? 0 : pos === prevPos + 1 ? e.kerningBefore : prevPos === pos + 1 ? line.entries[prevPos].kerningBefore : 0;
+      prevPos = pos;
+      const step = e.advance + e.tracking + (gaps.has(pos) ? gapExtra : 0);
+      const cell = {
+        srcIndex: e.srcIndex,
+        srcEnd: e.srcEnd,
+        cp: e.cp,
+        x: penX,
+        advance: step,
+        level: levelOf(pos),
+        drawsInk: e.drawsInk
+      };
+      cells[pos] = cell;
+      const scale = e.fontSize / e.metrics.size;
+      const baselineY = lineBaselineY - (e.run.baselineShift ?? 0);
+      const decoFill = e.run.fill;
+      if (decoFill !== null && (e.run.underline || e.run.strikethrough || e.run.overline)) {
+        const face = runFaces.get(e.run);
+        if (span !== null && span.underline === e.run.underline && span.strikethrough === e.run.strikethrough && span.overline === e.run.overline && span.fontSize === e.run.fontSize && span.face === face && span.baselineY === baselineY && sameFill(span.fill, e.run.fill)) {
+          span.x1 = penX + step;
+        } else {
+          flushSpan();
+          span = {
+            underline: e.run.underline,
+            strikethrough: e.run.strikethrough,
+            overline: e.run.overline,
+            fill: decoFill,
+            // The run's size, not the glyph's: a small-caps word is one rule.
+            fontSize: e.run.fontSize,
+            face,
+            baselineY,
+            x0: penX,
+            x1: penX + step
+          };
+        }
+      } else {
+        flushSpan();
+      }
+      const outlineD = outlineFor(e);
+      if (e.run.fill === null && !(outlineD !== null && strokePaints(e.run.stroke))) {
+        penX += step;
+        continue;
+      }
+      if (outlineD !== null) {
+        const group2 = getOrCreateGroup(ctx, e.run, e.resolved, 0, "outline");
+        group2.glyphs.push({
+          d: outlineD,
+          key: `${e.resolved.resolved.family}|${e.resolved.resolved.weight}|${e.resolved.resolved.style}|${e.cp}`,
+          x: penX,
+          baselineY,
+          // Em space is unit-scale, so world units per em is just the size.
+          scale: e.fontSize
+        });
+        penX += step;
+        continue;
+      }
+      if (e.font === null || e.glyph === null || e.advance === 0 || e.glyph.width === 0 || e.glyph.page < 0) {
+        penX += step;
+        continue;
+      }
+      const group = getOrCreateGroup(ctx, e.run, e.resolved, e.glyph.page);
+      const atlasW = e.font.common.scaleW;
+      const atlasH = e.font.common.scaleH;
+      const qx0 = penX + e.glyph.xoffset * scale;
+      const qy0 = baselineY + (e.glyph.yoffset - e.metrics.base) * scale;
+      const qx1 = qx0 + e.glyph.width * scale;
+      const qy1 = qy0 + e.glyph.height * scale;
+      const u0 = e.glyph.x / atlasW;
+      const v0 = e.glyph.y / atlasH;
+      const u1 = (e.glyph.x + e.glyph.width) / atlasW;
+      const v1 = (e.glyph.y + e.glyph.height) / atlasH;
+      group.quads.push({ x0: qx0, y0: qy0, x1: qx1, y1: qy1, u0, v0, u1, v1, baselineY });
+      penX += step;
+    }
+    flushSpan();
+    const lastCell = line.entries[line.entries.length - 1];
+    const srcEnd = lastCell ? lastCell.srcEnd : line.blank?.srcIndex ?? 0;
+    lineBoxes.push({
+      x0: lineX0,
+      y0: penY,
+      x1: lineX0 + line.width + spread,
+      y1: penY + line.height,
+      baselineY: lineBaselineY,
+      cells,
+      srcEnd
+    });
+    maxLineWidth = Math.max(maxLineWidth, inkWidth + spread);
+    penY += line.height;
+  }
+  return {
+    groups: [...ctx.groups.values()],
+    decorations,
+    lines: lineBoxes,
+    bounds: { width: maxLineWidth, height: penY }
+  };
+}
+var LAYOUT_CACHE_VARIANT_LIMIT = 8;
+var LAYOUT_CACHE_STRUCTURAL_LIMIT = 64;
+var cache = /* @__PURE__ */ new WeakMap();
+var structural = /* @__PURE__ */ new Map();
+var structuralGeneration = -1;
+function outlineBucket(runs, min) {
+  if (min === void 0) return -1;
+  const sizes = /* @__PURE__ */ new Set();
+  for (const r of runs) sizes.add(r.fontSize);
+  let n = 0;
+  for (const size of sizes) if (size >= min) n++;
+  return n;
+}
+function variantKey(runs, opts) {
+  const alignWidth = opts.alignWidth ?? opts.maxWidth;
+  const justify = opts.justify === true || opts.align === "justify";
+  return `${opts.maxWidth}|${alignWidth}|${opts.lineHeight}|${opts.align}|${justify ? "j" : ""}|${outlineBucket(runs, opts.outlineMinSize)}`;
+}
+var nextRefId = 1;
+var refIds = /* @__PURE__ */ new WeakMap();
+function refId(o) {
+  let id = refIds.get(o);
+  if (id === void 0) {
+    id = nextRefId++;
+    refIds.set(o, id);
+  }
+  return id;
+}
+function paintKey(p) {
+  if (p === null) return "none";
+  return "color" in p ? `s${p.color}:${p.opacity ?? 1}` : `#${refId(p)}`;
+}
+function strokeKey2(s) {
+  if (!s?.paint) return "-";
+  const width = s.width ?? 1;
+  return [
+    paintKey(s.paint),
+    typeof width === "number" ? width : `px${width.px}`,
+    s.join ?? "miter",
+    s.cap ?? "butt",
+    s.miterLimit ?? "",
+    s.align ?? "center",
+    (s.dash ?? []).join(",")
+  ].join(":");
+}
+function runsKey(runs) {
+  let out = "";
+  for (const r of runs) {
+    out += `${r.text.length}:${r.text}|${r.fontFamily.length}:${r.fontFamily}|${r.fontSize}|${r.fontWeight}|${r.fontStyle}|${r.letterSpacing}|${r.underline ? 1 : 0}${r.strikethrough ? 1 : 0}${r.overline ? 1 : 0}|${r.baselineShift}|${paintKey(r.fill)}|${strokeKey2(r.stroke)}|${r.srcMap ? `${r.srcMap.length}:${r.srcMap.starts.join(",")}` : ""}|${r.sizeMap ? r.sizeMap.join(",") : ""}|`;
+  }
+  return out;
+}
+function cachedLayoutRuns(runs, opts) {
+  const fonts = glyphGeneration();
+  let entry = cache.get(runs);
+  if (entry === void 0) {
+    entry = { generation: fonts, byVariant: /* @__PURE__ */ new Map() };
+    cache.set(runs, entry);
+  } else if (entry.generation !== fonts) {
+    entry.generation = fonts;
+    entry.byVariant.clear();
+  }
+  const key = variantKey(runs, opts);
+  const hit = entry.byVariant.get(key);
+  if (hit !== void 0) return hit;
+  if (structuralGeneration !== fonts) {
+    structural.clear();
+    structuralGeneration = fonts;
+  }
+  const structuralK = `${runsKey(runs)}\0${key}`;
+  let laid = structural.get(structuralK);
+  if (laid !== void 0) {
+    structural.delete(structuralK);
+  } else {
+    laid = layoutRuns(runs, opts);
+    if (structural.size >= LAYOUT_CACHE_STRUCTURAL_LIMIT) {
+      structural.delete(structural.keys().next().value);
+    }
+  }
+  structural.set(structuralK, laid);
+  if (entry.byVariant.size >= LAYOUT_CACHE_VARIANT_LIMIT) entry.byVariant.clear();
+  entry.byVariant.set(key, laid);
+  return laid;
+}
+function _resetLayoutCacheForTests() {
+  cache = /* @__PURE__ */ new WeakMap();
+  structural = /* @__PURE__ */ new Map();
+  structuralGeneration = -1;
+}
+
+export { BREAK_ALLOWED, BREAK_MANDATORY, DECORATION_KINDS, DEFAULT_DECORATION_METRICS, DEFAULT_TEXT_STYLE, LAYOUT_CACHE_STRUCTURAL_LIMIT, LAYOUT_CACHE_VARIANT_LIMIT, NO_BREAK, _resetLayoutCacheForTests, cachedLayoutRuns, decorationMetrics, decorationRule, fontString, graphemeCount, isHardLineBreak, layoutRuns, lineBreakOpportunities, resolveAlign, resolveTextStyle, wrapLines };
+//# sourceMappingURL=chunk-JQPOFIGT.js.map
+//# sourceMappingURL=chunk-JQPOFIGT.js.map