@pre-markdown/layout 0.2.0

package/dist/index.js

@@ -0,0 +1,1348 @@
+// src/index.ts
+import {
+  prepare as prepare2,
+  prepareWithSegments as prepareWithSegments2,
+  layout as layout2,
+  layoutWithLines as layoutWithLines2,
+  clearCache as pretextClearCache2,
+  setLocale as pretextSetLocale2
+} from "@chenglou/pretext";
+
+// src/worker-backend.ts
+import {
+  prepare,
+  prepareWithSegments,
+  layout,
+  layoutWithLines,
+  clearCache as pretextClearCache,
+  setLocale as pretextSetLocale
+} from "@chenglou/pretext";
+function createWorkerBackend(workerUrl) {
+  const preparedCache = /* @__PURE__ */ new Map();
+  const segmentCache = /* @__PURE__ */ new Map();
+  let worker = null;
+  let alive = true;
+  let nextId = 1;
+  const pending = /* @__PURE__ */ new Map();
+  function getWorker() {
+    if (worker) return worker;
+    const url = workerUrl ?? new URL("./worker-script.js", import.meta.url);
+    worker = new Worker(url, { type: "module" });
+    worker.onmessage = (event) => {
+      const { id, type, result, error } = event.data;
+      const handlers = pending.get(id);
+      if (!handlers) return;
+      pending.delete(id);
+      if (type === "error") {
+        handlers.reject(new Error(error ?? "Worker error"));
+      } else {
+        handlers.resolve(result);
+      }
+    };
+    worker.onerror = (event) => {
+      for (const [id, handlers] of pending) {
+        handlers.reject(new Error(`Worker error: ${event.message}`));
+      }
+      pending.clear();
+    };
+    return worker;
+  }
+  function sendMessage(msg) {
+    if (!alive) return Promise.reject(new Error("Worker has been terminated"));
+    return new Promise((resolve, reject) => {
+      const id = nextId++;
+      pending.set(id, { resolve, reject });
+      getWorker().postMessage({ ...msg, id });
+    });
+  }
+  function cacheKey(text, font, options) {
+    return `${font}|${options?.whiteSpace ?? "normal"}|${text}`;
+  }
+  const backend = {
+    // Synchronous prepare — uses main-thread pretext (with cache fallback)
+    prepare(text, font, options) {
+      const key = cacheKey(text, font, options);
+      let cached = preparedCache.get(key);
+      if (!cached) {
+        cached = prepare(text, font, options);
+        preparedCache.set(key, cached);
+      }
+      return cached;
+    },
+    prepareWithSegments(text, font, options) {
+      const key = cacheKey(text, font, options);
+      let cached = segmentCache.get(key);
+      if (!cached) {
+        cached = prepareWithSegments(text, font, options);
+        segmentCache.set(key, cached);
+      }
+      return cached;
+    },
+    // Layout is always synchronous (pure arithmetic)
+    layout(prepared, maxWidth, lineHeight) {
+      return layout(prepared, maxWidth, lineHeight);
+    },
+    layoutWithLines(prepared, maxWidth, lineHeight) {
+      return layoutWithLines(prepared, maxWidth, lineHeight);
+    },
+    clearCache() {
+      preparedCache.clear();
+      segmentCache.clear();
+      pretextClearCache();
+      if (alive && worker) {
+        sendMessage({ type: "clearCache" }).catch(() => {
+        });
+      }
+    },
+    setLocale(locale) {
+      pretextSetLocale(locale);
+      if (alive && worker) {
+        sendMessage({ type: "setLocale", locale }).catch(() => {
+        });
+      }
+    },
+    // --------------------------------------------------------
+    // Async API — offloads to Worker
+    // --------------------------------------------------------
+    async prepareAsync(texts, font, options) {
+      const results = new Array(texts.length);
+      const toProcess = [];
+      for (let i = 0; i < texts.length; i++) {
+        const key = cacheKey(texts[i], font, options);
+        const cached = preparedCache.get(key);
+        if (cached) {
+          results[i] = cached;
+        } else {
+          toProcess.push({ index: i, text: texts[i] });
+        }
+      }
+      if (toProcess.length > 0) {
+        const BATCH_SIZE = 50;
+        for (let b = 0; b < toProcess.length; b += BATCH_SIZE) {
+          const batch = toProcess.slice(b, b + BATCH_SIZE);
+          const promises = batch.map(
+            ({ text }) => sendMessage({ type: "prepare", text, font, options }).then((result) => result)
+          );
+          const batchResults = await Promise.all(promises);
+          for (let j = 0; j < batch.length; j++) {
+            const { index, text } = batch[j];
+            const prepared = batchResults[j];
+            const key = cacheKey(text, font, options);
+            preparedCache.set(key, prepared);
+            results[index] = prepared;
+          }
+        }
+      }
+      return results;
+    },
+    async prepareWithSegmentsAsync(texts, font, options) {
+      const results = new Array(texts.length);
+      const toProcess = [];
+      for (let i = 0; i < texts.length; i++) {
+        const key = cacheKey(texts[i], font, options);
+        const cached = segmentCache.get(key);
+        if (cached) {
+          results[i] = cached;
+        } else {
+          toProcess.push({ index: i, text: texts[i] });
+        }
+      }
+      if (toProcess.length > 0) {
+        const BATCH_SIZE = 50;
+        for (let b = 0; b < toProcess.length; b += BATCH_SIZE) {
+          const batch = toProcess.slice(b, b + BATCH_SIZE);
+          const promises = batch.map(
+            ({ text }) => sendMessage({ type: "prepareWithSegments", text, font, options }).then((result) => result)
+          );
+          const batchResults = await Promise.all(promises);
+          for (let j = 0; j < batch.length; j++) {
+            const { index, text } = batch[j];
+            const prepared = batchResults[j];
+            const key = cacheKey(text, font, options);
+            segmentCache.set(key, prepared);
+            results[index] = prepared;
+          }
+        }
+      }
+      return results;
+    },
+    get isAlive() {
+      return alive;
+    },
+    terminate() {
+      alive = false;
+      if (worker) {
+        worker.terminate();
+        worker = null;
+      }
+      for (const [, handlers] of pending) {
+        handlers.reject(new Error("Worker terminated"));
+      }
+      pending.clear();
+    }
+  };
+  return backend;
+}
+
+// src/virtual-list.ts
+var VirtualList = class {
+  engine;
+  viewportHeight;
+  overscan;
+  itemGap;
+  /** Item texts */
+  items = [];
+  /** Cached item heights (pretext-measured) */
+  heights = [];
+  /** Cumulative offsets (heights[0..i-1] + gaps) */
+  offsets = [];
+  /** Total height of all items */
+  totalHeight = 0;
+  /** Current scroll position */
+  scrollTop = 0;
+  /** Viewport change callback */
+  onViewportChange = null;
+  constructor(config) {
+    this.engine = config.engine;
+    this.viewportHeight = config.viewportHeight;
+    this.overscan = config.overscan ?? 5;
+    this.itemGap = config.itemGap ?? 0;
+  }
+  // --------------------------------------------------------
+  // Data Management
+  // --------------------------------------------------------
+  /**
+   * Set the full list of items. Computes all heights.
+   * For incremental updates, use updateItems() instead.
+   */
+  setItems(texts) {
+    this.items = texts;
+    this.heights = new Array(texts.length);
+    this.offsets = new Array(texts.length);
+    let cumHeight = 0;
+    for (let i = 0; i < texts.length; i++) {
+      this.offsets[i] = cumHeight;
+      const result = this.engine.computeLayout(texts[i]);
+      this.heights[i] = result.height;
+      cumHeight += result.height + this.itemGap;
+    }
+    this.totalHeight = texts.length > 0 ? cumHeight - this.itemGap : 0;
+  }
+  /**
+   * Incrementally update items. Only recomputes heights for changed items.
+   * Much faster than setItems() for editing scenarios.
+   *
+   * @returns Indices of items that changed height
+   */
+  updateItems(texts) {
+    const prevItems = this.items;
+    const prevHeights = this.heights;
+    this.items = texts;
+    const len = texts.length;
+    const heights = new Array(len);
+    const changedIndices = [];
+    for (let i = 0; i < len; i++) {
+      if (i < prevItems.length && prevItems[i] === texts[i]) {
+        heights[i] = prevHeights[i];
+      } else {
+        heights[i] = this.engine.computeLayout(texts[i]).height;
+        changedIndices.push(i);
+      }
+    }
+    this.heights = heights;
+    this.offsets = new Array(len);
+    let cumHeight = 0;
+    for (let i = 0; i < len; i++) {
+      this.offsets[i] = cumHeight;
+      cumHeight += heights[i] + this.itemGap;
+    }
+    this.totalHeight = len > 0 ? cumHeight - this.itemGap : 0;
+    return changedIndices;
+  }
+  /**
+   * Get the height of a specific item.
+   */
+  getItemHeight(index) {
+    return this.heights[index] ?? 0;
+  }
+  /**
+   * Get the offset of a specific item from the top.
+   */
+  getItemOffset(index) {
+    return this.offsets[index] ?? 0;
+  }
+  // --------------------------------------------------------
+  // Scroll & Viewport
+  // --------------------------------------------------------
+  /**
+   * Set the scroll position and compute the visible range.
+   * Fires the onViewportChange callback if registered.
+   */
+  setScrollTop(scrollTop) {
+    this.scrollTop = Math.max(0, Math.min(scrollTop, this.totalHeight - this.viewportHeight));
+    const range = this.computeViewport();
+    if (this.onViewportChange) {
+      this.onViewportChange(range);
+    }
+    return range;
+  }
+  /**
+   * Get the current scroll position.
+   */
+  getScrollTop() {
+    return this.scrollTop;
+  }
+  /**
+   * Update viewport height (e.g., on window resize).
+   */
+  setViewportHeight(height) {
+    this.viewportHeight = height;
+  }
+  /**
+   * Scroll to make a specific item visible.
+   * @param index - Item index to scroll to
+   * @param align - 'start' | 'center' | 'end' (default: 'start')
+   */
+  scrollToItem(index, align = "start") {
+    if (index < 0 || index >= this.items.length) {
+      return this.computeViewport();
+    }
+    const offset = this.offsets[index];
+    const height = this.heights[index];
+    let scrollTop;
+    switch (align) {
+      case "start":
+        scrollTop = offset;
+        break;
+      case "center":
+        scrollTop = offset - (this.viewportHeight - height) / 2;
+        break;
+      case "end":
+        scrollTop = offset - this.viewportHeight + height;
+        break;
+    }
+    return this.setScrollTop(scrollTop);
+  }
+  /**
+   * Register a callback for viewport changes.
+   */
+  onViewport(callback) {
+    this.onViewportChange = callback;
+  }
+  // --------------------------------------------------------
+  // Viewport Computation
+  // --------------------------------------------------------
+  /**
+   * Compute the current visible range.
+   */
+  computeViewport() {
+    const len = this.items.length;
+    if (len === 0) {
+      return {
+        startIndex: 0,
+        endIndex: 0,
+        items: [],
+        totalHeight: 0,
+        offsetY: 0
+      };
+    }
+    const scrollTop = this.scrollTop;
+    const scrollBottom = scrollTop + this.viewportHeight;
+    let startIndex = this.binarySearchOffset(scrollTop);
+    let endIndex = this.binarySearchOffset(scrollBottom);
+    if (endIndex < len) endIndex++;
+    startIndex = Math.max(0, startIndex - this.overscan);
+    endIndex = Math.min(len, endIndex + this.overscan);
+    const items = [];
+    for (let i = startIndex; i < endIndex; i++) {
+      items.push({
+        index: i,
+        offsetTop: this.offsets[i],
+        height: this.heights[i],
+        text: this.items[i]
+      });
+    }
+    return {
+      startIndex,
+      endIndex,
+      items,
+      totalHeight: this.totalHeight,
+      offsetY: this.offsets[startIndex] ?? 0
+    };
+  }
+  // --------------------------------------------------------
+  // Hit Testing
+  // --------------------------------------------------------
+  /**
+   * Find which item is at a given Y position.
+   * @returns Item index, or -1 if out of bounds
+   */
+  hitTest(y) {
+    if (this.items.length === 0 || y < 0) return -1;
+    if (y >= this.totalHeight) return -1;
+    return this.binarySearchOffset(y);
+  }
+  /**
+   * Find the item and local Y offset within it.
+   */
+  hitTestDetailed(y) {
+    const index = this.hitTest(y);
+    if (index === -1) return null;
+    return {
+      index,
+      localY: y - this.offsets[index]
+    };
+  }
+  // --------------------------------------------------------
+  // Resize Handling
+  // --------------------------------------------------------
+  /**
+   * Recompute all item heights (e.g., after maxWidth change).
+   * Call this after engine.updateConfig({ maxWidth: newWidth }).
+   *
+   * @returns Time taken in milliseconds
+   */
+  relayout() {
+    const start = performance.now();
+    let cumHeight = 0;
+    for (let i = 0; i < this.items.length; i++) {
+      this.offsets[i] = cumHeight;
+      const result = this.engine.computeLayout(this.items[i]);
+      this.heights[i] = result.height;
+      cumHeight += result.height + this.itemGap;
+    }
+    this.totalHeight = this.items.length > 0 ? cumHeight - this.itemGap : 0;
+    return performance.now() - start;
+  }
+  // --------------------------------------------------------
+  // Getters
+  // --------------------------------------------------------
+  /** Total height of all items */
+  getTotalHeight() {
+    return this.totalHeight;
+  }
+  /** Number of items */
+  getItemCount() {
+    return this.items.length;
+  }
+  /** Get all item heights (readonly) */
+  getHeights() {
+    return this.heights;
+  }
+  /** Get all item offsets (readonly) */
+  getOffsets() {
+    return this.offsets;
+  }
+  // --------------------------------------------------------
+  // Internal: Binary Search
+  // --------------------------------------------------------
+  /**
+   * Binary search for the item at a given Y offset.
+   * Returns the index of the item that contains the offset.
+   */
+  binarySearchOffset(y) {
+    const offsets = this.offsets;
+    const len = offsets.length;
+    if (len === 0) return 0;
+    let lo = 0;
+    let hi = len - 1;
+    while (lo < hi) {
+      const mid = lo + hi + 1 >>> 1;
+      if (offsets[mid] <= y) {
+        lo = mid;
+      } else {
+        hi = mid - 1;
+      }
+    }
+    return lo;
+  }
+};
+
+// src/cursor.ts
+var CursorEngine = class {
+  engine;
+  text = "";
+  hardLines = [""];
+  visualLines = [];
+  lineNumbers = [];
+  totalHeight = 0;
+  constructor(engine) {
+    this.engine = engine;
+  }
+  // --------------------------------------------------------
+  // Text Management
+  // --------------------------------------------------------
+  /**
+   * Set the text content and compute all visual line info.
+   * Call this when the editor content changes.
+   */
+  setText(text) {
+    this.text = text;
+    this.hardLines = text.split("\n");
+    this.recompute();
+  }
+  /** Get current text */
+  getText() {
+    return this.text;
+  }
+  /**
+   * Force recomputation of layout (e.g., after width change).
+   * Call after engine.updateConfig({ maxWidth: newWidth }).
+   */
+  recompute() {
+    const { hardLines } = this;
+    const visualLines = [];
+    const lineNumbers = [];
+    const lineHeight = this.engine.getConfig().lineHeight;
+    let globalOffset = 0;
+    let y = 0;
+    for (let srcLine = 0; srcLine < hardLines.length; srcLine++) {
+      const lineText = hardLines[srcLine];
+      const layout3 = this.engine.computeLayoutWithLines(lineText);
+      const lines = layout3.lines ?? [];
+      const lineNumInfo = {
+        lineNumber: srcLine + 1,
+        y,
+        visualLineCount: lines.length || 1,
+        height: layout3.height || lineHeight
+      };
+      lineNumbers.push(lineNumInfo);
+      if (lines.length === 0) {
+        visualLines.push({
+          index: visualLines.length,
+          text: "",
+          width: 0,
+          y,
+          sourceLine: srcLine,
+          startOffset: globalOffset,
+          endOffset: globalOffset
+        });
+        y += lineHeight;
+      } else {
+        let lineStartOffset = globalOffset;
+        for (let vl = 0; vl < lines.length; vl++) {
+          const line = lines[vl];
+          const endOffset = lineStartOffset + line.text.length;
+          visualLines.push({
+            index: visualLines.length,
+            text: line.text,
+            width: line.width,
+            y,
+            sourceLine: srcLine,
+            startOffset: lineStartOffset,
+            endOffset
+          });
+          lineStartOffset = endOffset;
+          y += lineHeight;
+        }
+      }
+      globalOffset += lineText.length;
+      if (srcLine < hardLines.length - 1) {
+        globalOffset += 1;
+      }
+    }
+    this.visualLines = visualLines;
+    this.lineNumbers = lineNumbers;
+    this.totalHeight = y;
+  }
+  // --------------------------------------------------------
+  // Cursor Positioning
+  // --------------------------------------------------------
+  /**
+   * Convert a text offset to pixel coordinates.
+   * Returns the cursor position (x, y) for rendering a blinking cursor.
+   */
+  offsetToPosition(offset) {
+    const clamped = Math.max(0, Math.min(offset, this.text.length));
+    const lineHeight = this.engine.getConfig().lineHeight;
+    const vl = this.findVisualLineByOffset(clamped);
+    if (!vl) {
+      return { offset: clamped, visualLine: 0, x: 0, y: 0, lineHeight };
+    }
+    const localOffset = clamped - vl.startOffset;
+    const prefix = vl.text.slice(0, localOffset);
+    let x = 0;
+    if (prefix.length > 0) {
+      const prefixLayout = this.engine.computeLayout(prefix);
+      const prefixLines = this.engine.computeLayoutWithLines(prefix);
+      const lastLine = prefixLines.lines?.[prefixLines.lines.length - 1];
+      x = lastLine?.width ?? 0;
+    }
+    return {
+      offset: clamped,
+      visualLine: vl.index,
+      x,
+      y: vl.y,
+      lineHeight
+    };
+  }
+  /**
+   * Convert pixel coordinates (from a click event) to a text offset.
+   * This is the reverse of offsetToPosition().
+   */
+  xyToOffset(x, y) {
+    const lineHeight = this.engine.getConfig().lineHeight;
+    const visualLineIdx = Math.floor(y / lineHeight);
+    const vl = this.visualLines[Math.max(0, Math.min(visualLineIdx, this.visualLines.length - 1))];
+    if (!vl) return 0;
+    const lineText = vl.text;
+    if (lineText.length === 0) return vl.startOffset;
+    let lo = 0;
+    let hi = lineText.length;
+    while (lo < hi) {
+      const mid = lo + hi >>> 1;
+      const prefix = lineText.slice(0, mid + 1);
+      const layout3 = this.engine.computeLayoutWithLines(prefix);
+      const lastLine = layout3.lines?.[layout3.lines.length - 1];
+      const w = lastLine?.width ?? 0;
+      if (w <= x) {
+        lo = mid + 1;
+      } else {
+        hi = mid;
+      }
+    }
+    if (lo > 0 && lo <= lineText.length) {
+      const prefixPrev = lineText.slice(0, lo - 1);
+      const prefixCurr = lineText.slice(0, lo);
+      const layoutPrev = this.engine.computeLayoutWithLines(prefixPrev);
+      const layoutCurr = this.engine.computeLayoutWithLines(prefixCurr);
+      const wPrev = layoutPrev.lines?.[layoutPrev.lines.length - 1]?.width ?? 0;
+      const wCurr = layoutCurr.lines?.[layoutCurr.lines.length - 1]?.width ?? 0;
+      if (x - wPrev < wCurr - x) {
+        lo = lo - 1;
+      }
+    }
+    return vl.startOffset + Math.min(lo, lineText.length);
+  }
+  // --------------------------------------------------------
+  // Selection
+  // --------------------------------------------------------
+  /**
+   * Compute selection highlight rectangles for a text range.
+   * Returns one rect per visual line that intersects the selection.
+   */
+  getSelectionRects(start, end) {
+    if (start === end) return [];
+    const s = Math.min(start, end);
+    const e = Math.max(start, end);
+    const lineHeight = this.engine.getConfig().lineHeight;
+    const maxWidth = this.engine.getConfig().maxWidth;
+    const rects = [];
+    for (const vl of this.visualLines) {
+      if (vl.endOffset <= s) continue;
+      if (vl.startOffset >= e) break;
+      const selStart = Math.max(s, vl.startOffset);
+      const selEnd = Math.min(e, vl.endOffset);
+      const localStart = selStart - vl.startOffset;
+      const localEnd = selEnd - vl.startOffset;
+      let x1 = 0;
+      if (localStart > 0) {
+        const prefix = vl.text.slice(0, localStart);
+        const layout3 = this.engine.computeLayoutWithLines(prefix);
+        x1 = layout3.lines?.[layout3.lines.length - 1]?.width ?? 0;
+      }
+      let x2;
+      if (localEnd >= vl.text.length) {
+        x2 = vl.text.length > 0 ? vl.width : 0;
+        if (selEnd > vl.endOffset || selEnd === vl.endOffset && e > vl.endOffset) {
+          x2 = Math.max(x2, maxWidth);
+        }
+      } else {
+        const prefix = vl.text.slice(0, localEnd);
+        const layout3 = this.engine.computeLayoutWithLines(prefix);
+        x2 = layout3.lines?.[layout3.lines.length - 1]?.width ?? 0;
+      }
+      if (x2 > x1 || x1 === 0 && x2 === 0 && selStart < selEnd) {
+        rects.push({
+          x: x1,
+          y: vl.y,
+          width: Math.max(x2 - x1, 4),
+          // min 4px for visibility on empty lines
+          height: lineHeight
+        });
+      }
+    }
+    return rects;
+  }
+  // --------------------------------------------------------
+  // Line Information
+  // --------------------------------------------------------
+  /** Get all visual lines */
+  getVisualLines() {
+    return this.visualLines;
+  }
+  /** Get visual line count (total lines including wrapped) */
+  getVisualLineCount() {
+    return this.visualLines.length;
+  }
+  /** Get source line count (hard lines from \n) */
+  getSourceLineCount() {
+    return this.hardLines.length;
+  }
+  /**
+   * Get line number info for rendering line numbers.
+   * Each entry represents a source line with its Y position
+   * and how many visual lines it spans (for proper alignment).
+   */
+  getLineNumbers() {
+    return this.lineNumbers;
+  }
+  /** Get total content height in pixels */
+  getTotalHeight() {
+    return this.totalHeight;
+  }
+  /**
+   * Get the source line number for a given text offset.
+   * Returns 1-based line number.
+   */
+  getLineNumberAtOffset(offset) {
+    const vl = this.findVisualLineByOffset(offset);
+    return vl ? vl.sourceLine + 1 : 1;
+  }
+  /**
+   * Get the visual line at a given Y coordinate.
+   */
+  getVisualLineAtY(y) {
+    const lineHeight = this.engine.getConfig().lineHeight;
+    const idx = Math.floor(y / lineHeight);
+    return this.visualLines[idx] ?? null;
+  }
+  /**
+   * Get all visual lines for a given source line.
+   */
+  getVisualLinesForSourceLine(sourceLine) {
+    return this.visualLines.filter((vl) => vl.sourceLine === sourceLine);
+  }
+  // --------------------------------------------------------
+  // Word boundary utilities (for double-click word selection)
+  // --------------------------------------------------------
+  /**
+   * Find word boundaries at a given offset.
+   * Returns [start, end] offsets of the word.
+   */
+  getWordBoundary(offset) {
+    const text = this.text;
+    if (text.length === 0) return [0, 0];
+    const clamped = Math.max(0, Math.min(offset, text.length - 1));
+    const isWordChar = (ch2) => ch2 >= 48 && ch2 <= 57 || // 0-9
+    ch2 >= 65 && ch2 <= 90 || // A-Z
+    ch2 >= 97 && ch2 <= 122 || // a-z
+    ch2 === 95 || // _
+    ch2 > 127;
+    const ch = text.charCodeAt(clamped);
+    if (!isWordChar(ch)) {
+      return [clamped, clamped + 1];
+    }
+    let start = clamped;
+    while (start > 0 && isWordChar(text.charCodeAt(start - 1))) start--;
+    let end = clamped;
+    while (end < text.length && isWordChar(text.charCodeAt(end))) end++;
+    return [start, end];
+  }
+  // --------------------------------------------------------
+  // Internal helpers
+  // --------------------------------------------------------
+  /**
+   * Find the visual line containing a given text offset.
+   * Uses binary search for O(log n) performance.
+   */
+  findVisualLineByOffset(offset) {
+    const lines = this.visualLines;
+    if (lines.length === 0) return null;
+    let lo = 0;
+    let hi = lines.length - 1;
+    while (lo < hi) {
+      const mid = lo + hi + 1 >>> 1;
+      if (lines[mid].startOffset <= offset) {
+        lo = mid;
+      } else {
+        hi = mid - 1;
+      }
+    }
+    return lines[lo] ?? null;
+  }
+};
+
+// src/line-renderer.ts
+var LineRenderer = class {
+  cursor;
+  container;
+  lineHeight;
+  activeClass;
+  virtual;
+  overscan;
+  activeLine = -1;
+  lastScrollTop = 0;
+  lastViewportHeight = 0;
+  renderedRange = [0, 0];
+  // DOM pool for virtual rendering
+  pool = [];
+  constructor(config) {
+    this.cursor = config.cursor;
+    this.container = config.container;
+    this.lineHeight = config.lineHeight;
+    this.activeClass = config.activeClass ?? "active-line";
+    this.virtual = config.virtual ?? true;
+    this.overscan = config.overscan ?? 20;
+  }
+  // --------------------------------------------------------
+  // Active Line
+  // --------------------------------------------------------
+  /**
+   * Set the active (cursor) line. Highlighted in the gutter.
+   * @param lineNumber - 1-based source line number
+   */
+  setActiveLine(lineNumber) {
+    if (lineNumber === this.activeLine) return;
+    if (this.activeLine > 0) {
+      const oldEl = this.container.querySelector(
+        `[data-line="${this.activeLine}"]`
+      );
+      if (oldEl) oldEl.classList.remove(this.activeClass);
+    }
+    this.activeLine = lineNumber;
+    const newEl = this.container.querySelector(
+      `[data-line="${lineNumber}"]`
+    );
+    if (newEl) newEl.classList.add(this.activeClass);
+  }
+  /** Get the current active line number (1-based) */
+  getActiveLine() {
+    return this.activeLine;
+  }
+  // --------------------------------------------------------
+  // Rendering
+  // --------------------------------------------------------
+  /**
+   * Full render: rebuild all line numbers.
+   * Use for initial render or after text content changes.
+   */
+  render() {
+    const lineNumbers = this.cursor.getLineNumbers();
+    const totalLines = lineNumbers.length;
+    if (this.virtual && totalLines > 1e3) {
+      this.renderVirtual();
+      return;
+    }
+    this.renderAll(lineNumbers);
+  }
+  /**
+   * Render all line numbers (non-virtual mode).
+   * Uses absolutely-positioned divs for correct alignment with soft-wrapped text.
+   */
+  renderAll(lineNumbers) {
+    const fragment = document.createDocumentFragment();
+    for (const info of lineNumbers) {
+      const div = document.createElement("div");
+      div.textContent = String(info.lineNumber);
+      div.setAttribute("data-line", String(info.lineNumber));
+      div.style.height = info.height + "px";
+      div.style.lineHeight = info.height + "px";
+      if (info.lineNumber === this.activeLine) {
+        div.classList.add(this.activeClass);
+      }
+      fragment.appendChild(div);
+    }
+    this.container.innerHTML = "";
+    this.container.appendChild(fragment);
+  }
+  /**
+   * Virtual rendering: only render line numbers visible in the viewport.
+   * Uses absolute positioning with a spacer for correct scroll height.
+   */
+  renderVirtual() {
+    const lineNumbers = this.cursor.getLineNumbers();
+    const totalHeight = this.cursor.getTotalHeight();
+    const scrollTop = this.lastScrollTop;
+    const viewportHeight = this.lastViewportHeight || 800;
+    const startY = Math.max(0, scrollTop - this.overscan * this.lineHeight);
+    const endY = scrollTop + viewportHeight + this.overscan * this.lineHeight;
+    let startIdx = 0;
+    let endIdx = lineNumbers.length;
+    {
+      let lo = 0, hi = lineNumbers.length - 1;
+      while (lo < hi) {
+        const mid = lo + hi + 1 >>> 1;
+        if (lineNumbers[mid].y <= startY) lo = mid;
+        else hi = mid - 1;
+      }
+      startIdx = lo;
+    }
+    {
+      let lo = startIdx, hi = lineNumbers.length - 1;
+      while (lo < hi) {
+        const mid = lo + hi + 1 >>> 1;
+        if (lineNumbers[mid].y <= endY) lo = mid;
+        else hi = mid - 1;
+      }
+      endIdx = lo + 1;
+    }
+    if (this.renderedRange[0] === startIdx && this.renderedRange[1] === endIdx) {
+      return;
+    }
+    this.renderedRange = [startIdx, endIdx];
+    this.container.innerHTML = "";
+    const spacer = document.createElement("div");
+    spacer.style.height = totalHeight + "px";
+    spacer.style.position = "relative";
+    const fragment = document.createDocumentFragment();
+    for (let i = startIdx; i < endIdx && i < lineNumbers.length; i++) {
+      const info = lineNumbers[i];
+      const div = this.getPooledDiv();
+      div.textContent = String(info.lineNumber);
+      div.setAttribute("data-line", String(info.lineNumber));
+      div.style.position = "absolute";
+      div.style.top = info.y + "px";
+      div.style.height = info.height + "px";
+      div.style.lineHeight = info.height + "px";
+      div.style.width = "100%";
+      div.style.textAlign = "right";
+      if (info.lineNumber === this.activeLine) {
+        div.classList.add(this.activeClass);
+      } else {
+        div.classList.remove(this.activeClass);
+      }
+      fragment.appendChild(div);
+    }
+    spacer.appendChild(fragment);
+    this.container.appendChild(spacer);
+  }
+  /**
+   * Update scroll position for virtual rendering.
+   * Call from the editor's scroll event handler.
+   */
+  updateScroll(scrollTop, viewportHeight) {
+    this.lastScrollTop = scrollTop;
+    this.lastViewportHeight = viewportHeight;
+    if (this.virtual && this.cursor.getSourceLineCount() > 1e3) {
+      this.renderVirtual();
+    }
+  }
+  /**
+   * Update after text changes. Re-renders line numbers.
+   */
+  update() {
+    this.render();
+  }
+  // --------------------------------------------------------
+  // Auto-wrap information
+  // --------------------------------------------------------
+  /**
+   * Get the number of visual lines for each source line.
+   * Useful for understanding how text wraps without DOM measurement.
+   *
+   * @returns Array where index = source line (0-based), value = visual line count
+   */
+  getWrapInfo() {
+    const lineNumbers = this.cursor.getLineNumbers();
+    return lineNumbers.map((ln) => ln.visualLineCount);
+  }
+  /**
+   * Check if a source line is soft-wrapped (spans multiple visual lines).
+   */
+  isLineWrapped(sourceLine) {
+    const lineNumbers = this.cursor.getLineNumbers();
+    const info = lineNumbers[sourceLine];
+    return info ? info.visualLineCount > 1 : false;
+  }
+  /**
+   * Get total visual line count (including wrapped lines).
+   */
+  getTotalVisualLines() {
+    return this.cursor.getVisualLineCount();
+  }
+  // --------------------------------------------------------
+  // Cleanup
+  // --------------------------------------------------------
+  /**
+   * Dispose resources.
+   */
+  dispose() {
+    this.container.innerHTML = "";
+    this.pool = [];
+  }
+  // --------------------------------------------------------
+  // Internal
+  // --------------------------------------------------------
+  getPooledDiv() {
+    if (this.pool.length > 0) {
+      return this.pool.pop();
+    }
+    return document.createElement("div");
+  }
+};
+
+// src/index.ts
+var LRUCache = class {
+  map = /* @__PURE__ */ new Map();
+  maxSize;
+  constructor(maxSize = 512) {
+    this.maxSize = maxSize;
+  }
+  get(key) {
+    const entry = this.map.get(key);
+    if (!entry) return void 0;
+    this.map.delete(key);
+    this.map.set(key, entry);
+    return entry.value;
+  }
+  set(key, value) {
+    if (this.map.has(key)) {
+      this.map.delete(key);
+    } else if (this.map.size >= this.maxSize) {
+      const first = this.map.keys().next().value;
+      if (first !== void 0) this.map.delete(first);
+    }
+    this.map.set(key, { value });
+  }
+  has(key) {
+    return this.map.has(key);
+  }
+  delete(key) {
+    return this.map.delete(key);
+  }
+  clear() {
+    this.map.clear();
+  }
+  get size() {
+    return this.map.size;
+  }
+};
+var pretextBackend = {
+  prepare: prepare2,
+  prepareWithSegments: prepareWithSegments2,
+  layout: layout2,
+  layoutWithLines: layoutWithLines2,
+  clearCache: pretextClearCache2,
+  setLocale: pretextSetLocale2
+};
+function createFallbackBackend(avgCharWidth = 8) {
+  return {
+    prepare(text, _font, _options) {
+      return { __fallback: true, text };
+    },
+    prepareWithSegments(text, _font, _options) {
+      return { __fallback: true, text, segments: text.split(/(\s+)/).filter(Boolean) };
+    },
+    layout(prepared, maxWidth, lineHeight) {
+      const text = prepared.text ?? "";
+      const lines = estimateLines(text, maxWidth, avgCharWidth);
+      return { height: lines * lineHeight, lineCount: lines };
+    },
+    layoutWithLines(prepared, maxWidth, lineHeight) {
+      const text = prepared.text ?? "";
+      const wrappedLines = wrapText(text, maxWidth, avgCharWidth);
+      const lines = wrappedLines.map((line, i) => ({
+        text: line,
+        width: line.length * avgCharWidth,
+        start: { segmentIndex: 0, graphemeIndex: 0 },
+        end: { segmentIndex: 0, graphemeIndex: 0 }
+      }));
+      return {
+        height: lines.length * lineHeight,
+        lineCount: lines.length,
+        lines
+      };
+    },
+    clearCache() {
+    },
+    setLocale() {
+    }
+  };
+}
+function estimateLines(text, maxWidth, avgCharWidth) {
+  if (text.length === 0) return 1;
+  const hardLines = text.split("\n");
+  let total = 0;
+  const charsPerLine = Math.max(1, Math.floor(maxWidth / avgCharWidth));
+  for (const line of hardLines) {
+    total += Math.max(1, Math.ceil(line.length / charsPerLine));
+  }
+  return total;
+}
+function wrapText(text, maxWidth, avgCharWidth) {
+  const charsPerLine = Math.max(1, Math.floor(maxWidth / avgCharWidth));
+  const result = [];
+  const hardLines = text.split("\n");
+  for (const line of hardLines) {
+    if (line.length <= charsPerLine) {
+      result.push(line);
+    } else {
+      for (let i = 0; i < line.length; i += charsPerLine) {
+        result.push(line.slice(i, i + charsPerLine));
+      }
+    }
+  }
+  return result.length > 0 ? result : [""];
+}
+var LayoutEngine = class {
+  config;
+  backend;
+  preparedCache;
+  preparedSegCache;
+  constructor(config, backend) {
+    this.config = {
+      viewportBuffer: 2,
+      whiteSpace: "normal",
+      ...config
+    };
+    this.backend = backend ?? pretextBackend;
+    this.preparedCache = new LRUCache(512);
+    this.preparedSegCache = new LRUCache(256);
+  }
+  // --------------------------------------------------------
+  // Configuration
+  // --------------------------------------------------------
+  /** Update layout configuration. Invalidates cache if font changes. */
+  updateConfig(config) {
+    const fontChanged = config.font && config.font !== this.config.font;
+    this.config = { ...this.config, ...config };
+    if (fontChanged) {
+      this.clearAllCaches();
+    }
+  }
+  /** Get current configuration (readonly). */
+  getConfig() {
+    return this.config;
+  }
+  /** Replace the measurement backend (e.g. for testing). */
+  setBackend(backend) {
+    this.backend = backend;
+    this.clearAllCaches();
+  }
+  /** Set locale for text segmentation. */
+  setLocale(locale) {
+    this.backend.setLocale(locale);
+    this.clearAllCaches();
+  }
+  // --------------------------------------------------------
+  // Core Layout API
+  // --------------------------------------------------------
+  /**
+   * Compute height and line count for a text block.
+   * Uses pretext prepare() + layout() pipeline.
+   * The PreparedText is cached by (text, font) key.
+   */
+  computeLayout(text) {
+    const prepared = this.getPrepared(text);
+    const result = this.backend.layout(prepared, this.config.maxWidth, this.config.lineHeight);
+    return {
+      height: result.height,
+      lineCount: result.lineCount
+    };
+  }
+  /**
+   * Compute layout for code blocks using code font.
+   * Falls back to main font if codeFont is not configured.
+   */
+  computeCodeLayout(text) {
+    const font = this.config.codeFont ?? this.config.font;
+    const lineHeight = this.config.codeLineHeight ?? this.config.lineHeight;
+    const key = `${font}|pre-wrap|${text}`;
+    let prepared = this.preparedCache.get(key);
+    if (!prepared) {
+      prepared = this.backend.prepare(text, font, { whiteSpace: "pre-wrap" });
+      this.preparedCache.set(key, prepared);
+    }
+    const result = this.backend.layout(prepared, this.config.maxWidth, lineHeight);
+    return {
+      height: result.height,
+      lineCount: result.lineCount
+    };
+  }
+  /**
+   * Compute layout with individual line information.
+   * Uses prepareWithSegments() + layoutWithLines().
+   */
+  computeLayoutWithLines(text) {
+    const prepared = this.getPreparedWithSegments(text);
+    const result = this.backend.layoutWithLines(
+      prepared,
+      this.config.maxWidth,
+      this.config.lineHeight
+    );
+    const lines = result.lines.map((line, i) => ({
+      text: line.text,
+      width: line.width,
+      y: i * this.config.lineHeight,
+      sourceIndex: i
+    }));
+    return {
+      height: result.height,
+      lineCount: result.lineCount,
+      lines
+    };
+  }
+  /**
+   * Compute layout for only the visible viewport.
+   * Key performance optimization: only measure and position visible lines.
+   * Includes configurable buffer (default 2x viewport) for smooth scrolling.
+   */
+  computeViewportLayout(text, scrollTop, viewportHeight) {
+    const allLayout = this.computeLayoutWithLines(text);
+    const allLines = allLayout.lines ?? [];
+    const { lineHeight } = this.config;
+    const buffer = (this.config.viewportBuffer ?? 2) * viewportHeight;
+    const bufferedTop = Math.max(0, scrollTop - buffer);
+    const bufferedBottom = scrollTop + viewportHeight + buffer;
+    const startIndex = Math.max(0, Math.floor(bufferedTop / lineHeight));
+    const endIndex = Math.min(allLines.length, Math.ceil(bufferedBottom / lineHeight));
+    const visibleLines = allLines.slice(startIndex, endIndex);
+    return {
+      visibleLines,
+      totalHeight: allLayout.height,
+      startY: startIndex * lineHeight,
+      startIndex,
+      endIndex
+    };
+  }
+  // --------------------------------------------------------
+  // Multi-paragraph Layout
+  // --------------------------------------------------------
+  /**
+   * Compute layout for an array of text blocks (paragraphs).
+   * Returns cumulative heights for virtual scrolling.
+   */
+  computeDocumentLayout(paragraphs) {
+    const offsets = [];
+    const heights = [];
+    let cumHeight = 0;
+    for (const text of paragraphs) {
+      offsets.push(cumHeight);
+      const result = this.computeLayout(text);
+      heights.push(result.height);
+      cumHeight += result.height;
+    }
+    return {
+      totalHeight: cumHeight,
+      paragraphOffsets: offsets,
+      paragraphHeights: heights
+    };
+  }
+  /**
+   * Find which paragraph and line is at a given scrollTop position.
+   */
+  hitTest(paragraphs, scrollTop) {
+    let cumHeight = 0;
+    for (let i = 0; i < paragraphs.length; i++) {
+      const result = this.computeLayout(paragraphs[i]);
+      if (cumHeight + result.height > scrollTop) {
+        const localY = scrollTop - cumHeight;
+        const lineIndex = Math.floor(localY / this.config.lineHeight);
+        return { paragraphIndex: i, lineIndex };
+      }
+      cumHeight += result.height;
+    }
+    return null;
+  }
+  // --------------------------------------------------------
+  // Incremental Document Layout
+  // --------------------------------------------------------
+  _lastParagraphs = [];
+  _lastHeights = [];
+  _lastTotalHeight = 0;
+  /**
+   * Incremental document layout — reuses cached heights for unchanged paragraphs.
+   * Only recomputes layout for paragraphs that changed since the last call.
+   * Use this for real-time editing instead of computeDocumentLayout().
+   *
+   * Returns the same structure as computeDocumentLayout().
+   */
+  updateDocumentLayout(paragraphs) {
+    const prev = this._lastParagraphs;
+    const prevHeights = this._lastHeights;
+    const len = paragraphs.length;
+    const heights = new Array(len);
+    const offsets = new Array(len);
+    const changedIndices = [];
+    let cumHeight = 0;
+    for (let i = 0; i < len; i++) {
+      const text = paragraphs[i];
+      if (i < prev.length && prev[i] === text) {
+        heights[i] = prevHeights[i];
+      } else {
+        heights[i] = this.computeLayout(text).height;
+        changedIndices.push(i);
+      }
+      offsets[i] = cumHeight;
+      cumHeight += heights[i];
+    }
+    this._lastParagraphs = paragraphs;
+    this._lastHeights = heights;
+    this._lastTotalHeight = cumHeight;
+    return {
+      totalHeight: cumHeight,
+      paragraphOffsets: offsets,
+      paragraphHeights: heights,
+      changedIndices
+    };
+  }
+  /**
+   * Get the cached total height from the last updateDocumentLayout() call.
+   * O(1) — no recomputation.
+   */
+  getCachedTotalHeight() {
+    return this._lastTotalHeight;
+  }
+  // --------------------------------------------------------
+  // Cache Management
+  // --------------------------------------------------------
+  /** Invalidate cache for a specific text block. */
+  invalidateCache(text) {
+    if (text) {
+      const key = this.cacheKey(text);
+      this.preparedCache.delete(key);
+      this.preparedSegCache.delete(key);
+    } else {
+      this.clearAllCaches();
+    }
+  }
+  /** Clear all caches including pretext internal cache. */
+  clearAllCaches() {
+    this.preparedCache.clear();
+    this.preparedSegCache.clear();
+    this.backend.clearCache();
+  }
+  /** Get current cache statistics. */
+  getCacheStats() {
+    return {
+      preparedSize: this.preparedCache.size,
+      segmentSize: this.preparedSegCache.size
+    };
+  }
+  // --------------------------------------------------------
+  // Internal Helpers
+  // --------------------------------------------------------
+  cacheKey(text) {
+    return `${this.config.font}|${this.config.whiteSpace ?? "normal"}|${text}`;
+  }
+  getPrepared(text) {
+    const key = this.cacheKey(text);
+    let prepared = this.preparedCache.get(key);
+    if (!prepared) {
+      const opts = this.config.whiteSpace === "pre-wrap" ? { whiteSpace: "pre-wrap" } : void 0;
+      prepared = this.backend.prepare(text, this.config.font, opts);
+      this.preparedCache.set(key, prepared);
+    }
+    return prepared;
+  }
+  getPreparedWithSegments(text) {
+    const key = this.cacheKey(text);
+    let prepared = this.preparedSegCache.get(key);
+    if (!prepared) {
+      const opts = this.config.whiteSpace === "pre-wrap" ? { whiteSpace: "pre-wrap" } : void 0;
+      prepared = this.backend.prepareWithSegments(text, this.config.font, opts);
+      this.preparedSegCache.set(key, prepared);
+    }
+    return prepared;
+  }
+};
+export {
+  CursorEngine,
+  LayoutEngine,
+  LineRenderer,
+  VirtualList,
+  createFallbackBackend,
+  createWorkerBackend
+};
+//# sourceMappingURL=index.js.map