@visulima/tui 1.0.0-alpha.6 → 1.0.0-alpha.8

package/dist/packem_shared/comparePoints-CAAlhiMS.js

@@ -1,287 +0,0 @@
-import { g as getPathToRoot } from './dom-CrbpQgat.js';
-import { t as toStyledLine } from './measure-text-BdOhbOeh.js';
-import { squashTextNodesWithMap } from './squashTextNodesWithMap-iqm6OMMT.js';
-
-const getPlainTextFromDomNode = (node) => {
-  if (node.nodeName === "#text") {
-    const styledLine2 = toStyledLine(node.nodeValue);
-    const charOffsetMap2 = /* @__PURE__ */ new Map([[node, { end: styledLine2.length, start: 0 }]]);
-    return { charOffsetMap: charOffsetMap2, styledLine: styledLine2 };
-  }
-  const charOffsetMap = /* @__PURE__ */ new Map();
-  const offsetRef = { current: 0 };
-  const text = squashTextNodesWithMap(node, charOffsetMap, offsetRef);
-  const styledLine = toStyledLine(text);
-  charOffsetMap.set(node, { end: styledLine.length, start: 0 });
-  return { charOffsetMap, styledLine };
-};
-const getRangeCharacterOffsets = (range, charOffsetMap) => {
-  if (!range.startContainer || !range.endContainer) {
-    return void 0;
-  }
-  const getOffset = (node, offset) => {
-    const nodeRange = charOffsetMap.get(node);
-    if (!nodeRange) {
-      return void 0;
-    }
-    if (node.nodeName === "#text") {
-      return nodeRange.start + offset;
-    }
-    const element = node;
-    if (offset >= element.childNodes.length) {
-      return nodeRange.end;
-    }
-    const child = element.childNodes[offset];
-    const childRange = charOffsetMap.get(child);
-    if (childRange) {
-      return childRange.start;
-    }
-    for (let index = offset - 1; index >= 0; index--) {
-      const sibling = element.childNodes[index];
-      const siblingRange = charOffsetMap.get(sibling);
-      if (siblingRange) {
-        return siblingRange.end;
-      }
-    }
-    return nodeRange.start;
-  };
-  const start = getOffset(range.startContainer, range.startOffset);
-  const end = getOffset(range.endContainer, range.endOffset);
-  if (start === void 0 || end === void 0) {
-    return void 0;
-  }
-  return { end, start };
-};
-const comparePoints = (nodeA, offsetA, nodeB, offsetB) => {
-  if (nodeA === nodeB) {
-    return offsetA === offsetB ? 0 : offsetA < offsetB ? -1 : 1;
-  }
-  const pathA = getPathToRoot(nodeA);
-  const pathB = getPathToRoot(nodeB);
-  let lca;
-  let index = 0;
-  while (index < pathA.length && index < pathB.length && pathA[index] === pathB[index]) {
-    lca = pathA[index];
-    index++;
-  }
-  if (!lca) {
-    return 0;
-  }
-  if (index === pathA.length) {
-    const childB2 = pathB[index];
-    const indexChildB2 = nodeA.childNodes.indexOf(childB2);
-    if (offsetA <= indexChildB2) {
-      return -1;
-    }
-    return 1;
-  }
-  if (index === pathB.length) {
-    const childA2 = pathA[index];
-    const indexChildA2 = nodeB.childNodes.indexOf(childA2);
-    if (indexChildA2 < offsetB) {
-      return -1;
-    }
-    return 1;
-  }
-  const childA = pathA[index];
-  const childB = pathB[index];
-  const indexChildA = lca.childNodes.indexOf(childA);
-  const indexChildB = lca.childNodes.indexOf(childB);
-  return indexChildA < indexChildB ? -1 : 1;
-};
-class Range {
-  startContainer = void 0;
-  startOffset = 0;
-  endContainer = void 0;
-  endOffset = 0;
-  collapsed = true;
-  commonAncestorContainer = void 0;
-  setStart(node, offset) {
-    this.startContainer = node;
-    this.startOffset = offset;
-    this.updateCollapsed();
-    this.updateCommonAncestor();
-  }
-  setEnd(node, offset) {
-    this.endContainer = node;
-    this.endOffset = offset;
-    this.updateCollapsed();
-    this.updateCommonAncestor();
-  }
-  collapse(toStart) {
-    if (toStart) {
-      this.endContainer = this.startContainer;
-      this.endOffset = this.startOffset;
-    } else {
-      this.startContainer = this.endContainer;
-      this.startOffset = this.endOffset;
-    }
-    this.collapsed = true;
-    this.updateCommonAncestor();
-  }
-  selectNode(node) {
-    if (!node.parentNode) {
-      throw new Error("Node has no parent");
-    }
-    const index = node.parentNode.childNodes.indexOf(node);
-    this.setStart(node.parentNode, index);
-    this.setEnd(node.parentNode, index + 1);
-  }
-  selectNodeContents(node) {
-    this.setStart(node, 0);
-    if (node.nodeName === "#text") {
-      this.setEnd(node, node.nodeValue.length);
-    } else {
-      this.setEnd(node, node.childNodes.length);
-    }
-  }
-  toString() {
-    if (this.collapsed || !this.startContainer || !this.endContainer) {
-      return "";
-    }
-    if (!this.commonAncestorContainer) {
-      return "";
-    }
-    const { charOffsetMap, styledLine } = getPlainTextFromDomNode(this.commonAncestorContainer);
-    const offsets = getRangeCharacterOffsets(this, charOffsetMap);
-    if (!offsets) {
-      return "";
-    }
-    const sliced = styledLine.slice(offsets.start, offsets.end);
-    return sliced.getTextRange(0, sliced.length);
-  }
-  updateCollapsed() {
-    this.collapsed = this.startContainer === this.endContainer && this.startOffset === this.endOffset;
-  }
-  updateCommonAncestor() {
-    if (!this.startContainer || !this.endContainer) {
-      this.commonAncestorContainer = void 0;
-      return;
-    }
-    if (this.startContainer === this.endContainer) {
-      this.commonAncestorContainer = this.startContainer;
-      return;
-    }
-    const startPath = getPathToRoot(this.startContainer);
-    const endPath = getPathToRoot(this.endContainer);
-    let common;
-    for (let index = 0; index < Math.min(startPath.length, endPath.length); index++) {
-      if (startPath[index] === endPath[index]) {
-        common = startPath[index];
-      } else {
-        break;
-      }
-    }
-    this.commonAncestorContainer = common;
-  }
-}
-class Selection {
-  anchorNode = void 0;
-  anchorOffset = 0;
-  focusNode = void 0;
-  focusOffset = 0;
-  isCollapsed = true;
-  rangeCount = 0;
-  ranges = [];
-  listeners = /* @__PURE__ */ new Set();
-  onChange(listener) {
-    this.listeners.add(listener);
-    return () => {
-      this.listeners.delete(listener);
-    };
-  }
-  toString() {
-    return this.ranges.map((range) => range.toString()).join("");
-  }
-  getRangeAt(index) {
-    return this.ranges[index];
-  }
-  addRange(range) {
-    if (!this.ranges.includes(range)) {
-      this.ranges.push(range);
-      this.rangeCount = this.ranges.length;
-      if (this.rangeCount === 1) {
-        this.anchorNode = range.startContainer;
-        this.anchorOffset = range.startOffset;
-        this.focusNode = range.endContainer;
-        this.focusOffset = range.endOffset;
-        this.isCollapsed = range.collapsed;
-      }
-      this.notifyChange();
-    }
-  }
-  removeRange(range) {
-    const index = this.ranges.indexOf(range);
-    if (index !== -1) {
-      this.ranges.splice(index, 1);
-      this.rangeCount = this.ranges.length;
-      if (this.rangeCount === 0) {
-        this.clearState();
-      }
-      this.notifyChange();
-    }
-  }
-  removeAllRanges() {
-    this.ranges = [];
-    this.rangeCount = 0;
-    this.clearState();
-    this.notifyChange();
-  }
-  collapse(node, offset) {
-    this.removeAllRanges();
-    const range = new Range();
-    range.setStart(node, offset);
-    range.setEnd(node, offset);
-    this.addRange(range);
-  }
-  containsNode(node, allowPartialContainment = false) {
-    if (!node.parentNode) {
-      return false;
-    }
-    const parent = node.parentNode;
-    const index = parent.childNodes.indexOf(node);
-    const nodeStartContainer = parent;
-    const nodeStartOffset = index;
-    const nodeEndContainer = parent;
-    const nodeEndOffset = index + 1;
-    return this.ranges.some((range) => {
-      if (!range.startContainer || !range.endContainer) {
-        return false;
-      }
-      const startToStart = comparePoints(range.startContainer, range.startOffset, nodeStartContainer, nodeStartOffset);
-      const endToEnd = comparePoints(range.endContainer, range.endOffset, nodeEndContainer, nodeEndOffset);
-      if (allowPartialContainment) {
-        const startToEnd = comparePoints(range.startContainer, range.startOffset, nodeEndContainer, nodeEndOffset);
-        const endToStart = comparePoints(range.endContainer, range.endOffset, nodeStartContainer, nodeStartOffset);
-        return startToEnd < 0 && endToStart > 0;
-      }
-      return startToStart <= 0 && endToEnd >= 0;
-    });
-  }
-  clearState() {
-    this.anchorNode = void 0;
-    this.anchorOffset = 0;
-    this.focusNode = void 0;
-    this.focusOffset = 0;
-    this.isCollapsed = true;
-  }
-  notifyChange() {
-    for (const listener of this.listeners) {
-      listener();
-    }
-  }
-}
-const applySelectionToStyledLine = (line, range) => {
-  if (line.length === 0 || range.start >= range.end) {
-    return line;
-  }
-  const result = line.clone();
-  const selStart = Math.max(0, range.start);
-  const selEnd = Math.min(line.length, range.end);
-  for (let i = selStart; i < selEnd; i++) {
-    result.setInverted(i, true);
-  }
-  return result;
-};
-
-export { Range, Selection, applySelectionToStyledLine, comparePoints };

package/dist/packem_shared/controlled-scroll-view-DJXfdWMm.js

@@ -1,286 +0,0 @@
-import { jsx, jsxs } from 'react/jsx-runtime';
-import { useState, useRef, useCallback, useLayoutEffect, isValidElement, useImperativeHandle, Fragment } from 'react';
-import { m as measureElement } from './measure-element-Bc6PEaIe.js';
-import Box from './Box-W1w_NGin.js';
-
-const useStateRef = (initialValue) => {
-  const [state, setStateInternal] = useState(initialValue);
-  const ref = useRef(initialValue);
-  const setState = useCallback((update) => {
-    const nextValue = typeof update === "function" ? update(ref.current) : update;
-    ref.current = nextValue;
-    setStateInternal(nextValue);
-  }, []);
-  const getState = useCallback(() => ref.current, []);
-  return [state, setState, getState];
-};
-
-const MeasurableItem = ({
-  children,
-  index,
-  measureKey,
-  onMeasure,
-  width
-}) => {
-  const ref = useRef(null);
-  useLayoutEffect(() => {
-    if (ref.current) {
-      const { height } = measureElement(ref.current);
-      onMeasure(index, height);
-    }
-  }, [index, onMeasure, width, measureKey, children]);
-  return jsx(Box, { flexDirection: "column", flexShrink: 0, ref, width: "100%", children });
-};
-const toChildArray = (children) => {
-  if (children == null) {
-    return [];
-  }
-  if (Array.isArray(children)) {
-    const result = [];
-    for (let index = 0; index < children.length; index += 1) {
-      const child = children[index];
-      if (isValidElement(child) && child.type === Fragment) {
-        result.push(...toChildArray(child.props.children));
-      } else {
-        result.push(child);
-      }
-    }
-    return result;
-  }
-  if (isValidElement(children) && children.type === Fragment) {
-    return toChildArray(children.props.children);
-  }
-  return [children];
-};
-const ControlledScrollView = ({
-  children,
-  debug = false,
-  onContentHeightChange,
-  onItemHeightChange,
-  onViewportSizeChange,
-  overscan = 3,
-  ref,
-  scrollOffset,
-  virtualize = false,
-  ...boxProps
-}) => {
-  const hasMeasuredRef = useRef(false);
-  const [viewportSize, setViewportSize, getViewportSize] = useStateRef({
-    height: 0,
-    width: 0
-  });
-  const [contentHeight, setContentHeight, getContentHeight] = useStateRef(0);
-  const [itemMeasureKeys, setItemMeasureKeys] = useState({});
-  const viewportRef = useRef(null);
-  const previousContentHeightRef = useRef(0);
-  useLayoutEffect(() => {
-    if (contentHeight !== previousContentHeightRef.current) {
-      onContentHeightChange?.(contentHeight, previousContentHeightRef.current);
-      previousContentHeightRef.current = contentHeight;
-    }
-  }, [contentHeight, onContentHeightChange]);
-  const itemHeightsRef = useRef({});
-  const itemKeysRef = useRef([]);
-  const itemOffsetsRef = useRef([]);
-  const firstInvalidOffsetIndexRef = useRef(0);
-  const handleItemMeasure = useCallback(
-    (index, height) => {
-      const key = itemKeysRef.current[index] ?? index;
-      if (itemHeightsRef.current[key] !== height) {
-        const previousHeight = itemHeightsRef.current[key] ?? 0;
-        itemHeightsRef.current = {
-          ...itemHeightsRef.current,
-          [key]: height
-        };
-        let newTotalHeight = 0;
-        for (let i = 0; i < itemKeysRef.current.length; i += 1) {
-          const itemKey = itemKeysRef.current[i];
-          if (itemKey != null) {
-            newTotalHeight += itemHeightsRef.current[itemKey] ?? 0;
-          }
-        }
-        const currentHeight = getContentHeight();
-        if (newTotalHeight !== currentHeight) {
-          setContentHeight(newTotalHeight);
-        }
-        onItemHeightChange?.(index, height, previousHeight);
-        firstInvalidOffsetIndexRef.current = Math.min(firstInvalidOffsetIndexRef.current, index + 1);
-      }
-    },
-    [onItemHeightChange, getContentHeight, setContentHeight]
-  );
-  const measureViewport = useCallback(() => {
-    if (viewportRef.current) {
-      const { height, width } = measureElement(viewportRef.current);
-      const currentSize = getViewportSize();
-      if (width !== currentSize.width || height !== currentSize.height) {
-        onViewportSizeChange?.({ height, width }, currentSize);
-        setViewportSize({ height, width });
-      }
-    }
-  }, [viewportRef, onViewportSizeChange, getViewportSize, setViewportSize]);
-  useLayoutEffect(() => {
-    measureViewport();
-  });
-  const previousChildrenRef = useRef(null);
-  if (previousChildrenRef.current !== children) {
-    previousChildrenRef.current = children;
-    const newItemKeys = [];
-    const newItemHeights = {};
-    const childArray2 = toChildArray(children);
-    childArray2.forEach((child, index) => {
-      if (!child) {
-        return;
-      }
-      const key = isValidElement(child) ? child.key : null;
-      const effectiveKey = key ?? index;
-      newItemKeys[index] = effectiveKey;
-      const itemHeight = itemHeightsRef.current[effectiveKey] ?? 0;
-      newItemHeights[effectiveKey] = itemHeight;
-    });
-    itemHeightsRef.current = newItemHeights;
-    itemKeysRef.current = newItemKeys;
-    itemOffsetsRef.current = Array.from({ length: newItemKeys.length }).fill(0);
-    firstInvalidOffsetIndexRef.current = 0;
-    let newTotalHeight = 0;
-    newItemKeys.forEach((itemKey) => {
-      newTotalHeight += newItemHeights[itemKey] ?? 0;
-    });
-    const currentHeight = getContentHeight();
-    if (newTotalHeight !== currentHeight) {
-      setContentHeight(newTotalHeight);
-    }
-  }
-  useImperativeHandle(ref, () => {
-    return {
-      getBottomOffset: () => Math.max(0, getContentHeight() - getViewportSize().height),
-      getContentHeight,
-      getItemHeight: (index) => {
-        const key = itemKeysRef.current[index] ?? index;
-        return itemHeightsRef.current[key] ?? 0;
-      },
-      getItemPosition: (index) => {
-        if (index < 0 || index >= itemKeysRef.current.length) {
-          return null;
-        }
-        if (index >= firstInvalidOffsetIndexRef.current) {
-          let currentOffset = 0;
-          let startIndex = 0;
-          if (firstInvalidOffsetIndexRef.current > 0) {
-            startIndex = firstInvalidOffsetIndexRef.current;
-            const previousIndex = startIndex - 1;
-            const previousKey = itemKeysRef.current[previousIndex] ?? previousIndex;
-            const previousHeight = itemHeightsRef.current[previousKey] ?? 0;
-            currentOffset = (itemOffsetsRef.current[previousIndex] ?? 0) + previousHeight;
-          }
-          for (let i = startIndex; i <= index; i += 1) {
-            itemOffsetsRef.current[i] = currentOffset;
-            const key2 = itemKeysRef.current[i] ?? i;
-            const height2 = itemHeightsRef.current[key2] ?? 0;
-            currentOffset += height2;
-          }
-          firstInvalidOffsetIndexRef.current = index + 1;
-        }
-        const top = itemOffsetsRef.current[index] ?? 0;
-        const key = itemKeysRef.current[index] ?? index;
-        const height = itemHeightsRef.current[key] ?? 0;
-        return { height, top };
-      },
-      getViewportHeight: () => getViewportSize().height,
-      remeasure: measureViewport,
-      remeasureItem: (index) => {
-        setItemMeasureKeys((previous) => {
-          return {
-            ...previous,
-            [index]: (previous[index] ?? 0) + 1
-          };
-        });
-      }
-    };
-  }, [measureViewport, getContentHeight, getViewportSize, setItemMeasureKeys]);
-  const childArray = toChildArray(children);
-  if (!hasMeasuredRef.current && contentHeight > 0) {
-    hasMeasuredRef.current = true;
-  }
-  let firstRenderIndex = 0;
-  let lastRenderIndex = childArray.length - 1;
-  let aboveSpacerHeight = 0;
-  let belowSpacerHeight = 0;
-  const allItemsMeasured = childArray.length > 0 && childArray.every((_, index) => {
-    const key = itemKeysRef.current[index] ?? index;
-    return (itemHeightsRef.current[key] ?? 0) > 0;
-  });
-  const shouldVirtualize = virtualize && hasMeasuredRef.current && allItemsMeasured;
-  if (shouldVirtualize) {
-    const totalItems = itemKeysRef.current.length;
-    if (firstInvalidOffsetIndexRef.current < totalItems) {
-      let currentOffset = 0;
-      let startIndex = 0;
-      if (firstInvalidOffsetIndexRef.current > 0) {
-        startIndex = firstInvalidOffsetIndexRef.current;
-        const previousIndex = startIndex - 1;
-        const previousKey = itemKeysRef.current[previousIndex] ?? previousIndex;
-        const previousHeight = itemHeightsRef.current[previousKey] ?? 0;
-        currentOffset = (itemOffsetsRef.current[previousIndex] ?? 0) + previousHeight;
-      }
-      for (let i = startIndex; i < totalItems; i += 1) {
-        itemOffsetsRef.current[i] = currentOffset;
-        const key = itemKeysRef.current[i] ?? i;
-        currentOffset += itemHeightsRef.current[key] ?? 0;
-      }
-      firstInvalidOffsetIndexRef.current = totalItems;
-    }
-    const viewEnd = scrollOffset + viewportSize.height;
-    firstRenderIndex = childArray.length;
-    lastRenderIndex = -1;
-    for (let i = 0; i < totalItems; i += 1) {
-      const itemTop = itemOffsetsRef.current[i] ?? 0;
-      const key = itemKeysRef.current[i] ?? i;
-      const itemHeight = itemHeightsRef.current[key] ?? 0;
-      const itemBottom = itemTop + itemHeight;
-      if (itemBottom > scrollOffset && itemTop < viewEnd) {
-        if (i < firstRenderIndex) {
-          firstRenderIndex = i;
-        }
-        lastRenderIndex = i;
-      }
-    }
-    if (firstRenderIndex > lastRenderIndex) {
-      firstRenderIndex = 0;
-      lastRenderIndex = -1;
-    }
-    firstRenderIndex = Math.max(0, firstRenderIndex - overscan);
-    lastRenderIndex = Math.min(childArray.length - 1, Math.max(-1, lastRenderIndex) + overscan);
-    aboveSpacerHeight = itemOffsetsRef.current[firstRenderIndex] ?? 0;
-    if (lastRenderIndex < childArray.length - 1) {
-      const lastKey = itemKeysRef.current[lastRenderIndex] ?? lastRenderIndex;
-      const lastItemBottom = (itemOffsetsRef.current[lastRenderIndex] ?? 0) + (itemHeightsRef.current[lastKey] ?? 0);
-      belowSpacerHeight = contentHeight - lastItemBottom;
-    }
-  }
-  return jsx(Box, { ...boxProps, children: jsx(Box, { ref: viewportRef, width: "100%", children: jsx(Box, { overflow: debug ? void 0 : "hidden", width: "100%", children: jsxs(Box, { flexDirection: "column", marginTop: -scrollOffset, width: "100%", children: [
-    shouldVirtualize && aboveSpacerHeight > 0 && jsx(Box, { height: aboveSpacerHeight }),
-    childArray.map((child, index) => {
-      if (!child) {
-        return null;
-      }
-      if (shouldVirtualize && (index < firstRenderIndex || index > lastRenderIndex)) {
-        return null;
-      }
-      return jsx(
-        MeasurableItem,
-        {
-          index,
-          measureKey: itemMeasureKeys[index],
-          onMeasure: handleItemMeasure,
-          width: viewportSize.width,
-          children: child
-        },
-        isValidElement(child) ? child.key ?? index : index
-      );
-    }),
-    shouldVirtualize && belowSpacerHeight > 0 && jsx(Box, { height: belowSpacerHeight })
-  ] }) }) }) });
-};
-
-export { ControlledScrollView as C, useStateRef as u };

package/dist/packem_shared/createInlineLoop-Dnfm1ZSJ.js

@@ -1,99 +0,0 @@
-import { createDecMode, setMode, resetMode, BracketedPasteMode, cursorUp, cursorToColumn1, cursorHide, REQUEST_CURSOR_POSITION, cursorPosition, eraseLine, cursorShow } from '@visulima/ansi';
-import { terminalSize, Renderer } from './Renderer-zZ5O3vxc.js';
-
-const SynchronizedOutputMode = createDecMode(2026);
-const DEC_2026_ON = setMode(SynchronizedOutputMode);
-const DEC_2026_OFF = resetMode(SynchronizedOutputMode);
-const enableBracketedPaste = setMode(BracketedPasteMode);
-const disableBracketedPaste = resetMode(BracketedPasteMode);
-function createInlineLoop(paint, options = {}) {
-  const reservedRows = options.rows ?? 10;
-  const fps = options.fps ?? 60;
-  const onExit = options.onExit ?? "preserve";
-  let interval = null;
-  let renderer = null;
-  let buf = null;
-  let cols = 80;
-  let renderRows = 10;
-  let frame = 0;
-  let regionTopRow = 1;
-  function write(s) {
-    renderer.writeRaw(s);
-  }
-  function tick() {
-    buf.fill(0);
-    paint(buf, cols, renderRows, frame++);
-    write(DEC_2026_ON);
-    try {
-      renderer.render(buf);
-    } finally {
-      write(DEC_2026_OFF);
-    }
-  }
-  function startRendering(cursorRow) {
-    regionTopRow = cursorRow - renderRows;
-    write(cursorUp(renderRows) + cursorToColumn1);
-    renderer.setRowOffset(regionTopRow);
-    tick();
-    interval = setInterval(
-      () => {
-        tick();
-      },
-      Math.round(1e3 / fps)
-    );
-  }
-  function start() {
-    const size = terminalSize();
-    cols = size.cols;
-    const termRows = size.rows;
-    renderRows = Math.min(reservedRows, termRows);
-    if (process.stdin.isTTY) {
-      process.stdin.setRawMode(true);
-    }
-    process.stdin.resume();
-    process.stdin.setEncoding("utf8");
-    renderer = new Renderer(cols, renderRows);
-    buf = new Uint32Array(cols * renderRows * 2);
-    write(cursorHide);
-    write(enableBracketedPaste);
-    write("\n".repeat(renderRows));
-    write(REQUEST_CURSOR_POSITION);
-    process.on("SIGINT", stop);
-    let cprBuf = "";
-    const onData = (chunk) => {
-      cprBuf += chunk;
-      const m = cprBuf.match(/\u001B\[(\d+);(\d+)R/);
-      if (m) {
-        process.stdin.off("data", onData);
-        startRendering(Number.parseInt(m[1], 10));
-      }
-    };
-    process.stdin.on("data", onData);
-  }
-  function stop() {
-    if (interval) {
-      clearInterval(interval);
-      interval = null;
-    }
-    if (renderer) {
-      if (onExit === "destroy") {
-        for (let i = 0; i < renderRows; i++) {
-          write(cursorPosition(regionTopRow + 1 + i, 1) + eraseLine);
-        }
-        write(cursorPosition(regionTopRow + 1, 1));
-      } else {
-        write(cursorPosition(regionTopRow + renderRows + 1, 1));
-      }
-      write(disableBracketedPaste);
-      write(cursorShow);
-    }
-    if (process.stdin.isTTY) {
-      process.stdin.setRawMode(false);
-    }
-    process.stdin.pause();
-    process.exit(0);
-  }
-  return { start, stop };
-}
-
-export { createInlineLoop };