@opentui/core 0.3.1 → 0.3.2

package/{index-zv319bjp.js → index-3mx8q5t1.js}

@@ -182,7 +182,7 @@ import {
   white,
   wrapWithDelegates,
   yellow
-} from "./index-jx0p1c2f.js";
+} from "./index-218h9p3f.js";
 
 // src/index.ts
 var exports_src2 = {};
@@ -278,6 +278,7 @@ __export(exports_src2, {
   createTextAttributes: () => createTextAttributes,
   createTerminalPalette: () => createTerminalPalette,
   createSlotRegistry: () => createSlotRegistry,
+  createMarkdownCodeBlockRenderer: () => createMarkdownCodeBlockRenderer,
   createExtmarksController: () => createExtmarksController,
   createCoreSlotRegistry: () => createCoreSlotRegistry,
   createCliRenderer: () => createCliRenderer,
@@ -4248,6 +4249,8 @@ class DiffRenderable extends Renderable {
   _view;
   _parsedDiff = null;
   _parseError = null;
+  _hunkStartLines = [];
+  _hunkRowOffsets = null;
   _fg;
   _filetype;
   _syntaxStyle;
@@ -4336,6 +4339,8 @@ class DiffRenderable extends Renderable {
     }
   }
   buildView() {
+    this._hunkStartLines = [];
+    this.invalidateHunkRowOffsets();
     if (this._parseError) {
       this.buildErrorView();
       return;
@@ -4396,6 +4401,9 @@ class DiffRenderable extends Renderable {
       }
     });
   }
+  invalidateHunkRowOffsets() {
+    this._hunkRowOffsets = null;
+  }
   rebuildView() {
     if (this._view === "split") {
       this.requestRebuild();
@@ -4404,6 +4412,7 @@ class DiffRenderable extends Renderable {
     }
   }
   handleLineInfoChange = () => {
+    this.invalidateHunkRowOffsets();
     if (!this._waitingForHighlight)
       return;
     if (!this.leftCodeRenderable || !this.rightCodeRenderable)
@@ -4416,13 +4425,17 @@ class DiffRenderable extends Renderable {
     }
   };
   attachLineInfoListeners() {
-    if (this._lineInfoChangeHandler)
-      return;
-    if (!this.leftCodeRenderable || !this.rightCodeRenderable)
+    if (!this.leftCodeRenderable && !this.rightCodeRenderable)
       return;
-    this._lineInfoChangeHandler = this.handleLineInfoChange;
-    this.leftCodeRenderable.on("line-info-change", this._lineInfoChangeHandler);
-    this.rightCodeRenderable.on("line-info-change", this._lineInfoChangeHandler);
+    this._lineInfoChangeHandler ??= this.handleLineInfoChange;
+    if (this.leftCodeRenderable) {
+      this.leftCodeRenderable.off("line-info-change", this._lineInfoChangeHandler);
+      this.leftCodeRenderable.on("line-info-change", this._lineInfoChangeHandler);
+    }
+    if (this.rightCodeRenderable) {
+      this.rightCodeRenderable.off("line-info-change", this._lineInfoChangeHandler);
+      this.rightCodeRenderable.on("line-info-change", this._lineInfoChangeHandler);
+    }
   }
   detachLineInfoListeners() {
     if (!this._lineInfoChangeHandler)
@@ -4612,6 +4625,7 @@ class DiffRenderable extends Renderable {
     const lineNumbers = new Map;
     let lineIndex = 0;
     for (const hunk of this._parsedDiff.hunks) {
+      this._hunkStartLines.push(lineIndex);
       let oldLineNum = hunk.oldStart;
       let newLineNum = hunk.newStart;
       for (const line of hunk.lines) {
@@ -4674,6 +4688,7 @@ class DiffRenderable extends Renderable {
     const content = contentLines.join(`
 `);
     const codeRenderable = this.createOrUpdateCodeRenderable("left", content, this._wrapMode);
+    this.attachLineInfoListeners();
     this.createOrUpdateSide("left", codeRenderable, lineColors, lineSigns, lineNumbers, new Set, "100%");
     if (this.rightSide && this.rightSideAdded) {
       super.remove(this.rightSide.id);
@@ -4698,7 +4713,9 @@ class DiffRenderable extends Renderable {
     }
     const leftLogicalLines = [];
     const rightLogicalLines = [];
+    const hunkFirstLeftLine = [];
     for (const hunk of this._parsedDiff.hunks) {
+      hunkFirstLeftLine.push(leftLogicalLines.length);
       let oldLineNum = hunk.oldStart;
       let newLineNum = hunk.newStart;
       let i = 0;
@@ -4785,6 +4802,11 @@ class DiffRenderable extends Renderable {
         }
       }
     }
+    for (const startIndex of hunkFirstLeftLine) {
+      const firstLine = leftLogicalLines[startIndex];
+      if (firstLine)
+        firstLine.hunkStart = true;
+    }
     const canDoWrapAlignment = this.width > 0 && (this._wrapMode === "word" || this._wrapMode === "char");
     const preLeftContent = leftLogicalLines.map((l) => l.content).join(`
 `);
@@ -4794,6 +4816,7 @@ class DiffRenderable extends Renderable {
     const drawUnstyledText = !needsConsistentConcealing;
     const leftCodeRenderable = this.createOrUpdateCodeRenderable("left", preLeftContent, this._wrapMode, drawUnstyledText);
     const rightCodeRenderable = this.createOrUpdateCodeRenderable("right", preRightContent, this._wrapMode, drawUnstyledText);
+    this.attachLineInfoListeners();
     let finalLeftLines;
     let finalRightLines;
     const leftIsHighlighting = leftCodeRenderable.isHighlighting;
@@ -4824,8 +4847,8 @@ class DiffRenderable extends Renderable {
       for (let i = 0;i < leftLogicalLines.length; i++) {
         const leftLine = leftLogicalLines[i];
         const rightLine = rightLogicalLines[i];
-        const leftVisualCount = leftVisualCounts.get(i) || 1;
-        const rightVisualCount = rightVisualCounts.get(i) || 1;
+        const leftVisualCount = leftVisualCounts.get(i) ?? 0;
+        const rightVisualCount = rightVisualCounts.get(i) ?? 0;
         if (leftVisualPos < rightVisualPos) {
           const pad = rightVisualPos - leftVisualPos;
           for (let p = 0;p < pad; p++) {
@@ -4868,6 +4891,9 @@ class DiffRenderable extends Renderable {
     const leftLineNumbers = new Map;
     const rightLineNumbers = new Map;
     finalLeftLines.forEach((line, index) => {
+      if (line.hunkStart) {
+        this._hunkStartLines.push(index);
+      }
       if (line.lineNum !== undefined) {
         leftLineNumbers.set(index, line.lineNum);
       }
@@ -4957,9 +4983,6 @@ class DiffRenderable extends Renderable {
   set syncScroll(value) {
     if (this._syncScroll !== value) {
       this._syncScroll = value;
-      if (!value) {
-        this.detachLineInfoListeners();
-      }
     }
   }
   get view() {
@@ -4996,6 +5019,7 @@ class DiffRenderable extends Renderable {
   set wrapMode(value) {
     if (this._wrapMode !== value) {
       this._wrapMode = value;
+      this.invalidateHunkRowOffsets();
       if (this._view === "unified" && this.leftCodeRenderable) {
         this.leftCodeRenderable.wrapMode = value ?? "none";
       } else if (this._view === "split") {
@@ -5215,6 +5239,28 @@ class DiffRenderable extends Renderable {
     this.leftSide?.clearHighlightLines(startLine, endLine);
     this.rightSide?.clearHighlightLines(startLine, endLine);
   }
+  getHunkRowOffsets() {
+    if (this._hunkRowOffsets)
+      return [...this._hunkRowOffsets];
+    this._hunkRowOffsets = this.computeHunkRowOffsets();
+    return [...this._hunkRowOffsets];
+  }
+  computeHunkRowOffsets() {
+    if (this._hunkStartLines.length === 0)
+      return [];
+    const sources = this.leftCodeRenderable?.lineInfo.lineSources;
+    if (!sources || sources.length === 0)
+      return [...this._hunkStartLines];
+    const offsets = [];
+    let visualRow = 0;
+    for (const hunkStartLine of this._hunkStartLines) {
+      while (visualRow < sources.length && sources[visualRow] < hunkStartLine) {
+        visualRow++;
+      }
+      offsets.push(visualRow < sources.length ? visualRow : hunkStartLine);
+    }
+    return offsets;
+  }
 }
 // src/renderables/Textarea.ts
 var defaultTextareaKeyBindings = [
@@ -8101,6 +8147,35 @@ function parseMarkdownIncremental(newContent, prevState, trailingUnstable = 2) {
 }
 
 // src/renderables/Markdown.ts
+function normalizeMarkdownCodeBlockRenderers(renderers) {
+  const rendererMap = new Map;
+  const maybeMap = renderers;
+  if (typeof maybeMap.forEach === "function") {
+    maybeMap.forEach((renderer, language) => {
+      rendererMap.set(language, renderer);
+    });
+    return rendererMap;
+  }
+  const rendererRecord = renderers;
+  for (const [language, renderer] of Object.entries(rendererRecord)) {
+    rendererMap.set(language, renderer);
+  }
+  return rendererMap;
+}
+function createMarkdownCodeBlockRenderer(renderers) {
+  const rendererMap = normalizeMarkdownCodeBlockRenderers(renderers);
+  const renderNode = (token, context) => {
+    if (token.type !== "code") {
+      return;
+    }
+    const language = infoStringToFiletype(token.lang ?? "");
+    if (!language)
+      return;
+    return rendererMap.get(language)?.(token, context);
+  };
+  renderNode.codeBlockOnly = true;
+  return renderNode;
+}
 var TRAILING_MARKDOWN_BLOCK_BREAKS_RE = /(?:\r?\n){2,}$/;
 var TRAILING_MARKDOWN_BLOCK_NEWLINES_RE = /(?:\r?\n)+$/;
 function colorsEqual(left, right) {
@@ -8739,8 +8814,11 @@ class MarkdownRenderable extends Renderable {
   normalizeScrollbackMarkdownBlockRaw(raw) {
     return raw.replace(TRAILING_MARKDOWN_BLOCK_NEWLINES_RE, "");
   }
+  isCodeBlockOnlyRenderer() {
+    return this._renderNode?.codeBlockOnly === true;
+  }
   buildRenderableTokens(tokens) {
-    if (this._renderNode) {
+    if (this._renderNode && !this.isCodeBlockOnlyRenderer()) {
       return tokens.filter((token) => token.type !== "space");
     }
     const renderTokens = [];
@@ -9057,58 +9135,50 @@ class MarkdownRenderable extends Renderable {
     if (token.type === "code") {
       const renderable2 = this.createCodeRenderable(token, id);
       renderable2.marginTop = marginTop;
-      return { renderable: renderable2 };
+      return { renderable: renderable2, canUpdateInPlace: true };
     }
     if (token.type === "table") {
       const next = this.createTableBlock(token, id);
       next.renderable.marginTop = marginTop;
-      return next;
+      return { ...next, canUpdateInPlace: true };
     }
     if (token.type === "blockquote") {
       const renderable2 = this.createBlockquoteRenderable(token, id);
       renderable2.marginTop = marginTop;
-      return { renderable: renderable2 };
+      return { renderable: renderable2, canUpdateInPlace: true };
     }
     if (token.type === "list") {
       const renderable2 = this.createListRenderable(token, id);
       renderable2.marginTop = marginTop;
-      return { renderable: renderable2 };
+      return { renderable: renderable2, canUpdateInPlace: true };
     }
     if (token.type === "hr") {
       const renderable2 = this.createHorizontalRuleRenderable(id);
       renderable2.marginTop = marginTop;
-      return { renderable: renderable2 };
+      return { renderable: renderable2, canUpdateInPlace: true };
     }
     const markdownRaw = this.getTopLevelBlockRaw(token);
     if (!markdownRaw) {
-      return { renderable: undefined };
+      return { renderable: undefined, canUpdateInPlace: true };
     }
     const renderable = this.createMarkdownCodeRenderable(markdownRaw, id);
     renderable.marginTop = marginTop;
-    return { renderable };
+    return { renderable, canUpdateInPlace: true };
   }
   createTopLevelRenderable(block, index) {
     if (!this._renderNode) {
       return this.createTopLevelDefaultRenderable(block, index);
     }
-    let next;
-    const context = {
-      syntaxStyle: this._syntaxStyle,
-      conceal: this._conceal,
-      concealCode: this._concealCode,
-      treeSitterClient: this._treeSitterClient,
-      defaultRender: () => {
-        next = this.createTopLevelDefaultRenderable(block, index);
-        return next.renderable ?? null;
-      }
+    const custom = this.createTopLevelCustomRenderable(block, index);
+    if (!custom.renderable)
+      return this.createTopLevelDefaultRenderable(block, index);
+    const marginTop = typeof custom.renderable.marginTop === "number" ? Math.max(custom.renderable.marginTop, block.marginTop) : block.marginTop;
+    this.applyMargins(custom.renderable, marginTop, 0);
+    return {
+      renderable: custom.renderable,
+      tableContentCache: custom.tableContentCache,
+      canUpdateInPlace: custom.canUpdateInPlace
     };
-    const custom = this._renderNode(block.token, context);
-    if (custom) {
-      const marginTop = typeof custom.marginTop === "number" ? Math.max(custom.marginTop, block.marginTop) : block.marginTop;
-      this.applyMargins(custom, marginTop, 0);
-      return { renderable: custom };
-    }
-    return next ?? this.createTopLevelDefaultRenderable(block, index);
   }
   createDefaultRenderable(token, index, nextToken) {
     const id = `${this.id}-block-${index}`;
@@ -9136,6 +9206,57 @@ class MarkdownRenderable extends Renderable {
     }
     return this.createMarkdownCodeRenderable(token.raw, id, marginBottom);
   }
+  createCustomRenderable(token, index, nextToken) {
+    const custom = this.renderCustomNode(token, () => {
+      return { renderable: this.createDefaultRenderable(token, index, nextToken) };
+    });
+    if (!custom.renderable) {
+      return { tracksInterBlockMargin: true, canUpdateInPlace: true };
+    }
+    const canUpdateInPlace = custom.renderable === custom.defaultResult?.renderable;
+    return {
+      renderable: custom.renderable,
+      tracksInterBlockMargin: canUpdateInPlace,
+      canUpdateInPlace
+    };
+  }
+  createTopLevelCustomRenderable(block, index) {
+    const custom = this.renderCustomNode(block.token, () => {
+      return this.createTopLevelDefaultRenderable(block, index);
+    });
+    if (!custom.renderable) {
+      return { tracksInterBlockMargin: true, canUpdateInPlace: true };
+    }
+    const canUpdateInPlace = custom.renderable === custom.defaultResult?.renderable;
+    return {
+      renderable: custom.renderable,
+      tableContentCache: canUpdateInPlace ? custom.defaultResult?.tableContentCache : undefined,
+      tracksInterBlockMargin: canUpdateInPlace,
+      canUpdateInPlace
+    };
+  }
+  renderCustomNode(token, createDefault) {
+    if (!this._renderNode)
+      return {};
+    let defaultResult;
+    const custom = this._renderNode(token, {
+      syntaxStyle: this._syntaxStyle,
+      conceal: this._conceal,
+      concealCode: this._concealCode,
+      treeSitterClient: this._treeSitterClient,
+      defaultRender: () => {
+        defaultResult = createDefault();
+        return defaultResult.renderable ?? null;
+      }
+    });
+    this.destroyUnusedDefaultRenderable(defaultResult?.renderable, custom ?? undefined);
+    return custom ? { renderable: custom, defaultResult } : {};
+  }
+  destroyUnusedDefaultRenderable(renderable, usedRenderable) {
+    if (!renderable || renderable === usedRenderable || renderable.parent)
+      return;
+    renderable.destroyRecursively();
+  }
   updateBlockRenderable(state, token, index, nextToken, forceListRefresh = false) {
     const marginBottom = this.getInterBlockMargin(token, nextToken);
     if (token.type === "code") {
@@ -9222,7 +9343,29 @@ class MarkdownRenderable extends Renderable {
         blockIndex++;
         continue;
       }
-      if (existing && !forceTableRefresh && !this._renderNode && existing.token.type === block.token.type && this.canUpdateBlockRenderable(existing.renderable, block.token)) {
+      if (existing && !forceTableRefresh && existing.canUpdateInPlace && existing.token.type === block.token.type && this.canUpdateBlockRenderable(existing.renderable, block.token)) {
+        if (this._renderNode) {
+          const custom = this.createTopLevelCustomRenderable(block, blockIndex);
+          if (custom.renderable && !custom.canUpdateInPlace) {
+            const marginTop = typeof custom.renderable.marginTop === "number" ? Math.max(custom.renderable.marginTop, block.marginTop) : block.marginTop;
+            this.applyMargins(custom.renderable, marginTop, 0);
+            if (custom.renderable !== existing.renderable) {
+              existing.renderable.destroyRecursively();
+              this.add(custom.renderable, blockIndex);
+            }
+            this._blockStates[blockIndex] = {
+              token: block.token,
+              tokenRaw: block.token.raw,
+              marginTop: block.marginTop,
+              renderable: custom.renderable,
+              tableContentCache: custom.tableContentCache,
+              canUpdateInPlace: custom.canUpdateInPlace
+            };
+            blockIndex++;
+            continue;
+          }
+          this.destroyUnusedDefaultRenderable(custom.renderable);
+        }
         this.updateBlockRenderable(existing, block.token, blockIndex, blocks[i + 1]?.token);
         existing.renderable.marginBottom = 0;
         if (existing.marginTop !== block.marginTop) {
@@ -9243,7 +9386,8 @@ class MarkdownRenderable extends Renderable {
           tokenRaw: block.token.raw,
           marginTop: block.marginTop,
           renderable: next.renderable,
-          tableContentCache: next.tableContentCache
+          tableContentCache: next.tableContentCache,
+          canUpdateInPlace: next.canUpdateInPlace
         };
       }
       blockIndex++;
@@ -9289,7 +9433,8 @@ class MarkdownRenderable extends Renderable {
           tokenRaw: this._content,
           marginTop: 0,
           renderable: fallback,
-          tracksInterBlockMargin: true
+          tracksInterBlockMargin: true,
+          canUpdateInPlace: true
         }
       ];
       return;
@@ -9327,7 +9472,24 @@ class MarkdownRenderable extends Renderable {
         blockIndex++;
         continue;
       }
-      if (existing && existing.token.type === token.type) {
+      if (existing && existing.canUpdateInPlace && existing.token.type === token.type) {
+        const custom2 = this.createCustomRenderable(token, blockIndex, nextToken);
+        if (custom2.renderable && !custom2.canUpdateInPlace) {
+          if (custom2.renderable !== existing.renderable) {
+            existing.renderable.destroyRecursively();
+            this.add(custom2.renderable, blockIndex);
+          }
+          this._blockStates[blockIndex] = {
+            token,
+            tokenRaw: token.raw,
+            renderable: custom2.renderable,
+            tracksInterBlockMargin: custom2.tracksInterBlockMargin,
+            canUpdateInPlace: custom2.canUpdateInPlace
+          };
+          blockIndex++;
+          continue;
+        }
+        this.destroyUnusedDefaultRenderable(custom2.renderable);
         this.updateBlockRenderable(existing, token, blockIndex, nextToken);
         existing.token = token;
         existing.tokenRaw = token.raw;
@@ -9341,23 +9503,12 @@ class MarkdownRenderable extends Renderable {
       let renderable;
       let tableContentCache;
       let tracksInterBlockMargin = true;
-      if (this._renderNode) {
-        let defaultRenderable;
-        const context = {
-          syntaxStyle: this._syntaxStyle,
-          conceal: this._conceal,
-          concealCode: this._concealCode,
-          treeSitterClient: this._treeSitterClient,
-          defaultRender: () => {
-            defaultRenderable = this.createDefaultRenderable(token, blockIndex, nextToken);
-            return defaultRenderable;
-          }
-        };
-        const custom = this._renderNode(token, context);
-        if (custom) {
-          renderable = custom;
-          tracksInterBlockMargin = custom === defaultRenderable;
-        }
+      let canUpdateInPlace = true;
+      const custom = this.createCustomRenderable(token, blockIndex, nextToken);
+      if (custom.renderable) {
+        renderable = custom.renderable;
+        tracksInterBlockMargin = custom.tracksInterBlockMargin;
+        canUpdateInPlace = custom.canUpdateInPlace;
       }
       if (!renderable) {
         if (token.type === "table") {
@@ -9379,7 +9530,8 @@ class MarkdownRenderable extends Renderable {
           tokenRaw: token.raw,
           renderable,
           tableContentCache,
-          tracksInterBlockMargin
+          tracksInterBlockMargin,
+          canUpdateInPlace
         };
       }
       blockIndex++;
@@ -10169,12 +10321,6 @@ class ScrollBoxRenderable extends BoxRenderable {
   }
   set scrollTop(value) {
     this.verticalScrollBar.scrollPosition = value;
-    if (!this._isApplyingStickyScroll) {
-      const maxScrollTop = Math.max(0, this.scrollHeight - this.viewport.height);
-      if (!this.isAtStickyPosition() && maxScrollTop > 1) {
-        this._hasManualScroll = true;
-      }
-    }
     this.updateStickyState();
   }
   get scrollLeft() {
@@ -10182,12 +10328,6 @@ class ScrollBoxRenderable extends BoxRenderable {
   }
   set scrollLeft(value) {
     this.horizontalScrollBar.scrollPosition = value;
-    if (!this._isApplyingStickyScroll) {
-      const maxScrollLeft = Math.max(0, this.scrollWidth - this.viewport.width);
-      if (!this.isAtStickyPosition() && maxScrollLeft > 1) {
-        this._hasManualScroll = true;
-      }
-    }
     this.updateStickyState();
   }
   get scrollWidth() {
@@ -10197,22 +10337,18 @@ class ScrollBoxRenderable extends BoxRenderable {
     return this.verticalScrollBar.scrollSize;
   }
   updateStickyState() {
-    if (!this._stickyScroll)
+    if (!this._stickyScroll) {
+      this.syncManualScrollState();
       return;
+    }
     const maxScrollTop = Math.max(0, this.scrollHeight - this.viewport.height);
     const maxScrollLeft = Math.max(0, this.scrollWidth - this.viewport.width);
     if (this.scrollTop <= 0) {
       this._stickyScrollTop = true;
       this._stickyScrollBottom = false;
-      if (!this._isApplyingStickyScroll && (this._stickyStart === "top" || this._stickyStart === "bottom" && maxScrollTop === 0)) {
-        this._hasManualScroll = false;
-      }
     } else if (this.scrollTop >= maxScrollTop) {
       this._stickyScrollTop = false;
       this._stickyScrollBottom = true;
-      if (!this._isApplyingStickyScroll && this._stickyStart === "bottom") {
-        this._hasManualScroll = false;
-      }
     } else {
       this._stickyScrollTop = false;
       this._stickyScrollBottom = false;
@@ -10220,19 +10356,30 @@ class ScrollBoxRenderable extends BoxRenderable {
     if (this.scrollLeft <= 0) {
       this._stickyScrollLeft = true;
       this._stickyScrollRight = false;
-      if (!this._isApplyingStickyScroll && (this._stickyStart === "left" || this._stickyStart === "right" && maxScrollLeft === 0)) {
-        this._hasManualScroll = false;
-      }
     } else if (this.scrollLeft >= maxScrollLeft) {
       this._stickyScrollLeft = false;
       this._stickyScrollRight = true;
-      if (!this._isApplyingStickyScroll && this._stickyStart === "right") {
-        this._hasManualScroll = false;
-      }
     } else {
       this._stickyScrollLeft = false;
       this._stickyScrollRight = false;
     }
+    this.syncManualScrollState();
+  }
+  syncManualScrollState() {
+    if (!this._stickyScroll) {
+      this._hasManualScroll = false;
+      return;
+    }
+    const maxScrollTop = Math.max(0, this.scrollHeight - this.viewport.height);
+    const maxScrollLeft = Math.max(0, this.scrollWidth - this.viewport.width);
+    const hasScrollableContent = maxScrollTop > 1 || maxScrollLeft > 1;
+    if (this._isApplyingStickyScroll) {
+      if (this._hasManualScroll && hasScrollableContent && this.isAtStickyPosition()) {
+        this._hasManualScroll = false;
+      }
+      return;
+    }
+    this._hasManualScroll = hasScrollableContent && !this.isAtStickyPosition();
   }
   applyStickyStart(stickyStart) {
     const wasApplyingStickyScroll = this._isApplyingStickyScroll;
@@ -10342,12 +10489,6 @@ class ScrollBoxRenderable extends BoxRenderable {
       orientation: "vertical",
       onChange: (position) => {
         this.content.translateY = -position;
-        if (!this._isApplyingStickyScroll) {
-          const maxScrollTop = Math.max(0, this.scrollHeight - this.viewport.height);
-          if (!this.isAtStickyPosition() && maxScrollTop > 1) {
-            this._hasManualScroll = true;
-          }
-        }
         this.updateStickyState();
       }
     });
@@ -10363,12 +10504,6 @@ class ScrollBoxRenderable extends BoxRenderable {
       orientation: "horizontal",
       onChange: (position) => {
         this.content.translateX = -position;
-        if (!this._isApplyingStickyScroll) {
-          const maxScrollLeft = Math.max(0, this.scrollWidth - this.viewport.width);
-          if (!this.isAtStickyPosition() && maxScrollLeft > 1) {
-            this._hasManualScroll = true;
-          }
-        }
         this.updateStickyState();
       }
     });
@@ -10519,11 +10654,7 @@ class ScrollBoxRenderable extends BoxRenderable {
           this.scrollAccumulatorX -= integerScroll;
         }
       }
-      const maxScrollTop = Math.max(0, this.scrollHeight - this.viewport.height);
-      const maxScrollLeft = Math.max(0, this.scrollWidth - this.viewport.width);
-      if (maxScrollTop > 1 || maxScrollLeft > 1) {
-        this._hasManualScroll = true;
-      }
+      this.syncManualScrollState();
     }
     if (event.type === "drag" && event.isDragging) {
       this.updateAutoScroll(event.x, event.y);
@@ -10533,15 +10664,15 @@ class ScrollBoxRenderable extends BoxRenderable {
   }
   handleKeyPress(key) {
     if (this.verticalScrollBar.handleKeyPress(key)) {
-      this._hasManualScroll = true;
       this.scrollAccel.reset();
       this.resetScrollAccumulators();
+      this.syncManualScrollState();
       return true;
     }
     if (this.horizontalScrollBar.handleKeyPress(key)) {
-      this._hasManualScroll = true;
       this.scrollAccel.reset();
       this.resetScrollAccumulators();
+      this.syncManualScrollState();
       return true;
     }
     return false;
@@ -11533,7 +11664,7 @@ class TimeToFirstDrawRenderable extends Renderable {
     return Math.max(0, Math.floor(value));
   }
 }
-export { DistortionEffect, VignetteEffect, CloudsEffect, FlamesEffect, CRTRollingBarEffect, RainbowTextEffect, applyScanlines, applyInvert, applyNoise, applyChromaticAberration, applyAsciiArt, applyBrightness, applyGain, applySaturation, BloomEffect, SEPIA_MATRIX, PROTANOPIA_SIM_MATRIX, DEUTERANOPIA_SIM_MATRIX, TRITANOPIA_SIM_MATRIX, ACHROMATOPSIA_MATRIX, PROTANOPIA_COMP_MATRIX, DEUTERANOPIA_COMP_MATRIX, TRITANOPIA_COMP_MATRIX, TECHNICOLOR_MATRIX, SOLARIZATION_MATRIX, SYNTHWAVE_MATRIX, GREENSCALE_MATRIX, GRAYSCALE_MATRIX, INVERT_MATRIX, Timeline, engine, createTimeline, SlotRegistry, createSlotRegistry, createCoreSlotRegistry, registerCorePlugin, resolveCoreSlot, SlotRenderable, Audio, setupAudio, FrameBufferRenderable, ASCIIFontRenderable, Generic, Box, Text, ASCIIFont, Input, Select, TabSelect, FrameBuffer, Code, ScrollBox, vstyles, VRenderable, LineNumberRenderable, DiffRenderable, defaultTextareaKeyBindings, TextareaRenderable, InputRenderableEvents, InputRenderable, TextTableRenderable, MarkdownRenderable, SliderRenderable, ScrollBarRenderable, ArrowRenderable, ScrollBoxRenderable, SelectRenderableEvents, SelectRenderable, TabSelectRenderableEvents, TabSelectRenderable, TimeToFirstDrawRenderable, exports_src2 as exports_src };
+export { DistortionEffect, VignetteEffect, CloudsEffect, FlamesEffect, CRTRollingBarEffect, RainbowTextEffect, applyScanlines, applyInvert, applyNoise, applyChromaticAberration, applyAsciiArt, applyBrightness, applyGain, applySaturation, BloomEffect, SEPIA_MATRIX, PROTANOPIA_SIM_MATRIX, DEUTERANOPIA_SIM_MATRIX, TRITANOPIA_SIM_MATRIX, ACHROMATOPSIA_MATRIX, PROTANOPIA_COMP_MATRIX, DEUTERANOPIA_COMP_MATRIX, TRITANOPIA_COMP_MATRIX, TECHNICOLOR_MATRIX, SOLARIZATION_MATRIX, SYNTHWAVE_MATRIX, GREENSCALE_MATRIX, GRAYSCALE_MATRIX, INVERT_MATRIX, Timeline, engine, createTimeline, SlotRegistry, createSlotRegistry, createCoreSlotRegistry, registerCorePlugin, resolveCoreSlot, SlotRenderable, Audio, setupAudio, FrameBufferRenderable, ASCIIFontRenderable, Generic, Box, Text, ASCIIFont, Input, Select, TabSelect, FrameBuffer, Code, ScrollBox, vstyles, VRenderable, LineNumberRenderable, DiffRenderable, defaultTextareaKeyBindings, TextareaRenderable, InputRenderableEvents, InputRenderable, TextTableRenderable, createMarkdownCodeBlockRenderer, MarkdownRenderable, SliderRenderable, ScrollBarRenderable, ArrowRenderable, ScrollBoxRenderable, SelectRenderableEvents, SelectRenderable, TabSelectRenderableEvents, TabSelectRenderable, TimeToFirstDrawRenderable, exports_src2 as exports_src };
 
-//# debugId=FF9419E6A578C71164756E2164756E21
-//# sourceMappingURL=index-zv319bjp.js.map
+//# debugId=99C613C726810CD764756E2164756E21
+//# sourceMappingURL=index-3mx8q5t1.js.map