@visulima/tui 0.0.1 → 1.0.0-alpha.2

package/dist/packem_shared/getScrollHeight-BubfU_df.js

@@ -0,0 +1,63 @@
+import Yoga from 'yoga-layout';
+
+const calculateScrollDimensions = (node) => {
+  const { yogaNode } = node;
+  if (!yogaNode) {
+    return { scrollHeight: 0, scrollWidth: 0 };
+  }
+  const top = yogaNode.getComputedBorder(Yoga.EDGE_TOP);
+  const left = yogaNode.getComputedBorder(Yoga.EDGE_LEFT);
+  let maxBottom = top;
+  let maxRight = yogaNode.getComputedPadding(Yoga.EDGE_LEFT);
+  for (let index = 0; index < yogaNode.getChildCount(); index++) {
+    const child = yogaNode.getChild(index);
+    const childBottom = child.getComputedTop() + child.getComputedHeight() + child.getComputedMargin(Yoga.EDGE_BOTTOM);
+    if (childBottom > maxBottom) {
+      maxBottom = childBottom;
+    }
+    const childRight = child.getComputedLeft() + child.getComputedWidth() + child.getComputedMargin(Yoga.EDGE_RIGHT);
+    if (childRight > maxRight) {
+      maxRight = childRight;
+    }
+  }
+  const scrollHeight = maxBottom - top + yogaNode.getComputedPadding(Yoga.EDGE_BOTTOM);
+  const scrollWidth = maxRight - left + yogaNode.getComputedPadding(Yoga.EDGE_RIGHT);
+  return { scrollHeight, scrollWidth };
+};
+const getScrollHeight = (node) => node.internal_scrollState?.scrollHeight ?? 0;
+const getScrollWidth = (node) => node.internal_scrollState?.scrollWidth ?? 0;
+const calculateScroll = (node) => {
+  const { yogaNode } = node;
+  if (!yogaNode) {
+    return;
+  }
+  const { scrollHeight: actualScrollHeight, scrollWidth } = calculateScrollDimensions(node);
+  let scrollHeight = actualScrollHeight;
+  const clientHeight = Math.max(0, yogaNode.getComputedHeight() - yogaNode.getComputedBorder(Yoga.EDGE_TOP) - yogaNode.getComputedBorder(Yoga.EDGE_BOTTOM));
+  if (node.style.stableScrollback && node.style.overflowToBackbuffer) {
+    const actualMaxScrollTop = Math.max(0, actualScrollHeight - clientHeight);
+    if (node.internal_isScrollbackDirty) {
+      node.internal_maxScrollTop = actualMaxScrollTop;
+      node.internal_isScrollbackDirty = false;
+    } else {
+      node.internal_maxScrollTop = Math.max(node.internal_maxScrollTop ?? 0, actualMaxScrollTop);
+    }
+    scrollHeight = Math.max(actualScrollHeight, (node.internal_maxScrollTop ?? 0) + clientHeight);
+  }
+  const scrollTop = Math.max(0, Math.min(node.style.scrollTop ?? 0, scrollHeight - clientHeight));
+  const clientWidth = Math.max(0, yogaNode.getComputedWidth() - yogaNode.getComputedBorder(Yoga.EDGE_LEFT) - yogaNode.getComputedBorder(Yoga.EDGE_RIGHT));
+  const scrollLeft = Math.max(0, Math.min(node.style.scrollLeft ?? 0, scrollWidth - clientWidth));
+  node.internal_scrollState = {
+    actualScrollHeight,
+    clientHeight,
+    clientWidth,
+    scrollHeight,
+    scrollLeft,
+    scrollTop,
+    scrollWidth
+  };
+};
+const getScrollTop = (node) => node.internal_scrollState?.scrollTop ?? 0;
+const getScrollLeft = (node) => node.internal_scrollState?.scrollLeft ?? 0;
+
+export { calculateScroll, getScrollHeight, getScrollLeft, getScrollTop, getScrollWidth };

package/dist/packem_shared/input-utils-ViAEXa0Z.js

@@ -0,0 +1,19 @@
+const IS_ASCII_LETTER = /^[a-z]$/i;
+const isControlCharacter = (input) => {
+  const codepoint = input.codePointAt(0);
+  return codepoint !== void 0 && (codepoint < 32 || codepoint === 127);
+};
+const isInsertableInput = (input, key) => {
+  if (input.length === 0 || isControlCharacter(input)) {
+    return false;
+  }
+  if (key.ctrl && key.meta) {
+    return !IS_ASCII_LETTER.test(input);
+  }
+  if (key.ctrl || key.meta) {
+    return false;
+  }
+  return true;
+};
+
+export { isInsertableInput as i };

package/dist/packem_shared/isIntersecting-fEXHJN5R.js

@@ -0,0 +1,10 @@
+const isIntersecting = ({
+  element,
+  mouse: { x, y }
+}) => {
+  const isOutsideHorizontally = x < element.left || x >= element.left + element.width;
+  const isOutsideVertically = y < element.top || y >= element.top + element.height;
+  return !isOutsideHorizontally && !isOutsideVertically;
+};
+
+export { isIntersecting as default };

package/dist/packem_shared/isOsc52Supported-G0k4sXJx.js

@@ -0,0 +1,36 @@
+const BEL = "\x07";
+const OSC = "\x1B]";
+const SUPPORTED_TERMINALS = /* @__PURE__ */ new Set(["Alacritty", "contour", "foot", "Ghostty", "iTerm2", "iTerm.app", "kitty", "rio", "WezTerm"]);
+const isOsc52Supported = () => {
+  const termProgram = process.env["TERM_PROGRAM"] ?? "";
+  if (SUPPORTED_TERMINALS.has(termProgram)) {
+    return true;
+  }
+  const term = process.env["TERM"] ?? "";
+  if (term.startsWith("xterm")) {
+    return true;
+  }
+  if (process.env["WT_SESSION"]) {
+    return true;
+  }
+  if (process.env["TMUX"]) {
+    return true;
+  }
+  if (term.startsWith("screen")) {
+    return true;
+  }
+  return false;
+};
+const VALID_TARGETS = /* @__PURE__ */ new Set(["c", "p", "s"]);
+const writeOsc52 = (stream, text, target = "c") => {
+  if (!VALID_TARGETS.has(target)) {
+    throw new Error(`Invalid clipboard target: ${target}`);
+  }
+  const encoded = Buffer.from(text, "utf8").toString("base64");
+  stream.write(`${OSC}52;${target};${encoded}${BEL}`);
+};
+const clearOsc52 = (stream, target = "c") => {
+  stream.write(`${OSC}52;${target};${BEL}`);
+};
+
+export { clearOsc52, isOsc52Supported, writeOsc52 };

package/dist/packem_shared/isTerminalPaletteQuerySupported-EeiwMKbr.js

@@ -0,0 +1,93 @@
+const BEL = "\x07";
+const OSC = "\x1B]";
+const parseOscColorResponse = (response) => {
+  const match = /rgb:([\da-f]{2,4})\/([\da-f]{2,4})\/([\da-f]{2,4})/i.exec(response);
+  if (!match) {
+    return null;
+  }
+  const toHex = (value) => {
+    if (value.length <= 2) {
+      return value.padStart(2, "0");
+    }
+    return value.slice(0, 2);
+  };
+  return `#${toHex(match[1])}${toHex(match[2])}${toHex(match[3])}`;
+};
+const isTerminalPaletteQuerySupported = () => {
+  const termProgram = process.env["TERM_PROGRAM"] ?? "";
+  const supported = /* @__PURE__ */ new Set(["Alacritty", "contour", "foot", "Ghostty", "iTerm2", "iTerm.app", "kitty", "rio", "WezTerm"]);
+  if (supported.has(termProgram)) {
+    return true;
+  }
+  const term = process.env["TERM"] ?? "";
+  return term.startsWith("xterm") || Boolean(process.env["WT_SESSION"]);
+};
+const MAX_RESPONSE_BYTES = 256;
+const queryOsc = (stdin, stdout, sequence, timeout = 500) => new Promise((resolve) => {
+  let buffer = "";
+  let timer;
+  const cleanup = () => {
+    if (timer) {
+      clearTimeout(timer);
+    }
+    stdin.removeListener("data", onData);
+  };
+  const onData = (data) => {
+    buffer += data.toString();
+    if (buffer.length > MAX_RESPONSE_BYTES) {
+      cleanup();
+      resolve(null);
+      return;
+    }
+    if (buffer.includes(BEL) || buffer.includes("\x1B\\")) {
+      cleanup();
+      resolve(buffer);
+    }
+  };
+  timer = setTimeout(() => {
+    cleanup();
+    resolve(null);
+  }, timeout);
+  stdin.on("data", onData);
+  stdout.write(sequence);
+});
+const queryTerminalPalette = async (stdin, stdout, timeout = 500) => {
+  const result = {};
+  const fgResponse = await queryOsc(stdin, stdout, `${OSC}10;?${BEL}`, timeout);
+  if (fgResponse) {
+    const fg = parseOscColorResponse(fgResponse);
+    if (fg) {
+      result.foreground = fg;
+    }
+  }
+  const bgResponse = await queryOsc(stdin, stdout, `${OSC}11;?${BEL}`, timeout);
+  if (bgResponse) {
+    const bg = parseOscColorResponse(bgResponse);
+    if (bg) {
+      result.background = bg;
+    }
+  }
+  const cursorResponse = await queryOsc(stdin, stdout, `${OSC}12;?${BEL}`, timeout);
+  if (cursorResponse) {
+    const cursor = parseOscColorResponse(cursorResponse);
+    if (cursor) {
+      result.cursor = cursor;
+    }
+  }
+  const colors = [];
+  for (let index = 0; index < 16; index++) {
+    const colorResponse = await queryOsc(stdin, stdout, `${OSC}4;${index};?${BEL}`, timeout);
+    if (colorResponse) {
+      const color = parseOscColorResponse(colorResponse);
+      colors.push(color ?? "");
+    } else {
+      colors.push("");
+    }
+  }
+  if (colors.some((c) => c.length > 0)) {
+    result.colors = colors;
+  }
+  return result;
+};
+
+export { isTerminalPaletteQuerySupported, queryTerminalPalette };

package/dist/packem_shared/kittyFlags-bNNf_9kX.js

@@ -0,0 +1,26 @@
+const kittyFlags = {
+  disambiguateEscapeCodes: 1,
+  reportAllKeysAsEscapeCodes: 8,
+  reportAlternateKeys: 4,
+  reportAssociatedText: 16,
+  reportEventTypes: 2
+};
+function resolveFlags(flags) {
+  let result = 0;
+  for (const flag of flags) {
+    result |= kittyFlags[flag];
+  }
+  return result;
+}
+const kittyModifiers = {
+  alt: 2,
+  capsLock: 64,
+  ctrl: 4,
+  hyper: 16,
+  meta: 32,
+  numLock: 128,
+  shift: 1,
+  super: 8
+};
+
+export { kittyFlags, kittyModifiers, resolveFlags };

package/dist/packem_shared/measure-element-Reza_yfC.js

@@ -0,0 +1,396 @@
+import Yoga from 'yoga-layout';
+import { getScrollTop, getScrollLeft } from './getScrollHeight-BubfU_df.js';
+import squashTextNodes from './squashTextNodesWithMap-iqm6OMMT.js';
+
+const getAbsoluteBorderPosition = (node) => {
+  let currentNode = node;
+  let x = 0;
+  let y = 0;
+  while (currentNode?.parentNode) {
+    if (!currentNode.yogaNode) {
+      return void 0;
+    }
+    x += currentNode.yogaNode.getComputedLeft();
+    y += currentNode.yogaNode.getComputedTop();
+    currentNode = currentNode.parentNode;
+  }
+  return { x, y };
+};
+const getAbsolutePosition = (node) => getAbsoluteBorderPosition(node);
+const getAbsoluteContentPosition = (node) => {
+  const borderPosition = getAbsoluteBorderPosition(node);
+  if (!borderPosition || !node.yogaNode) {
+    return void 0;
+  }
+  return {
+    x: borderPosition.x + node.yogaNode.getComputedBorder(Yoga.EDGE_LEFT) + node.yogaNode.getComputedPadding(Yoga.EDGE_LEFT),
+    y: borderPosition.y + node.yogaNode.getComputedBorder(Yoga.EDGE_TOP) + node.yogaNode.getComputedPadding(Yoga.EDGE_TOP)
+  };
+};
+const processLayout = (node, callbacks) => {
+  const { initialState, onNewline, onSpace, onText } = callbacks;
+  if (node.nodeName !== "ink-box" && node.nodeName !== "ink-root" && node.nodeName !== "ink-text" && node.nodeName !== "ink-virtual-text" || !node.yogaNode) {
+    return { lineBottom: 0, state: initialState() };
+  }
+  const { fragments } = collectSortedFragments(node);
+  const state = initialState();
+  state.currentX = 0;
+  state.lineBottom = 0;
+  state.yieldedContent = false;
+  for (const fragment of fragments) {
+    if (fragment.y >= state.lineBottom) {
+      const gap = fragment.y - state.lineBottom;
+      const newlines = state.yieldedContent ? 1 + gap : gap;
+      if (newlines > 0) {
+        onNewline(newlines, state);
+        state.currentX = 0;
+      }
+      state.lineBottom = fragment.y;
+    }
+    if (fragment.x > state.currentX) {
+      const spaces = fragment.x - state.currentX;
+      onSpace(spaces, state);
+      state.currentX = fragment.x;
+    }
+    if (fragment.text.length > 0) {
+      state.yieldedContent = true;
+      onText(fragment, state);
+    }
+    const newlinesInText = (fragment.text.match(/\n/g) ?? []).length;
+    if (newlinesInText > 0) {
+      const lastNewlineIndex = fragment.text.lastIndexOf("\n");
+      state.currentX = fragment.text.length - lastNewlineIndex - 1;
+    } else {
+      state.currentX += fragment.text.length;
+    }
+    state.lineBottom = Math.max(state.lineBottom, fragment.y + fragment.height);
+  }
+  return { lineBottom: state.lineBottom, state };
+};
+
+const measureElement = (node) => {
+  const position = getAbsolutePosition(node);
+  return {
+    height: node.yogaNode?.getComputedHeight() ?? 0,
+    width: node.yogaNode?.getComputedWidth() ?? 0,
+    x: position?.x ?? 0,
+    y: position?.y ?? 0
+  };
+};
+const getInnerWidth = (node) => {
+  const { yogaNode } = node;
+  if (!yogaNode) {
+    return 0;
+  }
+  const width = yogaNode.getComputedWidth() ?? 0;
+  const borderLeft = yogaNode.getComputedBorder(Yoga.EDGE_LEFT);
+  const borderRight = yogaNode.getComputedBorder(Yoga.EDGE_RIGHT);
+  return width - borderLeft - borderRight;
+};
+const getInnerHeight = (node) => {
+  const { yogaNode } = node;
+  if (!yogaNode) {
+    return 0;
+  }
+  const height = yogaNode.getComputedHeight() ?? 0;
+  const borderTop = yogaNode.getComputedBorder(Yoga.EDGE_TOP);
+  const borderBottom = yogaNode.getComputedBorder(Yoga.EDGE_BOTTOM);
+  return height - borderTop - borderBottom;
+};
+const getBoundingBox = (node) => {
+  const { yogaNode } = node;
+  if (!yogaNode) {
+    return { height: 0, width: 0, x: 0, y: 0 };
+  }
+  const width = yogaNode.getComputedWidth() ?? 0;
+  const height = yogaNode.getComputedHeight() ?? 0;
+  let x = yogaNode.getComputedLeft();
+  let y = yogaNode.getComputedTop();
+  let parent = node.parentNode;
+  while (parent?.yogaNode) {
+    x += parent.yogaNode.getComputedLeft();
+    y += parent.yogaNode.getComputedTop();
+    if (parent.nodeName === "ink-box") {
+      const overflow = parent.style.overflow ?? "visible";
+      const overflowX = parent.style.overflowX ?? overflow;
+      const overflowY = parent.style.overflowY ?? overflow;
+      if (overflowY === "scroll") {
+        y -= getScrollTop(parent);
+      }
+      if (overflowX === "scroll") {
+        x -= getScrollLeft(parent);
+      }
+    }
+    parent = parent.parentNode;
+  }
+  return { height, width, x, y };
+};
+const getAddedScrollHeight = (node) => {
+  const scrollHeight = node.internal_scrollState?.scrollHeight ?? 0;
+  const actualScrollHeight = node.internal_scrollState?.actualScrollHeight ?? 0;
+  return Math.max(0, scrollHeight - actualScrollHeight);
+};
+const calculateScrollbarThumb = (options) => {
+  const { axis, clientDimension, scrollbarDimension, scrollDimension, scrollPosition } = options;
+  const scrollbarDimensionHalves = scrollbarDimension * 2;
+  const thumbDimensionHalves = Math.max(axis === "vertical" ? 2 : 1, Math.round(clientDimension / scrollDimension * scrollbarDimensionHalves));
+  const maxScrollPosition = scrollDimension - clientDimension;
+  const maxThumbPosition = scrollbarDimensionHalves - thumbDimensionHalves;
+  const thumbPosition = maxScrollPosition > 0 ? Math.round(scrollPosition / maxScrollPosition * maxThumbPosition) : 0;
+  const thumbStartHalf = thumbPosition;
+  const thumbEndHalf = thumbPosition + thumbDimensionHalves;
+  const startIndex = Math.floor(thumbStartHalf / 2);
+  const endIndex = Math.min(scrollbarDimension, Math.ceil(thumbEndHalf / 2));
+  return { endIndex, startIndex, thumbEndHalf, thumbStartHalf };
+};
+const calculateScrollbarLayout = (options) => {
+  const { axis, clientDimension, hasOppositeScrollbar, height, marginBottom, marginRight, scrollDimension, scrollPosition, width, x, y } = options;
+  if (scrollDimension <= clientDimension) {
+    return void 0;
+  }
+  if (axis === "vertical") {
+    const { endIndex: endIndex2, startIndex: startIndex2, thumbEndHalf: thumbEndHalf2, thumbStartHalf: thumbStartHalf2 } = calculateScrollbarThumb({
+      axis,
+      clientDimension,
+      scrollbarDimension: height,
+      scrollDimension,
+      scrollPosition
+    });
+    const scrollbarX = x + width - 1 - marginRight;
+    return {
+      height,
+      thumb: {
+        end: endIndex2,
+        endHalf: thumbEndHalf2,
+        height: endIndex2 - startIndex2,
+        start: startIndex2,
+        startHalf: thumbStartHalf2,
+        width: 1,
+        x: scrollbarX,
+        y: y + startIndex2
+      },
+      width: 1,
+      x: scrollbarX,
+      y
+    };
+  }
+  const scrollbarWidth = width - (hasOppositeScrollbar ? 1 : 0);
+  const { endIndex, startIndex, thumbEndHalf, thumbStartHalf } = calculateScrollbarThumb({
+    axis,
+    clientDimension,
+    scrollbarDimension: scrollbarWidth,
+    scrollDimension,
+    scrollPosition
+  });
+  const scrollbarY = y + height - 1 - marginBottom;
+  return {
+    height: 1,
+    thumb: {
+      end: endIndex,
+      endHalf: thumbEndHalf,
+      height: 1,
+      start: startIndex,
+      startHalf: thumbStartHalf,
+      width: endIndex - startIndex,
+      x: x + startIndex,
+      y: scrollbarY
+    },
+    width: scrollbarWidth,
+    x,
+    y: scrollbarY
+  };
+};
+const getVerticalScrollbarBoundingBox = (node, offset) => {
+  const { yogaNode } = node;
+  if (!yogaNode) {
+    return void 0;
+  }
+  const overflow = node.style.overflow ?? "visible";
+  const overflowY = node.style.overflowY ?? overflow;
+  if (overflowY !== "scroll") {
+    return void 0;
+  }
+  const clientHeight = node.internal_scrollState?.clientHeight ?? 0;
+  const scrollHeight = node.internal_scrollState?.scrollHeight ?? 0;
+  if (scrollHeight <= clientHeight) {
+    return void 0;
+  }
+  const { x, y } = offset ?? getBoundingBox(node);
+  const scrollbarHeight = yogaNode.getComputedHeight() - yogaNode.getComputedBorder(Yoga.EDGE_TOP) - yogaNode.getComputedBorder(Yoga.EDGE_BOTTOM);
+  return calculateScrollbarLayout({
+    axis: "vertical",
+    clientDimension: clientHeight,
+    hasOppositeScrollbar: false,
+    height: scrollbarHeight,
+    marginBottom: yogaNode.getComputedBorder(Yoga.EDGE_BOTTOM),
+    marginRight: yogaNode.getComputedBorder(Yoga.EDGE_RIGHT),
+    scrollDimension: scrollHeight,
+    scrollPosition: node.internal_scrollState?.scrollTop ?? 0,
+    width: yogaNode.getComputedWidth() - yogaNode.getComputedBorder(Yoga.EDGE_LEFT),
+    x: x + yogaNode.getComputedBorder(Yoga.EDGE_LEFT),
+    y: y + yogaNode.getComputedBorder(Yoga.EDGE_TOP)
+  });
+};
+const getHorizontalScrollbarBoundingBox = (node, offset) => {
+  const { yogaNode } = node;
+  if (!yogaNode) {
+    return void 0;
+  }
+  const overflow = node.style.overflow ?? "visible";
+  const overflowX = node.style.overflowX ?? overflow;
+  if (overflowX !== "scroll") {
+    return void 0;
+  }
+  const clientWidth = node.internal_scrollState?.clientWidth ?? 0;
+  const scrollWidth = node.internal_scrollState?.scrollWidth ?? 0;
+  if (scrollWidth <= clientWidth) {
+    return void 0;
+  }
+  const { x, y } = offset ?? getBoundingBox(node);
+  const overflowY = node.style.overflowY ?? overflow;
+  const clientHeight = node.internal_scrollState?.clientHeight ?? 0;
+  const scrollHeight = node.internal_scrollState?.scrollHeight ?? 0;
+  const isVerticalScrollbarVisible = overflowY === "scroll" && scrollHeight > clientHeight;
+  return calculateScrollbarLayout({
+    axis: "horizontal",
+    clientDimension: clientWidth,
+    hasOppositeScrollbar: isVerticalScrollbarVisible,
+    height: yogaNode.getComputedHeight() - yogaNode.getComputedBorder(Yoga.EDGE_TOP),
+    marginBottom: yogaNode.getComputedBorder(Yoga.EDGE_BOTTOM),
+    marginRight: yogaNode.getComputedBorder(Yoga.EDGE_RIGHT),
+    scrollDimension: scrollWidth,
+    scrollPosition: node.internal_scrollState?.scrollLeft ?? 0,
+    width: yogaNode.getComputedWidth() - yogaNode.getComputedBorder(Yoga.EDGE_LEFT) - yogaNode.getComputedBorder(Yoga.EDGE_RIGHT),
+    x: x + yogaNode.getComputedBorder(Yoga.EDGE_LEFT),
+    y: y + yogaNode.getComputedBorder(Yoga.EDGE_TOP)
+  });
+};
+const getRelativeTop = (node, ancestor) => {
+  if (!node.yogaNode || node === ancestor) {
+    return 0;
+  }
+  let top = node.yogaNode.getComputedTop();
+  let parent = node.parentNode;
+  while (parent && parent !== ancestor) {
+    if (parent.yogaNode) {
+      top += parent.yogaNode.getComputedTop();
+    }
+    parent = parent.parentNode;
+  }
+  if (ancestor !== void 0 && parent !== ancestor) {
+    return void 0;
+  }
+  return top;
+};
+const getRelativeLeft = (node, ancestor) => {
+  if (!node.yogaNode || node === ancestor) {
+    return 0;
+  }
+  let left = node.yogaNode.getComputedLeft();
+  let parent = node.parentNode;
+  while (parent && parent !== ancestor) {
+    if (parent.yogaNode) {
+      left += parent.yogaNode.getComputedLeft();
+    }
+    parent = parent.parentNode;
+  }
+  if (ancestor !== void 0 && parent !== ancestor) {
+    return void 0;
+  }
+  return left;
+};
+const getText = (node) => {
+  if (node.nodeName === "#text") {
+    return node.nodeValue;
+  }
+  if (node.nodeName === "ink-text" || node.nodeName === "ink-virtual-text") {
+    return squashTextNodes(node);
+  }
+  return "";
+};
+const collectSortedFragments = (node) => {
+  const fragments = [];
+  const collect = (currentNode, coords, selectable) => {
+    const { visualX, visualY, x, y } = coords;
+    let v2 = 0;
+    let h2 = 0;
+    let currentSelectable = selectable;
+    const { userSelect } = currentNode.style;
+    if (userSelect === "none") {
+      currentSelectable = false;
+    } else if (userSelect === "text" || userSelect === "all") {
+      currentSelectable = true;
+    }
+    if (currentNode.nodeName === "ink-text" || currentNode.nodeName === "ink-virtual-text") {
+      if (currentSelectable) {
+        const text = getText(currentNode);
+        fragments.push({
+          height: currentNode.yogaNode?.getComputedHeight() ?? 0,
+          node: currentNode,
+          text,
+          visualX,
+          visualY,
+          width: currentNode.yogaNode?.getComputedWidth() ?? 0,
+          x,
+          y
+        });
+        return { h: 0, hasContent: true, v: 0 };
+      }
+      return {
+        h: currentNode.yogaNode?.getComputedWidth() ?? 0,
+        hasContent: false,
+        v: currentNode.yogaNode?.getComputedHeight() ?? 0
+      };
+    }
+    if (currentNode.nodeName === "ink-box" || currentNode.nodeName === "ink-root") {
+      if (!currentNode.yogaNode || currentNode.yogaNode.getDisplay() === Yoga.DISPLAY_NONE) {
+        return { h: 0, hasContent: false, v: 0 };
+      }
+      const borderTop = currentNode.yogaNode.getComputedBorder(Yoga.EDGE_TOP);
+      const borderBottom = currentNode.yogaNode.getComputedBorder(Yoga.EDGE_BOTTOM);
+      const borderLeft = currentNode.yogaNode.getComputedBorder(Yoga.EDGE_LEFT);
+      const borderRight = currentNode.yogaNode.getComputedBorder(Yoga.EDGE_RIGHT);
+      v2 += borderTop + borderBottom;
+      h2 += borderLeft + borderRight;
+      const flexDirection = currentNode.yogaNode.getFlexDirection();
+      const isColumn = flexDirection === Yoga.FLEX_DIRECTION_COLUMN || flexDirection === Yoga.FLEX_DIRECTION_COLUMN_REVERSE;
+      let siblingRemovedH = 0;
+      let siblingRemovedV = 0;
+      let childHasContent = false;
+      for (const child of currentNode.childNodes) {
+        if (child.yogaNode) {
+          const childX = x + child.yogaNode.getComputedLeft() - borderLeft - siblingRemovedH;
+          const childY = y + child.yogaNode.getComputedTop() - borderTop - siblingRemovedV;
+          const childVisualX = visualX + child.yogaNode.getComputedLeft();
+          const childVisualY = visualY + child.yogaNode.getComputedTop();
+          const res = collect(child, { visualX: childVisualX, visualY: childVisualY, x: childX, y: childY }, currentSelectable);
+          if (res.hasContent) {
+            childHasContent = true;
+          }
+          if (isColumn) {
+            siblingRemovedV += res.v;
+          } else {
+            siblingRemovedH += res.h;
+          }
+        }
+      }
+      if (isColumn) {
+        v2 += siblingRemovedV;
+      } else {
+        h2 += siblingRemovedH;
+      }
+      return { h: h2, hasContent: childHasContent, v: v2 };
+    }
+    return { h: 0, hasContent: false, v: 0 };
+  };
+  const { h, v } = collect(node, { visualX: 0, visualY: 0, x: 0, y: 0 }, true);
+  fragments.sort((a, b) => {
+    if (a.y !== b.y) {
+      return a.y - b.y;
+    }
+    return a.x - b.x;
+  });
+  return { fragments, removedHorizontal: h, removedVertical: v };
+};
+
+export { calculateScrollbarThumb as a, collectSortedFragments as b, calculateScrollbarLayout as c, getBoundingBox as d, getHorizontalScrollbarBoundingBox as e, getInnerHeight as f, getAddedScrollHeight as g, getInnerWidth as h, getRelativeLeft as i, getRelativeTop as j, getText as k, getVerticalScrollbarBoundingBox as l, measureElement as m, getAbsoluteContentPosition as n, getAbsolutePosition as o, processLayout as p };