@vectojs/core 0.1.0

package/dist/chunk-72WVPMSJ.js

@@ -0,0 +1,615 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; } var _class; var _class2;
+
+
+var _chunkRW6NC4RBjs = require('./chunk-RW6NC4RB.js');
+
+// src/layout/LayoutEngine.ts
+function computeLineSegments(top, bottom, maxWidth, exclusions) {
+  const blocks = [];
+  for (const r of exclusions) {
+    if (r.y < bottom && r.y + r.height > top) {
+      const x0 = Math.max(0, r.x);
+      const x1 = Math.min(maxWidth, r.x + r.width);
+      if (x1 > x0) blocks.push([x0, x1]);
+    }
+  }
+  if (blocks.length === 0) return [{ x0: 0, x1: maxWidth }];
+  blocks.sort((a, b) => a[0] - b[0]);
+  const merged = [];
+  for (const b of blocks) {
+    const last = merged[merged.length - 1];
+    if (last && b[0] <= last[1]) last[1] = Math.max(last[1], b[1]);
+    else merged.push([b[0], b[1]]);
+  }
+  const segs = [];
+  let cursor = 0;
+  for (const [bx0, bx1] of merged) {
+    if (bx0 > cursor) segs.push({ x0: cursor, x1: bx0 });
+    cursor = Math.max(cursor, bx1);
+  }
+  if (cursor < maxWidth) segs.push({ x0: cursor, x1: maxWidth });
+  return segs;
+}
+var LayoutEngine = (_class = class {
+  
+  
+  __init() {this.preserveLeadingSpaces = false}
+  
+  
+  __init2() {this.wordCache = /* @__PURE__ */ new Map()}
+  __init3() {this.graphemeCache = /* @__PURE__ */ new Map()}
+  // Paragraph-level memo so re-`prepare()` of mostly-unchanged text (streaming
+  // append, live logs) reuses untouched paragraphs by reference instead of
+  // re-segmenting/re-measuring the whole document — turning per-token cost from
+  // O(document) into O(changed paragraph). Keyed by fontSize + text; invalidated
+  // when the font atlas (which drives glyph widths) changes.
+  __init4() {this.paragraphCache = /* @__PURE__ */ new Map()}
+  // Same memo for the rich path ({@link prepareRich}); keyed by fontSize + text +
+  // a per-paragraph *value* signature of the inline styles, so a streaming
+  // typewriter that appends styled runs reuses its untouched paragraphs.
+  __init5() {this.richParagraphCache = /* @__PURE__ */ new Map()}
+  __init6() {this.lastAtlas = null}
+  
+  constructor(maxWidth, maxHeight, measurer) {;_class.prototype.__init.call(this);_class.prototype.__init2.call(this);_class.prototype.__init3.call(this);_class.prototype.__init4.call(this);_class.prototype.__init5.call(this);_class.prototype.__init6.call(this);
+    this.maxWidth = maxWidth;
+    this.maxHeight = maxHeight;
+    this.measurer = _nullishCoalesce(measurer, () => ( null));
+    const locale = typeof navigator !== "undefined" ? navigator.language : "en-US";
+    this.wordSegmenter = new Intl.Segmenter(locale, { granularity: "word" });
+    this.charSegmenter = new Intl.Segmenter(locale, { granularity: "grapheme" });
+  }
+  getWordSegments(paragraph) {
+    const cached = this.wordCache.get(paragraph);
+    if (cached) return cached;
+    const fresh = Array.from(this.wordSegmenter.segment(paragraph)).map((s) => ({
+      segment: s.segment,
+      isWordLike: s.isWordLike
+    }));
+    if (this.wordCache.size > 500) this.wordCache.clear();
+    this.wordCache.set(paragraph, fresh);
+    return fresh;
+  }
+  /**
+   * Resolve a grapheme's advance width at `fontSize`, in priority order:
+   * pre-baked atlas entry → injected {@link GlyphMeasurer} → `0.5em` fallback.
+   */
+  glyphWidth(char, fontAtlas, fontSize) {
+    const glyphInfo = fontAtlas[char];
+    if (glyphInfo) return glyphInfo.width * (fontSize / glyphInfo.baseSize);
+    if (this.measurer) return this.measurer.measure(char, fontSize);
+    return fontSize * 0.5;
+  }
+  getGraphemes(word) {
+    const cached = this.graphemeCache.get(word);
+    if (cached) return cached;
+    const fresh = Array.from(this.charSegmenter.segment(word)).map((g) => g.segment);
+    if (this.graphemeCache.size > 2e3) this.graphemeCache.clear();
+    this.graphemeCache.set(word, fresh);
+    return fresh;
+  }
+  /**
+   * Lay out a Unicode string into a list of positioned {@link LayoutNode} glyphs.
+   *
+   * Uses `Intl.Segmenter` to correctly handle CJK, emoji, and Western word
+   * boundaries.  An optional `exclusionMask` callback allows glyphs to flow
+   * around arbitrary shapes (e.g. physics bodies or video regions).
+   *
+   * @param text - The raw text string to lay out (newlines force paragraph breaks).
+   * @param fontAtlas - Pre-measured glyph metrics keyed by grapheme character.
+   * @param fontSize - Target font size in pixels (default: `32`).
+   * @param exclusionMask - Optional callback returning `true` when a candidate
+   *   glyph bounding box overlaps a forbidden region; the engine skips that
+   *   position and advances horizontally.
+   * @returns A {@link LayoutResult} with all positioned glyph nodes and total dimensions.
+   * @example
+   * const result = engine.layoutText('Hello 世界', atlas, 24);
+   * result.nodes.forEach(n => console.log(n.char, n.x, n.y));
+   */
+  layoutText(text, fontAtlas, fontSize = 32, exclusionMask) {
+    return this.layoutPrepared(this.prepare(text, fontAtlas, fontSize), exclusionMask);
+  }
+  /**
+   * **Cold pass.** Segment and measure `text` once into a reusable
+   * {@link PreparedText}. Runs `Intl.Segmenter` (word + grapheme) and resolves
+   * each grapheme's advance width — the expensive work. The result is
+   * independent of `maxWidth`/`maxHeight`/exclusion masks, so it can be re-laid
+   * out cheaply by {@link layoutPrepared} on resize / reposition / animation.
+   *
+   * @param text - The raw text string (newlines force paragraph breaks).
+   * @param fontAtlas - Pre-measured glyph metrics keyed by grapheme character.
+   * @param fontSize - Target font size in pixels (default: `32`).
+   */
+  prepare(text, fontAtlas, fontSize = 32) {
+    if (fontAtlas !== this.lastAtlas) {
+      this.paragraphCache.clear();
+      this.richParagraphCache.clear();
+      this.lastAtlas = fontAtlas;
+    }
+    const paragraphs = [];
+    let offset = 0;
+    let fallbackToCanvas = false;
+    for (const paragraph of text.split("\n")) {
+      if (paragraph.length === 0) {
+        paragraphs.push({ words: [], isEmpty: true });
+        offset += 1;
+        continue;
+      }
+      const key = `${fontSize} ${paragraph}`;
+      const cached = this.paragraphCache.get(key);
+      if (cached) {
+        paragraphs.push(cached);
+        if (cached.fallbackToCanvas) fallbackToCanvas = true;
+        offset += paragraph.length + 1;
+        continue;
+      }
+      const { shapedText, indexMap } = _chunkRW6NC4RBjs.ArabicShaper.shapeArabic(paragraph);
+      const levels = _chunkRW6NC4RBjs.BidiResolver.resolveLevels(shapedText);
+      const words = [];
+      let shapedCharIdx = 0;
+      let pFallback = false;
+      for (const segment of this.getWordSegments(shapedText)) {
+        const word = segment.segment;
+        const glyphs = [];
+        let width = 0;
+        for (const char of this.getGraphemes(word)) {
+          const visualStart = shapedCharIdx;
+          const visualEnd = shapedCharIdx + char.length;
+          const rawStart = indexMap[visualStart];
+          const rawEnd = visualEnd === shapedText.length ? paragraph.length : indexMap[visualEnd];
+          const sourceIndex = offset + rawStart;
+          const sourceLength = rawEnd - rawStart;
+          const baseChar = char[0];
+          const level = levels[visualStart];
+          const hasGlyph = !!fontAtlas[char] || !!fontAtlas[baseChar];
+          if (char.trim().length > 0 && !hasGlyph) {
+            pFallback = true;
+            fallbackToCanvas = true;
+          }
+          const w = this.glyphWidth(baseChar, fontAtlas, fontSize);
+          const combining = [];
+          for (let cIdx = 1; cIdx < char.length; cIdx++) {
+            combining.push(char[cIdx]);
+          }
+          glyphs.push({
+            char: baseChar,
+            width: w,
+            level,
+            sourceIndex,
+            sourceLength,
+            combining: combining.length > 0 ? combining : void 0
+          });
+          width += w;
+          shapedCharIdx += char.length;
+        }
+        words.push({
+          glyphs,
+          width,
+          isWordLike: segment.isWordLike,
+          isWhitespace: word.trim().length === 0
+        });
+      }
+      const prepared = {
+        words,
+        isEmpty: false,
+        fallbackToCanvas: pFallback || void 0,
+        baseLevel: _chunkRW6NC4RBjs.BidiResolver.getBaseLevel(shapedText)
+      };
+      if (this.paragraphCache.size > 1e3) this.paragraphCache.clear();
+      this.paragraphCache.set(key, prepared);
+      paragraphs.push(prepared);
+      offset += paragraph.length + 1;
+    }
+    return { paragraphs, fontSize, fallbackToCanvas: fallbackToCanvas || void 0 };
+  }
+  /**
+   * **Cold pass for rich text.** Like {@link prepare}, but takes an array of
+   * {@link StyledSpan}s so different inline runs (bold / italic / color / size /
+   * links) compose on the same wrapped lines. Each grapheme carries the
+   * (base-merged) style of the span it came from — so a style change *mid-word*
+   * (e.g. `He` + **`llo`**) is honored. Run `fontSize` affects measured width and
+   * line height; the rest is rendering metadata carried through to the nodes.
+   *
+   * The result feeds the same {@link layoutPrepared} as plain text.
+   *
+   * @param spans - The styled runs, in document order.
+   * @param fontAtlas - Pre-measured glyph metrics keyed by grapheme character.
+   * @param baseFontSize - Size for runs without an explicit `fontSize` (default 32).
+   * @param baseStyle - Style inherited by every run (each run's own style wins).
+   */
+  prepareRich(spans, fontAtlas, baseFontSize = 32, baseStyle) {
+    if (fontAtlas !== this.lastAtlas) {
+      this.paragraphCache.clear();
+      this.richParagraphCache.clear();
+      this.lastAtlas = fontAtlas;
+    }
+    let fullText = "";
+    const styleAt = [];
+    for (const span of spans) {
+      const merged = span.style || baseStyle ? { ...baseStyle, ...span.style } : void 0;
+      fullText += span.text;
+      for (let i = 0; i < span.text.length; i++) styleAt.push(merged);
+    }
+    const styleSig = (start, len) => {
+      let sig = "";
+      let i = 0;
+      while (i < len) {
+        const s = styleAt[start + i];
+        const fp = s ? `${_nullishCoalesce(s.fontSize, () => ( ""))}/${_nullishCoalesce(s.color, () => ( ""))}/${s.bold ? 1 : 0}/${s.italic ? 1 : 0}/${_nullishCoalesce(s.href, () => ( ""))}` : "";
+        let run = 1;
+        while (i + run < len) {
+          const t = styleAt[start + i + run];
+          const tfp = t ? `${_nullishCoalesce(t.fontSize, () => ( ""))}/${_nullishCoalesce(t.color, () => ( ""))}/${t.bold ? 1 : 0}/${t.italic ? 1 : 0}/${_nullishCoalesce(t.href, () => ( ""))}` : "";
+          if (tfp !== fp) break;
+          run++;
+        }
+        sig += `${fp}:${run};`;
+        i += run;
+      }
+      return sig;
+    };
+    const paragraphs = [];
+    let offset = 0;
+    let fallbackToCanvas = false;
+    for (const paragraph of fullText.split("\n")) {
+      if (paragraph.length === 0) {
+        paragraphs.push({ words: [], isEmpty: true });
+        offset += 1;
+        continue;
+      }
+      const key = `${baseFontSize} ${paragraph} ${styleSig(offset, paragraph.length)}`;
+      const cached = this.richParagraphCache.get(key);
+      if (cached) {
+        paragraphs.push(cached);
+        if (cached.fallbackToCanvas) fallbackToCanvas = true;
+        offset += paragraph.length + 1;
+        continue;
+      }
+      const { shapedText, indexMap } = _chunkRW6NC4RBjs.ArabicShaper.shapeArabic(paragraph);
+      const levels = _chunkRW6NC4RBjs.BidiResolver.resolveLevels(shapedText);
+      const words = [];
+      let shapedCharIdx = 0;
+      let pFallback = false;
+      for (const segment of this.getWordSegments(shapedText)) {
+        const word = segment.segment;
+        const glyphs = [];
+        let width = 0;
+        for (const char of this.getGraphemes(word)) {
+          const visualStart = shapedCharIdx;
+          const visualEnd = shapedCharIdx + char.length;
+          const rawStart = indexMap[visualStart];
+          const rawEnd = visualEnd === shapedText.length ? paragraph.length : indexMap[visualEnd];
+          const sourceIndex = offset + rawStart;
+          const sourceLength = rawEnd - rawStart;
+          const baseChar = char[0];
+          const level = levels[visualStart];
+          const style = styleAt[offset + rawStart];
+          const gfs = _nullishCoalesce(_optionalChain([style, 'optionalAccess', _ => _.fontSize]), () => ( baseFontSize));
+          const hasGlyph = !!fontAtlas[char] || !!fontAtlas[baseChar];
+          if (char.trim().length > 0 && !hasGlyph) {
+            pFallback = true;
+            fallbackToCanvas = true;
+          }
+          const w = this.glyphWidth(baseChar, fontAtlas, gfs);
+          const combining = [];
+          for (let cIdx = 1; cIdx < char.length; cIdx++) {
+            combining.push(char[cIdx]);
+          }
+          glyphs.push({
+            char: baseChar,
+            width: w,
+            style,
+            level,
+            sourceIndex,
+            sourceLength,
+            combining: combining.length > 0 ? combining : void 0
+          });
+          width += w;
+          shapedCharIdx += char.length;
+        }
+        words.push({
+          glyphs,
+          width,
+          isWordLike: segment.isWordLike,
+          isWhitespace: word.trim().length === 0
+        });
+      }
+      const prepared = {
+        words,
+        isEmpty: false,
+        fallbackToCanvas: pFallback || void 0,
+        baseLevel: _chunkRW6NC4RBjs.BidiResolver.getBaseLevel(shapedText)
+      };
+      if (this.richParagraphCache.size > 1e3) this.richParagraphCache.clear();
+      this.richParagraphCache.set(key, prepared);
+      paragraphs.push(prepared);
+      offset += paragraph.length + 1;
+    }
+    return {
+      paragraphs,
+      fontSize: baseFontSize,
+      fallbackToCanvas: fallbackToCanvas || void 0
+    };
+  }
+  /**
+   * **Hot pass.** Place an already-measured {@link PreparedText} into positioned
+   * glyphs. Does only wrap/positioning arithmetic — no `Intl.Segmenter`, no
+   * re-measurement — so it is cheap enough to call every frame or on every
+   * resize. Reads the engine's current `maxWidth`/`maxHeight`, so changing those
+   * and re-calling reflows the same prepared text.
+   *
+   * @param prepared - Output of {@link prepare}.
+   * @param exclusionMask - Optional per-glyph collision callback (see {@link layoutText}).
+   * @param exclusions - Optional rect regions text flows around (exclusion shapes); each
+   *   line is split into the free x-segments left after subtracting them. Omitting
+   *   it (or passing `[]`) leaves the single-column path byte-for-byte unchanged.
+   */
+  layoutPrepared(prepared, exclusionMask, exclusions) {
+    const layoutNodes = [];
+    const fontSize = prepared.fontSize;
+    let currentX = 0;
+    let currentY = 0;
+    let maxLineWidth = 0;
+    const hasEx = !!(exclusions && exclusions.length);
+    let segs = [{ x0: 0, x1: this.maxWidth }];
+    let si = 0;
+    let currentLineNodes = [];
+    let paragraphBaseLevel = 0;
+    const commitLine = () => {
+      if (currentLineNodes.length === 0) return;
+      const runs = [];
+      let currentRun = [];
+      for (let j = 0; j < currentLineNodes.length; j++) {
+        const node = currentLineNodes[j];
+        const prev = currentLineNodes[j - 1];
+        if (prev && Math.abs(node.x - (prev.x + prev.width)) > 1e-3) {
+          runs.push(currentRun);
+          currentRun = [];
+        }
+        currentRun.push(node);
+      }
+      if (currentRun.length > 0) {
+        runs.push(currentRun);
+      }
+      for (const run of runs) {
+        const runStartX = run[0].x;
+        _chunkRW6NC4RBjs.BidiResolver.reorderVisual(run, paragraphBaseLevel);
+        let x = runStartX;
+        for (const node of run) {
+          node.x = x;
+          node.isRTL = node.level % 2 === 1;
+          x += node.width;
+        }
+        for (const node of run) {
+          layoutNodes.push(node);
+        }
+      }
+      currentLineNodes = [];
+    };
+    const startLine = (lineHeight) => {
+      while (currentY < this.maxHeight) {
+        const s = hasEx ? computeLineSegments(currentY, currentY + lineHeight, this.maxWidth, exclusions) : segs;
+        if (s.length > 0) {
+          segs = s;
+          si = 0;
+          currentX = segs[0].x0;
+          return true;
+        }
+        currentY += lineHeight;
+      }
+      return false;
+    };
+    for (const paragraph of prepared.paragraphs) {
+      if (paragraph.isEmpty) {
+        commitLine();
+        currentY += fontSize * 1.5;
+        currentX = 0;
+        continue;
+      }
+      paragraphBaseLevel = _nullishCoalesce(paragraph.baseLevel, () => ( 0));
+      let pMax = fontSize;
+      for (const word of paragraph.words) {
+        for (const glyph of word.glyphs) {
+          const gfs = _nullishCoalesce(_optionalChain([glyph, 'access', _2 => _2.style, 'optionalAccess', _3 => _3.fontSize]), () => ( fontSize));
+          if (gfs > pMax) pMax = gfs;
+        }
+      }
+      const lineHeight = pMax * 1.5;
+      if (!startLine(lineHeight)) break;
+      for (const word of paragraph.words) {
+        if (currentX + word.width > segs[si].x1 && currentX > segs[si].x0) {
+          if (word.isWordLike === false && word.isWhitespace) continue;
+          if (si < segs.length - 1) {
+            si++;
+            currentX = segs[si].x0;
+          } else {
+            commitLine();
+            currentY += lineHeight;
+            if (!startLine(lineHeight)) break;
+          }
+        }
+        for (const glyph of word.glyphs) {
+          const charWidth = glyph.width;
+          const gfs = _nullishCoalesce(_optionalChain([glyph, 'access', _4 => _4.style, 'optionalAccess', _5 => _5.fontSize]), () => ( fontSize));
+          let foundSpot = false;
+          while (currentY < this.maxHeight) {
+            if (currentX + charWidth > segs[si].x1 && currentX > segs[si].x0) {
+              if (si < segs.length - 1) {
+                si++;
+                currentX = segs[si].x0;
+              } else {
+                commitLine();
+                currentY += lineHeight;
+                if (!startLine(lineHeight)) break;
+              }
+              continue;
+            }
+            if (exclusionMask && exclusionMask(currentX, currentY, charWidth, gfs)) {
+              currentX += charWidth;
+              continue;
+            }
+            foundSpot = true;
+            break;
+          }
+          if (!foundSpot || currentY >= this.maxHeight) break;
+          if (currentX === segs[si].x0 && glyph.char.trim().length === 0 && !this.preserveLeadingSpaces)
+            continue;
+          currentLineNodes.push({
+            char: glyph.char,
+            x: currentX,
+            // Drop smaller glyphs to the shared baseline (no-op when gfs === pMax).
+            y: currentY + (pMax - gfs),
+            width: charWidth,
+            height: gfs,
+            style: glyph.style,
+            level: glyph.level,
+            sourceIndex: glyph.sourceIndex,
+            sourceLength: glyph.sourceLength,
+            combining: glyph.combining
+          });
+          currentX += charWidth;
+          if (currentX > maxLineWidth) maxLineWidth = currentX;
+        }
+      }
+      commitLine();
+      currentX = 0;
+      currentY += lineHeight;
+    }
+    return {
+      nodes: layoutNodes,
+      totalWidth: maxLineWidth,
+      totalHeight: currentY,
+      fallbackToCanvas: prepared.fallbackToCanvas
+    };
+  }
+  /**
+   * Lay out a Unicode string directly into a pre-allocated {@link LayoutResultBuffer}.
+   *
+   * Avoids GC allocations by writing results directly to flat typed arrays in the buffer.
+   *
+   * @param text - The raw text string to lay out.
+   * @param fontAtlas - Pre-measured glyph metrics keyed by grapheme character.
+   * @param fontSize - Target font size in pixels.
+   * @param buffer - The pre-allocated buffer to write layout results into.
+   * @param exclusionMask - Optional collision-detection callback.
+   */
+  layoutTextIntoBuffer(text, fontAtlas, fontSize, buffer, exclusionMask) {
+    this.layoutPreparedIntoBuffer(this.prepare(text, fontAtlas, fontSize), buffer, exclusionMask);
+  }
+  /**
+   * **Hot pass, zero-GC variant.** Place an already-measured {@link PreparedText}
+   * directly into a pre-allocated {@link LayoutResultBuffer}. Like
+   * {@link layoutPrepared} but writes flat typed arrays instead of allocating
+   * {@link LayoutNode} objects — the per-frame path for large dynamic scenes.
+   */
+  layoutPreparedIntoBuffer(prepared, buffer, exclusionMask) {
+    buffer.reset();
+    const fontSize = prepared.fontSize;
+    const lineHeight = fontSize * 1.5;
+    let currentX = 0;
+    let currentY = 0;
+    for (const paragraph of prepared.paragraphs) {
+      if (paragraph.isEmpty) {
+        currentY += lineHeight;
+        currentX = 0;
+        continue;
+      }
+      for (const word of paragraph.words) {
+        if (currentX + word.width > this.maxWidth && currentX > 0) {
+          if (word.isWordLike === false && word.isWhitespace) continue;
+          currentX = 0;
+          currentY += lineHeight;
+        }
+        for (const glyph of word.glyphs) {
+          if (buffer.count >= LayoutResultBuffer.CAPACITY) break;
+          const charWidth = glyph.width;
+          let foundSpot = false;
+          while (currentY < this.maxHeight) {
+            if (currentX + charWidth > this.maxWidth && currentX > 0) {
+              currentX = 0;
+              currentY += lineHeight;
+              continue;
+            }
+            if (exclusionMask && exclusionMask(currentX, currentY, charWidth, fontSize)) {
+              currentX += charWidth;
+              continue;
+            }
+            foundSpot = true;
+            break;
+          }
+          if (!foundSpot || currentY >= this.maxHeight) break;
+          if (currentX === 0 && glyph.char.trim().length === 0) continue;
+          const idx = buffer.count;
+          buffer.chars[idx] = glyph.char;
+          buffer.xs[idx] = currentX;
+          buffer.ys[idx] = currentY;
+          buffer.ws[idx] = charWidth;
+          buffer.hs[idx] = fontSize;
+          buffer.count++;
+          currentX += charWidth;
+        }
+      }
+      currentX = 0;
+      currentY += lineHeight;
+    }
+  }
+}, _class);
+var LayoutResultBuffer = (_class2 = class _LayoutResultBuffer {constructor() { _class2.prototype.__init7.call(this);_class2.prototype.__init8.call(this);_class2.prototype.__init9.call(this);_class2.prototype.__init10.call(this);_class2.prototype.__init11.call(this);_class2.prototype.__init12.call(this); }
+  static __initStatic() {this.CAPACITY = 16384}
+  /** X positions of each glyph. */
+  __init7() {this.xs = new Float32Array(_LayoutResultBuffer.CAPACITY)}
+  /** Y positions of each glyph. */
+  __init8() {this.ys = new Float32Array(_LayoutResultBuffer.CAPACITY)}
+  /** Widths of each glyph. */
+  __init9() {this.ws = new Float32Array(_LayoutResultBuffer.CAPACITY)}
+  /** Heights of each glyph. */
+  __init10() {this.hs = new Float32Array(_LayoutResultBuffer.CAPACITY)}
+  /** Character for each glyph slot. */
+  __init11() {this.chars = Array.from({ length: _LayoutResultBuffer.CAPACITY })}
+  /** Number of valid glyphs written in this buffer. */
+  __init12() {this.count = 0}
+  /** Reset the buffer for reuse. Does NOT free memory. */
+  reset() {
+    this.count = 0;
+  }
+  /** Convert to the standard LayoutResult format (allocates — use sparingly). */
+  toLayoutResult() {
+    const nodes = [];
+    for (let i = 0; i < this.count; i++) {
+      nodes.push({
+        char: this.chars[i],
+        x: this.xs[i],
+        y: this.ys[i],
+        width: this.ws[i],
+        height: this.hs[i]
+      });
+    }
+    return { nodes, totalWidth: 0, totalHeight: 0 };
+  }
+}, _class2.__initStatic(), _class2);
+
+// src/layout/measure.ts
+function createCanvasMeasurer(fontFamily = "sans-serif", baseSize = 100) {
+  if (typeof document === "undefined") return null;
+  const ctx = document.createElement("canvas").getContext("2d");
+  if (!ctx) return null;
+  const font = `${baseSize}px ${fontFamily}`;
+  const cache = /* @__PURE__ */ new Map();
+  return {
+    measure(char, fontSize) {
+      let base = cache.get(char);
+      if (base === void 0) {
+        ctx.font = font;
+        base = ctx.measureText(char).width;
+        cache.set(char, base);
+      }
+      return base * (fontSize / baseSize);
+    }
+  };
+}
+
+
+
+
+
+
+exports.computeLineSegments = computeLineSegments; exports.LayoutEngine = LayoutEngine; exports.LayoutResultBuffer = LayoutResultBuffer; exports.createCanvasMeasurer = createCanvasMeasurer;