@vectojs/core 1.13.0 → 1.15.0

package/dist/chunk-BA5HUUDF.js

@@ -1,760 +0,0 @@
-"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 _chunk4AR425ARjs = require('./chunk-4AR425AR.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 {
-  
-  /**
-   * Horizontal alignment. `'justify'` stretches inter-word spaces (or, for
-   * space-less CJK lines, inter-character gaps) so wrapped lines end flush at
-   * `maxWidth`; the last line of each paragraph stays ragged. Only applies to
-   * the object layout path without exclusion shapes.
-   */
-  __init() {this.textAlign = "left"}
-  
-  __init2() {this.preserveLeadingSpaces = false}
-  
-  
-  __init3() {this.wordCache = /* @__PURE__ */ new Map()}
-  __init4() {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.
-  __init5() {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.
-  __init6() {this.richParagraphCache = /* @__PURE__ */ new Map()}
-  __init7() {this.lastAtlas = null}
-  
-  __init8() {this._hyphenate = null}
-  /**
-   * Optional hyphenator: given a word, return its break parts (e.g.
-   * `['hyphen', 'ation']`). Used at wrap time when a word doesn't fit; a
-   * visible '-' is drawn at the chosen break. Soft hyphens (U+00AD) in the
-   * source work without any hyphenator. Setting this clears the prepared
-   * caches (break opportunities are baked in during prepare()).
-   */
-  get hyphenate() {
-    return this._hyphenate;
-  }
-  set hyphenate(fn) {
-    this._hyphenate = fn;
-    this.paragraphCache.clear();
-    this.richParagraphCache.clear();
-  }
-  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);_class.prototype.__init7.call(this);_class.prototype.__init8.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;
-  }
-  glyphKeyFor(grapheme, fontAtlas) {
-    if (fontAtlas[grapheme]) return grapheme;
-    const firstCodePoint = Array.from(grapheme)[0];
-    if (firstCodePoint && fontAtlas[firstCodePoint]) return firstCodePoint;
-    return grapheme;
-  }
-  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 } = _chunk4AR425ARjs.ArabicShaper.shapeArabic(paragraph);
-      const levels = _chunk4AR425ARjs.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;
-        let breakPoints;
-        for (const char of this.getGraphemes(word)) {
-          if (char === "\xAD") {
-            (breakPoints ??= []).push(glyphs.length);
-            shapedCharIdx += char.length;
-            continue;
-          }
-          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 glyphKey = this.glyphKeyFor(char, fontAtlas);
-          const level = levels[visualStart];
-          const hasGlyph = !!fontAtlas[glyphKey];
-          if (char.trim().length > 0 && !hasGlyph) {
-            pFallback = true;
-            fallbackToCanvas = true;
-          }
-          const w = this.glyphWidth(glyphKey, fontAtlas, fontSize);
-          glyphs.push({
-            char,
-            width: w,
-            level,
-            sourceIndex,
-            sourceLength
-          });
-          width += w;
-          shapedCharIdx += char.length;
-        }
-        if (!breakPoints && this._hyphenate && segment.isWordLike && glyphs.length > 3) {
-          const parts = this._hyphenate(word);
-          if (parts.length > 1) {
-            breakPoints = [];
-            let count = 0;
-            for (let pi = 0; pi < parts.length - 1; pi++) {
-              for (const _g of this.getGraphemes(parts[pi])) count++;
-              breakPoints.push(count);
-            }
-          }
-        }
-        words.push({
-          glyphs,
-          width,
-          isWordLike: segment.isWordLike,
-          isWhitespace: word.trim().length === 0,
-          breakPoints
-        });
-      }
-      const prepared = {
-        words,
-        isEmpty: false,
-        fallbackToCanvas: pFallback || void 0,
-        baseLevel: _chunk4AR425ARjs.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,
-      hyphenWidth: this.glyphWidth(this.glyphKeyFor("-", fontAtlas), fontAtlas, fontSize)
-    };
-  }
-  /**
-   * **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 } = _chunk4AR425ARjs.ArabicShaper.shapeArabic(paragraph);
-      const levels = _chunk4AR425ARjs.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;
-        let breakPoints;
-        for (const char of this.getGraphemes(word)) {
-          if (char === "\xAD") {
-            (breakPoints ??= []).push(glyphs.length);
-            shapedCharIdx += char.length;
-            continue;
-          }
-          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 glyphKey = this.glyphKeyFor(char, fontAtlas);
-          const level = levels[visualStart];
-          const style = styleAt[offset + rawStart];
-          const gfs = _nullishCoalesce(_optionalChain([style, 'optionalAccess', _ => _.fontSize]), () => ( baseFontSize));
-          const hasGlyph = !!fontAtlas[glyphKey];
-          if (char.trim().length > 0 && !hasGlyph) {
-            pFallback = true;
-            fallbackToCanvas = true;
-          }
-          const w = this.glyphWidth(glyphKey, fontAtlas, gfs);
-          glyphs.push({
-            char,
-            width: w,
-            style,
-            level,
-            sourceIndex,
-            sourceLength
-          });
-          width += w;
-          shapedCharIdx += char.length;
-        }
-        if (!breakPoints && this._hyphenate && segment.isWordLike && glyphs.length > 3) {
-          const parts = this._hyphenate(word);
-          if (parts.length > 1) {
-            breakPoints = [];
-            let count = 0;
-            for (let pi = 0; pi < parts.length - 1; pi++) {
-              for (const _g of this.getGraphemes(parts[pi])) count++;
-              breakPoints.push(count);
-            }
-          }
-        }
-        words.push({
-          glyphs,
-          width,
-          isWordLike: segment.isWordLike,
-          isWhitespace: word.trim().length === 0,
-          breakPoints
-        });
-      }
-      const prepared = {
-        words,
-        isEmpty: false,
-        fallbackToCanvas: pFallback || void 0,
-        baseLevel: _chunk4AR425ARjs.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 = (justifyTo) => {
-      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;
-        _chunk4AR425ARjs.BidiResolver.reorderVisual(run, paragraphBaseLevel);
-        let x = runStartX;
-        for (const node of run) {
-          node.x = x;
-          node.isRTL = node.level % 2 === 1;
-          x += node.width;
-        }
-        if (justifyTo !== void 0 && runs.length === 1) {
-          let lastContent = run.length - 1;
-          while (lastContent >= 0 && run[lastContent].char.trim() === "") lastContent--;
-          if (lastContent > 0) {
-            const contentEnd = run[lastContent].x + run[lastContent].width;
-            const slack = justifyTo - contentEnd;
-            if (slack > 0 && slack <= (justifyTo - runStartX) * 0.5) {
-              const spaceIdx = [];
-              for (let k = 1; k < lastContent; k++) {
-                if (run[k].char.trim() === "") spaceIdx.push(k);
-              }
-              if (spaceIdx.length > 0) {
-                const extra = slack / spaceIdx.length;
-                let shift = 0;
-                let nextSpace = 0;
-                for (let k = 0; k <= lastContent; k++) {
-                  run[k].x += shift;
-                  if (nextSpace < spaceIdx.length && k === spaceIdx[nextSpace]) {
-                    run[k].width += extra;
-                    shift += extra;
-                    nextSpace++;
-                  }
-                }
-              } else {
-                const extra = slack / lastContent;
-                for (let k = 1; k <= lastContent; k++) run[k].x += extra * k;
-              }
-              if (justifyTo > maxLineWidth) maxLineWidth = justifyTo;
-            }
-          }
-        }
-        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;
-    };
-    const justifyTarget = this.textAlign === "justify" && !hasEx ? this.maxWidth : void 0;
-    const hyphenWidth = _nullishCoalesce(prepared.hyphenWidth, () => ( fontSize * 0.3));
-    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;
-      const wordQueue = paragraph.words.slice();
-      for (let qi = 0; qi < wordQueue.length; qi++) {
-        const word = wordQueue[qi];
-        if (currentX + word.width > segs[si].x1) {
-          if (!hasEx && word.breakPoints && word.breakPoints.length > 0) {
-            const avail = segs[si].x1 - currentX;
-            let chosen = -1;
-            let prefixWidth = 0;
-            let acc = 0;
-            let bpIdx = 0;
-            for (let g = 0; g < word.glyphs.length && bpIdx < word.breakPoints.length; g++) {
-              acc += word.glyphs[g].width;
-              if (g + 1 === word.breakPoints[bpIdx]) {
-                if (acc + hyphenWidth <= avail) {
-                  chosen = word.breakPoints[bpIdx];
-                  prefixWidth = acc;
-                }
-                bpIdx++;
-              }
-            }
-            if (chosen > 0) {
-              const anchorGlyph = word.glyphs[chosen - 1];
-              const prefix = {
-                glyphs: [
-                  ...word.glyphs.slice(0, chosen),
-                  {
-                    char: "-",
-                    width: hyphenWidth,
-                    level: anchorGlyph.level,
-                    sourceIndex: anchorGlyph.sourceIndex,
-                    sourceLength: 0
-                  }
-                ],
-                width: prefixWidth + hyphenWidth,
-                isWordLike: true,
-                isWhitespace: false
-              };
-              const rest = {
-                glyphs: word.glyphs.slice(chosen),
-                width: word.width - prefixWidth,
-                isWordLike: true,
-                isWhitespace: false,
-                breakPoints: word.breakPoints.filter((bp) => bp > chosen).map((bp) => bp - chosen)
-              };
-              wordQueue.splice(qi, 1, prefix, rest);
-              qi--;
-              continue;
-            }
-          }
-          if (currentX > segs[si].x0) {
-            if (word.isWordLike === false && word.isWhitespace) continue;
-            if (si < segs.length - 1) {
-              si++;
-              currentX = segs[si].x0;
-            } else {
-              commitLine(justifyTarget);
-              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(justifyTarget);
-                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,
-            // Canvas text is positioned by baseline, while `y` is the local
-            // top used by the renderer. Offset smaller runs by their baseline
-            // delta, not by their full em-box delta, so mixed-size glyphs share
-            // one real baseline in every Canvas 2D implementation.
-            y: currentY + (pMax - gfs) * 0.8,
-            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.__init9.call(this);_class2.prototype.__init10.call(this);_class2.prototype.__init11.call(this);_class2.prototype.__init12.call(this);_class2.prototype.__init13.call(this);_class2.prototype.__init14.call(this); }
-  static __initStatic() {this.CAPACITY = 16384}
-  /** X positions of each glyph. */
-  __init9() {this.xs = new Float32Array(_LayoutResultBuffer.CAPACITY)}
-  /** Y positions of each glyph. */
-  __init10() {this.ys = new Float32Array(_LayoutResultBuffer.CAPACITY)}
-  /** Widths of each glyph. */
-  __init11() {this.ws = new Float32Array(_LayoutResultBuffer.CAPACITY)}
-  /** Heights of each glyph. */
-  __init12() {this.hs = new Float32Array(_LayoutResultBuffer.CAPACITY)}
-  /** Character for each glyph slot. */
-  __init13() {this.chars = Array.from({ length: _LayoutResultBuffer.CAPACITY })}
-  /** Number of valid glyphs written in this buffer. */
-  __init14() {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;