@vyaz/core 0.0.8 → 0.0.10

package/dist/index.js

@@ -1,4 +1,1643 @@
 // @bun
+var __defProp = Object.defineProperty;
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: __exportSetter.bind(all, name)
+    });
+};
+var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
+var __require = import.meta.require;
+
+// src/measure/canvas-polyfill.ts
+var exports_canvas_polyfill = {};
+__export(exports_canvas_polyfill, {
+  registerCanvasFont: () => registerCanvasFont,
+  enableOfficeTextMeasure: () => enableOfficeTextMeasure,
+  disableOfficeTextMeasure: () => disableOfficeTextMeasure
+});
+async function _initNodeDeps() {
+  try {
+    const m = await import("module");
+    _require = m.createRequire(import.meta.url);
+    const canvas = _require("@napi-rs/canvas");
+    _createCanvas = canvas.createCanvas;
+  } catch {
+    _createCanvas = null;
+  }
+}
+function needsCanvasPolyfill() {
+  if (typeof globalThis.document === "undefined")
+    return true;
+  try {
+    const el = globalThis.document.createElement("canvas");
+    if (!el || typeof el.getContext !== "function")
+      return true;
+    return false;
+  } catch {
+    return true;
+  }
+}
+function parseFont(fontStr) {
+  const pxMatch = fontStr.match(/(\d+(?:\.\d+)?)px\s+(.+)/);
+  if (!pxMatch)
+    return null;
+  const size = parseFloat(pxMatch[1]);
+  const family = pxMatch[2].trim();
+  const weightMatch = fontStr.match(/\b(bold|italic|\d{3})\b/);
+  const weight = weightMatch ? weightMatch[1] === "bold" ? "bold" : weightMatch[1] : "normal";
+  return { family, size, weight };
+}
+function cacheKey(family, weight) {
+  return `${family}_${weight}_normal`;
+}
+function officeMeasureText(text) {
+  if (!officeFontCache) {
+    return originalMeasureText?.call(this, text) ?? createEmptyMetrics();
+  }
+  const parsed = parseFont(this.font);
+  if (!parsed) {
+    return originalMeasureText?.call(this, text) ?? createEmptyMetrics();
+  }
+  const key = cacheKey(parsed.family, parsed.weight);
+  const fontFace = officeFontCache.get(key);
+  if (!fontFace) {
+    return originalMeasureText?.call(this, text) ?? createEmptyMetrics();
+  }
+  const raw = fontFace._raw;
+  const scale = parsed.size / fontFace.unitsPerEm;
+  let totalWidth = 0;
+  for (let i = 0;i < text.length; i++) {
+    const codePoint = text.codePointAt(i);
+    const glyph = raw.glyphForCodePoint(codePoint);
+    if (glyph) {
+      totalWidth += glyph.advanceWidth * scale;
+    } else {
+      if (originalMeasureText) {
+        return originalMeasureText.call(this, text);
+      }
+      totalWidth += parsed.size * 0.5;
+    }
+    if (codePoint > 65535)
+      i++;
+  }
+  return createMetricsObject(totalWidth);
+}
+function createMetricsObject(width) {
+  return {
+    width,
+    actualBoundingBoxAscent: 0,
+    actualBoundingBoxDescent: 0,
+    fontBoundingBoxAscent: 0,
+    fontBoundingBoxDescent: 0,
+    actualBoundingBoxLeft: 0,
+    actualBoundingBoxRight: width
+  };
+}
+function createEmptyMetrics() {
+  return createMetricsObject(0);
+}
+function registerCanvasFont(fontPath, family) {
+  if (!_require)
+    return;
+  try {
+    const mod = _require("@napi-rs/canvas");
+    if (mod?.registerFont) {
+      mod.registerFont(fontPath, { family });
+    }
+  } catch {}
+}
+function enableOfficeTextMeasure(fontCache) {
+  if (officeEnabled)
+    return;
+  officeFontCache = fontCache;
+  officeEnabled = true;
+  const CtxProto = globalThis.CanvasRenderingContext2D?.prototype;
+  if (CtxProto && originalMeasureText) {
+    CtxProto.measureText = officeMeasureText;
+  }
+}
+function disableOfficeTextMeasure() {
+  if (!officeEnabled)
+    return;
+  officeEnabled = false;
+  officeFontCache = null;
+  const CtxProto = globalThis.CanvasRenderingContext2D?.prototype;
+  if (CtxProto && originalMeasureText) {
+    CtxProto.measureText = originalMeasureText;
+  }
+}
+var _process, _require = null, _createCanvas = null, originalMeasureText, officeFontCache = null, officeEnabled = false;
+var init_canvas_polyfill = __esm(async () => {
+  _process = typeof globalThis !== "undefined" ? globalThis.process : undefined;
+  if (_process && (_process.versions?.node || _process.versions?.bun)) {
+    await _initNodeDeps();
+  }
+  if (needsCanvasPolyfill()) {
+    globalThis.document = {
+      createElement: (tag) => {
+        if (tag === "canvas" && _createCanvas)
+          return _createCanvas(1, 1);
+        return {};
+      }
+    };
+  }
+  if (typeof globalThis.OffscreenCanvas === "undefined" && _createCanvas) {
+    globalThis.OffscreenCanvas = class OffscreenCanvasShim {
+      _canvas;
+      _w;
+      _h;
+      constructor(width, height) {
+        this._w = width;
+        this._h = height;
+        this._canvas = _createCanvas(width, height);
+      }
+      get width() {
+        return this._w;
+      }
+      set width(v) {
+        this._w = v;
+        this._canvas.width = v;
+      }
+      get height() {
+        return this._h;
+      }
+      set height(v) {
+        this._h = v;
+        this._canvas.height = v;
+      }
+      getContext(type, attrs) {
+        return this._canvas.getContext(type, attrs);
+      }
+      async convertToBlob({ type: _type } = {}) {
+        const buffer = this._canvas.toBuffer("image/png");
+        return new Blob([buffer], { type: "image/png" });
+      }
+    };
+  }
+  originalMeasureText = globalThis.CanvasRenderingContext2D?.prototype?.measureText;
+});
+
+// src/measure/FontEngine.ts
+var exports_FontEngine = {};
+__export(exports_FontEngine, {
+  isFontEngineAvailable: () => isFontEngineAvailable,
+  getGlyphAdvance: () => getGlyphAdvance,
+  createFontFace: () => createFontFace,
+  computePixelMetrics: () => computePixelMetrics
+});
+async function _getFontkit() {
+  if (_fontkitModule)
+    return _fontkitModule;
+  const mod = await import("fontkit");
+  _fontkitModule = mod.default || mod;
+  return _fontkitModule;
+}
+function _extractMetrics(raw) {
+  const os2 = raw["OS/2"];
+  return {
+    unitsPerEm: raw.unitsPerEm,
+    ascent: raw.ascent,
+    descent: raw.descent,
+    capHeight: raw.capHeight ?? raw.ascent,
+    winAscent: os2?.winAscent ?? null,
+    winDescent: os2?.winDescent ?? null
+  };
+}
+function _getGlyph(raw, codePoint) {
+  return raw.glyphForCodePoint(codePoint) ?? null;
+}
+async function createFontFace(buffer) {
+  const fontkit = await _getFontkit();
+  const raw = fontkit.create(buffer);
+  const metrics = _extractMetrics(raw);
+  return {
+    _raw: raw,
+    ...metrics
+  };
+}
+function getGlyphAdvance(font, codePoint) {
+  const glyph = _getGlyph(font._raw, codePoint);
+  if (!glyph)
+    return null;
+  return glyph.advanceWidth;
+}
+function computePixelMetrics(font, fontSize, mode) {
+  const scale = fontSize / font.unitsPerEm;
+  if (mode === "office" && font.winAscent != null && font.winDescent != null) {
+    return {
+      ascent: font.winAscent * scale * 1.078,
+      descent: Math.abs(font.winDescent) * scale * 1.078,
+      capHeight: (font.capHeight ?? font.ascent) * scale,
+      unitsPerEm: font.unitsPerEm,
+      sourceTable: "OS/2"
+    };
+  }
+  return {
+    ascent: font.ascent * scale,
+    descent: Math.abs(font.descent) * scale,
+    capHeight: (font.capHeight ?? font.ascent) * scale,
+    unitsPerEm: font.unitsPerEm,
+    sourceTable: "hhea"
+  };
+}
+async function isFontEngineAvailable() {
+  try {
+    const fk = await _getFontkit();
+    return typeof fk.create === "function";
+  } catch {
+    return false;
+  }
+}
+var _fontkitModule = null;
+
+// src/utils/font.ts
+var exports_font = {};
+__export(exports_font, {
+  getFontBuffer: () => getFontBuffer
+});
+async function getFontBuffer(fontUrl) {
+  const response = await fetch(fontUrl);
+  if (!response.ok) {
+    throw new Error(`[vyaz] Failed to download font from "${fontUrl}": ${response.status} ${response.statusText}`);
+  }
+  const buffer = await response.arrayBuffer();
+  return buffer;
+}
+
+// src/types/Document.ts
+var DEFAULT_PARAGRAPH_STYLE = {
+  alignment: "left",
+  lineHeight: 1.15,
+  spaceBefore: 0,
+  spaceAfter: 0,
+  whiteSpace: "normal"
+};
+var DEFAULT_TEXT_STYLE = {
+  fontFamily: "Arial",
+  fontSize: 12,
+  fontWeight: "normal",
+  fontStyle: "normal",
+  color: "#000000"
+};
+
+// src/utils/textTransform.ts
+function transformText(text, transform) {
+  if (!transform || transform === "none" || !text) {
+    return text;
+  }
+  switch (transform) {
+    case "uppercase":
+      return text.toUpperCase();
+    case "lowercase":
+      return text.toLowerCase();
+    case "capitalize": {
+      const segments = text.split(/([^\p{L}']+)/u);
+      const result = new Array(segments.length);
+      for (let i = 0;i < segments.length; i++) {
+        const seg = segments[i];
+        if (!seg) {
+          result[i] = seg;
+          continue;
+        }
+        if (/^[^\p{L}']+$/u.test(seg)) {
+          result[i] = seg;
+          continue;
+        }
+        const firstLetter = seg.match(/\p{L}/u);
+        if (!firstLetter) {
+          result[i] = seg;
+          continue;
+        }
+        const idx = firstLetter.index;
+        const before = seg.slice(0, idx);
+        const letter = seg[idx].toUpperCase();
+        const after = seg.slice(idx + 1);
+        result[i] = `${before}${letter}${after}`;
+      }
+      return result.join("");
+    }
+    default:
+      return text;
+  }
+}
+
+// src/compile/DocumentCompiler.ts
+var FONT_WEIGHTS = {
+  thin: 100,
+  hairline: 100,
+  ultralight: 200,
+  extralight: 200,
+  light: 300,
+  normal: 400,
+  medium: 500,
+  semibold: 600,
+  demibold: 600,
+  bold: 700,
+  ultrabold: 800,
+  extrabold: 800,
+  heavy: 900,
+  black: 900
+};
+function normalizeFontWeight(weight) {
+  if (weight == null)
+    return FONT_WEIGHTS.normal;
+  if (typeof weight === "number")
+    return weight;
+  return FONT_WEIGHTS[weight.toLowerCase()] ?? FONT_WEIGHTS.normal;
+}
+function makeFontToken(run, effectiveFontSize) {
+  const fontStyle = run.fontStyle || DEFAULT_TEXT_STYLE.fontStyle || "normal";
+  const fontWeight = normalizeFontWeight(run.fontWeight ?? DEFAULT_TEXT_STYLE.fontWeight);
+  const fontFamily = run.fontFamily || DEFAULT_TEXT_STYLE.fontFamily || "Arial";
+  return `${fontStyle} ${fontWeight} ${effectiveFontSize}px ${fontFamily}`;
+}
+var SUPER_SUB_SCALE = 0.65;
+var SUPER_OFFSET_RATIO = -0.4;
+var SUB_OFFSET_RATIO = 0.25;
+var COLLAPSIBLE_WS_RE = /[ \t\f\r]+/g;
+function collapseSegmentWhitespace(segment) {
+  return segment.replace(COLLAPSIBLE_WS_RE, " ").trim();
+}
+function compileParagraph(paragraph) {
+  const items = [];
+  for (let i = 0;i < paragraph.children.length; i++) {
+    const run = paragraph.children[i];
+    const baseFontSize = run.fontSize ?? DEFAULT_TEXT_STYLE.fontSize ?? 12;
+    let effectiveFontSize = baseFontSize;
+    let baselineOffset = 0;
+    if (run.script === "super") {
+      effectiveFontSize = baseFontSize * SUPER_SUB_SCALE;
+      baselineOffset = baseFontSize * SUPER_OFFSET_RATIO;
+    } else if (run.script === "sub") {
+      effectiveFontSize = baseFontSize * SUPER_SUB_SCALE;
+      baselineOffset = baseFontSize * SUB_OFFSET_RATIO;
+    }
+    const rawText = run.type === "inline-box" ? "\uFFFC" : run.text;
+    const textTransformValue = run.textTransform;
+    const text = transformText(rawText, textTransformValue);
+    const resolvedFontWeight = normalizeFontWeight(run.fontWeight ?? DEFAULT_TEXT_STYLE.fontWeight);
+    const resolvedStyle = {
+      ...DEFAULT_TEXT_STYLE,
+      ...run,
+      fontSize: effectiveFontSize,
+      fontWeight: resolvedFontWeight,
+      text: run.text,
+      type: run.type
+    };
+    const item = {
+      text,
+      font: makeFontToken(run, effectiveFontSize),
+      letterSpacing: run.letterSpacing,
+      ...text !== rawText ? { originalText: rawText } : {},
+      metadata: {
+        originalRunIndex: i,
+        baselineOffset,
+        effectiveFontSize,
+        style: resolvedStyle,
+        inlineWidget: run.inlineWidget
+      }
+    };
+    if (run.type === "inline-box" && run.inlineWidget) {
+      item.extraWidth = run.inlineWidget.width;
+      item.break = "never";
+    }
+    items.push(item);
+  }
+  return items;
+}
+function splitParagraphByHardBreaks(paragraph) {
+  const ws = paragraph.style.whiteSpace;
+  if (ws !== "pre-line" && ws !== "pre" && ws !== "pre-wrap") {
+    return [paragraph];
+  }
+  const result = [];
+  let currentRuns = [];
+  for (const run of paragraph.children) {
+    const nlIndex = run.text.indexOf(`
+`);
+    if (nlIndex === -1) {
+      currentRuns.push({ ...run });
+      continue;
+    }
+    const before = run.text.slice(0, nlIndex);
+    const after = run.text.slice(nlIndex + 1);
+    const textTransform = run.textTransform;
+    const effectiveFontSize = computeEffFs(run);
+    if (before.length > 0) {
+      const text = ws === "pre-line" ? collapseSegmentWhitespace(before) : before;
+      currentRuns.push({ ...run, text: transformText(text, textTransform) });
+    }
+    result.push({ style: paragraph.style, children: currentRuns });
+    let afterIdx = nlIndex + 1;
+    while (afterIdx < run.text.length && run.text[afterIdx] === `
+`) {
+      result.push({ style: paragraph.style, children: [] });
+      afterIdx++;
+    }
+    const remaining = run.text.slice(afterIdx);
+    if (remaining.length > 0) {
+      const text = ws === "pre-line" ? collapseSegmentWhitespace(remaining) : remaining;
+      currentRuns = [{ ...run, text: transformText(text, textTransform) }];
+    } else {
+      currentRuns = [];
+    }
+  }
+  result.push({ style: paragraph.style, children: currentRuns });
+  return result;
+}
+function computeEffFs(run) {
+  const base = run.fontSize ?? DEFAULT_TEXT_STYLE.fontSize ?? 12;
+  return run.script === "super" || run.script === "sub" ? base * SUPER_SUB_SCALE : base;
+}
+function getParagraphText(paragraph) {
+  return paragraph.children.map((r) => r.text).join("");
+}
+
+// src/measure/FontMetricsProvider.ts
+await init_canvas_polyfill();
+
+// src/measure/FontNotFoundError.ts
+class FontNotFoundError extends Error {
+  constructor(family, weight = "normal", style = "normal") {
+    super(`Font not found: "${family}" (weight: ${weight}, style: ${style}). ` + `Use SystemFontRegistry.scan() to register system fonts.`);
+    this.name = "FontNotFoundError";
+  }
+}
+
+// src/measure/FontMetricsProvider.ts
+var MISSING_GLYPH_FACTOR = 0.5;
+var WEIGHT_TO_NUM = {
+  thin: "100",
+  hairline: "100",
+  ultralight: "200",
+  extralight: "200",
+  light: "300",
+  normal: "400",
+  medium: "500",
+  semibold: "600",
+  demibold: "600",
+  bold: "700",
+  ultrabold: "800",
+  extrabold: "800",
+  heavy: "900",
+  black: "900"
+};
+function normaliseWeight(weight) {
+  const lower = weight.toLowerCase();
+  const mapped = WEIGHT_TO_NUM[lower];
+  if (mapped)
+    return mapped;
+  return weight;
+}
+function cacheKey2(family, weight, style) {
+  return `${family}_${normaliseWeight(weight)}_${style}`;
+}
+
+class FontMetricsProvider {
+  cache = new Map;
+  metricsCache = new Map;
+  mode = "browser";
+  pendingRegistrations = new Set;
+  _measureCanvas = null;
+  _measureCtx = null;
+  _getMeasureContext() {
+    if (!this._measureCtx) {
+      if (typeof OffscreenCanvas !== "undefined") {
+        this._measureCanvas = new OffscreenCanvas(1, 1);
+        this._measureCtx = this._measureCanvas.getContext("2d");
+      } else {
+        this._measureCanvas = document.createElement("canvas");
+        this._measureCtx = this._measureCanvas.getContext("2d");
+      }
+    }
+    return this._measureCtx;
+  }
+  setMode(mode) {
+    if (this.mode === mode)
+      return;
+    this.mode = mode;
+    this.metricsCache.clear();
+    if (mode === "office") {
+      enableOfficeTextMeasure(this.cache);
+    } else {
+      disableOfficeTextMeasure();
+    }
+  }
+  getMode() {
+    return this.mode;
+  }
+  async registerFont(family, options, source, sourcePath) {
+    const promise = this._registerFontInternal(family, options, source, sourcePath);
+    this.pendingRegistrations.add(promise);
+    try {
+      await promise;
+    } finally {
+      this.pendingRegistrations.delete(promise);
+    }
+  }
+  async _registerFontInternal(family, options, source, sourcePath) {
+    const { createFontFace: createFontFace2 } = await Promise.resolve().then(() => exports_FontEngine);
+    const { registerCanvasFont: registerCanvasFont2 } = await init_canvas_polyfill().then(() => exports_canvas_polyfill);
+    if (typeof source === "string") {
+      const { getFontBuffer: getFontBuffer2 } = await Promise.resolve().then(() => exports_font);
+      source = await getFontBuffer2(source);
+    }
+    const font = await createFontFace2(source);
+    const key = cacheKey2(family, options.weight || "normal", options.style || "normal");
+    this.cache.set(key, font);
+    this.metricsCache.delete(key);
+    if (sourcePath) {
+      registerCanvasFont2(sourcePath, family);
+    }
+  }
+  async waitForPendingRegistrations() {
+    await Promise.all(this.pendingRegistrations);
+  }
+  getFont(family, weight = "normal", style = "normal") {
+    const key = cacheKey2(family, weight, style);
+    return this.cache.get(key);
+  }
+  getMetrics(fontFamily, fontSize, weight = "normal", style = "normal") {
+    const _process2 = typeof globalThis !== "undefined" ? globalThis.process : undefined;
+    if (this.pendingRegistrations.size > 0 && _process2?.env?.NODE_ENV !== "production") {
+      console.warn("[vyaz] getMetrics() called while registerFont() promises are still pending. Wait for registerFont() to resolve before layout to avoid inaccurate metrics. Use fontMetricsProvider.waitForPendingRegistrations() if needed.");
+    }
+    const key = cacheKey2(fontFamily, weight, style);
+    const metricsKey = `${key}_${fontSize}_${this.mode}`;
+    const cached = this.metricsCache.get(metricsKey);
+    if (cached)
+      return cached;
+    const font = this.cache.get(key);
+    if (font) {
+      const scale = fontSize / font.unitsPerEm;
+      let ascent;
+      let descent;
+      let sourceTable;
+      if (this.mode === "office" && font.winAscent != null && font.winDescent != null) {
+        ascent = font.winAscent * scale * 1.078;
+        descent = Math.abs(font.winDescent) * scale * 1.078;
+        sourceTable = "OS/2";
+      } else {
+        ascent = font.ascent * scale;
+        descent = Math.abs(font.descent) * scale;
+        sourceTable = "hhea";
+      }
+      const metrics = {
+        ascent,
+        descent,
+        capHeight: (font.capHeight ?? font.ascent) * scale,
+        unitsPerEm: font.unitsPerEm,
+        sourceTable
+      };
+      this.metricsCache.set(metricsKey, metrics);
+      return metrics;
+    }
+    if (this.cache.size > 0) {
+      throw new FontNotFoundError(fontFamily, weight, style);
+    }
+    if (typeof document !== "undefined") {
+      try {
+        const ctx = this._getMeasureContext();
+        ctx.font = `${style} ${weight} ${fontSize}px ${fontFamily}`;
+        const m = ctx.measureText("M");
+        const metrics = {
+          ascent: m.fontBoundingBoxAscent || fontSize * 0.85,
+          descent: m.fontBoundingBoxDescent || fontSize * 0.15,
+          capHeight: m.actualBoundingBoxAscent || fontSize * 0.7,
+          unitsPerEm: 1000,
+          sourceTable: "canvas"
+        };
+        this.metricsCache.set(metricsKey, metrics);
+        return metrics;
+      } catch {}
+    }
+    throw new FontNotFoundError(fontFamily, weight, style);
+  }
+}
+var fontMetricsProvider = new FontMetricsProvider;
+
+// src/layout/estimateWidth.ts
+function correctToSumInvariant(measured, occupiedWidth) {
+  const sum = measured.reduce((a, b) => a + b, 0);
+  if (sum === 0 || Math.abs(occupiedWidth - sum) < 0.001) {
+    return measured;
+  }
+  const delta = occupiedWidth - sum;
+  return measured.map((m) => m + m / sum * delta);
+}
+function resolveFragmentWidths(fragments, fullText, occupiedWidth, measureFn) {
+  if (fragments.length === 0)
+    return [];
+  if (fragments.length === 1) {
+    return [occupiedWidth];
+  }
+  const measured = fragments.map((f) => measureFn(f));
+  return correctToSumInvariant(measured, occupiedWidth);
+}
+
+// src/utils/list.ts
+var BULLET_CHARACTERS = {
+  0: "\u2022",
+  1: "\u25CB",
+  2: "\u25AA"
+};
+var FALLBACK_BULLET = "\u25AA";
+function defaultBulletChar(level) {
+  return BULLET_CHARACTERS[level] ?? FALLBACK_BULLET;
+}
+function formatListNumber(n, format) {
+  switch (format) {
+    case "decimal":
+      return String(n);
+    case "upper-roman":
+      return toRoman(n).toUpperCase();
+    case "lower-roman":
+      return toRoman(n).toLowerCase();
+    case "upper-alpha":
+      return toAlpha(n).toUpperCase();
+    case "lower-alpha":
+      return toAlpha(n).toLowerCase();
+    default:
+      return String(n);
+  }
+}
+function toRoman(n) {
+  if (n < 1 || n > 3999)
+    return String(n);
+  const romanMap = [
+    [1000, "m"],
+    [900, "cm"],
+    [500, "d"],
+    [400, "cd"],
+    [100, "c"],
+    [90, "xc"],
+    [50, "l"],
+    [40, "xl"],
+    [10, "x"],
+    [9, "ix"],
+    [5, "v"],
+    [4, "iv"],
+    [1, "i"]
+  ];
+  let result = "";
+  for (const [value, symbol] of romanMap) {
+    while (n >= value) {
+      result += symbol;
+      n -= value;
+    }
+  }
+  return result;
+}
+function toAlpha(n) {
+  if (n < 1)
+    return String(n);
+  const base = 26;
+  const offset = 97;
+  let result = "";
+  while (n > 0) {
+    n--;
+    result = String.fromCharCode(offset + n % base) + result;
+    n = Math.floor(n / base);
+  }
+  return result;
+}
+
+// src/layout/PositioningEngine.ts
+function getMarkerText(listStyle, listIndex) {
+  if (listStyle.type === "bullet") {
+    return listStyle.bulletChar ?? defaultBulletChar(listStyle.level ?? 0);
+  }
+  if (listStyle.type === "number") {
+    const fmt = listStyle.numberFormat ?? "decimal";
+    return formatListNumber(listIndex, fmt) + ".";
+  }
+  return "";
+}
+function getParagraphFontSize(items) {
+  if (items.length === 0)
+    return 12;
+  return items[0].metadata.style.fontSize ?? 12;
+}
+function resolveBulletIndent(listStyle, paraFontSize) {
+  const level = listStyle.level ?? 0;
+  const indents = listStyle.indents;
+  if (indents && indents[level] !== undefined) {
+    return indents[level];
+  }
+  const defaultIndent = listStyle.bulletIndent ?? paraFontSize * 1.5;
+  return defaultIndent * (level + 1);
+}
+function positionLines(pretextLines, items, fontMetricsFn, style, maxWidth, startY = 0, mode = "browser", measureText, tag, listStyle, listIndex, listMarkerWidth) {
+  const lines = [];
+  let currentY = startY + style.spaceBefore;
+  let charIndex = 0;
+  let isFirstLine = true;
+  let contentWidth = 0;
+  const isListItem = listStyle && listStyle.type !== "none" && listIndex !== undefined;
+  let markerText = "";
+  let markerWidth = 0;
+  let bulletZoneIndent = 0;
+  let effectiveLeftIndent = style.leftIndent ?? 0;
+  if (isListItem) {
+    markerText = getMarkerText(listStyle, listIndex);
+    const paraFontSize = getParagraphFontSize(items);
+    bulletZoneIndent = resolveBulletIndent(listStyle, paraFontSize);
+    if (listMarkerWidth !== undefined && listMarkerWidth > bulletZoneIndent) {
+      bulletZoneIndent = listMarkerWidth;
+    }
+    const firstRunFontFamily = items[0]?.metadata.style.fontFamily ?? "Arial";
+    const firstRunFontWeight = String(items[0]?.metadata.style.fontWeight ?? 400);
+    const firstRunFontStyle = items[0]?.metadata.style.fontStyle ?? "normal";
+    const markerFontSize = listStyle.type === "bullet" ? paraFontSize * 0.9 : paraFontSize;
+    markerWidth = measureText(markerText, markerFontSize, firstRunFontFamily, firstRunFontWeight, firstRunFontStyle);
+    if (listStyle.position !== "inside") {
+      effectiveLeftIndent += bulletZoneIndent;
+    }
+  }
+  for (let lineIdx = 0;lineIdx < pretextLines.length; lineIdx++) {
+    const ptLine = pretextLines[lineIdx];
+    let maxAscent = 0;
+    let maxDescent = 0;
+    let maxLineHeightBase = 0;
+    const spans = [];
+    for (const frag of ptLine.fragments) {
+      const item = items[frag.itemIndex];
+      if (!item)
+        continue;
+      const metrics = fontMetricsFn(item);
+      const effectiveAscent = metrics.ascent - (item.metadata.baselineOffset || 0);
+      const effectiveDescent = metrics.descent + (item.metadata.baselineOffset || 0);
+      maxAscent = Math.max(maxAscent, effectiveAscent);
+      maxDescent = Math.max(maxDescent, effectiveDescent);
+      maxLineHeightBase = Math.max(maxLineHeightBase, metrics.ascent + metrics.descent);
+      const gapWidth = frag.gapBefore || 0;
+      const textWidth = frag.occupiedWidth;
+      const baseFontMetrics = {
+        ascent: metrics.ascent,
+        descent: metrics.descent,
+        fontSize: item.metadata.effectiveFontSize,
+        baselineOffset: item.metadata.baselineOffset || undefined
+      };
+      if (gapWidth > 0) {
+        spans.push({
+          x: 0,
+          width: gapWidth,
+          text: " ",
+          itemIndex: frag.itemIndex,
+          pIdx: 0,
+          tag,
+          fontMetrics: baseFontMetrics,
+          style: item.metadata.style,
+          inlineWidget: item.metadata.inlineWidget,
+          type: "space"
+        });
+      }
+      const text = frag.text;
+      const leadingMatch = text.match(/^(\s+)/);
+      let remainingText = text;
+      let leadingSpaceChars = 0;
+      let trailingSpaceChars = 0;
+      if (leadingMatch) {
+        leadingSpaceChars = leadingMatch[1].length;
+        remainingText = remainingText.slice(leadingSpaceChars);
+      }
+      if (remainingText.length > 0) {
+        const trailMatch = remainingText.match(/(\s+)$/);
+        if (trailMatch) {
+          trailingSpaceChars = trailMatch[1].length;
+          remainingText = remainingText.slice(0, -trailingSpaceChars);
+        }
+      }
+      const fragments = [];
+      if (leadingSpaceChars > 0)
+        fragments.push(text.slice(0, leadingSpaceChars));
+      if (remainingText.length > 0)
+        fragments.push(remainingText);
+      if (trailingSpaceChars > 0)
+        fragments.push(text.slice(leadingSpaceChars + remainingText.length));
+      const { fontFamily, fontWeight, fontStyle } = item.metadata.style;
+      const fsWeight = String(fontWeight || 400);
+      const fsStyle = fontStyle || "normal";
+      const fragmentMeasureFn = (t) => measureText(t, baseFontMetrics.fontSize, fontFamily, fsWeight, fsStyle);
+      const resolvedWidths = resolveFragmentWidths(fragments, text, textWidth, fragmentMeasureFn);
+      let resolvedIdx = 0;
+      const leadingWidth = leadingSpaceChars > 0 ? resolvedWidths[resolvedIdx++] : 0;
+      const trimmedWidth = remainingText.length > 0 ? resolvedWidths[resolvedIdx++] : 0;
+      const trailingWidthVal = trailingSpaceChars > 0 ? resolvedWidths[resolvedIdx++] : 0;
+      if (leadingSpaceChars > 0) {
+        const leadingText = text.slice(0, leadingSpaceChars);
+        spans.push({
+          x: 0,
+          width: leadingWidth,
+          text: leadingText,
+          itemIndex: frag.itemIndex,
+          pIdx: 0,
+          tag,
+          fontMetrics: baseFontMetrics,
+          style: item.metadata.style,
+          inlineWidget: item.metadata.inlineWidget,
+          type: "space"
+        });
+      }
+      if (remainingText.length > 0) {
+        const actualTextWidth = trimmedWidth;
+        spans.push({
+          x: 0,
+          width: actualTextWidth,
+          text: remainingText,
+          itemIndex: frag.itemIndex,
+          pIdx: 0,
+          tag,
+          fontMetrics: baseFontMetrics,
+          style: item.metadata.style,
+          inlineWidget: item.metadata.inlineWidget,
+          type: "text"
+        });
+      }
+      if (trailingSpaceChars > 0) {
+        const trailingStart = leadingSpaceChars + remainingText.length;
+        const trailingText = text.slice(trailingStart, trailingStart + trailingSpaceChars);
+        spans.push({
+          x: 0,
+          width: trailingWidthVal,
+          text: trailingText,
+          itemIndex: frag.itemIndex,
+          pIdx: 0,
+          tag,
+          fontMetrics: baseFontMetrics,
+          style: item.metadata.style,
+          inlineWidget: item.metadata.inlineWidget,
+          type: "space"
+        });
+      }
+    }
+    for (const s of spans) {
+      if (s.inlineWidget) {
+        s.width = s.inlineWidget.width;
+      }
+    }
+    let outsideMarkerSpan = null;
+    if (isListItem && isFirstLine) {
+      const paraFontSize = getParagraphFontSize(items);
+      const firstRun = items[0];
+      const markerFontSize = listStyle.type === "bullet" ? paraFontSize * 0.9 : paraFontSize;
+      const markerAscent = markerFontSize * 0.8;
+      const markerDescent = markerFontSize * 0.2;
+      maxAscent = Math.max(maxAscent, markerAscent);
+      maxDescent = Math.max(maxDescent, markerDescent);
+      maxLineHeightBase = Math.max(maxLineHeightBase, markerAscent + markerDescent);
+      const markerStyle = {
+        ...firstRun?.metadata.style ?? {
+          fontFamily: "Arial",
+          fontSize: markerFontSize,
+          fontWeight: 400,
+          fontStyle: "normal",
+          color: "#000000",
+          type: "text",
+          text: markerText
+        },
+        fontSize: markerFontSize,
+        text: markerText
+      };
+      const markerSpanBase = {
+        x: 0,
+        width: markerWidth,
+        text: markerText,
+        itemIndex: 0,
+        pIdx: 0,
+        tag,
+        fontMetrics: {
+          ascent: markerAscent,
+          descent: markerDescent,
+          fontSize: markerFontSize
+        },
+        style: markerStyle,
+        type: "marker"
+      };
+      if (listStyle.position === "inside") {
+        spans.unshift(markerSpanBase);
+        const gapWidth = markerFontSize * 0.5;
+        spans.splice(1, 0, {
+          x: 0,
+          width: gapWidth,
+          text: " ",
+          itemIndex: 0,
+          pIdx: 0,
+          tag,
+          fontMetrics: {
+            ascent: 0,
+            descent: 0,
+            fontSize: markerFontSize
+          },
+          style: markerStyle,
+          type: "space"
+        });
+      } else {
+        outsideMarkerSpan = markerSpanBase;
+      }
+    }
+    let trailingStartIndex = spans.length;
+    for (let i = spans.length - 1;i >= 0; i--) {
+      if (spans[i].type === "space") {
+        trailingStartIndex = i;
+      } else {
+        break;
+      }
+    }
+    const trailingWidth = spans.slice(trailingStartIndex).reduce((sum, f) => sum + f.width, 0);
+    for (let i = trailingStartIndex;i < spans.length; i++) {
+      spans[i].trailing = true;
+    }
+    const totalSpanWidth = spans.reduce((sum, f) => sum + f.width, 0);
+    const effectiveLineWidth = totalSpanWidth - trailingWidth;
+    const indent = isFirstLine ? effectiveLeftIndent + (style.indent || 0) : effectiveLeftIndent;
+    const rightIndent = style.rightIndent || 0;
+    const availableWidth = maxWidth - indent - rightIndent;
+    const slack = Math.max(0, availableWidth - effectiveLineWidth);
+    let xOffset = indent;
+    if (style.alignment === "center") {
+      xOffset = indent + slack / 2;
+    } else if (style.alignment === "right") {
+      xOffset = indent + slack;
+    } else if (style.alignment === "justify") {
+      const isLastLine = lineIdx === pretextLines.length - 1;
+      const stretchableSpaces = spans.filter((f) => f.type === "space" && !f.trailing);
+      const spaceCount = stretchableSpaces.length;
+      if (!isLastLine && spaceCount > 0 && slack > 0) {
+        const extraPerSpace = slack / spaceCount;
+        for (const sf of stretchableSpaces) {
+          sf.width += extraPerSpace;
+        }
+      }
+      xOffset = indent;
+    }
+    let runX = xOffset;
+    for (const frag of spans) {
+      frag.x = Math.round(runX * 100) / 100;
+      runX += frag.width;
+    }
+    if (outsideMarkerSpan) {
+      const gap = outsideMarkerSpan.fontMetrics.fontSize * 0.25;
+      outsideMarkerSpan.x = Math.round((xOffset - outsideMarkerSpan.width - gap) * 100) / 100;
+      spans.unshift(outsideMarkerSpan);
+    }
+    let lineX = xOffset;
+    let lineWidth = runX - xOffset;
+    if (spans.length > 0) {
+      const minSpanX = Math.min(...spans.map((s) => s.x));
+      const maxSpanRight = Math.max(...spans.map((s) => s.x + s.width));
+      lineX = minSpanX;
+      lineWidth = maxSpanRight - minSpanX;
+    }
+    contentWidth = Math.max(contentWidth, lineX + lineWidth);
+    const maxFontSize = spans.reduce((max, f) => Math.max(max, f.fontMetrics.fontSize), 0);
+    const ascentRounded = Math.round(maxAscent);
+    const descentRounded = Math.round(maxDescent);
+    let lineBoxHeight;
+    let baseline;
+    if (mode === "office") {
+      lineBoxHeight = maxLineHeightBase;
+      baseline = ascentRounded;
+    } else {
+      const lineHeightPx = maxFontSize * style.lineHeight;
+      const ascentDescentRounded = ascentRounded + descentRounded;
+      const rawLineBoxHeight = Math.round(lineHeightPx);
+      lineBoxHeight = Math.max(rawLineBoxHeight, ascentDescentRounded);
+      const leading = lineBoxHeight - ascentDescentRounded;
+      if (leading <= 0) {
+        baseline = ascentRounded;
+      } else {
+        const ascentDescent = maxAscent + maxDescent;
+        const aboveLeadingFloat = ascentDescent > 0 ? leading * maxAscent / ascentDescent : leading / 2;
+        let aboveLeading = Math.round(aboveLeadingFloat);
+        let belowLeading = leading - aboveLeading;
+        if (aboveLeading >= belowLeading) {
+          aboveLeading = Math.floor((leading - 1) / 2);
+          belowLeading = leading - aboveLeading;
+        }
+        baseline = ascentRounded + aboveLeading;
+      }
+    }
+    const startIdx = charIndex;
+    let lineCharCount = 0;
+    for (const frag of spans) {
+      if (frag.type !== "marker") {
+        lineCharCount += frag.text.length;
+      }
+    }
+    const endIdx = startIdx + lineCharCount;
+    charIndex = endIdx;
+    if (spans.length > 0) {
+      const lastSpan = spans[spans.length - 1];
+      const lastSpanItem = items[lastSpan.itemIndex];
+      if (lastSpanItem && lastSpan.text.endsWith(`
+`)) {
+        lastSpan.breakType = "hard";
+      } else if (lineIdx < pretextLines.length - 1) {
+        lastSpan.breakType = "soft";
+      }
+    }
+    lines.push({
+      x: Math.round(lineX * 100) / 100,
+      y: Math.round(currentY * 100) / 100,
+      width: Math.round(lineWidth * 100) / 100,
+      height: Math.round(lineBoxHeight * 100) / 100,
+      baseline: Math.round(baseline * 100) / 100,
+      ascent: Math.round(maxAscent * 100) / 100,
+      descent: Math.round(maxDescent * 100) / 100,
+      startIndex: startIdx,
+      endIndex: endIdx,
+      alignment: style.alignment,
+      spans
+    });
+    currentY += lineBoxHeight;
+    isFirstLine = false;
+  }
+  return { lines, contentWidth };
+}
+
+// src/layout/LineBoxValidator.ts
+import { dump } from "js-yaml";
+var EPSILON = 0.5;
+function assertLineInvariants(lines, originalText, maxWidth) {
+  if (lines.length === 0)
+    return;
+  const errors = [];
+  for (let i = 0;i < lines.length; i++) {
+    const line = lines[i];
+    if (i > 0) {
+      const prev = lines[i - 1];
+      if (line.y < prev.y + prev.height - EPSILON) {
+        errors.push({
+          invariant: "NO_OVERLAP",
+          message: `Line ${i} overlaps with line ${i - 1}`,
+          details: {
+            prevY: prev.y,
+            prevHeight: prev.height,
+            prevBottom: prev.y + prev.height,
+            currentY: line.y
+          }
+        });
+      }
+    }
+    if (i > 0 && line.y <= lines[i - 1].y) {
+      errors.push({
+        invariant: "MONOTONIC_Y",
+        message: `Line ${i} has Y=${line.y} not > prev Y=${lines[i - 1].y}`
+      });
+    }
+    if (line.endIndex <= line.startIndex) {
+      errors.push({
+        invariant: "INDEX_CONSIST",
+        message: `Line ${i}: endIndex=${line.endIndex} <= startIndex=${line.startIndex}`
+      });
+    }
+    if (maxWidth > 0 && line.width > maxWidth + EPSILON) {
+      errors.push({
+        invariant: "WIDTH_FIT",
+        message: `Line ${i}: width=${line.width} > maxWidth=${maxWidth}`
+      });
+    }
+    if (line.spans.length > 1) {
+      const firstBaseline = line.baseline;
+      for (let j = 0;j < line.spans.length; j++) {
+        const span = line.spans[j];
+        const spanBaseline = span.fontMetrics.ascent;
+        if (Math.abs(spanBaseline - firstBaseline) > EPSILON) {
+          if (spanBaseline <= 0) {
+            errors.push({
+              invariant: "BASELINE_EQ",
+              message: `Line ${i}, span ${j}: baseline=${spanBaseline} is invalid`
+            });
+          }
+        }
+      }
+    }
+  }
+}
+function spanStyleLabel(span) {
+  if (span.style.fontStyle === "italic")
+    return "italic";
+  const w = span.style.fontWeight;
+  if (w === "bold" || w === 700)
+    return "bold";
+  return "normal";
+}
+function linesToYAML(lines, paragraphWidth, paragraphHeight) {
+  const obj = {
+    width: paragraphWidth,
+    height: paragraphHeight,
+    lines: lines.map((line) => ({
+      y: Math.round(line.y * 100) / 100,
+      width: Math.round(line.width * 100) / 100,
+      height: Math.round(line.height * 100) / 100,
+      baseline: Math.round(line.baseline * 100) / 100,
+      fragments: line.spans.map((span) => ({
+        text: span.text,
+        x: Math.round(span.x * 100) / 100,
+        width: Math.round(span.width * 100) / 100,
+        ...spanStyleLabel(span) !== "normal" ? { style: spanStyleLabel(span) } : {}
+      }))
+    }))
+  };
+  return dump(obj, {
+    indent: 2,
+    lineWidth: 120,
+    noRefs: true,
+    sortKeys: false
+  });
+}
+
+// src/layout/ParagraphLayoutEngine.ts
+import { prepareRichInline, materializeRichInlineLineRange, walkRichInlineLineRanges } from "@chenglou/pretext/rich-inline";
+function glyphCacheKey(text, fontSize, fontFamily, fontWeight, fontStyle) {
+  return `${fontSize}_${fontFamily || ""}_${fontWeight || ""}_${fontStyle || ""}_${text}`;
+}
+function getFontMetricsForItem(item) {
+  return fontMetricsProvider.getMetrics(item.metadata.style.fontFamily, item.metadata.effectiveFontSize, String(item.metadata.style.fontWeight || 400), item.metadata.style.fontStyle || "normal");
+}
+
+class ParagraphLayoutEngine {
+  preparedCache = new Map;
+  layout(paragraph, maxWidth, yOffset = 0, fontProvider, listStyle, listIndex, listMarkerWidth) {
+    const provider = fontProvider || fontMetricsProvider;
+    const items = compileParagraph(paragraph);
+    const cacheKey3 = JSON.stringify(paragraph);
+    let prepared = this.preparedCache.get(cacheKey3);
+    if (!prepared) {
+      prepared = prepareRichInline(items);
+      this.preparedCache.set(cacheKey3, prepared);
+    }
+    const effectiveMaxWidth = paragraph.style.whiteSpace === "nowrap" ? Infinity : maxWidth;
+    const pretextLines = [];
+    walkRichInlineLineRanges(prepared, effectiveMaxWidth, (range) => {
+      pretextLines.push(range);
+    });
+    const materializedLines = [];
+    for (const range of pretextLines) {
+      materializedLines.push(materializeRichInlineLineRange(prepared, range));
+    }
+    const renderMode = provider.getMode();
+    const glyphCache = new Map;
+    const measureTextFn = (text, fontSize, fontFamily, fontWeight, fontStyle) => {
+      if (!text)
+        return 0;
+      const key = glyphCacheKey(text, fontSize, fontFamily, fontWeight, fontStyle);
+      let advances = glyphCache.get(key);
+      if (!advances) {
+        advances = this.computeGlyphAdvances(text, fontSize, fontFamily, fontWeight, fontStyle);
+        glyphCache.set(key, advances);
+      }
+      let total = 0;
+      for (let i = 0;i < advances.length; i++)
+        total += advances[i];
+      return Math.round(total * 100) / 100;
+    };
+    const { lines, contentWidth } = positionLines(materializedLines, items, (item) => {
+      if (fontProvider) {
+        return fontProvider.getMetrics(item.metadata.style.fontFamily, item.metadata.effectiveFontSize, String(item.metadata.style.fontWeight || 400), item.metadata.style.fontStyle || "normal");
+      }
+      return getFontMetricsForItem(item);
+    }, paragraph.style, maxWidth, yOffset, renderMode, measureTextFn, paragraph.id, paragraph.style.listStyle, paragraph.style.listStyle ? listIndex ?? 1 : undefined, listMarkerWidth);
+    for (const line of lines) {
+      for (const span of line.spans) {
+        if (span.type === "text" && span.text.length > 0 && !span.inlineWidget && !span.glyphAdvances) {
+          const key = glyphCacheKey(span.text, span.fontMetrics.fontSize, span.style.fontFamily, String(span.style.fontWeight || 400), span.style.fontStyle || "normal");
+          const cached = glyphCache.get(key);
+          if (cached) {
+            span.glyphAdvances = Array.from(cached);
+          } else {
+            span.glyphAdvances = Array.from(this.computeGlyphAdvances(span.text, span.fontMetrics.fontSize, span.style.fontFamily, String(span.style.fontWeight || 400), span.style.fontStyle || "normal"));
+          }
+        }
+      }
+    }
+    assertLineInvariants(lines, getParagraphText(paragraph), maxWidth);
+    const totalHeight = lines.length > 0 ? lines[lines.length - 1].y + lines[lines.length - 1].height + (paragraph.style.spaceAfter || 0) : 0;
+    const contentHeight = lines.length > 0 ? lines[lines.length - 1].y + lines[lines.length - 1].height : 0;
+    return { width: maxWidth, height: totalHeight, lines, contentWidth, contentHeight };
+  }
+  layoutGlyph(paragraph, maxWidth, yOffset = 0) {
+    return this.layout(paragraph, maxWidth, yOffset);
+  }
+  computeGlyphAdvances(text, fontSize, fontFamily, fontWeight, fontStyle) {
+    const font = fontMetricsProvider.getFont(fontFamily || "Arial", fontWeight || "400", fontStyle || "normal");
+    if (!font) {
+      throw new FontNotFoundError(fontFamily || "Arial", fontWeight || "400", fontStyle || "normal");
+    }
+    const scale = fontSize / font.unitsPerEm;
+    const advances = new Float32Array(text.length);
+    for (let i = 0;i < text.length; i++) {
+      const codePoint = text.codePointAt(i);
+      const advance = font._raw.glyphForCodePoint(codePoint)?.advanceWidth;
+      if (advance != null) {
+        advances[i] = advance * scale;
+      } else {
+        advances[i] = fontSize * MISSING_GLYPH_FACTOR;
+      }
+      if (codePoint > 65535)
+        i++;
+    }
+    return advances;
+  }
+}
+var paragraphLayoutEngine = new ParagraphLayoutEngine;
+// src/layout/TextFrameLayoutEngine.ts
+function getMarkerTextHelper(listStyle, listIndex) {
+  if (listStyle.type === "bullet") {
+    return listStyle.bulletChar ?? defaultBulletChar(listStyle.level ?? 0);
+  }
+  if (listStyle.type === "number") {
+    const fmt = listStyle.numberFormat ?? "decimal";
+    return formatListNumber(listIndex, fmt) + ".";
+  }
+  return "";
+}
+function computeMaxMarkerWidth(listStyle, startIndex, count, measureText) {
+  if (listStyle.type !== "number")
+    return 0;
+  let maxWidth = 0;
+  for (let i = 0;i < count; i++) {
+    const markerText = getMarkerTextHelper(listStyle, startIndex + i);
+    const width = measureText(markerText, 12);
+    maxWidth = Math.max(maxWidth, width);
+  }
+  return maxWidth;
+}
+function applyVerticalAlignment(lines, colHeight, alignment) {
+  if (alignment === "top" || lines.length === 0)
+    return;
+  const firstLineY = lines[0].y;
+  const lastLineEnd = lines[lines.length - 1].y + lines[lines.length - 1].height;
+  const contentHeight = lastLineEnd - firstLineY;
+  const extraSpace = colHeight - contentHeight;
+  if (extraSpace <= 0)
+    return;
+  let offset = 0;
+  if (alignment === "middle") {
+    offset = extraSpace / 2;
+  } else if (alignment === "bottom") {
+    offset = extraSpace;
+  }
+  for (const line of lines) {
+    line.y += offset;
+  }
+}
+function layoutTextFrame(frame) {
+  const leftPad = frame.padding?.left ?? 0;
+  const rightPad = frame.padding?.right ?? 0;
+  const topPad = frame.padding?.top ?? 0;
+  const bottomPad = frame.padding?.bottom ?? 0;
+  const hasColumns = frame.columns != null && frame.columns.count > 1 && frame.width != null;
+  let colWidth;
+  let colCount = 1;
+  let colGap = 0;
+  if (hasColumns) {
+    colCount = frame.columns.count;
+    colGap = frame.columns.gap;
+    const totalPad = leftPad + rightPad + (colCount - 1) * colGap;
+    colWidth = (frame.width - totalPad) / colCount;
+  }
+  const colHeight = frame.height != null ? frame.height - topPad - bottomPad : Infinity;
+  const verticalAlign = frame.verticalAlignment ?? "top";
+  const listIndices = new Array(frame.paragraphs.length).fill(undefined);
+  const listMarkerWidths = new Array(frame.paragraphs.length).fill(undefined);
+  let i = 0;
+  while (i < frame.paragraphs.length) {
+    const p = frame.paragraphs[i];
+    const ls = p.style.listStyle;
+    if (!ls || ls.type === "none") {
+      i++;
+      continue;
+    }
+    let groupStart = i;
+    let groupEnd = i + 1;
+    while (groupEnd < frame.paragraphs.length) {
+      const nextP = frame.paragraphs[groupEnd];
+      const nextLs = nextP.style.listStyle;
+      if (!nextLs || nextLs.type !== ls.type || nextP.style.listRestart) {
+        break;
+      }
+      if ((nextLs.level ?? 0) !== (ls.level ?? 0)) {
+        break;
+      }
+      groupEnd++;
+    }
+    const groupSize = groupEnd - groupStart;
+    const startNumber = ls.startNumber ?? 1;
+    for (let j = 0;j < groupSize; j++) {
+      listIndices[groupStart + j] = startNumber + j;
+    }
+    const paraFontSize = p.children[0]?.fontSize ?? 12;
+    const measureMarkerWidth = (text, fontSize) => {
+      return text.length * fontSize * 0.6;
+    };
+    const maxMW = computeMaxMarkerWidth(ls, startNumber, groupSize, measureMarkerWidth);
+    for (let j = 0;j < groupSize; j++) {
+      listMarkerWidths[groupStart + j] = maxMW;
+    }
+    i = groupEnd;
+  }
+  const allLines = [];
+  let contentWidth = 0;
+  const currentColY = new Array(colCount).fill(topPad);
+  function layoutSingleParagraph(p, maxWidth, pIdx, listIndex, listMarkerWidth) {
+    const listStyle = p.style.listStyle;
+    if (p.children.length === 0) {
+      const fontSize = 12;
+      const lineHeight = p.style.lineHeight;
+      const lineHeightPx = Math.round(fontSize * lineHeight);
+      return {
+        lines: [{
+          x: 0,
+          y: 0,
+          width: 0,
+          height: lineHeightPx,
+          baseline: Math.round(fontSize * 0.8),
+          ascent: Math.round(fontSize * 0.8),
+          descent: Math.round(fontSize * 0.2),
+          startIndex: 0,
+          endIndex: 0,
+          isHardBreak: true,
+          spans: []
+        }],
+        height: lineHeightPx,
+        contentWidth: 0
+      };
+    }
+    const result = paragraphLayoutEngine.layout(p, maxWidth, 0, undefined, listStyle, listIndex, listMarkerWidth);
+    return {
+      lines: result.lines,
+      height: result.contentHeight,
+      contentWidth: result.contentWidth
+    };
+  }
+  for (let i2 = 0;i2 < frame.paragraphs.length; i2++) {
+    const p = frame.paragraphs[i2];
+    const subParagraphs = splitParagraphByHardBreaks(p);
+    const maxWidth = hasColumns ? colWidth : frame.width !== undefined ? frame.width - leftPad - rightPad : Infinity;
+    if (frame.wrap === false) {
+      p.style = { ...p.style, whiteSpace: "nowrap" };
+    }
+    const listIndex = listIndices[i2];
+    const listMarkerWidth = listMarkerWidths[i2];
+    for (let subIdx = 0;subIdx < subParagraphs.length; subIdx++) {
+      const subPara = subParagraphs[subIdx];
+      if (!hasColumns && subIdx === 0) {
+        currentColY[0] += p.style.spaceBefore;
+      }
+      const subResult = layoutSingleParagraph(subPara, maxWidth, i2, listIndex, listMarkerWidth);
+      for (const line of subResult.lines) {
+        if (!hasColumns) {
+          line.x += leftPad;
+          for (const span of line.spans) {
+            span.pIdx = i2;
+          }
+          allLines.push(line);
+          contentWidth = Math.max(contentWidth, subResult.contentWidth);
+          line.y = currentColY[0];
+          currentColY[0] += line.height;
+          continue;
+        }
+        let colIdx = 0;
+        for (let c = 0;c < colCount; c++) {
+          if (currentColY[c] < currentColY[colIdx])
+            colIdx = c;
+        }
+        let placed = false;
+        for (let attempt = 0;attempt < colCount; attempt++) {
+          if (currentColY[colIdx] + line.height <= colHeight) {
+            line.x = colIdx * (colWidth + colGap) + leftPad;
+            line.y = currentColY[colIdx];
+            line.columnIndex = colIdx;
+            currentColY[colIdx] += line.height;
+            for (const span of line.spans) {
+              span.pIdx = i2;
+            }
+            allLines.push(line);
+            contentWidth = Math.max(contentWidth, line.x + line.width + rightPad);
+            placed = true;
+            break;
+          }
+          colIdx = (colIdx + 1) % colCount;
+          if (attempt === colCount - 1) {
+            line.x = colIdx * (colWidth + colGap) + leftPad;
+            line.y = currentColY[colIdx];
+            line.columnIndex = colIdx;
+            currentColY[colIdx] += line.height;
+            for (const span of line.spans) {
+              span.pIdx = i2;
+            }
+            allLines.push(line);
+            contentWidth = Math.max(contentWidth, line.x + line.width + rightPad);
+            placed = true;
+          }
+        }
+        if (!placed) {
+          line.x = leftPad;
+          line.y = currentColY[0];
+          line.columnIndex = 0;
+          currentColY[0] += line.height;
+          for (const span of line.spans) {
+            span.pIdx = i2;
+          }
+          allLines.push(line);
+        }
+      }
+      if (!hasColumns && subPara === subParagraphs[subParagraphs.length - 1]) {
+        currentColY[0] += p.style.spaceAfter;
+      }
+    }
+  }
+  if (hasColumns && verticalAlign !== "top" && frame.height != null) {
+    const colLines = new Array(colCount).fill(null).map(() => []);
+    for (const line of allLines) {
+      const ci = line.columnIndex ?? 0;
+      colLines[ci].push(line);
+    }
+    for (let c = 0;c < colCount; c++) {
+      applyVerticalAlignment(colLines[c], colHeight, verticalAlign);
+    }
+  }
+  if (hasColumns) {
+    contentWidth = frame.width;
+  } else {
+    contentWidth += rightPad;
+  }
+  const lastLine = allLines.length > 0 ? allLines[allLines.length - 1] : null;
+  const contentHeight = lastLine ? lastLine.y + lastLine.height + bottomPad : bottomPad;
+  return {
+    lines: allLines,
+    frameWidth: frame.width,
+    frameHeight: frame.height,
+    contentWidth,
+    contentHeight,
+    fitHorizontal: frame.width !== undefined ? "frame" : "content",
+    fitVertical: frame.height !== undefined ? "frame" : "content"
+  };
+}
+// src/layout/AutoFitEngine.ts
+function applyScale(doc, scale) {
+  const clone = JSON.parse(JSON.stringify(doc));
+  for (const paragraph of clone.paragraphs) {
+    for (const run of paragraph.children) {
+      run.fontSize = Math.round(run.fontSize * scale * 100) / 100;
+    }
+  }
+  if (clone.defaultStyle?.fontSize) {
+    clone.defaultStyle.fontSize = Math.round(clone.defaultStyle.fontSize * scale * 100) / 100;
+  }
+  return clone;
+}
+function findScale(doc, layoutFn, config, options) {
+  const minScale = options?.minScale ?? 0.1;
+  const tolerance = options?.tolerance ?? 0.01;
+  const maxIterations = options?.maxIterations ?? 50;
+  const maxHeight = config.maxHeight;
+  const maxWidth = config.maxWidth;
+  const origResult = layoutFn(doc);
+  if (origResult.height <= maxHeight && origResult.width <= maxWidth) {
+    return { scaleFactor: 1 };
+  }
+  let lo = minScale;
+  let hi = 1;
+  let best = minScale;
+  for (let iter = 0;iter < maxIterations; iter++) {
+    const mid = (lo + hi) / 2;
+    const scaledDoc = applyScale(doc, mid);
+    const result = layoutFn(scaledDoc);
+    if (result.height <= maxHeight && result.width <= maxWidth) {
+      best = mid;
+      lo = mid + tolerance / 2;
+    } else {
+      hi = mid - tolerance / 2;
+    }
+    if (hi - lo < tolerance)
+      break;
+  }
+  return { scaleFactor: Math.round(best * 100) / 100 };
+}
+// src/utils/groupLinesByParagraph.ts
+function groupLinesByParagraph(lines) {
+  const map = new Map;
+  for (const line of lines) {
+    const idx = line.spans[0]?.pIdx ?? -1;
+    let entry = map.get(idx);
+    if (!entry) {
+      entry = { lines: [] };
+      map.set(idx, entry);
+    }
+    entry.lines.push(line);
+    if (!entry.tag) {
+      entry.tag = line.spans[0]?.tag;
+    }
+  }
+  const groups = [];
+  const sortedKeys = Array.from(map.keys()).sort((a, b) => a - b);
+  for (const key of sortedKeys) {
+    if (key === -1)
+      continue;
+    const entry = map.get(key);
+    groups.push({ lines: entry.lines, pIdx: key, tag: entry.tag });
+  }
+  return groups;
+}
+// src/utils/env.ts
+var _process2 = typeof globalThis !== "undefined" ? globalThis.process : undefined;
+var isNodeLike = _process2 != null && _process2.versions != null && typeof _process2.versions.node === "string";
+
+// src/measure/SystemFontRegistry.ts
+function parseSubfamily(subfamily) {
+  const lower = subfamily.toLowerCase();
+  let style;
+  if (lower.includes("italic")) {
+    style = "italic";
+  } else {
+    style = "normal";
+  }
+  let weight;
+  if (lower.includes("thin") || lower.includes("hairline")) {
+    weight = "thin";
+  } else if (lower.includes("extralight") || lower.includes("ultralight")) {
+    weight = "extralight";
+  } else if (lower.includes("light")) {
+    weight = "light";
+  } else if (lower.includes("semibold") || lower.includes("demibold")) {
+    weight = "semibold";
+  } else if (lower.includes("bold") || lower.includes("heavy") || lower.includes("black")) {
+    weight = "bold";
+  } else if (lower.includes("medium") || lower.includes("medium")) {
+    weight = "medium";
+  } else {
+    weight = "normal";
+  }
+  return { weight, style };
+}
+
+class SystemFontRegistry {
+  static _instance;
+  registered = new Map;
+  constructor() {}
+  static get instance() {
+    if (!SystemFontRegistry._instance) {
+      SystemFontRegistry._instance = new SystemFontRegistry;
+    }
+    return SystemFontRegistry._instance;
+  }
+  async scan() {
+    if (!isNodeLike) {
+      console.warn("[vyaz] systemFontRegistry.scan() \u043D\u0435\u0434\u043E\u0441\u0442\u0443\u043F\u0435\u043D \u0432 \u0431\u0440\u0430\u0443\u0437\u0435\u0440\u0435");
+      return { total: 0, registered: 0 };
+    }
+    const [{ readFileSync }, getSystemFontsModule] = await Promise.all([
+      import("fs"),
+      import("get-system-fonts")
+    ]);
+    const getSystemFonts = getSystemFontsModule.default || getSystemFontsModule;
+    const paths = await getSystemFonts();
+    let registered = 0;
+    for (const fontPath of paths) {
+      try {
+        const buffer = readFileSync(fontPath);
+        const { createFontFace: createFontFace2 } = await Promise.resolve().then(() => exports_FontEngine);
+        const font = await createFontFace2(buffer);
+        const fontkit = font._raw;
+        const family = fontkit.familyName;
+        if (!family)
+          continue;
+        const { weight, style } = parseSubfamily(fontkit.subfamilyName || "Regular");
+        await fontMetricsProvider.registerFont(family, { weight, style }, buffer, fontPath);
+        this.registered.set(family, true);
+        registered++;
+      } catch {
+        continue;
+      }
+    }
+    return { total: paths.length, registered };
+  }
+  isRegistered(family) {
+    return this.registered.has(family);
+  }
+  getRegisteredFamilies() {
+    return Array.from(this.registered.keys());
+  }
+}
+var systemFontRegistry = SystemFontRegistry.instance;
+
+// src/index.ts
+var DEFAULT_PARAGRAPH_STYLE2 = { ...DEFAULT_PARAGRAPH_STYLE };
+var DEFAULT_TEXT_STYLE2 = { ...DEFAULT_TEXT_STYLE };
+var formatListNumber2 = formatListNumber;
+var defaultBulletChar2 = defaultBulletChar;
+var BULLET_CHARACTERS2 = { ...BULLET_CHARACTERS };
 export {
   transformText,
   systemFontRegistry,
@@ -13,10 +1652,10 @@ export {
   getParagraphText,
   getGlyphAdvance,
   getFontBuffer,
-  formatListNumber,
+  formatListNumber2 as formatListNumber,
   fontMetricsProvider,
   findScale,
-  defaultBulletChar,
+  defaultBulletChar2 as defaultBulletChar,
   createFontFace,
   computePixelMetrics,
   compileParagraph,
@@ -27,7 +1666,7 @@ export {
   ParagraphLayoutEngine,
   FontNotFoundError,
   FontMetricsProvider,
-  DEFAULT_TEXT_STYLE,
-  DEFAULT_PARAGRAPH_STYLE,
-  BULLET_CHARACTERS
+  DEFAULT_TEXT_STYLE2 as DEFAULT_TEXT_STYLE,
+  DEFAULT_PARAGRAPH_STYLE2 as DEFAULT_PARAGRAPH_STYLE,
+  BULLET_CHARACTERS2 as BULLET_CHARACTERS
 };