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

package/dist/packem_shared/Transition-CbNfKhaj.js

@@ -0,0 +1,108 @@
+import { jsx } from 'react/jsx-runtime';
+import { useState, useRef, useEffect } from 'react';
+import Box from './Box-W1w_NGin.js';
+import Text from './Text-CtUwV89_.js';
+
+const renderFade = (progress, children) => {
+  if (progress >= 1) {
+    return jsx(Box, { children });
+  }
+  if (progress <= 0) {
+    return jsx(Box, {});
+  }
+  return jsx(Box, { children: typeof children === "string" ? jsx(Text, { dimColor: progress < 0.7, children }) : children });
+};
+const slideOffset = (progress, distance) => Math.max(0, Math.min(distance, Math.round((1 - progress) * distance)));
+const renderSlide = (axis, sign) => (progress, children, distance) => {
+  const offset = slideOffset(progress, distance);
+  if (progress >= 1) {
+    return jsx(Box, { children });
+  }
+  if (progress <= 0) {
+    return jsx(Box, {});
+  }
+  if (axis === "x") {
+    return jsx(Box, { paddingLeft: sign === 1 ? offset : 0, paddingRight: sign === -1 ? offset : 0, children });
+  }
+  return jsx(Box, { flexDirection: "column", paddingBottom: sign === -1 ? offset : 0, paddingTop: sign === 1 ? offset : 0, children });
+};
+const renderReveal = (progress, children, distance) => {
+  if (progress >= 1) {
+    return jsx(Box, { children });
+  }
+  if (progress <= 0) {
+    return jsx(Box, {});
+  }
+  const rows = Math.max(0, Math.min(distance, Math.round(progress * distance)));
+  return jsx(Box, { flexDirection: "column", height: rows, overflowY: "hidden", children });
+};
+const PRESET_RENDERERS = {
+  fade: renderFade,
+  reveal: renderReveal,
+  "slide-down": renderSlide("y", -1),
+  "slide-left": renderSlide("x", -1),
+  "slide-right": renderSlide("x", 1),
+  "slide-up": renderSlide("y", 1)
+};
+const resolvePhase = (show, progress) => {
+  if (show) {
+    return progress >= 1 ? "entered" : "entering";
+  }
+  return progress <= 0 ? "exited" : "exiting";
+};
+function Transition({ children, distance = 4, duration = 240, onExit, preset = "fade", show = true, tickInterval = 30 }) {
+  const [progress, setProgress] = useState(show ? 1 : 0);
+  const targetRef = useRef(show ? 1 : 0);
+  const startRef = useRef(Date.now());
+  const startProgressRef = useRef(show ? 1 : 0);
+  const completedRef = useRef(!show);
+  const onExitRef = useRef(onExit);
+  onExitRef.current = onExit;
+  const [animationKey, setAnimationKey] = useState(0);
+  useEffect(() => {
+    const target = show ? 1 : 0;
+    if (targetRef.current === target) {
+      return;
+    }
+    targetRef.current = target;
+    startRef.current = Date.now();
+    startProgressRef.current = progress;
+    completedRef.current = false;
+    setAnimationKey((previous) => previous + 1);
+  }, [show]);
+  useEffect(() => {
+    const target = targetRef.current;
+    if (startProgressRef.current === target) {
+      if (target === 0 && !completedRef.current) {
+        completedRef.current = true;
+        onExitRef.current?.();
+      }
+      return void 0;
+    }
+    const id = setInterval(() => {
+      const elapsed = Date.now() - startRef.current;
+      const ratio = duration <= 0 ? 1 : Math.min(1, elapsed / duration);
+      const next = startProgressRef.current + (target - startProgressRef.current) * ratio;
+      setProgress(next);
+      if (ratio >= 1) {
+        clearInterval(id);
+        if (target === 0 && !completedRef.current) {
+          completedRef.current = true;
+          onExitRef.current?.();
+        }
+      }
+    }, tickInterval);
+    return () => {
+      clearInterval(id);
+    };
+  }, [animationKey, duration, tickInterval]);
+  const phase = resolvePhase(show, progress);
+  if (phase === "exited" && !show) {
+    return null;
+  }
+  const renderer = PRESET_RENDERERS[preset];
+  return renderer(progress, children, distance);
+}
+const TransitionWithMarker = Object.assign(Transition, { isAnimatable: true });
+
+export { TransitionWithMarker as default };

package/dist/packem_shared/{TreeView-C2062dtj.js → TreeView-DGlZeSsK.js}

@@ -1,9 +1,9 @@
 import { jsxs, jsx } from 'react/jsx-runtime';
-import useIsScreenReaderEnabled from './useIsScreenReaderEnabled-CnGKCe0f.js';
-import Box from './Box-D_pSJ9Jp.js';
-import Text from './Text-DvAUdZcK.js';
+import useIsScreenReaderEnabled from './useIsScreenReaderEnabled-BeoVqo1R.js';
+import Box from './Box-W1w_NGin.js';
+import Text from './Text-CtUwV89_.js';
 import { theme } from './treeViewTheme-BpSw9TMf.js';
-import { useTreeView } from './useTreeView-BT57P3Kx.js';
+import { useTreeView } from './useTreeView-mkN5Di7w.js';
 import { useTreeViewState } from './useTreeViewState-BpS_KZ-K.js';
 
 const POINTER = "❯";

package/dist/packem_shared/{TuiApp-DfxOnXqi.js → TuiApp-DtdgNRWa.js}

@@ -1,8 +1,10 @@
+import { createDecMode, setMode, resetMode } from '@visulima/ansi';
 import EventEmitter from 'eventemitter3';
 import { Renderer, TerminalGuard } from './Renderer-zZ5O3vxc.js';
 
-const DEC_2026_ON = "\x1B[?2026h";
-const DEC_2026_OFF = "\x1B[?2026l";
+const SynchronizedOutputMode = createDecMode(2026);
+const DEC_2026_ON = setMode(SynchronizedOutputMode);
+const DEC_2026_OFF = resetMode(SynchronizedOutputMode);
 class TuiApp extends EventEmitter {
   renderer;
   terminal = null;

package/dist/packem_shared/{TuiContext-CqEjMyXd.js → TuiContext-lXmJFd-x.js}

@@ -136,8 +136,9 @@ const usePaste = (handler, options = {}) => {
 };
 const useTuiContext = () => {
   const context = useContext(TuiContext);
-  if (!context)
+  if (!context) {
     throw new Error("useTuiContext must be used within a TUI App environment");
+  }
   return context;
 };
 const useApp = () => {
@@ -199,8 +200,9 @@ const useStdin = () => {
   };
 };
 const measureElement = (node) => {
-  if (!node || !node.yogaNode)
+  if (!node || !node.yogaNode) {
     return { height: 0, width: 0 };
+  }
   return {
     height: node.yogaNode.getComputedHeight() ?? 0,
     width: node.yogaNode.getComputedWidth() ?? 0
@@ -268,8 +270,9 @@ const useScrollable = ({ contentHeight, viewportHeight }) => {
 };
 const useMouse = (handler) => {
   const context = useContext(TuiContext);
-  if (!context)
+  if (!context) {
     throw new Error("useMouse must be used within a TUI App environment");
+  }
   const handlerRef = useRef(handler);
   useEffect(() => {
     handlerRef.current = handler;

package/dist/packem_shared/{UnorderedList-DhnadWjX.js → UnorderedList-D8RPaEAW.js}

@@ -1,6 +1,6 @@
 import { jsx, jsxs } from 'react/jsx-runtime';
-import Box from './Box-D_pSJ9Jp.js';
-import Text from './Text-DvAUdZcK.js';
+import Box from './Box-W1w_NGin.js';
+import Text from './Text-CtUwV89_.js';
 
 const DEFAULT_MARKERS = ["─", "◦", "▪"];
 const resolveMarkers = (marker) => {

package/dist/packem_shared/{ansi-parser-0BdVTKho.js → ansi-parser-BOP8fNdT.js}

@@ -1,12 +1,14 @@
+import { enableNormalMouse, enableAnyEventMouse, enableSgrMouse, disableSgrMouse, disableAnyEventMouse, disableNormalMouse } from '@visulima/ansi';
+
 const ANSI_CODES = {
   // SET_VT200_MOUSE - Terminal will send event on button pressed with mouse position
-  mouseButton: { off: "\x1B[?1000l", on: "\x1B[?1000h" },
+  mouseButton: { off: disableNormalMouse, on: enableNormalMouse },
   // SET_ANY_EVENT_MOUSE - Terminal will send event on button pressed and motion
-  mouseMotion: { off: "\x1B[?1003l", on: "\x1B[?1003h" },
-  // SET_URXVT_EXT_MODE_MOUSE
+  mouseMotion: { off: disableAnyEventMouse, on: enableAnyEventMouse },
+  // SET_URXVT_EXT_MODE_MOUSE — no dedicated helper in @visulima/ansi
   mouseMotionOthers: { off: "\x1B[?1015l", on: "\x1B[?1015h" },
   // SET_SGR_EXT_MODE_MOUSE - Another mouse protocol that extends coordinate mapping (without it, supports only 223 rows and columns)
-  mouseSGR: { off: "\x1B[?1006l", on: "\x1B[?1006h" }};
+  mouseSGR: { off: disableSgrMouse, on: enableSgrMouse }};
 const SGR_MOUSE_PATTERN = /\[<(\d+);(\d+);(\d+)(M)$/i;
 
 const CLICK_BUTTONS = { 0: "left", 1: "middle", 2: "right" };

package/dist/packem_shared/braille-BoEWoH2I.js

@@ -0,0 +1,93 @@
+const BRAILLE_BASE = 10240;
+const BRAILLE_BITS = [
+  1,
+  8,
+  // row 0: col 0, col 1
+  2,
+  16,
+  // row 1
+  4,
+  32,
+  // row 2
+  64,
+  128
+  // row 3
+];
+const createBrailleGrid = (cellWidth, cellHeight) => {
+  const pixelWidth = Math.max(0, cellWidth * 2);
+  const pixelHeight = Math.max(0, cellHeight * 4);
+  const bits = new Uint8Array(cellWidth * cellHeight);
+  const dirty = new Uint8Array(cellWidth * cellHeight);
+  const plotPoint = (x, y) => {
+    if (x < 0 || y < 0 || x >= pixelWidth || y >= pixelHeight) {
+      return;
+    }
+    const cellX = Math.floor(x / 2);
+    const cellY = Math.floor(y / 4);
+    const subX = x % 2;
+    const subY = y % 4;
+    const bit = BRAILLE_BITS[subY * 2 + subX];
+    const index = cellY * cellWidth + cellX;
+    if ((bits[index] & bit) === 0) {
+      bits[index] = (bits[index] ?? 0) | bit;
+      dirty[index] = 1;
+    }
+  };
+  const plotLine = (x0, y0, x1, y1) => {
+    let x = Math.round(x0);
+    let y = Math.round(y0);
+    const endX = Math.round(x1);
+    const endY = Math.round(y1);
+    const dx = Math.abs(endX - x);
+    const sx = x < endX ? 1 : -1;
+    const dy = -Math.abs(endY - y);
+    const sy = y < endY ? 1 : -1;
+    let error = dx + dy;
+    while (true) {
+      plotPoint(x, y);
+      if (x === endX && y === endY) {
+        break;
+      }
+      const error2 = 2 * error;
+      if (error2 >= dy) {
+        if (x === endX) {
+          break;
+        }
+        error += dy;
+        x += sx;
+      }
+      if (error2 <= dx) {
+        if (y === endY) {
+          break;
+        }
+        error += dx;
+        y += sy;
+      }
+    }
+  };
+  return {
+    cellHeight,
+    cellWidth,
+    clear: () => {
+      bits.fill(0);
+      dirty.fill(0);
+    },
+    flush: (context, style) => {
+      for (const [index, bit] of bits.entries()) {
+        if (dirty[index] === 0) {
+          continue;
+        }
+        const cellX = index % cellWidth;
+        const cellY = Math.floor(index / cellWidth);
+        const codepoint = BRAILLE_BASE + bit;
+        context.setCell(cellX, cellY, codepoint, style);
+      }
+    },
+    pixelHeight,
+    pixelWidth,
+    plotLine,
+    plotPoint
+  };
+};
+
+export { createBrailleGrid as c };

package/dist/packem_shared/{comparePoints-CGMDnd3_.js → comparePoints-CAAlhiMS.js}

@@ -1,5 +1,5 @@
-import { g as getPathToRoot } from './dom-DvzhsAez.js';
-import { t as toStyledLine } from './measure-text-DItZYotK.js';
+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) => {

package/dist/packem_shared/{ControlledScrollView-BlOaxcsN.js → controlled-scroll-view-DJXfdWMm.js}

@@ -1,7 +1,7 @@
 import { jsx, jsxs } from 'react/jsx-runtime';
 import { useState, useRef, useCallback, useLayoutEffect, isValidElement, useImperativeHandle, Fragment } from 'react';
-import { m as measureElement } from './measure-element-Reza_yfC.js';
-import Box from './Box-D_pSJ9Jp.js';
+import { m as measureElement } from './measure-element-Bc6PEaIe.js';
+import Box from './Box-W1w_NGin.js';
 
 const useStateRef = (initialValue) => {
   const [state, setStateInternal] = useState(initialValue);

package/dist/packem_shared/{createInlineLoop-BxMmcq9D.js → createInlineLoop-Dnfm1ZSJ.js}

@@ -1,7 +1,11 @@
+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 DEC_2026_ON = "\x1B[?2026h";
-const DEC_2026_OFF = "\x1B[?2026l";
+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;
@@ -28,7 +32,7 @@ function createInlineLoop(paint, options = {}) {
   }
   function startRendering(cursorRow) {
     regionTopRow = cursorRow - renderRows;
-    write(`\x1B[${renderRows}A\x1B[1G`);
+    write(cursorUp(renderRows) + cursorToColumn1);
     renderer.setRowOffset(regionTopRow);
     tick();
     interval = setInterval(
@@ -43,16 +47,17 @@ function createInlineLoop(paint, options = {}) {
     cols = size.cols;
     const termRows = size.rows;
     renderRows = Math.min(reservedRows, termRows);
-    if (process.stdin.isTTY)
+    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("\x1B[?25l");
-    write("\x1B[?2004h");
+    write(cursorHide);
+    write(enableBracketedPaste);
     write("\n".repeat(renderRows));
-    write("\x1B[6n");
+    write(REQUEST_CURSOR_POSITION);
     process.on("SIGINT", stop);
     let cprBuf = "";
     const onData = (chunk) => {
@@ -73,17 +78,18 @@ function createInlineLoop(paint, options = {}) {
     if (renderer) {
       if (onExit === "destroy") {
         for (let i = 0; i < renderRows; i++) {
-          write(`\x1B[${regionTopRow + 1 + i};1H\x1B[2K`);
+          write(cursorPosition(regionTopRow + 1 + i, 1) + eraseLine);
         }
-        write(`\x1B[${regionTopRow + 1};1H`);
+        write(cursorPosition(regionTopRow + 1, 1));
       } else {
-        write(`\x1B[${regionTopRow + renderRows + 1};1H`);
+        write(cursorPosition(regionTopRow + renderRows + 1, 1));
       }
-      write("\x1B[?2004l");
-      write("\x1B[?25h");
+      write(disableBracketedPaste);
+      write(cursorShow);
     }
-    if (process.stdin.isTTY)
+    if (process.stdin.isTTY) {
       process.stdin.setRawMode(false);
+    }
     process.stdin.pause();
     process.exit(0);
   }

package/dist/packem_shared/createMemoryStorage-esFJ61La.js

@@ -0,0 +1,115 @@
+import { createRequire as __cjs_createRequire } from "node:module";
+
+const __cjs_require = __cjs_createRequire(import.meta.url);
+
+const __cjs_getProcess = typeof globalThis !== "undefined" && typeof globalThis.process !== "undefined" ? globalThis.process : process;
+
+const __cjs_getBuiltinModule = (module) => {
+    // Check if we're in Node.js and version supports getBuiltinModule
+    if (typeof __cjs_getProcess !== "undefined" && __cjs_getProcess.versions && __cjs_getProcess.versions.node) {
+        const [major, minor] = __cjs_getProcess.versions.node.split(".").map(Number);
+        // Node.js 20.16.0+ and 22.3.0+
+        if (major > 22 || (major === 22 && minor >= 3) || (major === 20 && minor >= 16)) {
+            return __cjs_getProcess.getBuiltinModule(module);
+        }
+    }
+    // Fallback to createRequire
+    return __cjs_require(module);
+};
+
+const {
+  mkdirSync,
+  writeFileSync,
+  renameSync,
+  readFileSync
+} = __cjs_getBuiltinModule("node:fs");
+const {
+  homedir
+} = __cjs_getBuiltinModule("node:os");
+const path = __cjs_getBuiltinModule("node:path");
+const process = __cjs_getProcess;
+import { useRef, useState, useCallback } from 'react';
+
+const createMemoryStorage = () => {
+  const memory = /* @__PURE__ */ new Map();
+  return {
+    read: (key) => memory.get(key),
+    write: (key, value) => {
+      memory.set(key, value);
+    }
+  };
+};
+const createFileStorage = (namespace) => {
+  const filePath = path.join(homedir(), ".cache", "visulima-tui", `${namespace}.json`);
+  const reportError = (operation, error) => {
+    const message = error instanceof Error ? error.message : String(error);
+    process.stderr.write(`[visulima/tui] persistent-state ${operation} failed: ${message}
+`);
+  };
+  const load = () => {
+    try {
+      const raw = readFileSync(filePath, "utf8");
+      const parsed = JSON.parse(raw);
+      if (parsed && typeof parsed === "object") {
+        return parsed;
+      }
+      return {};
+    } catch (error) {
+      const code = error?.code;
+      if (code !== "ENOENT" && code !== "EACCES") {
+        reportError("read", error);
+      }
+      return {};
+    }
+  };
+  return {
+    read: (key) => load()[key],
+    write: (key, value) => {
+      const directory = path.dirname(filePath);
+      const temporaryPath = `${filePath}.tmp.${process.pid}`;
+      try {
+        mkdirSync(directory, { recursive: true });
+        const current = load();
+        current[key] = value;
+        writeFileSync(temporaryPath, JSON.stringify(current, null, 2), {
+          encoding: "utf8",
+          flag: "w"
+        });
+        renameSync(temporaryPath, filePath);
+      } catch (error) {
+        reportError("write", error);
+      }
+    }
+  };
+};
+const readInitial = (storage, key, fallback) => {
+  const raw = storage.read(key);
+  if (raw === void 0) {
+    return fallback;
+  }
+  try {
+    return JSON.parse(raw);
+  } catch {
+    return fallback;
+  }
+};
+const usePersistentState = (key, initialValue, options) => {
+  const storageRef = useRef(options?.storage ?? createFileStorage(options?.namespace ?? "tui"));
+  const [value, setValue] = useState(() => readInitial(storageRef.current, key, initialValue));
+  const update = useCallback(
+    (next) => {
+      setValue((previous) => {
+        const resolved = typeof next === "function" ? next(previous) : next;
+        try {
+          storageRef.current.write(key, JSON.stringify(resolved));
+        } catch {
+        }
+        return resolved;
+      });
+    },
+    [key]
+  );
+  return [value, update];
+};
+
+export { createFileStorage, createMemoryStorage, usePersistentState as default };

package/dist/packem_shared/createScreen-Dh0sZlQ0.js

@@ -0,0 +1,38 @@
+import { strip } from '@visulima/ansi';
+
+const createScreen = (lastFrame, allFrames) => {
+  const clean = (s) => {
+    if (s === void 0) {
+      return "";
+    }
+    return strip(s);
+  };
+  return {
+    contains(text) {
+      return this.text().includes(text);
+    },
+    frames() {
+      return allFrames.map((f) => strip(f));
+    },
+    line(n) {
+      return this.text().split("\n")[n] ?? "";
+    },
+    lines() {
+      return this.text().split("\n").filter((l) => l.trim() !== "");
+    },
+    matches(pattern) {
+      return pattern.test(this.text());
+    },
+    rawFrames() {
+      return [...allFrames];
+    },
+    rawText() {
+      return lastFrame() ?? "";
+    },
+    text() {
+      return clean(lastFrame());
+    }
+  };
+};
+
+export { createScreen };

package/dist/packem_shared/{dom-DvzhsAez.js → dom-CrbpQgat.js}

@@ -1,5 +1,5 @@
 import Yoga from 'yoga-layout';
-import { m as measureText } from './measure-text-DItZYotK.js';
+import { m as measureText } from './measure-text-BdOhbOeh.js';
 import squashTextNodes from './squashTextNodesWithMap-iqm6OMMT.js';
 import { wordWrap, truncate } from '@visulima/string';
 
@@ -56,6 +56,9 @@ const createNode = (nodeName) => {
   }
   return node;
 };
+const markNodeAndParentIfStaticAsDirty = (node) => {
+  markNodeAsDirty(node.nodeName === "ink-static-render" && node.cachedRender ? node.parentNode : node);
+};
 const appendChildNode = (node, childNode) => {
   if (childNode.parentNode) {
     removeChildNode(childNode.parentNode, childNode);
@@ -65,9 +68,7 @@ const appendChildNode = (node, childNode) => {
   if (childNode.yogaNode) {
     node.yogaNode?.insertChild(childNode.yogaNode, node.yogaNode.getChildCount());
   }
-  if (node.nodeName === "ink-text" || node.nodeName === "ink-virtual-text") {
-    markNodeAsDirty(node);
-  }
+  markNodeAndParentIfStaticAsDirty(node);
 };
 const insertBeforeNode = (node, newChildNode, beforeChildNode) => {
   if (newChildNode.parentNode) {
@@ -87,9 +88,7 @@ const insertBeforeNode = (node, newChildNode, beforeChildNode) => {
       node.yogaNode?.insertChild(newChildNode.yogaNode, yogaIndex);
     }
   }
-  if (node.nodeName === "ink-text" || node.nodeName === "ink-virtual-text") {
-    markNodeAsDirty(node);
-  }
+  markNodeAndParentIfStaticAsDirty(node);
 };
 const removeChildNode = (node, removeNode) => {
   if (removeNode.yogaNode) {
@@ -103,9 +102,7 @@ const removeChildNode = (node, removeNode) => {
   if (index !== -1) {
     node.childNodes.splice(index, 1);
   }
-  if (node.nodeName === "ink-text" || node.nodeName === "ink-virtual-text") {
-    markNodeAsDirty(node);
-  }
+  markNodeAndParentIfStaticAsDirty(node);
 };
 const setAttribute = (node, key, value) => {
   if (key === "internal_accessibility") {
@@ -138,7 +135,7 @@ const measureTextNode = function(node, width) {
     return dimensions;
   }
   const textWrap = node.style?.textWrap ?? "wrap";
-  const wrappedText = wrapText(text, width, textWrap);
+  const wrappedText = wrapText(text, Math.floor(width), textWrap);
   return measureText(wrappedText);
 };
 const findClosestYogaNode = (node) => {
@@ -148,14 +145,20 @@ const findClosestYogaNode = (node) => {
   return node.yogaNode ?? findClosestYogaNode(node.parentNode);
 };
 const markNodeAsDirty = (node) => {
-  const yogaNode = findClosestYogaNode(node);
-  yogaNode?.markDirty();
+  if (node?.nodeName === "#text" || node?.nodeName === "ink-text" || node?.nodeName === "ink-virtual-text") {
+    const yogaNode = findClosestYogaNode(node);
+    yogaNode?.markDirty();
+  }
   let current = node;
   while (current) {
     if (current.nodeName === "ink-text" || current.nodeName === "ink-virtual-text") {
       current.internal_textCache = void 0;
     }
-    if ("cachedRender" in current) {
+    if ("childNodes" in current) {
+      const shouldPreserveStaticCache = current !== node && current.nodeName === "ink-static-render" && Boolean(current.cachedRender);
+      if (shouldPreserveStaticCache) {
+        break;
+      }
       current.cachedRender = void 0;
     }
     current = current.parentNode;

package/dist/packem_shared/{getPathToRoot-a1wbwxfL.js → getPathToRoot-BbvlppLC.js}

@@ -1,4 +1,4 @@
 import 'yoga-layout';
-import './measure-text-DItZYotK.js';
+import './measure-text-BdOhbOeh.js';
 import './squashTextNodesWithMap-iqm6OMMT.js';
-export { a as addLayoutListener, d as appendChildNode, c as createNode, f as createTextNode, e as emitLayoutListeners, g as getPathToRoot, b as insertBeforeNode, i as isNodeSelectable, m as markNodeAsDirty, r as removeChildNode, j as setAttribute, k as setCachedRender, h as setStyle, s as setTextNodeValue } from './dom-DvzhsAez.js';
+export { a as addLayoutListener, d as appendChildNode, c as createNode, f as createTextNode, e as emitLayoutListeners, g as getPathToRoot, b as insertBeforeNode, i as isNodeSelectable, m as markNodeAsDirty, r as removeChildNode, j as setAttribute, k as setCachedRender, h as setStyle, s as setTextNodeValue } from './dom-CrbpQgat.js';

package/dist/packem_shared/{getScrollHeight-BubfU_df.js → getScrollHeight-Cz3CDQN2.js}

@@ -22,10 +22,10 @@ const calculateScrollDimensions = (node) => {
   }
   const scrollHeight = maxBottom - top + yogaNode.getComputedPadding(Yoga.EDGE_BOTTOM);
   const scrollWidth = maxRight - left + yogaNode.getComputedPadding(Yoga.EDGE_RIGHT);
-  return { scrollHeight, scrollWidth };
+  return { scrollHeight: Math.round(scrollHeight), scrollWidth: Math.round(scrollWidth) };
 };
-const getScrollHeight = (node) => node.internal_scrollState?.scrollHeight ?? 0;
-const getScrollWidth = (node) => node.internal_scrollState?.scrollWidth ?? 0;
+const getScrollHeight = (node) => Math.round(node.internal_scrollState?.scrollHeight ?? 0);
+const getScrollWidth = (node) => Math.round(node.internal_scrollState?.scrollWidth ?? 0);
 const calculateScroll = (node) => {
   const { yogaNode } = node;
   if (!yogaNode) {
@@ -57,7 +57,7 @@ const calculateScroll = (node) => {
     scrollWidth
   };
 };
-const getScrollTop = (node) => node.internal_scrollState?.scrollTop ?? 0;
-const getScrollLeft = (node) => node.internal_scrollState?.scrollLeft ?? 0;
+const getScrollTop = (node) => Math.round(node.internal_scrollState?.scrollTop ?? 0);
+const getScrollLeft = (node) => Math.round(node.internal_scrollState?.scrollLeft ?? 0);
 
 export { calculateScroll, getScrollHeight, getScrollLeft, getScrollTop, getScrollWidth };