@visulima/tui 1.0.0-alpha.2 → 1.0.0-alpha.21

package/dist/packem_shared/renderer-B3wROkeg.js

@@ -1,1431 +0,0 @@
-import { w as wrapText, i as isNodeSelectable } from './dom-DvzhsAez.js';
-import { getStringWidth, isFullwidthCodePoint, indent } from '@visulima/string';
-import { B as BOLD_MASK, D as DIM_MASK, I as ITALIC_MASK, U as UNDERLINE_MASK, e as INVERSE_MASK, H as HIDDEN_MASK, f as STRIKETHROUGH_MASK, g as colorToSgrParams, F as FULL_WIDTH_MASK, h as colorToAnsi256, S as StyledLine, j as textToStyledLine, p as plainTextToStyledLine } from './measure-text-DItZYotK.js';
-import Yoga from 'yoga-layout';
-import { j as getRelativeTop, i as getRelativeLeft, n as getAbsoluteContentPosition, c as calculateScrollbarLayout } from './measure-element-Reza_yfC.js';
-import { g as getBackgroundColorEscape, c as colorize } from './colorize-88_Vk8cn.js';
-import colorizeDefault from '@visulima/colorize';
-import { c as cliBoxes } from './boxes-oi3WUbyR.js';
-import { getScrollTop } from './getScrollHeight-BubfU_df.js';
-import squashTextNodes from './squashTextNodesWithMap-iqm6OMMT.js';
-
-import __cjs_mod__ from "node:module"; // -- packem CommonJS require shim --
-const require = __cjs_mod__.createRequire(import.meta.url);
-const getMaxWidth = (yogaNode) => yogaNode.getComputedWidth() - yogaNode.getComputedPadding(Yoga.EDGE_LEFT) - yogaNode.getComputedPadding(Yoga.EDGE_RIGHT) - yogaNode.getComputedBorder(Yoga.EDGE_LEFT) - yogaNode.getComputedBorder(Yoga.EDGE_RIGHT);
-
-const CONTINUATION_CELL_CODE = 1114112;
-
-const SGR_BOLD = 1;
-const SGR_DIM = 2;
-const SGR_ITALIC = 3;
-const SGR_UNDERLINE = 4;
-const SGR_INVERSE = 7;
-const SGR_HIDDEN = 8;
-const SGR_STRIKETHROUGH = 9;
-const SGR_NO_BOLD = 22;
-const SGR_NO_ITALIC = 23;
-const SGR_NO_UNDERLINE = 24;
-const SGR_NO_INVERSE = 27;
-const SGR_NO_HIDDEN = 28;
-const SGR_NO_STRIKETHROUGH = 29;
-const SGR_FG_DEFAULT = 39;
-const SGR_BG_DEFAULT = 49;
-const ESC = "\x1B[";
-const sgr = (params) => {
-  if (params.length === 0) {
-    return "";
-  }
-  return `${ESC}${params.join(";")}m`;
-};
-const styledLineToString = (line) => {
-  if (line.length === 0) {
-    return "";
-  }
-  let result = "";
-  let previousFlags = 0;
-  let previousFg;
-  let previousBg;
-  let previousLink;
-  let hasActiveStyles = false;
-  let charIndex = 0;
-  const spans = line.getSpans();
-  for (const span of spans) {
-    const spanFlags = span.formatFlags & 127;
-    const { fgColor } = span;
-    const { bgColor } = span;
-    const { link } = span;
-    const flags = spanFlags;
-    if (flags !== previousFlags || fgColor !== previousFg || bgColor !== previousBg || link !== previousLink) {
-      if (link !== previousLink) {
-        if (previousLink) {
-          result += previousLink.startsWith("ST:") ? "\x1B]8;;\x1B\\" : "\x1B]8;;\x07";
-        }
-        if (link) {
-          const useST = link.startsWith("ST:");
-          result += `\x1B]8;;${useST ? link.slice(3) : link}${useST ? "\x1B\\" : "\x07"}`;
-        }
-      }
-      const previousBoldDim = previousFlags & (BOLD_MASK | DIM_MASK);
-      const newBoldDim = flags & (BOLD_MASK | DIM_MASK);
-      if (previousBoldDim !== newBoldDim) {
-        const removingBold = previousFlags & BOLD_MASK && !(flags & BOLD_MASK);
-        const removingDim = previousFlags & DIM_MASK && !(flags & DIM_MASK);
-        if (removingBold || removingDim) {
-          result += sgr([SGR_NO_BOLD]);
-        }
-        if (flags & BOLD_MASK && (!(previousFlags & BOLD_MASK) || removingDim)) {
-          result += sgr([SGR_BOLD]);
-        }
-        if (flags & DIM_MASK && (!(previousFlags & DIM_MASK) || removingBold)) {
-          result += sgr([SGR_DIM]);
-        }
-      }
-      if (flags & ITALIC_MASK && !(previousFlags & ITALIC_MASK)) {
-        result += sgr([SGR_ITALIC]);
-      } else if (!(flags & ITALIC_MASK) && previousFlags & ITALIC_MASK) {
-        result += sgr([SGR_NO_ITALIC]);
-      }
-      if (flags & UNDERLINE_MASK && !(previousFlags & UNDERLINE_MASK)) {
-        result += sgr([SGR_UNDERLINE]);
-      } else if (!(flags & UNDERLINE_MASK) && previousFlags & UNDERLINE_MASK) {
-        result += sgr([SGR_NO_UNDERLINE]);
-      }
-      if (flags & INVERSE_MASK && !(previousFlags & INVERSE_MASK)) {
-        result += sgr([SGR_INVERSE]);
-      } else if (!(flags & INVERSE_MASK) && previousFlags & INVERSE_MASK) {
-        result += sgr([SGR_NO_INVERSE]);
-      }
-      if (flags & HIDDEN_MASK && !(previousFlags & HIDDEN_MASK)) {
-        result += sgr([SGR_HIDDEN]);
-      } else if (!(flags & HIDDEN_MASK) && previousFlags & HIDDEN_MASK) {
-        result += sgr([SGR_NO_HIDDEN]);
-      }
-      if (flags & STRIKETHROUGH_MASK && !(previousFlags & STRIKETHROUGH_MASK)) {
-        result += sgr([SGR_STRIKETHROUGH]);
-      } else if (!(flags & STRIKETHROUGH_MASK) && previousFlags & STRIKETHROUGH_MASK) {
-        result += sgr([SGR_NO_STRIKETHROUGH]);
-      }
-      if (fgColor !== previousFg) {
-        result += fgColor ? sgr(colorToSgrParams(fgColor, true)) : sgr([SGR_FG_DEFAULT]);
-      }
-      if (bgColor !== previousBg) {
-        result += bgColor ? sgr(colorToSgrParams(bgColor, false)) : sgr([SGR_BG_DEFAULT]);
-      }
-      hasActiveStyles = flags !== 0 || fgColor !== void 0 || bgColor !== void 0;
-      previousFlags = flags;
-      previousFg = fgColor;
-      previousBg = bgColor;
-      previousLink = link;
-    }
-    result += line.getTextRange(charIndex, charIndex + span.length);
-    charIndex += span.length;
-  }
-  if (hasActiveStyles) {
-    if (previousFlags & (BOLD_MASK | DIM_MASK)) {
-      result += sgr([SGR_NO_BOLD]);
-    }
-    if (previousFlags & ITALIC_MASK) {
-      result += sgr([SGR_NO_ITALIC]);
-    }
-    if (previousFlags & UNDERLINE_MASK) {
-      result += sgr([SGR_NO_UNDERLINE]);
-    }
-    if (previousFlags & INVERSE_MASK) {
-      result += sgr([SGR_NO_INVERSE]);
-    }
-    if (previousFlags & HIDDEN_MASK) {
-      result += sgr([SGR_NO_HIDDEN]);
-    }
-    if (previousFlags & STRIKETHROUGH_MASK) {
-      result += sgr([SGR_NO_STRIKETHROUGH]);
-    }
-    if (previousFg !== void 0) {
-      result += sgr([SGR_FG_DEFAULT]);
-    }
-    if (previousBg !== void 0) {
-      result += sgr([SGR_BG_DEFAULT]);
-    }
-  }
-  if (previousLink) {
-    result += previousLink.startsWith("ST:") ? "\x1B]8;;\x1B\\" : "\x1B]8;;\x07";
-  }
-  return result;
-};
-
-class OutputCaches {
-  widths = /* @__PURE__ */ new Map();
-  blockWidths = /* @__PURE__ */ new Map();
-  styledLines = /* @__PURE__ */ new Map();
-  lines = /* @__PURE__ */ new Map();
-  maxEntries;
-  pruneToFactor;
-  constructor(options = {}) {
-    const { maxEntries = 3e4, pruneToFactor = 0.8 } = options;
-    this.maxEntries = Math.max(1, maxEntries);
-    this.pruneToFactor = Math.min(0.99, Math.max(0.1, pruneToFactor));
-  }
-  getStyledLine(line) {
-    let cached = this.styledLines.get(line);
-    if (cached === void 0) {
-      cached = this.hasAnsiControlMarker(line) ? textToStyledLine(line) : plainTextToStyledLine(line);
-      this.setCacheEntry(this.styledLines, line, cached);
-    }
-    return cached;
-  }
-  getStringWidth(text) {
-    let cached = this.widths.get(text);
-    if (cached === void 0) {
-      cached = getStringWidth(text);
-      this.setCacheEntry(this.widths, text, cached);
-    }
-    return cached;
-  }
-  getWidestLine(text) {
-    let cached = this.blockWidths.get(text);
-    if (cached === void 0) {
-      let lineWidth = 0;
-      for (const line of this.getLines(text)) {
-        lineWidth = Math.max(lineWidth, this.getStringWidth(line));
-      }
-      cached = lineWidth;
-      this.setCacheEntry(this.blockWidths, text, cached);
-    }
-    return cached;
-  }
-  getLines(text) {
-    let cached = this.lines.get(text);
-    if (cached === void 0) {
-      cached = text.split("\n");
-      this.setCacheEntry(this.lines, text, cached);
-    }
-    return cached;
-  }
-  hasAnsiControlMarker(text) {
-    for (const character of text) {
-      const codePoint = character.codePointAt(0);
-      if (ansiControlMarkerCodePoints.has(codePoint)) {
-        return true;
-      }
-    }
-    return false;
-  }
-  setCacheEntry(cache, key, value) {
-    if (!cache.has(key) && cache.size >= this.maxEntries) {
-      this.pruneCache(cache);
-    }
-    cache.set(key, value);
-  }
-  pruneCache(cache) {
-    const targetSize = Math.floor(this.maxEntries * this.pruneToFactor);
-    for (const existingKey of cache.keys()) {
-      cache.delete(existingKey);
-      if (cache.size <= targetSize) {
-        break;
-      }
-    }
-  }
-}
-const ansiControlMarkerCodePoints = /* @__PURE__ */ new Set([27, 144, 152, 155, 157, 158, 159]);
-const memoizationDisableRatio = 0.6;
-const memoizationProbeInterval = 30;
-class Output {
-  width;
-  height;
-  caches;
-  // Single flat grid — all writes go directly here, clipped by bounds.
-  grid;
-  // Clip stack — bounds for writes. No child region allocation or compositing.
-  clipStack = [];
-  previousLines = [];
-  previousRenderedLines = [];
-  lineMemoizationEnabled = true;
-  memoizationProbeCountdown = 0;
-  constructor(options) {
-    const { caches, height, width } = options;
-    this.width = width;
-    this.height = height;
-    this.caches = caches ?? new OutputCaches();
-    this.grid = this.createGrid(width, height);
-  }
-  reset(width, height) {
-    this.width = width;
-    this.height = height;
-    this.clipStack.length = 0;
-    this.grid = this.createGrid(width, height);
-  }
-  startChildRegion(absX, absY, width, height) {
-    this.clipStack.push({ x1: absX, x2: absX + width, y1: absY, y2: absY + height });
-  }
-  endChildRegion() {
-    this.clipStack.pop();
-  }
-  write(x, y, text, options) {
-    if (!text) {
-      return;
-    }
-    const { transformers } = options;
-    const clip = this.clipStack.at(-1);
-    const lines = this.caches.getLines(text);
-    const hasTransformers = transformers.length > 0;
-    for (const [lineIndex, rawLine] of lines.entries()) {
-      const rowIndex = y + lineIndex;
-      if (rowIndex < 0 || rowIndex >= this.grid.length) {
-        continue;
-      }
-      if (clip && (rowIndex < clip.y1 || rowIndex >= clip.y2)) {
-        continue;
-      }
-      let line = rawLine;
-      if (hasTransformers) {
-        for (const transformer of transformers) {
-          line = transformer(line, lineIndex);
-        }
-      }
-      if (line.length === 0) {
-        continue;
-      }
-      const row = this.grid[rowIndex];
-      const parsed = this.caches.getStyledLine(line);
-      let offsetX = x;
-      const maxX = clip ? Math.min(clip.x2, row.length) : Infinity;
-      for (let i = 0; i < parsed.length; i++) {
-        if (offsetX >= maxX) {
-          break;
-        }
-        if (clip && (offsetX < clip.x1 || offsetX >= clip.x2)) {
-          offsetX++;
-          if (parsed.getFullWidth(i)) {
-            offsetX++;
-          }
-          continue;
-        }
-        if (offsetX >= 0) {
-          if (offsetX >= row.length) {
-            row.ensureWidth(offsetX + 2);
-          }
-          const span = parsed.getSpan(i);
-          const isFullWidth = parsed.getFullWidth(i);
-          const flags = (span?.formatFlags ?? 0) | (isFullWidth ? FULL_WIDTH_MASK : 0);
-          row.setCharFast(offsetX, parsed.getValue(i), flags, span?.fgColor, span?.bgColor, span?.link);
-          if (isFullWidth) {
-            offsetX++;
-            if (offsetX >= row.length) {
-              row.ensureWidth(offsetX + 1);
-            }
-            row.setCharFast(offsetX, "", flags & ~FULL_WIDTH_MASK, span?.fgColor, span?.bgColor, span?.link);
-          }
-        }
-        offsetX++;
-      }
-    }
-  }
-  writeStyledLine(x, y, line) {
-    if (line.length === 0 || y < 0 || y >= this.grid.length) {
-      return;
-    }
-    const clip = this.clipStack.at(-1);
-    if (clip && (y < clip.y1 || y >= clip.y2)) {
-      return;
-    }
-    this.writeStyledLineToRow(this.grid[y], x, line, this.width, clip);
-  }
-  getRootLines() {
-    return this.grid;
-  }
-  getCurrentClip() {
-    return this.clipStack.at(-1);
-  }
-  addRegionTree(region, x, y) {
-    for (let ry = 0; ry < region.height; ry++) {
-      const targetY = y + ry;
-      if (targetY < 0 || targetY >= this.grid.length) {
-        continue;
-      }
-      const srcLine = region.lines[ry];
-      if (!srcLine) {
-        continue;
-      }
-      const destinationRow = this.grid[targetY];
-      for (let rx = 0; rx < srcLine.length; rx++) {
-        const targetX = x + rx;
-        if (targetX < 0 || targetX >= destinationRow.length) {
-          continue;
-        }
-        const value = srcLine.getValue(rx);
-        if (value !== " " || srcLine.hasStyles(rx)) {
-          destinationRow.setCharFast(targetX, value, srcLine.getFormatFlags(rx), srcLine.getFgColor(rx), srcLine.getBgColor(rx), srcLine.getLink(rx));
-        }
-      }
-    }
-    for (const child of region.children) {
-      this.addRegionTree(child, x + child.x, y + child.y);
-    }
-  }
-  writeStyledLineToRow(row, x, source, maxWidth, clip) {
-    let col = x;
-    const effectiveMax = clip ? Math.min(clip.x2, maxWidth) : Infinity;
-    for (let i = 0; i < source.length; i++) {
-      if (col >= effectiveMax) {
-        break;
-      }
-      if (clip && (col < clip.x1 || col >= clip.x2)) {
-        col++;
-        if (source.getFullWidth(i)) {
-          col++;
-        }
-        continue;
-      }
-      if (col >= 0) {
-        if (col >= row.length) {
-          row.ensureWidth(col + 2);
-        }
-        const span = source.getSpan(i);
-        const isFullWidth = source.getFullWidth(i);
-        const flags = (span?.formatFlags ?? 0) | (isFullWidth ? FULL_WIDTH_MASK : 0);
-        row.setCharFast(col, source.getValue(i), flags, span?.fgColor, span?.bgColor, span?.link);
-        if (isFullWidth) {
-          col++;
-          if (col >= row.length) {
-            row.ensureWidth(col + 1);
-          }
-          row.setCharFast(col, "", flags & ~FULL_WIDTH_MASK, span?.fgColor, span?.bgColor, span?.link);
-        }
-      }
-      col++;
-    }
-  }
-  get() {
-    const output = this.grid;
-    if (!this.lineMemoizationEnabled) {
-      if (this.memoizationProbeCountdown > 0) {
-        this.memoizationProbeCountdown--;
-      } else {
-        this.lineMemoizationEnabled = true;
-      }
-    }
-    const canUseMemoization = this.lineMemoizationEnabled;
-    const hasPrevious = this.previousLines.length > 0;
-    const canReuseRows = canUseMemoization && hasPrevious && this.previousLines.length === output.length && this.previousRenderedLines.length === output.length;
-    if (this.previousLines.length > output.length) {
-      this.previousLines.length = output.length;
-    }
-    if (this.previousRenderedLines.length > output.length) {
-      this.previousRenderedLines.length = output.length;
-    }
-    const generatedLines = Array.from({ length: output.length });
-    let changedRows = 0;
-    for (const [rowIndex, element] of output.entries()) {
-      const row = element;
-      if (canReuseRows && this.previousLines[rowIndex]?.equals(row)) {
-        generatedLines[rowIndex] = this.previousRenderedLines[rowIndex] ?? "";
-        continue;
-      }
-      changedRows++;
-      const trimmed = row.trimEnd();
-      const renderedLine = styledLineToString(trimmed);
-      generatedLines[rowIndex] = renderedLine;
-      if (canUseMemoization) {
-        this.previousRenderedLines[rowIndex] = renderedLine;
-        this.previousLines[rowIndex] = row.clone();
-      }
-    }
-    if (canUseMemoization && canReuseRows && output.length > 0) {
-      const changedRatio = changedRows / output.length;
-      if (changedRatio > memoizationDisableRatio) {
-        this.disableLineMemoization();
-      }
-    }
-    return {
-      height: output.length,
-      output: generatedLines.join("\n")
-    };
-  }
-  getBuffer() {
-    const output = this.grid;
-    const rows = output.length;
-    const buffer = new Uint32Array(this.width * rows * 2);
-    const defaultAttribute = 0 << 16 | 255 << 8 | 255;
-    for (let index = 0; index < buffer.length; index += 2) {
-      buffer[index] = 32;
-      buffer[index + 1] = defaultAttribute;
-    }
-    for (let y = 0; y < rows; y++) {
-      const row = output[y];
-      for (let x = 0; x < row.length && x < this.width; x++) {
-        const value = row.getValue(x);
-        if (value.length === 0) {
-          continue;
-        }
-        const charCode = value.codePointAt(0) ?? 32;
-        const bufIndex = (y * this.width + x) * 2;
-        const span = row.getSpan(x);
-        const formatFlags = span?.formatFlags ?? 0;
-        const fgColor = span?.fgColor;
-        const bgColor = span?.bgColor;
-        const fg = fgColor ? colorToAnsi256(fgColor) : 255;
-        const bg = bgColor ? colorToAnsi256(bgColor) : 255;
-        const styleBits = formatFlags & 255;
-        const attributeCode = styleBits << 16 | (bg & 255) << 8 | fg & 255;
-        buffer[bufIndex] = charCode;
-        buffer[bufIndex + 1] = attributeCode;
-        if (row.getFullWidth(x) && x + 1 < this.width) {
-          const nextIndex = bufIndex + 2;
-          buffer[nextIndex] = CONTINUATION_CELL_CODE;
-          buffer[nextIndex + 1] = attributeCode;
-          x++;
-        }
-      }
-    }
-    return { buffer, height: rows };
-  }
-  createGrid(width, height) {
-    const grid = [];
-    for (let y = 0; y < height; y++) {
-      grid.push(StyledLine.empty(width));
-    }
-    return grid;
-  }
-  disableLineMemoization() {
-    this.lineMemoizationEnabled = false;
-    this.memoizationProbeCountdown = memoizationProbeInterval;
-    this.previousLines.length = 0;
-    this.previousRenderedLines.length = 0;
-  }
-}
-
-const renderBackground = (x, y, node, output) => {
-  if (!node.style.backgroundColor) {
-    return;
-  }
-  const width = node.yogaNode.getComputedWidth();
-  const height = node.yogaNode.getComputedHeight();
-  const leftBorderWidth = node.style.borderStyle && node.style.borderLeft !== false ? 1 : 0;
-  const rightBorderWidth = node.style.borderStyle && node.style.borderRight !== false ? 1 : 0;
-  const topBorderHeight = node.style.borderStyle && node.style.borderTop !== false ? 1 : 0;
-  const bottomBorderHeight = node.style.borderStyle && node.style.borderBottom !== false ? 1 : 0;
-  const contentWidth = width - leftBorderWidth - rightBorderWidth;
-  const contentHeight = height - topBorderHeight - bottomBorderHeight;
-  if (!(contentWidth > 0 && contentHeight > 0)) {
-    return;
-  }
-  const bgEsc = getBackgroundColorEscape(node.style.backgroundColor);
-  if (!bgEsc) {
-    return;
-  }
-  const backgroundLine = `${bgEsc}${" ".repeat(contentWidth)}\x1B[49m`;
-  for (let row = 0; row < contentHeight; row++) {
-    output.write(x + leftBorderWidth, y + topBorderHeight + row, backgroundLine, { transformers: [] });
-  }
-};
-
-const stylePiece = (segment, fg, bg, dim) => {
-  let styled = colorize(segment, fg, "foreground");
-  styled = colorize(styled, bg, "background");
-  if (dim) {
-    styled = colorizeDefault.dim(styled);
-  }
-  return styled;
-};
-const buildBorderWithTitle = (borderChar, contentWidth, title, titleAlignment, rightTitle, borderFg, borderBg, borderDim) => {
-  if (!title && !rightTitle) {
-    return stylePiece(borderChar.repeat(contentWidth), borderFg, borderBg, borderDim);
-  }
-  const leftTitle = title ? ` ${title} ` : "";
-  const right = rightTitle ? ` ${rightTitle} ` : "";
-  const leftLength = leftTitle.length;
-  const rightLength = right.length;
-  const alignment = titleAlignment ?? "left";
-  if (leftLength + rightLength >= contentWidth) {
-    if (leftLength >= contentWidth) {
-      return `${leftTitle.slice(0, contentWidth - 1)}…`;
-    }
-    const remainingForRight = contentWidth - leftLength;
-    if (remainingForRight > 3) {
-      return leftTitle + right.slice(0, remainingForRight);
-    }
-    return leftTitle + stylePiece(borderChar.repeat(contentWidth - leftLength), borderFg, borderBg, borderDim);
-  }
-  const middleWidth = contentWidth - leftLength - rightLength;
-  if (alignment === "left" || rightTitle) {
-    return leftTitle + stylePiece(borderChar.repeat(middleWidth), borderFg, borderBg, borderDim) + right;
-  }
-  if (alignment === "right") {
-    const fillWidth = contentWidth - leftLength;
-    return stylePiece(borderChar.repeat(fillWidth), borderFg, borderBg, borderDim) + leftTitle;
-  }
-  const leftFill = Math.floor(middleWidth / 2);
-  const rightFill = middleWidth - leftFill;
-  return stylePiece(borderChar.repeat(leftFill), borderFg, borderBg, borderDim) + leftTitle + stylePiece(borderChar.repeat(rightFill), borderFg, borderBg, borderDim);
-};
-const renderBorder = (x, y, node, output) => {
-  if (node.style.borderStyle) {
-    const width = node.yogaNode.getComputedWidth();
-    const height = node.yogaNode.getComputedHeight();
-    const box = typeof node.style.borderStyle === "string" ? cliBoxes[node.style.borderStyle] : node.style.borderStyle;
-    const topBorderColor = node.style.borderTopColor ?? node.style.borderColor;
-    const bottomBorderColor = node.style.borderBottomColor ?? node.style.borderColor;
-    const leftBorderColor = node.style.borderLeftColor ?? node.style.borderColor;
-    const rightBorderColor = node.style.borderRightColor ?? node.style.borderColor;
-    const topBorderBackgroundColor = node.style.borderTopBackgroundColor ?? node.style.borderBackgroundColor;
-    const bottomBorderBackgroundColor = node.style.borderBottomBackgroundColor ?? node.style.borderBackgroundColor;
-    const leftBorderBackgroundColor = node.style.borderLeftBackgroundColor ?? node.style.borderBackgroundColor;
-    const rightBorderBackgroundColor = node.style.borderRightBackgroundColor ?? node.style.borderBackgroundColor;
-    const dimTopBorderColor = node.style.borderTopDimColor ?? node.style.borderDimColor;
-    const dimBottomBorderColor = node.style.borderBottomDimColor ?? node.style.borderDimColor;
-    const dimLeftBorderColor = node.style.borderLeftDimColor ?? node.style.borderDimColor;
-    const dimRightBorderColor = node.style.borderRightDimColor ?? node.style.borderDimColor;
-    const showTopBorder = node.style.borderTop !== false;
-    const showBottomBorder = node.style.borderBottom !== false;
-    const showLeftBorder = node.style.borderLeft !== false;
-    const showRightBorder = node.style.borderRight !== false;
-    const contentWidth = Math.max(0, width - (showLeftBorder ? 1 : 0) - (showRightBorder ? 1 : 0));
-    let topBorder;
-    if (showTopBorder) {
-      const topLeftCorner = showLeftBorder ? stylePiece(box.topLeft, topBorderColor, topBorderBackgroundColor, dimTopBorderColor) : "";
-      const topRightCorner = showRightBorder ? stylePiece(box.topRight, topBorderColor, topBorderBackgroundColor, dimTopBorderColor) : "";
-      const topContent = buildBorderWithTitle(
-        box.top,
-        contentWidth,
-        node.style.borderTopTitle,
-        node.style.borderTopTitleAlignment,
-        node.style.borderTopRightTitle,
-        topBorderColor,
-        topBorderBackgroundColor,
-        dimTopBorderColor
-      );
-      topBorder = topLeftCorner + topContent + topRightCorner;
-    }
-    let verticalBorderHeight = height;
-    if (showTopBorder) {
-      verticalBorderHeight -= 1;
-    }
-    if (showBottomBorder) {
-      verticalBorderHeight -= 1;
-    }
-    verticalBorderHeight = Math.max(0, verticalBorderHeight);
-    let leftBorder = "";
-    if (showLeftBorder) {
-      const one = stylePiece(box.left, leftBorderColor, leftBorderBackgroundColor, dimLeftBorderColor);
-      leftBorder = `${one}
-`.repeat(verticalBorderHeight);
-    }
-    let rightBorder = "";
-    if (showRightBorder) {
-      const one = stylePiece(box.right, rightBorderColor, rightBorderBackgroundColor, dimRightBorderColor);
-      rightBorder = `${one}
-`.repeat(verticalBorderHeight);
-    }
-    let bottomBorder;
-    if (showBottomBorder) {
-      const bottomLeftCorner = showLeftBorder ? stylePiece(box.bottomLeft, bottomBorderColor, bottomBorderBackgroundColor, dimBottomBorderColor) : "";
-      const bottomRightCorner = showRightBorder ? stylePiece(box.bottomRight, bottomBorderColor, bottomBorderBackgroundColor, dimBottomBorderColor) : "";
-      const bottomContent = buildBorderWithTitle(
-        box.bottom,
-        contentWidth,
-        node.style.borderBottomTitle,
-        node.style.borderBottomTitleAlignment,
-        void 0,
-        bottomBorderColor,
-        bottomBorderBackgroundColor,
-        dimBottomBorderColor
-      );
-      bottomBorder = bottomLeftCorner + bottomContent + bottomRightCorner;
-    }
-    const offsetY = showTopBorder ? 1 : 0;
-    if (topBorder) {
-      output.write(x, y, topBorder, { transformers: [] });
-    }
-    if (leftBorder) {
-      output.write(x, y + offsetY, leftBorder, { transformers: [] });
-    }
-    if (rightBorder) {
-      output.write(x + width - 1, y + offsetY, rightBorder, {
-        transformers: []
-      });
-    }
-    if (bottomBorder) {
-      output.write(x, y + height - 1, bottomBorder, { transformers: [] });
-    }
-  }
-};
-
-const noTransformers = [];
-const renderScrollbar = ({ axis, color, layout, output }) => {
-  const {
-    thumb: { end: endIndex, endHalf: thumbEndHalf, start: startIndex, startHalf: thumbStartHalf },
-    x,
-    y
-  } = layout;
-  if (axis === "vertical") {
-    for (let index = startIndex; index < endIndex; index++) {
-      let char = "█";
-      const hasUpper = 2 * index >= thumbStartHalf && 2 * index < thumbEndHalf;
-      const hasLower = 2 * index + 1 >= thumbStartHalf && 2 * index + 1 < thumbEndHalf;
-      if (hasUpper && !hasLower) {
-        char = "▀";
-      } else if (!hasUpper && hasLower) {
-        char = "▄";
-      }
-      const charString = color ? colorize(char, color, "foreground") : char;
-      output.write(x, y + index, charString, { transformers: noTransformers });
-    }
-  } else {
-    for (let index = startIndex; index < endIndex; index++) {
-      let char = "█";
-      const hasLeft = 2 * index >= thumbStartHalf && 2 * index < thumbEndHalf;
-      const hasRight = 2 * index + 1 >= thumbStartHalf && 2 * index + 1 < thumbEndHalf;
-      if (hasLeft && !hasRight) {
-        char = "▌";
-      } else if (!hasLeft && hasRight) {
-        char = "▐";
-      }
-      const charString = color ? colorize(char, color, "foreground") : char;
-      output.write(x + index, y, charString, { transformers: noTransformers });
-    }
-  }
-};
-
-const getStickyDescendants = (node, result = []) => {
-  for (const child of node.childNodes) {
-    if (child.nodeName === "#text") {
-      continue;
-    }
-    const domChild = child;
-    if (domChild.internal_stickyAlternate) {
-      continue;
-    }
-    if (domChild.internal_sticky) {
-      result.push({
-        node: domChild,
-        type: domChild.internal_sticky === "bottom" ? "bottom" : "top"
-      });
-    } else {
-      const overflow = domChild.style.overflow ?? "visible";
-      const overflowX = domChild.style.overflowX ?? overflow;
-      const overflowY = domChild.style.overflowY ?? overflow;
-      const isScrollable = overflowX === "scroll" || overflowY === "scroll";
-      if (!isScrollable && domChild.childNodes) {
-        getStickyDescendants(domChild, result);
-      }
-    }
-  }
-  return result;
-};
-const identifyActiveStickyNodes = (stickyNodes, node, scrollTop, viewportBottom) => {
-  let activeTopStickyNode;
-  let activeTopStickyNodeIndex = -1;
-  let activeBottomStickyNode;
-  let activeBottomStickyNodeIndex = -1;
-  for (const [index, stickyNodeInfo] of stickyNodes.entries()) {
-    const { node: stickyChild, type: stickyType } = stickyNodeInfo;
-    if (!stickyChild.yogaNode) {
-      continue;
-    }
-    const stickyNodeTop = getRelativeTop(stickyChild, node) ?? 0;
-    const stickyNodeHeight = stickyChild.yogaNode.getComputedHeight();
-    const stickyNodeBottom = stickyNodeTop + stickyNodeHeight;
-    const parent = stickyChild.parentNode;
-    let parentTop = 0;
-    let parentHeight = Number.MAX_SAFE_INTEGER;
-    if (parent?.yogaNode) {
-      parentTop = getRelativeTop(parent, node) ?? 0;
-      parentHeight = parent.yogaNode.getComputedHeight();
-    }
-    if (stickyType === "top" && stickyNodeTop < scrollTop && parentTop + parentHeight > scrollTop) {
-      activeTopStickyNode = stickyNodeInfo;
-      activeTopStickyNodeIndex = index;
-    }
-    if (stickyType === "bottom" && Math.floor(stickyNodeBottom) > Math.floor(viewportBottom) && parentTop < viewportBottom) {
-      activeBottomStickyNode = stickyNodeInfo;
-      activeBottomStickyNodeIndex = index;
-    }
-  }
-  const result = [];
-  if (activeTopStickyNode) {
-    let nextStickyNodeInfo;
-    for (let index = activeTopStickyNodeIndex + 1; index < stickyNodes.length; index++) {
-      const info = stickyNodes[index];
-      if (info.type !== "bottom") {
-        nextStickyNodeInfo = info;
-        break;
-      }
-    }
-    result.push({
-      nextStickyNodeInfo,
-      stickyNode: activeTopStickyNode.node,
-      type: "top"
-    });
-  }
-  if (activeBottomStickyNode) {
-    let nextStickyNodeInfo;
-    for (let index = activeBottomStickyNodeIndex - 1; index >= 0; index--) {
-      const info = stickyNodes[index];
-      if (info.type === "bottom") {
-        nextStickyNodeInfo = info;
-        break;
-      }
-    }
-    result.push({
-      nextStickyNodeInfo,
-      stickyNode: activeBottomStickyNode.node,
-      type: "bottom"
-    });
-  }
-  return result;
-};
-const renderActiveStickyNodes = (activeStickyNodes, node, output, createOutput, options) => {
-  const { newTransformers, skipStaticElements, x, y } = options;
-  const { yogaNode } = node;
-  if (!yogaNode) {
-    return;
-  }
-  const currentBorderTop = yogaNode.getComputedBorder(Yoga.EDGE_TOP);
-  const currentBorderLeft = yogaNode.getComputedBorder(Yoga.EDGE_LEFT);
-  const currentScrollTop = getScrollTop(node);
-  const currentClientHeight = node.internal_scrollState?.clientHeight ?? 0;
-  for (const { nextStickyNodeInfo, stickyNode, type } of activeStickyNodes) {
-    if (!stickyNode.yogaNode) {
-      continue;
-    }
-    const stickyNodeTop = getRelativeTop(stickyNode, node) ?? 0;
-    const stickyNodeHeight = stickyNode.yogaNode.getComputedHeight();
-    const stickyOffsetX = x + (getRelativeLeft(stickyNode, node) ?? 0);
-    const parent = stickyNode.parentNode;
-    let parentTop = 0;
-    let parentHeight = Number.MAX_SAFE_INTEGER;
-    if (parent?.yogaNode) {
-      parentTop = getRelativeTop(parent, node) ?? 0;
-      parentHeight = parent.yogaNode.getComputedHeight();
-    }
-    let finalStickyY;
-    if (type === "top") {
-      const parentBorderBottom = parent?.yogaNode?.getComputedBorder(Yoga.EDGE_BOTTOM) ?? 0;
-      const parentBottom = parentTop + parentHeight - parentBorderBottom;
-      let maxStickyTop = y - currentScrollTop + parentBottom - stickyNodeHeight;
-      const naturalStickyY = y - currentScrollTop + stickyNodeTop;
-      const stuckStickyY = y + currentBorderTop;
-      if (nextStickyNodeInfo?.node?.yogaNode) {
-        const nextNodeTop = getRelativeTop(nextStickyNodeInfo.node, node) ?? 0;
-        const nextNodeTopInViewport = y - currentScrollTop + nextNodeTop;
-        const nextNodePushTop = nextNodeTopInViewport - stickyNodeHeight;
-        if (nextNodePushTop < maxStickyTop) {
-          maxStickyTop = nextNodePushTop;
-        }
-      }
-      finalStickyY = Math.min(Math.max(stuckStickyY, naturalStickyY), maxStickyTop);
-    } else {
-      const parentBorderTop = parent?.yogaNode?.getComputedBorder(Yoga.EDGE_TOP) ?? 0;
-      let minStickyTop = y - currentScrollTop + parentTop + parentBorderTop;
-      const naturalStickyY = y - currentScrollTop + stickyNodeTop;
-      const stuckStickyY = y + currentBorderTop + currentClientHeight - stickyNodeHeight;
-      if (nextStickyNodeInfo?.node?.yogaNode) {
-        const nextNodeHeight = nextStickyNodeInfo.node.yogaNode.getComputedHeight();
-        const nextNodeTop = getRelativeTop(nextStickyNodeInfo.node, node) ?? 0;
-        const nextNodeBottomInViewport = y - currentScrollTop + nextNodeTop + nextNodeHeight;
-        if (nextNodeBottomInViewport > minStickyTop) {
-          minStickyTop = nextNodeBottomInViewport;
-        }
-      }
-      finalStickyY = Math.max(Math.min(stuckStickyY, naturalStickyY), minStickyTop);
-    }
-    const stickyOutput = createOutput({
-      height: stickyNodeHeight,
-      width: stickyNode.yogaNode.getComputedWidth()
-    });
-    renderNodeToOutput(stickyNode, stickyOutput, {
-      offsetX: -stickyNode.yogaNode.getComputedLeft(),
-      offsetY: -stickyNode.yogaNode.getComputedTop(),
-      skipStaticElements,
-      transformers: newTransformers
-    });
-    const renderedResult = stickyOutput.get();
-    const renderedLines = renderedResult.output.split("\n");
-    for (const [lineIndex, line] of renderedLines.entries()) {
-      if (line && line.length > 0) {
-        output.write(stickyOffsetX - (x + currentBorderLeft), finalStickyY - (y + currentBorderTop) + lineIndex, line, {
-          transformers: []
-        });
-      }
-    }
-  }
-};
-
-const applyPaddingToText = (node, text) => {
-  const yogaNode = node.childNodes[0]?.yogaNode;
-  if (yogaNode) {
-    const offsetX = yogaNode.getComputedLeft();
-    const offsetY = yogaNode.getComputedTop();
-    text = "\n".repeat(offsetY) + indent(text, offsetX);
-  }
-  return text;
-};
-const c0ControlUpperBound = 31;
-const deleteCodePoint = 127;
-const c1ControlStart = 128;
-const c1ControlEnd = 159;
-const mightExceedWidth = (text, maxWidth) => {
-  if (!Number.isFinite(maxWidth)) {
-    return false;
-  }
-  if (maxWidth < 0) {
-    return true;
-  }
-  let lineCodePointCount = 0;
-  for (const character of text) {
-    if (character === "\n") {
-      if (lineCodePointCount > maxWidth) {
-        return true;
-      }
-      lineCodePointCount = 0;
-      continue;
-    }
-    const codePoint = character.codePointAt(0);
-    if (codePoint <= c0ControlUpperBound || codePoint === deleteCodePoint || codePoint >= c1ControlStart && codePoint <= c1ControlEnd) {
-      return true;
-    }
-    if (isFullwidthCodePoint(codePoint)) {
-      return true;
-    }
-    lineCodePointCount++;
-    if (lineCodePointCount > maxWidth) {
-      return true;
-    }
-  }
-  return false;
-};
-const isNodeHidden = (node) => (node.internal_hidden ?? false) || node.yogaNode?.getDisplay() === Yoga.DISPLAY_NONE;
-const isNodeOrAncestorHidden = (node) => {
-  let currentNode = node;
-  while (currentNode) {
-    if (isNodeHidden(currentNode)) {
-      return true;
-    }
-    currentNode = currentNode.parentNode;
-  }
-  return false;
-};
-const renderNodeToScreenReaderOutput = (node, options = {}) => {
-  if (options.skipStaticElements && node.internal_static) {
-    return "";
-  }
-  if (node.internal_hidden) {
-    return "";
-  }
-  if (node.internal_stickyAlternate) {
-    return "";
-  }
-  if (node.yogaNode?.getDisplay() === Yoga.DISPLAY_NONE) {
-    return "";
-  }
-  let output = "";
-  if (node.nodeName === "ink-text") {
-    output = squashTextNodes(node);
-  } else if (node.nodeName === "ink-box" || node.nodeName === "ink-root") {
-    const separator = node.style.flexDirection === "row" || node.style.flexDirection === "row-reverse" ? " " : "\n";
-    const childNodes = node.style.flexDirection === "row-reverse" || node.style.flexDirection === "column-reverse" ? node.childNodes.toReversed() : [...node.childNodes];
-    output = childNodes.map((childNode) => {
-      const screenReaderOutput = renderNodeToScreenReaderOutput(childNode, {
-        parentRole: node.internal_accessibility?.role,
-        skipStaticElements: options.skipStaticElements
-      });
-      return screenReaderOutput;
-    }).filter(Boolean).join(separator);
-  }
-  if (node.internal_accessibility) {
-    const { role, state } = node.internal_accessibility;
-    if (state) {
-      const stateKeys = Object.keys(state);
-      const stateDescription = stateKeys.filter((key) => state[key]).join(", ");
-      if (stateDescription) {
-        output = `(${stateDescription}) ${output}`;
-      }
-    }
-    if (role && role !== options.parentRole) {
-      output = `${role}: ${output}`;
-    }
-  }
-  return output;
-};
-const renderNodeToOutput = (node, output, options) => {
-  const { absoluteOffsetX, absoluteOffsetY, offsetX = 0, offsetY = 0, renderState, skipStaticElements, transformers = [] } = options;
-  if (skipStaticElements && node.internal_static) {
-    return;
-  }
-  if (node.internal_hidden) {
-    return;
-  }
-  if (node.cachedRender) {
-    const x = offsetX + (node.yogaNode?.getComputedLeft() ?? 0);
-    const y = offsetY + (node.yogaNode?.getComputedTop() ?? 0);
-    output.addRegionTree(node.cachedRender, x, y);
-    return;
-  }
-  if (node.nodeName === "ink-cursor") {
-    if (!renderState) {
-      return;
-    }
-    renderState.cursorRequested = true;
-    const marker = node.internal_cursor;
-    if (!marker) {
-      renderState.cursorPosition = void 0;
-      return;
-    }
-    if (marker.inline) {
-      if (renderState.lastTextWriteEnd) {
-        renderState.cursorPosition = {
-          x: renderState.lastTextWriteEnd.x,
-          y: renderState.lastTextWriteEnd.y
-        };
-      } else {
-        const parentPosition = node.parentNode ? getAbsoluteContentPosition(node.parentNode) : void 0;
-        renderState.cursorPosition = parentPosition ? { x: parentPosition.x, y: parentPosition.y } : void 0;
-      }
-      return;
-    }
-    const resolvedAnchorNode = marker.anchorRef ? marker.anchorRef.current : node.parentNode;
-    if (!resolvedAnchorNode) {
-      renderState.cursorPosition = void 0;
-      return;
-    }
-    if (marker.anchorRef && isNodeOrAncestorHidden(resolvedAnchorNode)) {
-      renderState.cursorPosition = void 0;
-      return;
-    }
-    const anchorPosition = getAbsoluteContentPosition(resolvedAnchorNode);
-    if (!anchorPosition) {
-      renderState.cursorPosition = void 0;
-      return;
-    }
-    renderState.cursorPosition = {
-      x: anchorPosition.x + marker.x,
-      y: anchorPosition.y + marker.y
-    };
-    return;
-  }
-  const { yogaNode } = node;
-  if (yogaNode) {
-    if (yogaNode.getDisplay() === Yoga.DISPLAY_NONE) {
-      return;
-    }
-    const x = offsetX + yogaNode.getComputedLeft();
-    const y = offsetY + yogaNode.getComputedTop();
-    const absX = (absoluteOffsetX ?? offsetX) + yogaNode.getComputedLeft();
-    const absY = (absoluteOffsetY ?? offsetY) + yogaNode.getComputedTop();
-    const currentClip = output.getCurrentClip();
-    if (currentClip) {
-      const nodeWidth = yogaNode.getComputedWidth();
-      const nodeHeight = yogaNode.getComputedHeight();
-      const nodeRight = absX + nodeWidth;
-      const nodeBottom = absY + nodeHeight;
-      const clipLeft = currentClip.x1 ?? -Infinity;
-      const clipRight = currentClip.x2 ?? Infinity;
-      const clipTop = currentClip.y1 ?? -Infinity;
-      const clipBottom = currentClip.y2 ?? Infinity;
-      if (nodeRight <= clipLeft || absX >= clipRight || nodeBottom <= clipTop || absY >= clipBottom) {
-        return;
-      }
-    }
-    let newTransformers = transformers;
-    if (typeof node.internal_transform === "function") {
-      newTransformers = [node.internal_transform, ...transformers];
-    }
-    if (node.nodeName === "ink-text") {
-      let text = squashTextNodes(node);
-      if (text.length > 0) {
-        const maxWidth = getMaxWidth(yogaNode);
-        if (mightExceedWidth(text, maxWidth)) {
-          const currentWidth = Math.max(...text.split("\n").map((line) => getStringWidth(line)));
-          if (currentWidth > maxWidth) {
-            const textWrap = node.style.textWrap ?? "wrap";
-            text = wrapText(text, maxWidth, textWrap);
-          }
-        }
-        text = applyPaddingToText(node, text);
-        output.write(x, y, text, { transformers: newTransformers });
-        if (renderState) {
-          const lines = text.split("\n");
-          const lastLine = lines.at(-1) ?? "";
-          renderState.lastTextWriteEnd = {
-            x: x + getStringWidth(lastLine),
-            y: y + lines.length - 1
-          };
-        }
-      }
-      return;
-    }
-    let clipped = false;
-    let scrollOffsetX = 0;
-    let scrollOffsetY = 0;
-    if (node.nodeName === "ink-box") {
-      renderBackground(x, y, node, output);
-      renderBorder(x, y, node, output);
-      const overflow = node.style.overflow ?? "visible";
-      const overflowX = node.style.overflowX ?? overflow;
-      const overflowY = node.style.overflowY ?? overflow;
-      const clipHorizontally = overflowX === "hidden" || overflowX === "scroll";
-      const clipVertically = overflowY === "hidden" || overflowY === "scroll";
-      if (clipHorizontally || clipVertically) {
-        const nodeW = yogaNode.getComputedWidth();
-        const nodeH = yogaNode.getComputedHeight();
-        const regionX = clipHorizontally ? x + yogaNode.getComputedBorder(Yoga.EDGE_LEFT) : x;
-        const regionW = clipHorizontally ? nodeW - yogaNode.getComputedBorder(Yoga.EDGE_LEFT) - yogaNode.getComputedBorder(Yoga.EDGE_RIGHT) : nodeW;
-        const regionY = clipVertically ? y + yogaNode.getComputedBorder(Yoga.EDGE_TOP) : y;
-        const regionH = clipVertically ? nodeH - yogaNode.getComputedBorder(Yoga.EDGE_TOP) - yogaNode.getComputedBorder(Yoga.EDGE_BOTTOM) : nodeH;
-        output.startChildRegion(regionX, regionY, Math.max(0, regionW), Math.max(0, regionH));
-        clipped = true;
-        if (overflowY === "scroll" && node.internal_scrollState) {
-          scrollOffsetY = -node.internal_scrollState.scrollTop;
-        }
-        if (overflowX === "scroll" && node.internal_scrollState) {
-          scrollOffsetX = -node.internal_scrollState.scrollLeft;
-        }
-      }
-    }
-    if (node.nodeName === "ink-root" || node.nodeName === "ink-box" || node.nodeName === "ink-static-render") {
-      for (const childNode of node.childNodes) {
-        renderNodeToOutput(childNode, output, {
-          absoluteOffsetX: absX + scrollOffsetX,
-          absoluteOffsetY: absY + scrollOffsetY,
-          offsetX: x + scrollOffsetX,
-          offsetY: y + scrollOffsetY,
-          renderState,
-          skipStaticElements,
-          transformers: newTransformers
-        });
-      }
-      if (node.nodeName === "ink-box" && node.internal_scrollState) {
-        const stickyNodes = getStickyDescendants(node);
-        if (stickyNodes.length > 0) {
-          const currentScrollTop = getScrollTop(node);
-          const currentClientHeight = node.internal_scrollState.clientHeight;
-          const viewportBottom = currentScrollTop + currentClientHeight;
-          const activeStickyNodes = identifyActiveStickyNodes(stickyNodes, node, currentScrollTop, viewportBottom);
-          if (activeStickyNodes.length > 0) {
-            const createOutput = (options_) => new Output(options_);
-            renderActiveStickyNodes(activeStickyNodes, node, output, createOutput, {
-              newTransformers,
-              skipStaticElements,
-              x,
-              y
-            });
-          }
-        }
-      }
-      if (node.nodeName === "ink-box" && node.internal_scrollState) {
-        const overflow = node.style.overflow ?? "visible";
-        const overflowX = node.style.overflowX ?? overflow;
-        const overflowY = node.style.overflowY ?? overflow;
-        const borderLeft = yogaNode.getComputedBorder(Yoga.EDGE_LEFT);
-        const borderRight = yogaNode.getComputedBorder(Yoga.EDGE_RIGHT);
-        const borderTop = yogaNode.getComputedBorder(Yoga.EDGE_TOP);
-        const borderBottom = yogaNode.getComputedBorder(Yoga.EDGE_BOTTOM);
-        const innerWidth = yogaNode.getComputedWidth() - borderLeft - borderRight;
-        const innerHeight = yogaNode.getComputedHeight() - borderTop - borderBottom;
-        const { clientHeight, clientWidth, scrollHeight, scrollLeft, scrollTop, scrollWidth } = node.internal_scrollState;
-        const isVerticalScrollable = overflowY === "scroll" && scrollHeight > clientHeight;
-        const isHorizontalScrollable = overflowX === "scroll" && scrollWidth > clientWidth;
-        const showScrollbar = node.internal_scrollbar !== false;
-        if (isVerticalScrollable && showScrollbar) {
-          const verticalLayout = calculateScrollbarLayout({
-            axis: "vertical",
-            clientDimension: clientHeight,
-            hasOppositeScrollbar: false,
-            height: innerHeight,
-            marginBottom: 0,
-            marginRight: 0,
-            scrollDimension: scrollHeight,
-            scrollPosition: scrollTop,
-            width: innerWidth,
-            x: x + borderLeft,
-            y: y + borderTop
-          });
-          if (verticalLayout) {
-            renderScrollbar({
-              axis: "vertical",
-              color: node.style.scrollbarThumbColor,
-              layout: verticalLayout,
-              output
-            });
-          }
-        }
-        if (isHorizontalScrollable && showScrollbar) {
-          const horizontalLayout = calculateScrollbarLayout({
-            axis: "horizontal",
-            clientDimension: clientWidth,
-            hasOppositeScrollbar: isVerticalScrollable,
-            height: innerHeight,
-            marginBottom: 0,
-            marginRight: 0,
-            scrollDimension: scrollWidth,
-            scrollPosition: scrollLeft,
-            width: innerWidth,
-            x: x + borderLeft,
-            y: y + borderTop
-          });
-          if (horizontalLayout) {
-            renderScrollbar({
-              axis: "horizontal",
-              color: node.style.scrollbarThumbColor,
-              layout: horizontalLayout,
-              output
-            });
-          }
-        }
-      }
-      if (clipped) {
-        output.endChildRegion();
-      }
-    }
-  }
-};
-const renderToStatic = (node, options) => {
-  if (!node.yogaNode) {
-    return;
-  }
-  const width = node.yogaNode.getComputedWidth();
-  const height = node.yogaNode.getComputedHeight();
-  if (width <= 0 || height <= 0) {
-    return;
-  }
-  const { setCachedRender } = require("./dom");
-  const staticOutput = new Output({
-    height,
-    width
-  });
-  for (const childNode of node.childNodes) {
-    renderNodeToOutput(childNode, staticOutput, {
-      skipStaticElements: options?.skipStaticElements
-    });
-  }
-  const region = {
-    children: [],
-    cursorPosition: void 0,
-    height,
-    id: node.internalId ?? "static",
-    isScrollable: false,
-    lines: [...staticOutput.getRootLines()],
-    selectableSpans: [],
-    stickyHeaders: [],
-    styledOutput: [...staticOutput.getRootLines()],
-    width,
-    x: 0,
-    y: 0
-  };
-  setCachedRender(node, region);
-};
-
-const calculateSelectionMap = (root, selection) => {
-  const map = /* @__PURE__ */ new Map();
-  if (selection.rangeCount === 0) {
-    return map;
-  }
-  const range = selection.getRangeAt(0);
-  const { endContainer, endOffset, startContainer, startOffset } = range;
-  if (!startContainer || !endContainer) {
-    return map;
-  }
-  let hasFoundStart = false;
-  let hasFoundEnd = false;
-  const visitChildren = (node, localLengthRef, startRef, endRef, startFoundRef, endFoundRef) => {
-    if (node.nodeName === "#text") {
-      const { length } = node.nodeValue;
-      if (startContainer === node) {
-        startFoundRef.value = true;
-        startRef.value = localLengthRef.value + startOffset;
-      }
-      if (endContainer === node) {
-        endFoundRef.value = true;
-        endRef.value = localLengthRef.value + endOffset;
-      }
-      localLengthRef.value += length;
-    } else if ("childNodes" in node) {
-      for (const child of node.childNodes) {
-        if (node === startContainer) {
-          startFoundRef.value = true;
-          startRef.value = localLengthRef.value;
-        }
-        if (node === endContainer) {
-          endFoundRef.value = true;
-          endRef.value = localLengthRef.value;
-        }
-        visitChildren(child, localLengthRef, startRef, endRef, startFoundRef, endFoundRef);
-      }
-      if (node === startContainer && startOffset === node.childNodes.length) {
-        startFoundRef.value = true;
-        startRef.value = localLengthRef.value;
-      }
-      if (node === endContainer && endOffset === node.childNodes.length) {
-        endFoundRef.value = true;
-        endRef.value = localLengthRef.value;
-      }
-    }
-  };
-  const visit = (node) => {
-    if (node.nodeName === "ink-text") {
-      if (!isNodeSelectable(node)) {
-        return;
-      }
-      const localLengthRef = { value: 0 };
-      const nodeStartRef = { value: -1 };
-      const nodeEndRef = { value: -1 };
-      const foundStartRef = { value: false };
-      const foundEndRef = { value: false };
-      for (const child of node.childNodes) {
-        if (node === startContainer) {
-          foundStartRef.value = true;
-          nodeStartRef.value = localLengthRef.value;
-        }
-        if (node === endContainer) {
-          foundEndRef.value = true;
-          nodeEndRef.value = localLengthRef.value;
-        }
-        visitChildren(child, localLengthRef, nodeStartRef, nodeEndRef, foundStartRef, foundEndRef);
-      }
-      if (node === startContainer && startOffset === node.childNodes.length) {
-        foundStartRef.value = true;
-        nodeStartRef.value = localLengthRef.value;
-      }
-      if (node === endContainer && endOffset === node.childNodes.length) {
-        foundEndRef.value = true;
-        nodeEndRef.value = localLengthRef.value;
-      }
-      if ((hasFoundStart || foundStartRef.value) && (!hasFoundEnd || foundEndRef.value)) {
-        const start = foundStartRef.value ? nodeStartRef.value : 0;
-        const end = foundEndRef.value ? nodeEndRef.value : localLengthRef.value;
-        if (start !== -1 && end !== -1 && start < end) {
-          map.set(node, { end, start });
-        }
-      }
-      if (foundStartRef.value) {
-        hasFoundStart = true;
-      }
-      if (foundEndRef.value) {
-        hasFoundEnd = true;
-      }
-    } else {
-      const { childNodes } = node;
-      if (childNodes) {
-        for (const child of childNodes) {
-          if (node === startContainer) {
-            hasFoundStart = true;
-          }
-          if (node === endContainer) {
-            hasFoundEnd = true;
-          }
-          visit(child);
-        }
-        if (node === startContainer && startOffset === childNodes.length) {
-          hasFoundStart = true;
-        }
-        if (node === endContainer && endOffset === childNodes.length) {
-          hasFoundEnd = true;
-        }
-      }
-    }
-  };
-  visit(root);
-  return map;
-};
-const interactiveOutputCaches = new OutputCaches();
-const staticOutputCaches = new OutputCaches();
-const interactiveOutputs = /* @__PURE__ */ new WeakMap();
-const staticOutputs = /* @__PURE__ */ new WeakMap();
-const getReusableOutput = ({ caches, height, node, outputs, width }) => {
-  let output = outputs.get(node);
-  if (!output) {
-    output = new Output({
-      caches,
-      height,
-      width
-    });
-    outputs.set(node, output);
-  }
-  output.reset(width, height);
-  return output;
-};
-const renderer = (node, isScreenReaderEnabled, options) => {
-  if (node.yogaNode) {
-    if (isScreenReaderEnabled) {
-      const output2 = renderNodeToScreenReaderOutput(node, {
-        skipStaticElements: true
-      });
-      const outputHeight2 = output2 === "" ? 0 : output2.split("\n").length;
-      let staticOutput2 = "";
-      if (node.staticNode) {
-        staticOutput2 = renderNodeToScreenReaderOutput(node.staticNode, {
-          skipStaticElements: false
-        });
-      }
-      return {
-        cursorPosition: void 0,
-        cursorRequested: false,
-        output: output2,
-        outputHeight: outputHeight2,
-        staticOutput: staticOutput2 ? `${staticOutput2}
-` : ""
-      };
-    }
-    options?.selection && options.selection.rangeCount > 0 ? calculateSelectionMap(node, options.selection) : void 0;
-    const output = getReusableOutput({
-      caches: interactiveOutputCaches,
-      height: node.yogaNode.getComputedHeight(),
-      node,
-      outputs: interactiveOutputs,
-      width: node.yogaNode.getComputedWidth()
-    });
-    const renderState = {
-      cursorPosition: void 0,
-      cursorRequested: false
-    };
-    renderNodeToOutput(node, output, {
-      renderState,
-      skipStaticElements: true
-    });
-    let staticOutput;
-    if (node.staticNode?.yogaNode) {
-      staticOutput = getReusableOutput({
-        caches: staticOutputCaches,
-        height: node.staticNode.yogaNode.getComputedHeight(),
-        node,
-        outputs: staticOutputs,
-        width: node.staticNode.yogaNode.getComputedWidth()
-      });
-      renderNodeToOutput(node.staticNode, staticOutput, {
-        skipStaticElements: false
-      });
-    }
-    if (options?.useNativeRenderer) {
-      const { buffer: outputBuffer, height: outputHeight2 } = output.getBuffer();
-      return {
-        cursorPosition: renderState.cursorPosition,
-        cursorRequested: renderState.cursorRequested,
-        output: "",
-        outputBuffer,
-        outputHeight: outputHeight2,
-        outputWidth: output.width,
-        staticOutput: staticOutput ? `${staticOutput.get().output}
-` : ""
-      };
-    }
-    const { height: outputHeight, output: generatedOutput } = output.get();
-    return {
-      cursorPosition: renderState.cursorPosition,
-      cursorRequested: renderState.cursorRequested,
-      output: generatedOutput,
-      outputHeight,
-      // Newline at the end is needed, because static output doesn't have one, so
-      // interactive output will override last line of static output
-      staticOutput: staticOutput ? `${staticOutput.get().output}
-` : ""
-    };
-  }
-  return {
-    cursorPosition: void 0,
-    cursorRequested: false,
-    output: "",
-    outputHeight: 0,
-    staticOutput: ""
-  };
-};
-
-export { renderToStatic as a, renderer as r };