@visulima/tui 0.0.1 → 1.0.0-alpha.2

package/dist/packem_shared/render-Bpjhf0lD.js

@@ -0,0 +1,195 @@
+import React from 'react';
+import { FocusProvider, useFocusManager } from './FocusContext-D5wFxSRz.js';
+import { TuiContext, useInput } from './TuiContext-CqEjMyXd.js';
+import { LayoutNode } from './LayoutNode-Cjnsodiy.js';
+import { T as TuiReconciler, s as setOnAfterCommit } from './reconciler-BXf6miSS.js';
+import { renderTreeToBuffer } from './renderTreeToBuffer-D3mo7M7m.js';
+import { TuiApp } from './TuiApp-DfxOnXqi.js';
+import { InputParser } from './InputParser-BKHpWfvN.js';
+import { terminalSize } from './Renderer-zZ5O3vxc.js';
+import { createInlineLoop } from './createInlineLoop-BxMmcq9D.js';
+
+const _Box = (props) => React.createElement("box", props, props.children);
+const _Text = (props) => React.createElement("text", props, props.children);
+const _Spacer = () => React.createElement(_Box, { flexGrow: 1 });
+const TabHandler = ({ children }) => {
+  const { disableFocus, enableFocus, focusNext, focusPrevious } = useFocusManager();
+  useInput((_input, key) => {
+    if (key.tab && !key.shift)
+      focusNext();
+    if (key.tab && key.shift)
+      focusPrevious();
+    if (key.escape) {
+      disableFocus();
+      enableFocus();
+    }
+  });
+  return React.createElement(React.Fragment, null, children);
+};
+function render(element, options) {
+  const app = new TuiApp();
+  const input = new InputParser(process.stdin);
+  const rootNode = new LayoutNode();
+  const { height, width } = app.getSize();
+  rootNode.yogaNode.setWidth(width);
+  rootNode.yogaNode.setHeight(height);
+  const container = TuiReconciler.createContainer(
+    rootNode,
+    0,
+    // Legacy root
+    null,
+    // hydrate
+    false,
+    null,
+    "",
+    // prefix
+    (error) => console.error(error),
+    null
+  );
+  const wrap = (element_) => React.createElement(
+    TuiContext.Provider,
+    {
+      value: {
+        app,
+        input,
+        writeStderr: (t) => app.writeStderr(t),
+        writeStdout: (t) => app.writeStdout(t)
+      }
+    },
+    React.createElement(FocusProvider, null, React.createElement(TabHandler, null, element_))
+  );
+  TuiReconciler.updateContainer(wrap(element), container, null, () => {
+  });
+  const calcLayout = (w, h) => rootNode.calculateLayout(w, h);
+  const renderBuf = (buf, w, h) => renderTreeToBuffer(rootNode, buf, w, h);
+  const paintNow = () => app.paintNow(calcLayout, renderBuf);
+  let pendingCommit = false;
+  setOnAfterCommit(() => {
+    pendingCommit = true;
+  });
+  const frameMs = Math.round(1e3 / (options?.maxFps ?? 60));
+  const renderLoop = setInterval(() => {
+    if (pendingCommit) {
+      pendingCommit = false;
+      paintNow();
+    }
+  }, frameMs);
+  let resolveExit;
+  const exitPromise = new Promise((resolve) => {
+    resolveExit = resolve;
+  });
+  const cleanup = () => {
+    clearInterval(renderLoop);
+    TuiReconciler.updateContainer(null, container, null, () => {
+    });
+    rootNode.destroy();
+    app.stop();
+    input.stop();
+    process.off("SIGWINCH", onSigwinch);
+    resolveExit();
+  };
+  input.on("exit", () => {
+    cleanup();
+    process.exit(0);
+  });
+  app.on("quit", () => {
+    cleanup();
+    process.exit(0);
+  });
+  input.start();
+  app.start();
+  const onSigwinch = () => {
+    const width2 = process.stdout.columns || 80;
+    const height2 = process.stdout.rows || 24;
+    app.resize(width2, height2);
+    rootNode.yogaNode.setWidth(width2);
+    rootNode.yogaNode.setHeight(height2);
+    app.emit("resize");
+    paintNow();
+  };
+  process.on("SIGWINCH", onSigwinch);
+  paintNow();
+  return {
+    // Internal access — not part of Ink's public API but useful for native renderer code
+    app,
+    input,
+    /** Re-render with a new root element */
+    rerender(newElement) {
+      TuiReconciler.updateContainer(wrap(newElement), container, null, () => {
+      });
+    },
+    /** Unmount the app and restore the terminal */
+    unmount() {
+      cleanup();
+    },
+    /** Resolves when unmount() is called or the app exits */
+    waitUntilExit() {
+      return exitPromise;
+    }
+  };
+}
+function renderInline(element, options) {
+  const size = terminalSize();
+  const reservedRows = options?.rows ?? 10;
+  const { cols } = size;
+  const rows = Math.min(reservedRows, size.rows);
+  const input = new InputParser(process.stdin);
+  const rootNode = new LayoutNode();
+  rootNode.yogaNode.setWidth(cols);
+  rootNode.yogaNode.setHeight(rows);
+  const stdoutLines = [];
+  const stderrLines = [];
+  const appLike = {
+    quit: () => loop.stop(),
+    writeStderr: (t) => stderrLines.push(t),
+    writeStdout: (t) => stdoutLines.push(t)
+  };
+  const container = TuiReconciler.createContainer(rootNode, 0, null, false, null, "", (error) => console.error(error), null);
+  const wrap = (element_) => React.createElement(
+    TuiContext.Provider,
+    {
+      value: {
+        app: appLike,
+        input,
+        writeStderr: appLike.writeStderr,
+        writeStdout: appLike.writeStdout
+      }
+    },
+    React.createElement(FocusProvider, null, React.createElement(TabHandler, null, element_))
+  );
+  TuiReconciler.updateContainer(wrap(element), container, null, () => {
+  });
+  setOnAfterCommit(() => {
+  });
+  const loop = createInlineLoop(
+    (buf, w, h) => {
+      rootNode.calculateLayout(w, h);
+      renderTreeToBuffer(rootNode, buf, w, h);
+    },
+    { ...options, fps: options?.maxFps ?? options?.fps ?? 60, rows }
+  );
+  input.on("exit", () => loop.stop());
+  let resolveExit;
+  const exitPromise = new Promise((r) => {
+    resolveExit = r;
+  });
+  process.on("exit", () => {
+    if (stdoutLines.length > 0)
+      process.stdout.write(stdoutLines.join(""));
+    if (stderrLines.length > 0)
+      process.stderr.write(stderrLines.join(""));
+    resolveExit();
+  });
+  loop.start();
+  input.start();
+  return {
+    unmount() {
+      loop.stop();
+    },
+    waitUntilExit() {
+      return exitPromise;
+    }
+  };
+}
+
+export { _Box, _Spacer, _Text, render, renderInline };

package/dist/packem_shared/renderToString-Cfg55DRD.js

@@ -0,0 +1,62 @@
+import React from 'react';
+import { FocusProvider } from './FocusContext-D5wFxSRz.js';
+import { TuiContext } from './TuiContext-CqEjMyXd.js';
+import { LayoutNode } from './LayoutNode-Cjnsodiy.js';
+import { T as TuiReconciler } from './reconciler-BXf6miSS.js';
+import { renderTreeToBuffer } from './renderTreeToBuffer-D3mo7M7m.js';
+import { Cell } from './Cell-DCg1kJY-.js';
+
+function renderToString(element, options) {
+  const cols = options?.columns ?? 80;
+  const rows = options?.rows ?? 24;
+  const rootNode = new LayoutNode();
+  rootNode.yogaNode.setWidth(cols);
+  rootNode.yogaNode.setHeight(rows);
+  const noopContext = {
+    app: null,
+    input: null,
+    writeStderr: (_t) => {
+    },
+    writeStdout: (_t) => {
+    }
+  };
+  const wrapped = React.createElement(TuiContext.Provider, { value: noopContext }, React.createElement(FocusProvider, null, element));
+  const container = TuiReconciler.createContainer(
+    rootNode,
+    0,
+    // LegacyRoot
+    null,
+    false,
+    null,
+    "renderToString",
+    () => {
+    },
+    null
+  );
+  TuiReconciler.updateContainerSync(wrapped, container, null, () => {
+  });
+  TuiReconciler.flushSyncWork();
+  rootNode.calculateLayout(cols, rows);
+  const buffer = new Uint32Array(cols * rows * 2);
+  renderTreeToBuffer(rootNode, buffer, cols, rows);
+  const lines = [];
+  for (let row = 0; row < rows; row++) {
+    let line = "";
+    for (let col = 0; col < cols; col++) {
+      const ch = buffer[(row * cols + col) * 2];
+      const charString = Cell.getChar(ch);
+      line += charString === "" ? " " : charString;
+    }
+    lines.push(line.trimEnd());
+  }
+  while (lines.length > 0 && lines.at(-1) === "") {
+    lines.pop();
+  }
+  TuiReconciler.updateContainerSync(null, container, null, () => {
+  });
+  TuiReconciler.flushSyncWork();
+  rootNode.destroy();
+  return lines.join("\n");
+}
+
+export { renderToString };

package/dist/packem_shared/renderToString-ClIaXgrC.js

@@ -0,0 +1,86 @@
+import { LegacyRoot } from 'react-reconciler/constants.js';
+import Yoga from 'yoga-layout';
+import { c as createNode } from './dom-DvzhsAez.js';
+import { r as reconcilerInstance } from './reconciler-gfmqURLy.js';
+import { r as renderer } from './renderer-B3wROkeg.js';
+import { calculateScroll } from './getScrollHeight-BubfU_df.js';
+
+const renderToString = (node, options) => {
+  const columns = options?.columns ?? 80;
+  const rootNode = createNode("ink-root");
+  let capturedStaticOutput = "";
+  rootNode.onComputeLayout = () => {
+    rootNode.yogaNode.setWidth(columns);
+    rootNode.yogaNode.calculateLayout(void 0, void 0, Yoga.DIRECTION_LTR);
+    const walkScroll = (element) => {
+      if (element.nodeName === "ink-box") {
+        const overflow = element.style.overflow ?? "visible";
+        const overflowX = element.style.overflowX ?? overflow;
+        const overflowY = element.style.overflowY ?? overflow;
+        if (overflowX === "scroll" || overflowY === "scroll") {
+          calculateScroll(element);
+        }
+      }
+      for (const child of element.childNodes) {
+        if (child.nodeName !== "#text") {
+          walkScroll(child);
+        }
+      }
+    };
+    walkScroll(rootNode);
+  };
+  rootNode.onImmediateRender = () => {
+    const { staticOutput } = renderer(rootNode, false);
+    if (staticOutput && staticOutput !== "\n") {
+      capturedStaticOutput += staticOutput;
+    }
+  };
+  let uncaughtError;
+  const container = reconcilerInstance.createContainer(
+    rootNode,
+    LegacyRoot,
+    null,
+    false,
+    null,
+    "render-to-string",
+    (error) => {
+      uncaughtError ??= error;
+    },
+    () => {
+    },
+    () => {
+    },
+    () => {
+    }
+  );
+  let teardownSucceeded = false;
+  try {
+    reconcilerInstance.updateContainerSync(node, container, null, () => {
+    });
+    reconcilerInstance.flushSyncWork();
+    const { output } = renderer(rootNode, false);
+    reconcilerInstance.updateContainerSync(null, container, null, () => {
+    });
+    reconcilerInstance.flushSyncWork();
+    teardownSucceeded = true;
+    rootNode.yogaNode.free();
+    if (uncaughtError !== void 0) {
+      throw uncaughtError instanceof Error ? uncaughtError : new Error(String(uncaughtError));
+    }
+    const normalizedStaticOutput = capturedStaticOutput.endsWith("\n") ? capturedStaticOutput.slice(0, -1) : capturedStaticOutput;
+    if (normalizedStaticOutput && output) {
+      return `${normalizedStaticOutput}
+${output}`;
+    }
+    return normalizedStaticOutput || output;
+  } finally {
+    if (!teardownSucceeded && rootNode.yogaNode) {
+      try {
+        rootNode.yogaNode.freeRecursive();
+      } catch {
+      }
+    }
+  }
+};
+
+export { renderToString as default };

package/dist/packem_shared/renderTreeToBuffer-D3mo7M7m.js

@@ -0,0 +1,308 @@
+import { c as cliBoxes } from './boxes-oi3WUbyR.js';
+import { resolveColor } from './NAMED_COLORS-a4QBvb5r.js';
+import { a as getCodePointWidth } from './text-width-DhuarWcB.js';
+
+const CONTINUATION_CELL_CODE = 1114112;
+const SCROLLBAR_FULL = 9608;
+const SCROLLBAR_UPPER = 9600;
+const SCROLLBAR_LOWER = 9604;
+function getEffectiveBorderWidths(nodeStyle) {
+  const base = nodeStyle?.borderStyle ? 1 : 0;
+  return {
+    bottom: nodeStyle?.borderBottom === false ? 0 : base,
+    left: nodeStyle?.borderLeft === false ? 0 : base,
+    right: nodeStyle?.borderRight === false ? 0 : base,
+    top: nodeStyle?.borderTop === false ? 0 : base
+  };
+}
+function getScrollContentHeight(node) {
+  let maxBottom = 0;
+  for (const child of node.children) {
+    const layout = child.getLayout();
+    const bottom = layout.top + layout.height;
+    if (bottom > maxBottom) {
+      maxBottom = bottom;
+    }
+  }
+  const style = node._style;
+  const paddingBottom = style?.paddingBottom ?? style?.paddingY ?? style?.padding ?? 0;
+  return maxBottom + paddingBottom;
+}
+function paintScrollbar(node, buffer, cols, rows, absX, absY, w, h, fg, parentStyles, clip, nodeStyle) {
+  const borders = getEffectiveBorderWidths(nodeStyle);
+  const innerHeight = h - borders.top - borders.bottom;
+  const scrollTop = nodeStyle.scrollTop ?? 0;
+  const scrollHeight = getScrollContentHeight(node);
+  const clientHeight = innerHeight;
+  if (scrollHeight <= clientHeight || innerHeight <= 0) {
+    return;
+  }
+  const halves = innerHeight * 2;
+  const thumbHalves = Math.max(2, Math.round(clientHeight / scrollHeight * halves));
+  const maxScroll = scrollHeight - clientHeight;
+  const maxThumbPos = halves - thumbHalves;
+  const thumbPos = maxScroll > 0 ? Math.round(scrollTop / maxScroll * maxThumbPos) : 0;
+  const thumbColor = typeof nodeStyle.scrollbarThumbColor === "string" ? resolveColor(nodeStyle.scrollbarThumbColor) : fg;
+  const scrollbarX = absX + w - 1 - borders.right;
+  const attributeCode = parentStyles << 16 | 255 << 8 | thumbColor;
+  for (let index = 0; index < innerHeight; index++) {
+    const halfTop = index * 2;
+    const halfBottom = halfTop + 1;
+    const hasUpper = halfTop >= thumbPos && halfTop < thumbPos + thumbHalves;
+    const hasLower = halfBottom >= thumbPos && halfBottom < thumbPos + thumbHalves;
+    if (!hasUpper && !hasLower) {
+      continue;
+    }
+    let charCode = SCROLLBAR_FULL;
+    if (hasUpper && !hasLower) {
+      charCode = SCROLLBAR_UPPER;
+    } else if (!hasUpper && hasLower) {
+      charCode = SCROLLBAR_LOWER;
+    }
+    writeCell(buffer, cols, rows, scrollbarX, absY + borders.top + index, charCode, attributeCode, clip);
+  }
+}
+function paintStickyHeaders(node, buffer, cols, rows, absX, absY, _w, _h, fg, bg, parentStyles, borderJobs, clip, nodeStyle) {
+  const borders = getEffectiveBorderWidths(nodeStyle);
+  const scrollTop = nodeStyle.scrollTop ?? 0;
+  const contentY = absY + borders.top;
+  for (const child of node.children) {
+    if (!child._style?.sticky) {
+      continue;
+    }
+    const childLayout = child.getLayout();
+    const childNaturalY = childLayout.top;
+    if (childNaturalY >= scrollTop) {
+      continue;
+    }
+    const childParent = child.parent;
+    if (childParent && childParent !== node) {
+      const parentLayout = childParent.getLayout();
+      const parentBottom = parentLayout.top + parentLayout.height;
+      if (parentBottom <= scrollTop) {
+        continue;
+      }
+    }
+    const stickyY = contentY;
+    const childFg = child.fg === 255 ? fg : child.fg;
+    const childBg = child.bg === 255 ? bg : child.bg;
+    const childStyles = child.styles === 0 ? parentStyles : child.styles;
+    paintNode(child, buffer, cols, rows, absX - childLayout.left, stickyY - childLayout.top, childFg, childBg, childStyles, borderJobs, clip);
+  }
+}
+function renderTreeToBuffer(root, buffer, cols, rows) {
+  for (let i = 0; i < buffer.length; i += 2) {
+    buffer[i] = 32;
+    buffer[i + 1] = 0 << 16 | 255 << 8 | 255;
+  }
+  const borderJobs = [];
+  const rootClip = { x0: 0, x1: cols, y0: 0, y1: rows };
+  try {
+    paintNode(root, buffer, cols, rows, 0, 0, root.fg, root.bg, root.styles, borderJobs, rootClip);
+    for (const job of borderJobs) {
+      paintBorder(job.node, buffer, cols, rows, job.absX, job.absY, job.w, job.h, job.fg, job.bg, job.styles, job.clip);
+    }
+  } catch (error) {
+    console.error("Renderer Error:", error);
+  }
+}
+function writeCell(buffer, cols, rows, sx, sy, charCode, attributeCode, clip) {
+  if (sx < clip.x0 || sx >= clip.x1 || sy < clip.y0 || sy >= clip.y1) {
+    return;
+  }
+  if (sx < 0 || sx >= cols || sy < 0 || sy >= rows) {
+    return;
+  }
+  const index = (sy * cols + sx) * 2;
+  buffer[index] = charCode;
+  buffer[index + 1] = attributeCode;
+}
+function paintBorder(node, buffer, cols, rows, absX, absY, w, h, fg, bg, styles, clip) {
+  if (!node._style?.borderStyle) {
+    return;
+  }
+  if (w <= 0 || h <= 0) {
+    return;
+  }
+  const box = cliBoxes[node._style.borderStyle];
+  const borderFg = node._style.borderColor === void 0 ? fg : resolveColor(node._style.borderColor);
+  const borderAttribute = styles << 16 | bg << 8 | borderFg;
+  const showTop = node._style.borderTop !== false;
+  const showBottom = node._style.borderBottom !== false;
+  const showLeft = node._style.borderLeft !== false;
+  const showRight = node._style.borderRight !== false;
+  const canShowBottom = showBottom && (h > 1 || !showTop);
+  if (showTop) {
+    for (let x = 0; x < w; x++) {
+      let ch;
+      if (w === 1) {
+        ch = showLeft && showRight ? box.left : showLeft ? box.topLeft : showRight ? box.topRight : box.top;
+      } else if (x === 0 && showLeft) {
+        ch = box.topLeft;
+      } else if (x === w - 1 && showRight) {
+        ch = box.topRight;
+      } else {
+        ch = box.top;
+      }
+      writeCell(buffer, cols, rows, absX + x, absY, ch.codePointAt(0), borderAttribute, clip);
+    }
+  }
+  if (canShowBottom) {
+    for (let x = 0; x < w; x++) {
+      let ch;
+      if (w === 1) {
+        ch = showLeft && showRight ? box.left : showLeft ? box.bottomLeft : showRight ? box.bottomRight : box.bottom;
+      } else if (x === 0 && showLeft) {
+        ch = box.bottomLeft;
+      } else if (x === w - 1 && showRight) {
+        ch = box.bottomRight;
+      } else {
+        ch = box.bottom;
+      }
+      writeCell(buffer, cols, rows, absX + x, absY + h - 1, ch.codePointAt(0), borderAttribute, clip);
+    }
+  }
+  const yStart = showTop ? 1 : 0;
+  const yEnd = canShowBottom ? h - 1 : h;
+  for (let y = yStart; y < yEnd; y++) {
+    if (showLeft)
+      writeCell(buffer, cols, rows, absX, absY + y, box.left.codePointAt(0), borderAttribute, clip);
+    if (showRight)
+      writeCell(buffer, cols, rows, absX + w - 1, absY + y, box.right.codePointAt(0), borderAttribute, clip);
+  }
+}
+function collectText(node) {
+  if (node._hidden) {
+    return "";
+  }
+  if (node.text !== void 0) {
+    return node.text;
+  }
+  const raw = node.children.map(collectText).join("");
+  if (typeof node.transform === "function") {
+    return node.transform(raw, 0);
+  }
+  return raw;
+}
+function paintText(text, buffer, cols, rows, absX, absY, w, h, attributeCode, clip) {
+  if (w <= 0 || h <= 0) {
+    return;
+  }
+  let cursorX = 0;
+  let cursorY = 0;
+  for (const char of text) {
+    if (char === "\n") {
+      cursorX = 0;
+      cursorY++;
+      continue;
+    }
+    const charCode = char.codePointAt(0) ?? 32;
+    const charWidth = getCodePointWidth(char);
+    if (cursorX + charWidth > w) {
+      cursorX = 0;
+      cursorY++;
+    }
+    if (cursorY >= h)
+      break;
+    if (charWidth > w) {
+      writeCell(buffer, cols, rows, absX + cursorX, absY + cursorY, 32, attributeCode, clip);
+      cursorX += 1;
+      continue;
+    }
+    writeCell(buffer, cols, rows, absX + cursorX, absY + cursorY, charCode, attributeCode, clip);
+    if (charWidth === 2 && cursorX + 1 < w) {
+      writeCell(buffer, cols, rows, absX + cursorX + 1, absY + cursorY, CONTINUATION_CELL_CODE, attributeCode, clip);
+    }
+    cursorX += charWidth;
+  }
+}
+function paintNode(node, buffer, cols, rows, parentX, parentY, parentFg, parentBg, parentStyles, borderJobs, clip) {
+  if (node._hidden) {
+    return;
+  }
+  const layout = node.getLayout();
+  const absX = Math.round(parentX + layout.left);
+  const absY = Math.round(parentY + layout.top);
+  const w = Math.round(layout.width);
+  const h = Math.round(layout.height);
+  const fg = node.fg === 255 ? parentFg : node.fg;
+  const bg = node.bg === 255 ? parentBg : node.bg;
+  const styles = node.styles === 0 ? parentStyles : node.styles;
+  const nodeClip = {
+    x0: Math.max(clip.x0, absX),
+    x1: Math.min(clip.x1, absX + w),
+    y0: Math.max(clip.y0, absY),
+    y1: Math.min(clip.y1, absY + h)
+  };
+  if (nodeClip.x0 >= nodeClip.x1 || nodeClip.y0 >= nodeClip.y1) {
+    return;
+  }
+  if (typeof node.transform === "function") {
+    const raw = collectText(node);
+    const transformed = node.transform(raw, 0);
+    const attributeCode = styles << 16 | bg << 8 | fg;
+    paintText(transformed, buffer, cols, rows, absX, absY, w, h, attributeCode, nodeClip);
+    return;
+  }
+  if (node.text === void 0) {
+    if (bg !== 255 || styles !== 0) {
+      const attributeCode = styles << 16 | bg << 8 | fg;
+      for (let y = 0; y < h; y++) {
+        for (let x = 0; x < w; x++) {
+          writeCell(buffer, cols, rows, absX + x, absY + y, 32, attributeCode, nodeClip);
+        }
+      }
+    }
+    if (node._style?.borderStyle) {
+      borderJobs.push({ absX, absY, bg, clip: nodeClip, fg, h, node, styles, w });
+    }
+  } else {
+    const attributeCode = styles << 16 | bg << 8 | fg;
+    if (node.bg !== 255) {
+      for (let y = 0; y < h; y++) {
+        for (let x = 0; x < w; x++) {
+          writeCell(buffer, cols, rows, absX + x, absY + y, 32, attributeCode, nodeClip);
+        }
+      }
+    }
+    paintText(node.text, buffer, cols, rows, absX, absY, w, h, attributeCode, nodeClip);
+  }
+  const nodeStyle = node._style;
+  const overflow = nodeStyle?.overflow ?? "visible";
+  const overflowX = nodeStyle?.overflowX ?? overflow;
+  const overflowY = nodeStyle?.overflowY ?? overflow;
+  const clipH = overflowX === "hidden" || overflowX === "scroll";
+  const clipV = overflowY === "hidden" || overflowY === "scroll";
+  let childClip = nodeClip;
+  let scrollOffsetX = 0;
+  let scrollOffsetY = 0;
+  if (clipH || clipV) {
+    const borders = getEffectiveBorderWidths(nodeStyle);
+    childClip = {
+      x0: clipH ? Math.max(nodeClip.x0, absX + borders.left) : nodeClip.x0,
+      x1: clipH ? Math.min(nodeClip.x1, absX + w - borders.right) : nodeClip.x1,
+      y0: clipV ? Math.max(nodeClip.y0, absY + borders.top) : nodeClip.y0,
+      y1: clipV ? Math.min(nodeClip.y1, absY + h - borders.bottom) : nodeClip.y1
+    };
+    if (overflowY === "scroll" && typeof nodeStyle?.scrollTop === "number") {
+      scrollOffsetY = -nodeStyle.scrollTop;
+    }
+    if (overflowX === "scroll" && typeof nodeStyle?.scrollLeft === "number") {
+      scrollOffsetX = -nodeStyle.scrollLeft;
+    }
+  }
+  for (const child of node.children) {
+    if (child._style?.internalStickyAlternate) {
+      continue;
+    }
+    paintNode(child, buffer, cols, rows, absX + scrollOffsetX, absY + scrollOffsetY, fg, bg, styles, borderJobs, childClip);
+  }
+  if ((overflowY === "scroll" || overflowX === "scroll") && nodeStyle?.scrollbar !== false) {
+    paintScrollbar(node, buffer, cols, rows, absX, absY, w, h, fg, styles, nodeClip, nodeStyle);
+  }
+  if (overflowY === "scroll" && typeof nodeStyle?.scrollTop === "number") {
+    paintStickyHeaders(node, buffer, cols, rows, absX, absY, w, h, fg, bg, styles, borderJobs, childClip, nodeStyle);
+  }
+}
+
+export { renderTreeToBuffer };