@opentui/core 0.1.83 → 0.1.85

package/index.js

@@ -78,6 +78,7 @@ import {
   cyan,
   defaultKeyAliases,
   delegate,
+  detectLinks,
   dim,
   env,
   envRegistry,
@@ -153,7 +154,7 @@ import {
   white,
   wrapWithDelegates,
   yellow
-} from "./index-a215gqtt.js";
+} from "./index-2yz42vd4.js";
 // src/text-buffer-view.ts
 class TextBufferView {
   lib;
@@ -3115,6 +3116,7 @@ class CodeRenderable extends TextBufferRenderable {
   _hadInitialContent = false;
   _lastHighlights = [];
   _onHighlight;
+  _onChunks;
   _contentDefaultOptions = {
     content: "",
     conceal: true,
@@ -3131,6 +3133,7 @@ class CodeRenderable extends TextBufferRenderable {
     this._drawUnstyledText = options.drawUnstyledText ?? this._contentDefaultOptions.drawUnstyledText;
     this._streaming = options.streaming ?? this._contentDefaultOptions.streaming;
     this._onHighlight = options.onHighlight;
+    this._onChunks = options.onChunks;
     if (this._content.length > 0) {
       this.textBuffer.setText(this._content);
       this.updateTextInfo();
@@ -3218,9 +3221,24 @@ class CodeRenderable extends TextBufferRenderable {
       this._highlightsDirty = true;
     }
   }
+  get onChunks() {
+    return this._onChunks;
+  }
+  set onChunks(value) {
+    if (this._onChunks !== value) {
+      this._onChunks = value;
+      this._highlightsDirty = true;
+    }
+  }
   get isHighlighting() {
     return this._isHighlighting;
   }
+  async transformChunks(chunks, context) {
+    if (!this._onChunks)
+      return chunks;
+    const modified = await this._onChunks(chunks, context);
+    return modified ?? chunks;
+  }
   ensureVisibleTextBeforeHighlight() {
     if (this.isDestroyed)
       return;
@@ -3279,9 +3297,23 @@ class CodeRenderable extends TextBufferRenderable {
         if (this._streaming) {
           this._lastHighlights = highlights;
         }
-        const chunks = treeSitterToTextChunks(content, highlights, this._syntaxStyle, {
+      }
+      if (highlights.length > 0 || this._onChunks) {
+        const context = {
+          content,
+          filetype,
+          syntaxStyle: this._syntaxStyle,
+          highlights
+        };
+        let chunks = treeSitterToTextChunks(content, highlights, this._syntaxStyle, {
           enabled: this._conceal
         });
+        chunks = await this.transformChunks(chunks, context);
+        if (snapshotId !== this._highlightSnapshotId) {
+          return;
+        }
+        if (this.isDestroyed)
+          return;
         const styledText = new StyledText(chunks);
         this.textBuffer.setStyledText(styledText);
       } else {
@@ -4140,617 +4172,6 @@ class LineNumberRenderable extends Renderable {
     }
   }
 }
-
-// ../../node_modules/.bun/diff@8.0.2/node_modules/diff/libesm/diff/base.js
-class Diff {
-  diff(oldStr, newStr, options = {}) {
-    let callback;
-    if (typeof options === "function") {
-      callback = options;
-      options = {};
-    } else if ("callback" in options) {
-      callback = options.callback;
-    }
-    const oldString = this.castInput(oldStr, options);
-    const newString = this.castInput(newStr, options);
-    const oldTokens = this.removeEmpty(this.tokenize(oldString, options));
-    const newTokens = this.removeEmpty(this.tokenize(newString, options));
-    return this.diffWithOptionsObj(oldTokens, newTokens, options, callback);
-  }
-  diffWithOptionsObj(oldTokens, newTokens, options, callback) {
-    var _a;
-    const done = (value) => {
-      value = this.postProcess(value, options);
-      if (callback) {
-        setTimeout(function() {
-          callback(value);
-        }, 0);
-        return;
-      } else {
-        return value;
-      }
-    };
-    const newLen = newTokens.length, oldLen = oldTokens.length;
-    let editLength = 1;
-    let maxEditLength = newLen + oldLen;
-    if (options.maxEditLength != null) {
-      maxEditLength = Math.min(maxEditLength, options.maxEditLength);
-    }
-    const maxExecutionTime = (_a = options.timeout) !== null && _a !== undefined ? _a : Infinity;
-    const abortAfterTimestamp = Date.now() + maxExecutionTime;
-    const bestPath = [{ oldPos: -1, lastComponent: undefined }];
-    let newPos = this.extractCommon(bestPath[0], newTokens, oldTokens, 0, options);
-    if (bestPath[0].oldPos + 1 >= oldLen && newPos + 1 >= newLen) {
-      return done(this.buildValues(bestPath[0].lastComponent, newTokens, oldTokens));
-    }
-    let minDiagonalToConsider = -Infinity, maxDiagonalToConsider = Infinity;
-    const execEditLength = () => {
-      for (let diagonalPath = Math.max(minDiagonalToConsider, -editLength);diagonalPath <= Math.min(maxDiagonalToConsider, editLength); diagonalPath += 2) {
-        let basePath;
-        const removePath = bestPath[diagonalPath - 1], addPath = bestPath[diagonalPath + 1];
-        if (removePath) {
-          bestPath[diagonalPath - 1] = undefined;
-        }
-        let canAdd = false;
-        if (addPath) {
-          const addPathNewPos = addPath.oldPos - diagonalPath;
-          canAdd = addPath && 0 <= addPathNewPos && addPathNewPos < newLen;
-        }
-        const canRemove = removePath && removePath.oldPos + 1 < oldLen;
-        if (!canAdd && !canRemove) {
-          bestPath[diagonalPath] = undefined;
-          continue;
-        }
-        if (!canRemove || canAdd && removePath.oldPos < addPath.oldPos) {
-          basePath = this.addToPath(addPath, true, false, 0, options);
-        } else {
-          basePath = this.addToPath(removePath, false, true, 1, options);
-        }
-        newPos = this.extractCommon(basePath, newTokens, oldTokens, diagonalPath, options);
-        if (basePath.oldPos + 1 >= oldLen && newPos + 1 >= newLen) {
-          return done(this.buildValues(basePath.lastComponent, newTokens, oldTokens)) || true;
-        } else {
-          bestPath[diagonalPath] = basePath;
-          if (basePath.oldPos + 1 >= oldLen) {
-            maxDiagonalToConsider = Math.min(maxDiagonalToConsider, diagonalPath - 1);
-          }
-          if (newPos + 1 >= newLen) {
-            minDiagonalToConsider = Math.max(minDiagonalToConsider, diagonalPath + 1);
-          }
-        }
-      }
-      editLength++;
-    };
-    if (callback) {
-      (function exec() {
-        setTimeout(function() {
-          if (editLength > maxEditLength || Date.now() > abortAfterTimestamp) {
-            return callback(undefined);
-          }
-          if (!execEditLength()) {
-            exec();
-          }
-        }, 0);
-      })();
-    } else {
-      while (editLength <= maxEditLength && Date.now() <= abortAfterTimestamp) {
-        const ret = execEditLength();
-        if (ret) {
-          return ret;
-        }
-      }
-    }
-  }
-  addToPath(path, added, removed, oldPosInc, options) {
-    const last = path.lastComponent;
-    if (last && !options.oneChangePerToken && last.added === added && last.removed === removed) {
-      return {
-        oldPos: path.oldPos + oldPosInc,
-        lastComponent: { count: last.count + 1, added, removed, previousComponent: last.previousComponent }
-      };
-    } else {
-      return {
-        oldPos: path.oldPos + oldPosInc,
-        lastComponent: { count: 1, added, removed, previousComponent: last }
-      };
-    }
-  }
-  extractCommon(basePath, newTokens, oldTokens, diagonalPath, options) {
-    const newLen = newTokens.length, oldLen = oldTokens.length;
-    let oldPos = basePath.oldPos, newPos = oldPos - diagonalPath, commonCount = 0;
-    while (newPos + 1 < newLen && oldPos + 1 < oldLen && this.equals(oldTokens[oldPos + 1], newTokens[newPos + 1], options)) {
-      newPos++;
-      oldPos++;
-      commonCount++;
-      if (options.oneChangePerToken) {
-        basePath.lastComponent = { count: 1, previousComponent: basePath.lastComponent, added: false, removed: false };
-      }
-    }
-    if (commonCount && !options.oneChangePerToken) {
-      basePath.lastComponent = { count: commonCount, previousComponent: basePath.lastComponent, added: false, removed: false };
-    }
-    basePath.oldPos = oldPos;
-    return newPos;
-  }
-  equals(left, right, options) {
-    if (options.comparator) {
-      return options.comparator(left, right);
-    } else {
-      return left === right || !!options.ignoreCase && left.toLowerCase() === right.toLowerCase();
-    }
-  }
-  removeEmpty(array) {
-    const ret = [];
-    for (let i = 0;i < array.length; i++) {
-      if (array[i]) {
-        ret.push(array[i]);
-      }
-    }
-    return ret;
-  }
-  castInput(value, options) {
-    return value;
-  }
-  tokenize(value, options) {
-    return Array.from(value);
-  }
-  join(chars) {
-    return chars.join("");
-  }
-  postProcess(changeObjects, options) {
-    return changeObjects;
-  }
-  get useLongestToken() {
-    return false;
-  }
-  buildValues(lastComponent, newTokens, oldTokens) {
-    const components = [];
-    let nextComponent;
-    while (lastComponent) {
-      components.push(lastComponent);
-      nextComponent = lastComponent.previousComponent;
-      delete lastComponent.previousComponent;
-      lastComponent = nextComponent;
-    }
-    components.reverse();
-    const componentLen = components.length;
-    let componentPos = 0, newPos = 0, oldPos = 0;
-    for (;componentPos < componentLen; componentPos++) {
-      const component = components[componentPos];
-      if (!component.removed) {
-        if (!component.added && this.useLongestToken) {
-          let value = newTokens.slice(newPos, newPos + component.count);
-          value = value.map(function(value2, i) {
-            const oldValue = oldTokens[oldPos + i];
-            return oldValue.length > value2.length ? oldValue : value2;
-          });
-          component.value = this.join(value);
-        } else {
-          component.value = this.join(newTokens.slice(newPos, newPos + component.count));
-        }
-        newPos += component.count;
-        if (!component.added) {
-          oldPos += component.count;
-        }
-      } else {
-        component.value = this.join(oldTokens.slice(oldPos, oldPos + component.count));
-        oldPos += component.count;
-      }
-    }
-    return components;
-  }
-}
-
-// ../../node_modules/.bun/diff@8.0.2/node_modules/diff/libesm/diff/character.js
-class CharacterDiff extends Diff {
-}
-var characterDiff = new CharacterDiff;
-
-// ../../node_modules/.bun/diff@8.0.2/node_modules/diff/libesm/util/string.js
-function longestCommonPrefix(str1, str2) {
-  let i;
-  for (i = 0;i < str1.length && i < str2.length; i++) {
-    if (str1[i] != str2[i]) {
-      return str1.slice(0, i);
-    }
-  }
-  return str1.slice(0, i);
-}
-function longestCommonSuffix(str1, str2) {
-  let i;
-  if (!str1 || !str2 || str1[str1.length - 1] != str2[str2.length - 1]) {
-    return "";
-  }
-  for (i = 0;i < str1.length && i < str2.length; i++) {
-    if (str1[str1.length - (i + 1)] != str2[str2.length - (i + 1)]) {
-      return str1.slice(-i);
-    }
-  }
-  return str1.slice(-i);
-}
-function replacePrefix(string, oldPrefix, newPrefix) {
-  if (string.slice(0, oldPrefix.length) != oldPrefix) {
-    throw Error(`string ${JSON.stringify(string)} doesn't start with prefix ${JSON.stringify(oldPrefix)}; this is a bug`);
-  }
-  return newPrefix + string.slice(oldPrefix.length);
-}
-function replaceSuffix(string, oldSuffix, newSuffix) {
-  if (!oldSuffix) {
-    return string + newSuffix;
-  }
-  if (string.slice(-oldSuffix.length) != oldSuffix) {
-    throw Error(`string ${JSON.stringify(string)} doesn't end with suffix ${JSON.stringify(oldSuffix)}; this is a bug`);
-  }
-  return string.slice(0, -oldSuffix.length) + newSuffix;
-}
-function removePrefix(string, oldPrefix) {
-  return replacePrefix(string, oldPrefix, "");
-}
-function removeSuffix(string, oldSuffix) {
-  return replaceSuffix(string, oldSuffix, "");
-}
-function maximumOverlap(string1, string2) {
-  return string2.slice(0, overlapCount(string1, string2));
-}
-function overlapCount(a, b) {
-  let startA = 0;
-  if (a.length > b.length) {
-    startA = a.length - b.length;
-  }
-  let endB = b.length;
-  if (a.length < b.length) {
-    endB = a.length;
-  }
-  const map = Array(endB);
-  let k = 0;
-  map[0] = 0;
-  for (let j = 1;j < endB; j++) {
-    if (b[j] == b[k]) {
-      map[j] = map[k];
-    } else {
-      map[j] = k;
-    }
-    while (k > 0 && b[j] != b[k]) {
-      k = map[k];
-    }
-    if (b[j] == b[k]) {
-      k++;
-    }
-  }
-  k = 0;
-  for (let i = startA;i < a.length; i++) {
-    while (k > 0 && a[i] != b[k]) {
-      k = map[k];
-    }
-    if (a[i] == b[k]) {
-      k++;
-    }
-  }
-  return k;
-}
-function trailingWs(string) {
-  let i;
-  for (i = string.length - 1;i >= 0; i--) {
-    if (!string[i].match(/\s/)) {
-      break;
-    }
-  }
-  return string.substring(i + 1);
-}
-function leadingWs(string) {
-  const match = string.match(/^\s*/);
-  return match ? match[0] : "";
-}
-
-// ../../node_modules/.bun/diff@8.0.2/node_modules/diff/libesm/diff/word.js
-var extendedWordChars = "a-zA-Z0-9_\\u{C0}-\\u{FF}\\u{D8}-\\u{F6}\\u{F8}-\\u{2C6}\\u{2C8}-\\u{2D7}\\u{2DE}-\\u{2FF}\\u{1E00}-\\u{1EFF}";
-var tokenizeIncludingWhitespace = new RegExp(`[${extendedWordChars}]+|\\s+|[^${extendedWordChars}]`, "ug");
-
-class WordDiff extends Diff {
-  equals(left, right, options) {
-    if (options.ignoreCase) {
-      left = left.toLowerCase();
-      right = right.toLowerCase();
-    }
-    return left.trim() === right.trim();
-  }
-  tokenize(value, options = {}) {
-    let parts;
-    if (options.intlSegmenter) {
-      const segmenter = options.intlSegmenter;
-      if (segmenter.resolvedOptions().granularity != "word") {
-        throw new Error('The segmenter passed must have a granularity of "word"');
-      }
-      parts = Array.from(segmenter.segment(value), (segment) => segment.segment);
-    } else {
-      parts = value.match(tokenizeIncludingWhitespace) || [];
-    }
-    const tokens = [];
-    let prevPart = null;
-    parts.forEach((part) => {
-      if (/\s/.test(part)) {
-        if (prevPart == null) {
-          tokens.push(part);
-        } else {
-          tokens.push(tokens.pop() + part);
-        }
-      } else if (prevPart != null && /\s/.test(prevPart)) {
-        if (tokens[tokens.length - 1] == prevPart) {
-          tokens.push(tokens.pop() + part);
-        } else {
-          tokens.push(prevPart + part);
-        }
-      } else {
-        tokens.push(part);
-      }
-      prevPart = part;
-    });
-    return tokens;
-  }
-  join(tokens) {
-    return tokens.map((token, i) => {
-      if (i == 0) {
-        return token;
-      } else {
-        return token.replace(/^\s+/, "");
-      }
-    }).join("");
-  }
-  postProcess(changes, options) {
-    if (!changes || options.oneChangePerToken) {
-      return changes;
-    }
-    let lastKeep = null;
-    let insertion = null;
-    let deletion = null;
-    changes.forEach((change) => {
-      if (change.added) {
-        insertion = change;
-      } else if (change.removed) {
-        deletion = change;
-      } else {
-        if (insertion || deletion) {
-          dedupeWhitespaceInChangeObjects(lastKeep, deletion, insertion, change);
-        }
-        lastKeep = change;
-        insertion = null;
-        deletion = null;
-      }
-    });
-    if (insertion || deletion) {
-      dedupeWhitespaceInChangeObjects(lastKeep, deletion, insertion, null);
-    }
-    return changes;
-  }
-}
-var wordDiff = new WordDiff;
-function dedupeWhitespaceInChangeObjects(startKeep, deletion, insertion, endKeep) {
-  if (deletion && insertion) {
-    const oldWsPrefix = leadingWs(deletion.value);
-    const oldWsSuffix = trailingWs(deletion.value);
-    const newWsPrefix = leadingWs(insertion.value);
-    const newWsSuffix = trailingWs(insertion.value);
-    if (startKeep) {
-      const commonWsPrefix = longestCommonPrefix(oldWsPrefix, newWsPrefix);
-      startKeep.value = replaceSuffix(startKeep.value, newWsPrefix, commonWsPrefix);
-      deletion.value = removePrefix(deletion.value, commonWsPrefix);
-      insertion.value = removePrefix(insertion.value, commonWsPrefix);
-    }
-    if (endKeep) {
-      const commonWsSuffix = longestCommonSuffix(oldWsSuffix, newWsSuffix);
-      endKeep.value = replacePrefix(endKeep.value, newWsSuffix, commonWsSuffix);
-      deletion.value = removeSuffix(deletion.value, commonWsSuffix);
-      insertion.value = removeSuffix(insertion.value, commonWsSuffix);
-    }
-  } else if (insertion) {
-    if (startKeep) {
-      const ws = leadingWs(insertion.value);
-      insertion.value = insertion.value.substring(ws.length);
-    }
-    if (endKeep) {
-      const ws = leadingWs(endKeep.value);
-      endKeep.value = endKeep.value.substring(ws.length);
-    }
-  } else if (startKeep && endKeep) {
-    const newWsFull = leadingWs(endKeep.value), delWsStart = leadingWs(deletion.value), delWsEnd = trailingWs(deletion.value);
-    const newWsStart = longestCommonPrefix(newWsFull, delWsStart);
-    deletion.value = removePrefix(deletion.value, newWsStart);
-    const newWsEnd = longestCommonSuffix(removePrefix(newWsFull, newWsStart), delWsEnd);
-    deletion.value = removeSuffix(deletion.value, newWsEnd);
-    endKeep.value = replacePrefix(endKeep.value, newWsFull, newWsEnd);
-    startKeep.value = replaceSuffix(startKeep.value, newWsFull, newWsFull.slice(0, newWsFull.length - newWsEnd.length));
-  } else if (endKeep) {
-    const endKeepWsPrefix = leadingWs(endKeep.value);
-    const deletionWsSuffix = trailingWs(deletion.value);
-    const overlap = maximumOverlap(deletionWsSuffix, endKeepWsPrefix);
-    deletion.value = removeSuffix(deletion.value, overlap);
-  } else if (startKeep) {
-    const startKeepWsSuffix = trailingWs(startKeep.value);
-    const deletionWsPrefix = leadingWs(deletion.value);
-    const overlap = maximumOverlap(startKeepWsSuffix, deletionWsPrefix);
-    deletion.value = removePrefix(deletion.value, overlap);
-  }
-}
-
-class WordsWithSpaceDiff extends Diff {
-  tokenize(value) {
-    const regex = new RegExp(`(\\r?\\n)|[${extendedWordChars}]+|[^\\S\\n\\r]+|[^${extendedWordChars}]`, "ug");
-    return value.match(regex) || [];
-  }
-}
-var wordsWithSpaceDiff = new WordsWithSpaceDiff;
-
-// ../../node_modules/.bun/diff@8.0.2/node_modules/diff/libesm/diff/line.js
-class LineDiff extends Diff {
-  constructor() {
-    super(...arguments);
-    this.tokenize = tokenize;
-  }
-  equals(left, right, options) {
-    if (options.ignoreWhitespace) {
-      if (!options.newlineIsToken || !left.includes(`
-`)) {
-        left = left.trim();
-      }
-      if (!options.newlineIsToken || !right.includes(`
-`)) {
-        right = right.trim();
-      }
-    } else if (options.ignoreNewlineAtEof && !options.newlineIsToken) {
-      if (left.endsWith(`
-`)) {
-        left = left.slice(0, -1);
-      }
-      if (right.endsWith(`
-`)) {
-        right = right.slice(0, -1);
-      }
-    }
-    return super.equals(left, right, options);
-  }
-}
-var lineDiff = new LineDiff;
-function tokenize(value, options) {
-  if (options.stripTrailingCr) {
-    value = value.replace(/\r\n/g, `
-`);
-  }
-  const retLines = [], linesAndNewlines = value.split(/(\n|\r\n)/);
-  if (!linesAndNewlines[linesAndNewlines.length - 1]) {
-    linesAndNewlines.pop();
-  }
-  for (let i = 0;i < linesAndNewlines.length; i++) {
-    const line = linesAndNewlines[i];
-    if (i % 2 && !options.newlineIsToken) {
-      retLines[retLines.length - 1] += line;
-    } else {
-      retLines.push(line);
-    }
-  }
-  return retLines;
-}
-
-// ../../node_modules/.bun/diff@8.0.2/node_modules/diff/libesm/diff/sentence.js
-function isSentenceEndPunct(char) {
-  return char == "." || char == "!" || char == "?";
-}
-
-class SentenceDiff extends Diff {
-  tokenize(value) {
-    var _a;
-    const result = [];
-    let tokenStartI = 0;
-    for (let i = 0;i < value.length; i++) {
-      if (i == value.length - 1) {
-        result.push(value.slice(tokenStartI));
-        break;
-      }
-      if (isSentenceEndPunct(value[i]) && value[i + 1].match(/\s/)) {
-        result.push(value.slice(tokenStartI, i + 1));
-        i = tokenStartI = i + 1;
-        while ((_a = value[i + 1]) === null || _a === undefined ? undefined : _a.match(/\s/)) {
-          i++;
-        }
-        result.push(value.slice(tokenStartI, i + 1));
-        tokenStartI = i + 1;
-      }
-    }
-    return result;
-  }
-}
-var sentenceDiff = new SentenceDiff;
-
-// ../../node_modules/.bun/diff@8.0.2/node_modules/diff/libesm/diff/css.js
-class CssDiff extends Diff {
-  tokenize(value) {
-    return value.split(/([{}:;,]|\s+)/);
-  }
-}
-var cssDiff = new CssDiff;
-
-// ../../node_modules/.bun/diff@8.0.2/node_modules/diff/libesm/diff/json.js
-class JsonDiff extends Diff {
-  constructor() {
-    super(...arguments);
-    this.tokenize = tokenize;
-  }
-  get useLongestToken() {
-    return true;
-  }
-  castInput(value, options) {
-    const { undefinedReplacement, stringifyReplacer = (k, v) => typeof v === "undefined" ? undefinedReplacement : v } = options;
-    return typeof value === "string" ? value : JSON.stringify(canonicalize(value, null, null, stringifyReplacer), null, "  ");
-  }
-  equals(left, right, options) {
-    return super.equals(left.replace(/,([\r\n])/g, "$1"), right.replace(/,([\r\n])/g, "$1"), options);
-  }
-}
-var jsonDiff = new JsonDiff;
-function canonicalize(obj, stack, replacementStack, replacer, key) {
-  stack = stack || [];
-  replacementStack = replacementStack || [];
-  if (replacer) {
-    obj = replacer(key === undefined ? "" : key, obj);
-  }
-  let i;
-  for (i = 0;i < stack.length; i += 1) {
-    if (stack[i] === obj) {
-      return replacementStack[i];
-    }
-  }
-  let canonicalizedObj;
-  if (Object.prototype.toString.call(obj) === "[object Array]") {
-    stack.push(obj);
-    canonicalizedObj = new Array(obj.length);
-    replacementStack.push(canonicalizedObj);
-    for (i = 0;i < obj.length; i += 1) {
-      canonicalizedObj[i] = canonicalize(obj[i], stack, replacementStack, replacer, String(i));
-    }
-    stack.pop();
-    replacementStack.pop();
-    return canonicalizedObj;
-  }
-  if (obj && obj.toJSON) {
-    obj = obj.toJSON();
-  }
-  if (typeof obj === "object" && obj !== null) {
-    stack.push(obj);
-    canonicalizedObj = {};
-    replacementStack.push(canonicalizedObj);
-    const sortedKeys = [];
-    let key2;
-    for (key2 in obj) {
-      if (Object.prototype.hasOwnProperty.call(obj, key2)) {
-        sortedKeys.push(key2);
-      }
-    }
-    sortedKeys.sort();
-    for (i = 0;i < sortedKeys.length; i += 1) {
-      key2 = sortedKeys[i];
-      canonicalizedObj[key2] = canonicalize(obj[key2], stack, replacementStack, replacer, key2);
-    }
-    stack.pop();
-    replacementStack.pop();
-  } else {
-    canonicalizedObj = obj;
-  }
-  return canonicalizedObj;
-}
-
-// ../../node_modules/.bun/diff@8.0.2/node_modules/diff/libesm/diff/array.js
-class ArrayDiff extends Diff {
-  tokenize(value) {
-    return value.slice();
-  }
-  join(value) {
-    return value;
-  }
-  removeEmpty(value) {
-    return value;
-  }
-}
-var arrayDiff = new ArrayDiff;
-
 // ../../node_modules/.bun/diff@8.0.2/node_modules/diff/libesm/patch/parse.js
 function parsePatch(uniDiff) {
   const diffstr = uniDiff.split(/\n/), list = [];
@@ -4855,7 +4276,6 @@ function parsePatch(uniDiff) {
   }
   return list;
 }
-
 // src/renderables/Text.ts
 class TextRenderable extends TextBufferRenderable {
   _text;
@@ -7171,6 +6591,7 @@ class TextTableRenderable extends Renderable {
   _content;
   _wrapMode;
   _columnWidthMode;
+  _columnFitter;
   _cellPadding;
   _showBorders;
   _border;
@@ -7198,8 +6619,9 @@ class TextTableRenderable extends Renderable {
   _cachedMeasureWidth = undefined;
   _defaultOptions = {
     content: [],
-    wrapMode: "none",
-    columnWidthMode: "content",
+    wrapMode: "word",
+    columnWidthMode: "full",
+    columnFitter: "proportional",
     cellPadding: 0,
     showBorders: true,
     border: true,
@@ -7216,10 +6638,11 @@ class TextTableRenderable extends Renderable {
     attributes: 0
   };
   constructor(ctx, options = {}) {
-    super(ctx, { ...options, buffered: true });
+    super(ctx, { ...options, flexShrink: options.flexShrink ?? 0, buffered: true });
     this._content = options.content ?? this._defaultOptions.content;
     this._wrapMode = options.wrapMode ?? this._defaultOptions.wrapMode;
     this._columnWidthMode = options.columnWidthMode ?? this._defaultOptions.columnWidthMode;
+    this._columnFitter = this.resolveColumnFitter(options.columnFitter);
     this._cellPadding = this.resolveCellPadding(options.cellPadding);
     this._showBorders = options.showBorders ?? this._defaultOptions.showBorders;
     this._border = options.border ?? this._defaultOptions.border;
@@ -7268,6 +6691,16 @@ class TextTableRenderable extends Renderable {
     this._columnWidthMode = value;
     this.invalidateLayoutAndRaster();
   }
+  get columnFitter() {
+    return this._columnFitter;
+  }
+  set columnFitter(value) {
+    const next = this.resolveColumnFitter(value);
+    if (this._columnFitter === next)
+      return;
+    this._columnFitter = next;
+    this.invalidateLayoutAndRaster();
+  }
   get cellPadding() {
     return this._cellPadding;
   }
@@ -7421,7 +6854,7 @@ class TextTableRenderable extends Renderable {
     super.destroySelf();
   }
   setupMeasureFunc() {
-    const measureFunc = (width, widthMode, height, heightMode) => {
+    const measureFunc = (width, widthMode, _height, _heightMode) => {
       const hasWidthConstraint = widthMode !== MeasureMode.Undefined && Number.isFinite(width);
       const rawWidthConstraint = hasWidthConstraint ? Math.max(1, Math.floor(width)) : undefined;
       const widthConstraint = this.resolveLayoutWidthConstraint(rawWidthConstraint);
@@ -7433,9 +6866,6 @@ class TextTableRenderable extends Renderable {
       if (widthMode === MeasureMode.AtMost && rawWidthConstraint !== undefined && this._positionType !== "absolute") {
         measuredWidth = Math.min(rawWidthConstraint, measuredWidth);
       }
-      if (heightMode === MeasureMode.AtMost && Number.isFinite(height) && this._positionType !== "absolute") {
-        measuredHeight = Math.min(Math.max(1, Math.floor(height)), measuredHeight);
-      }
       return {
         width: measuredWidth,
         height: measuredHeight
@@ -7607,6 +7037,9 @@ class TextTableRenderable extends Renderable {
       tableHeight: (rowOffsets[rowOffsets.length - 1] ?? 0) + 1
     };
   }
+  isFullWidthMode() {
+    return this._columnWidthMode === "full";
+  }
   computeColumnWidths(maxTableWidth, borderLayout) {
     const horizontalPadding = this.getHorizontalCellPadding();
     const intrinsicWidths = new Array(this._columnCount).fill(1 + horizontalPadding);
@@ -7629,7 +7062,7 @@ class TextTableRenderable extends Renderable {
       return intrinsicWidths;
     }
     if (currentWidth < maxContentWidth) {
-      if (this._columnWidthMode === "fill") {
+      if (this.isFullWidthMode()) {
         return this.expandColumnWidths(intrinsicWidths, maxContentWidth);
       }
       return intrinsicWidths;
@@ -7659,6 +7092,12 @@ class TextTableRenderable extends Renderable {
     return expanded;
   }
   fitColumnWidths(widths, targetContentWidth) {
+    if (this._columnFitter === "balanced") {
+      return this.fitColumnWidthsBalanced(widths, targetContentWidth);
+    }
+    return this.fitColumnWidthsProportional(widths, targetContentWidth);
+  }
+  fitColumnWidthsProportional(widths, targetContentWidth) {
     const minWidth = 1 + this.getHorizontalCellPadding();
     const hardMinWidths = new Array(widths.length).fill(minWidth);
     const baseWidths = widths.map((width) => Math.max(1, Math.floor(width)));
@@ -7709,6 +7148,80 @@ class TextTableRenderable extends Renderable {
     }
     return baseWidths.map((width, idx) => Math.max(floorWidths[idx], width - integerShrink[idx]));
   }
+  fitColumnWidthsBalanced(widths, targetContentWidth) {
+    const minWidth = 1 + this.getHorizontalCellPadding();
+    const hardMinWidths = new Array(widths.length).fill(minWidth);
+    const baseWidths = widths.map((width) => Math.max(1, Math.floor(width)));
+    const totalBaseWidth = baseWidths.reduce((sum, width) => sum + width, 0);
+    const columns = baseWidths.length;
+    if (columns === 0 || totalBaseWidth <= targetContentWidth) {
+      return baseWidths;
+    }
+    const evenShare = Math.max(minWidth, Math.floor(targetContentWidth / columns));
+    const preferredMinWidths = baseWidths.map((width) => Math.min(width, evenShare));
+    const preferredMinTotal = preferredMinWidths.reduce((sum, width) => sum + width, 0);
+    const floorWidths = preferredMinTotal <= targetContentWidth ? preferredMinWidths : hardMinWidths;
+    const floorTotal = floorWidths.reduce((sum, width) => sum + width, 0);
+    const clampedTarget = Math.max(floorTotal, targetContentWidth);
+    if (totalBaseWidth <= clampedTarget) {
+      return baseWidths;
+    }
+    const shrinkable = baseWidths.map((width, idx) => width - floorWidths[idx]);
+    const totalShrinkable = shrinkable.reduce((sum, value) => sum + value, 0);
+    if (totalShrinkable <= 0) {
+      return [...floorWidths];
+    }
+    const targetShrink = totalBaseWidth - clampedTarget;
+    const shrink = this.allocateShrinkByWeight(shrinkable, targetShrink, "sqrt");
+    return baseWidths.map((width, idx) => Math.max(floorWidths[idx], width - shrink[idx]));
+  }
+  allocateShrinkByWeight(shrinkable, targetShrink, mode) {
+    const shrink = new Array(shrinkable.length).fill(0);
+    if (targetShrink <= 0) {
+      return shrink;
+    }
+    const weights = shrinkable.map((value) => {
+      if (value <= 0) {
+        return 0;
+      }
+      return mode === "sqrt" ? Math.sqrt(value) : value;
+    });
+    const totalWeight = weights.reduce((sum, value) => sum + value, 0);
+    if (totalWeight <= 0) {
+      return shrink;
+    }
+    const fractions = new Array(shrinkable.length).fill(0);
+    let usedShrink = 0;
+    for (let idx = 0;idx < shrinkable.length; idx++) {
+      if (shrinkable[idx] <= 0 || weights[idx] <= 0)
+        continue;
+      const exact = weights[idx] / totalWeight * targetShrink;
+      const whole = Math.min(shrinkable[idx], Math.floor(exact));
+      shrink[idx] = whole;
+      fractions[idx] = exact - whole;
+      usedShrink += whole;
+    }
+    let remainingShrink = targetShrink - usedShrink;
+    while (remainingShrink > 0) {
+      let bestIdx = -1;
+      let bestFraction = -1;
+      for (let idx = 0;idx < shrinkable.length; idx++) {
+        if (shrinkable[idx] - shrink[idx] <= 0)
+          continue;
+        if (bestIdx === -1 || fractions[idx] > bestFraction || fractions[idx] === bestFraction && shrinkable[idx] > shrinkable[bestIdx]) {
+          bestIdx = idx;
+          bestFraction = fractions[idx];
+        }
+      }
+      if (bestIdx === -1) {
+        break;
+      }
+      shrink[bestIdx] += 1;
+      fractions[bestIdx] = 0;
+      remainingShrink -= 1;
+    }
+    return shrink;
+  }
   computeRowHeights(columnWidths) {
     const horizontalPadding = this.getHorizontalCellPadding();
     const verticalPadding = this.getVerticalCellPadding();
@@ -8032,7 +7545,7 @@ class TextTableRenderable extends Renderable {
     if (width === undefined || !Number.isFinite(width) || width <= 0) {
       return;
     }
-    if (this._wrapMode !== "none" || this._columnWidthMode === "fill") {
+    if (this._wrapMode !== "none" || this.isFullWidthMode()) {
       return Math.max(1, Math.floor(width));
     }
     return;
@@ -8043,6 +7556,12 @@ class TextTableRenderable extends Renderable {
   getVerticalCellPadding() {
     return this._cellPadding * 2;
   }
+  resolveColumnFitter(value) {
+    if (value === undefined) {
+      return this._defaultOptions.columnFitter;
+    }
+    return value === "balanced" ? "balanced" : "proportional";
+  }
   resolveCellPadding(value) {
     if (value === undefined || !Number.isFinite(value)) {
       return this._defaultOptions.cellPadding;
@@ -9365,15 +8884,23 @@ function parseMarkdownIncremental(newContent, prevState, trailingUnstable = 2) {
     const newTokens = x.lex(remainingContent, { gfm: true });
     return { content: newContent, tokens: [...stableTokens, ...newTokens] };
   } catch {
-    return { content: newContent, tokens: stableTokens };
+    try {
+      const fullTokens = x.lex(newContent, { gfm: true });
+      return { content: newContent, tokens: fullTokens };
+    } catch {
+      return { content: newContent, tokens: [] };
+    }
   }
 }
 
 // src/renderables/Markdown.ts
+var TRAILING_MARKDOWN_BLOCK_BREAKS_RE = /(?:\r?\n){2,}$/;
+
 class MarkdownRenderable extends Renderable {
   _content = "";
   _syntaxStyle;
   _conceal;
+  _concealCode;
   _treeSitterClient;
   _tableOptions;
   _renderNode;
@@ -9381,9 +8908,14 @@ class MarkdownRenderable extends Renderable {
   _streaming = false;
   _blockStates = [];
   _styleDirty = false;
+  _linkifyMarkdownChunks = (chunks, context) => detectLinks(chunks, {
+    content: context.content,
+    highlights: context.highlights
+  });
   _contentDefaultOptions = {
     content: "",
     conceal: true,
+    concealCode: false,
     streaming: false
   };
   constructor(ctx, options) {
@@ -9394,6 +8926,7 @@ class MarkdownRenderable extends Renderable {
     });
     this._syntaxStyle = options.syntaxStyle;
     this._conceal = options.conceal ?? this._contentDefaultOptions.conceal;
+    this._concealCode = options.concealCode ?? this._contentDefaultOptions.concealCode;
     this._content = options.content ?? this._contentDefaultOptions.content;
     this._treeSitterClient = options.treeSitterClient;
     this._tableOptions = options.tableOptions;
@@ -9405,6 +8938,8 @@ class MarkdownRenderable extends Renderable {
     return this._content;
   }
   set content(value) {
+    if (this.isDestroyed)
+      return;
     if (this._content !== value) {
       this._content = value;
       this.updateBlocks();
@@ -9429,13 +8964,24 @@ class MarkdownRenderable extends Renderable {
       this._styleDirty = true;
     }
   }
+  get concealCode() {
+    return this._concealCode;
+  }
+  set concealCode(value) {
+    if (this._concealCode !== value) {
+      this._concealCode = value;
+      this._styleDirty = true;
+    }
+  }
   get streaming() {
     return this._streaming;
   }
   set streaming(value) {
+    if (this.isDestroyed)
+      return;
     if (this._streaming !== value) {
       this._streaming = value;
-      this.clearCache();
+      this.updateBlocks(true);
     }
   }
   get tableOptions() {
@@ -9597,92 +9143,17 @@ class MarkdownRenderable extends Renderable {
         break;
     }
   }
-  renderHeadingChunks(token) {
-    const chunks = [];
-    const group = `markup.heading.${token.depth}`;
-    const marker = "#".repeat(token.depth) + " ";
-    if (!this._conceal) {
-      chunks.push(this.createChunk(marker, group));
-    }
-    for (const child of token.tokens) {
-      this.renderInlineTokenWithStyle(child, chunks, group);
-    }
-    return chunks;
-  }
-  renderParagraphChunks(token) {
-    const chunks = [];
-    this.renderInlineContent(token.tokens, chunks);
-    return chunks;
-  }
-  renderBlockquoteChunks(token) {
-    const chunks = [];
-    for (const child of token.tokens) {
-      chunks.push(this.createChunk("> ", "punctuation.special"));
-      const childChunks = this.renderTokenToChunks(child);
-      chunks.push(...childChunks);
-      chunks.push(this.createDefaultChunk(`
-`));
-    }
-    return chunks;
-  }
-  renderListChunks(token) {
-    const chunks = [];
-    let index = typeof token.start === "number" ? token.start : 1;
-    for (const item of token.items) {
-      if (token.ordered) {
-        chunks.push(this.createChunk(`${index}. `, "markup.list"));
-        index++;
-      } else {
-        chunks.push(this.createChunk("- ", "markup.list"));
-      }
-      for (let i = 0;i < item.tokens.length; i++) {
-        const child = item.tokens[i];
-        if (child.type === "text" && i === 0 && "tokens" in child && child.tokens) {
-          this.renderInlineContent(child.tokens, chunks);
-          chunks.push(this.createDefaultChunk(`
-`));
-        } else if (child.type === "paragraph" && i === 0) {
-          this.renderInlineContent(child.tokens, chunks);
-          chunks.push(this.createDefaultChunk(`
-`));
-        } else {
-          const childChunks = this.renderTokenToChunks(child);
-          chunks.push(...childChunks);
-          chunks.push(this.createDefaultChunk(`
-`));
-        }
-      }
-    }
-    return chunks;
-  }
-  renderThematicBreakChunks() {
-    return [this.createChunk("---", "punctuation.special")];
-  }
-  renderTokenToChunks(token) {
-    switch (token.type) {
-      case "heading":
-        return this.renderHeadingChunks(token);
-      case "paragraph":
-        return this.renderParagraphChunks(token);
-      case "blockquote":
-        return this.renderBlockquoteChunks(token);
-      case "list":
-        return this.renderListChunks(token);
-      case "hr":
-        return this.renderThematicBreakChunks();
-      case "space":
-        return [];
-      default:
-        if ("raw" in token && token.raw) {
-          return [this.createDefaultChunk(token.raw)];
-        }
-        return [];
-    }
-  }
-  createTextRenderable(chunks, id, marginBottom = 0) {
-    return new TextRenderable(this.ctx, {
+  createMarkdownCodeRenderable(content, id, marginBottom = 0) {
+    return new CodeRenderable(this.ctx, {
       id,
-      content: new StyledText(chunks),
+      content,
+      filetype: "markdown",
+      syntaxStyle: this._syntaxStyle,
+      conceal: this._conceal,
+      drawUnstyledText: false,
+      streaming: true,
+      onChunks: this._linkifyMarkdownChunks,
+      treeSitterClient: this._treeSitterClient,
       width: "100%",
       marginBottom
     });
@@ -9693,14 +9164,95 @@ class MarkdownRenderable extends Renderable {
       content: token.text,
       filetype: token.lang || undefined,
       syntaxStyle: this._syntaxStyle,
-      conceal: this._conceal,
+      conceal: this._concealCode,
+      drawUnstyledText: !(this._streaming && this._concealCode),
+      streaming: this._streaming,
       treeSitterClient: this._treeSitterClient,
       width: "100%",
       marginBottom
     });
   }
+  applyMarkdownCodeRenderable(renderable, content, marginBottom) {
+    renderable.content = content;
+    renderable.filetype = "markdown";
+    renderable.syntaxStyle = this._syntaxStyle;
+    renderable.conceal = this._conceal;
+    renderable.drawUnstyledText = false;
+    renderable.streaming = true;
+    renderable.marginBottom = marginBottom;
+  }
+  applyCodeBlockRenderable(renderable, token, marginBottom) {
+    renderable.content = token.text;
+    renderable.filetype = token.lang || undefined;
+    renderable.syntaxStyle = this._syntaxStyle;
+    renderable.conceal = this._concealCode;
+    renderable.drawUnstyledText = !(this._streaming && this._concealCode);
+    renderable.streaming = this._streaming;
+    renderable.marginBottom = marginBottom;
+  }
+  shouldRenderSeparately(token) {
+    return token.type === "code" || token.type === "table" || token.type === "blockquote";
+  }
+  getInterBlockMargin(token, hasNextToken) {
+    if (!hasNextToken)
+      return 0;
+    return this.shouldRenderSeparately(token) ? 1 : 0;
+  }
+  createMarkdownBlockToken(raw) {
+    return {
+      type: "paragraph",
+      raw,
+      text: raw,
+      tokens: []
+    };
+  }
+  normalizeMarkdownBlockRaw(raw) {
+    return raw.replace(TRAILING_MARKDOWN_BLOCK_BREAKS_RE, `
+`);
+  }
+  buildRenderableTokens(tokens) {
+    if (this._renderNode) {
+      return tokens.filter((token) => token.type !== "space");
+    }
+    const renderTokens = [];
+    let markdownRaw = "";
+    const flushMarkdownRaw = () => {
+      if (markdownRaw.length === 0)
+        return;
+      const normalizedRaw = this.normalizeMarkdownBlockRaw(markdownRaw);
+      if (normalizedRaw.length > 0) {
+        renderTokens.push(this.createMarkdownBlockToken(normalizedRaw));
+      }
+      markdownRaw = "";
+    };
+    for (let i = 0;i < tokens.length; i += 1) {
+      const token = tokens[i];
+      if (token.type === "space") {
+        if (markdownRaw.length === 0) {
+          continue;
+        }
+        let nextIndex = i + 1;
+        while (nextIndex < tokens.length && tokens[nextIndex].type === "space") {
+          nextIndex += 1;
+        }
+        const nextToken = tokens[nextIndex];
+        if (nextToken && !this.shouldRenderSeparately(nextToken)) {
+          markdownRaw += token.raw;
+        }
+        continue;
+      }
+      if (this.shouldRenderSeparately(token)) {
+        flushMarkdownRaw();
+        renderTokens.push(token);
+        continue;
+      }
+      markdownRaw += token.raw;
+    }
+    flushMarkdownRaw();
+    return renderTokens;
+  }
   getTableRowsToRender(table) {
-    return this._streaming && table.rows.length > 0 ? table.rows.slice(0, -1) : table.rows;
+    return table.rows;
   }
   hashString(value, seed) {
     let hash = seed >>> 0;
@@ -9823,8 +9375,9 @@ class MarkdownRenderable extends Renderable {
   resolveTableRenderableOptions() {
     const borders = this._tableOptions?.borders ?? true;
     return {
-      columnWidthMode: this._tableOptions?.widthMode ?? "content",
-      wrapMode: this._tableOptions?.wrapMode ?? "none",
+      columnWidthMode: this._tableOptions?.widthMode ?? "full",
+      columnFitter: this._tableOptions?.columnFitter ?? "proportional",
+      wrapMode: this._tableOptions?.wrapMode ?? "word",
       cellPadding: this._tableOptions?.cellPadding ?? 0,
       border: borders,
       outerBorder: this._tableOptions?.outerBorder ?? borders,
@@ -9836,6 +9389,7 @@ class MarkdownRenderable extends Renderable {
   }
   applyTableRenderableOptions(tableRenderable, options) {
     tableRenderable.columnWidthMode = options.columnWidthMode;
+    tableRenderable.columnFitter = options.columnFitter;
     tableRenderable.wrapMode = options.wrapMode;
     tableRenderable.cellPadding = options.cellPadding;
     tableRenderable.border = options.border;
@@ -9866,6 +9420,7 @@ class MarkdownRenderable extends Renderable {
       width: "100%",
       marginBottom,
       columnWidthMode: options.columnWidthMode,
+      columnFitter: options.columnFitter,
       wrapMode: options.wrapMode,
       cellPadding: options.cellPadding,
       border: options.border,
@@ -9880,7 +9435,7 @@ class MarkdownRenderable extends Renderable {
     const { cache } = this.buildTableContentCache(table, previousCache, forceRegenerate);
     if (!cache) {
       return {
-        renderable: this.createTextRenderable([this.createDefaultChunk(table.raw)], id, marginBottom)
+        renderable: this.createMarkdownCodeRenderable(table.raw, id, marginBottom)
       };
     }
     return {
@@ -9890,7 +9445,7 @@ class MarkdownRenderable extends Renderable {
   }
   createDefaultRenderable(token, index, hasNextToken = false) {
     const id = `${this.id}-block-${index}`;
-    const marginBottom = hasNextToken ? 1 : 0;
+    const marginBottom = this.getInterBlockMargin(token, hasNextToken);
     if (token.type === "code") {
       return this.createCodeRenderable(token, id, marginBottom);
     }
@@ -9900,39 +9455,28 @@ class MarkdownRenderable extends Renderable {
     if (token.type === "space") {
       return null;
     }
-    const chunks = this.renderTokenToChunks(token);
-    if (chunks.length === 0) {
+    if (!token.raw) {
       return null;
     }
-    return this.createTextRenderable(chunks, id, marginBottom);
+    return this.createMarkdownCodeRenderable(token.raw, id, marginBottom);
   }
   updateBlockRenderable(state, token, index, hasNextToken) {
-    const marginBottom = hasNextToken ? 1 : 0;
+    const marginBottom = this.getInterBlockMargin(token, hasNextToken);
     if (token.type === "code") {
-      const codeRenderable = state.renderable;
-      const codeToken = token;
-      codeRenderable.content = codeToken.text;
-      if (codeToken.lang) {
-        codeRenderable.filetype = codeToken.lang;
-      }
-      codeRenderable.marginBottom = marginBottom;
+      this.applyCodeBlockRenderable(state.renderable, token, marginBottom);
       return;
     }
     if (token.type === "table") {
       const tableToken = token;
       const { cache, changed } = this.buildTableContentCache(tableToken, state.tableContentCache);
       if (!cache) {
-        const fallbackChunks = [this.createDefaultChunk(tableToken.raw)];
-        if (state.renderable instanceof TextRenderable) {
-          if (state.tokenRaw !== tableToken.raw) {
-            state.renderable.content = new StyledText(fallbackChunks);
-          }
-          state.renderable.marginBottom = marginBottom;
+        if (state.renderable instanceof CodeRenderable) {
+          this.applyMarkdownCodeRenderable(state.renderable, tableToken.raw, marginBottom);
           state.tableContentCache = undefined;
           return;
         }
         state.renderable.destroyRecursively();
-        const fallbackRenderable = this.createTextRenderable(fallbackChunks, `${this.id}-block-${index}`, marginBottom);
+        const fallbackRenderable = this.createMarkdownCodeRenderable(tableToken.raw, `${this.id}-block-${index}`, marginBottom);
         this.add(fallbackRenderable);
         state.renderable = fallbackRenderable;
         state.tableContentCache = undefined;
@@ -9954,12 +9498,18 @@ class MarkdownRenderable extends Renderable {
       state.tableContentCache = cache;
       return;
     }
-    const textRenderable = state.renderable;
-    const chunks = this.renderTokenToChunks(token);
-    textRenderable.content = new StyledText(chunks);
-    textRenderable.marginBottom = marginBottom;
+    if (state.renderable instanceof CodeRenderable) {
+      this.applyMarkdownCodeRenderable(state.renderable, token.raw, marginBottom);
+      return;
+    }
+    state.renderable.destroyRecursively();
+    const markdownRenderable = this.createMarkdownCodeRenderable(token.raw, `${this.id}-block-${index}`, marginBottom);
+    this.add(markdownRenderable);
+    state.renderable = markdownRenderable;
   }
-  updateBlocks() {
+  updateBlocks(forceTableRefresh = false) {
+    if (this.isDestroyed)
+      return;
     if (!this._content) {
       this.clearBlockStates();
       this._parseState = null;
@@ -9970,35 +9520,39 @@ class MarkdownRenderable extends Renderable {
     const tokens = this._parseState.tokens;
     if (tokens.length === 0 && this._content.length > 0) {
       this.clearBlockStates();
-      const text = this.createTextRenderable([this.createDefaultChunk(this._content)], `${this.id}-fallback`);
-      this.add(text);
+      const fallback = this.createMarkdownCodeRenderable(this._content, `${this.id}-fallback`);
+      this.add(fallback);
       this._blockStates = [
         {
           token: { type: "text", raw: this._content, text: this._content },
           tokenRaw: this._content,
-          renderable: text
+          renderable: fallback
         }
       ];
       return;
     }
-    const blockTokens = [];
-    for (let i = 0;i < tokens.length; i++) {
-      if (tokens[i].type !== "space") {
-        blockTokens.push({ token: tokens[i], originalIndex: i });
-      }
-    }
+    const blockTokens = this.buildRenderableTokens(tokens);
     const lastBlockIndex = blockTokens.length - 1;
     let blockIndex = 0;
     for (let i = 0;i < blockTokens.length; i++) {
-      const { token } = blockTokens[i];
+      const token = blockTokens[i];
       const hasNextToken = i < lastBlockIndex;
       const existing = this._blockStates[blockIndex];
+      const shouldForceRefresh = forceTableRefresh;
       if (existing && existing.token === token) {
+        if (shouldForceRefresh) {
+          this.updateBlockRenderable(existing, token, blockIndex, hasNextToken);
+          existing.tokenRaw = token.raw;
+        }
         blockIndex++;
         continue;
       }
       if (existing && existing.tokenRaw === token.raw && existing.token.type === token.type) {
         existing.token = token;
+        if (shouldForceRefresh) {
+          this.updateBlockRenderable(existing, token, blockIndex, hasNextToken);
+          existing.tokenRaw = token.raw;
+        }
         blockIndex++;
         continue;
       }
@@ -10018,6 +9572,7 @@ class MarkdownRenderable extends Renderable {
         const context = {
           syntaxStyle: this._syntaxStyle,
           conceal: this._conceal,
+          concealCode: this._concealCode,
           treeSitterClient: this._treeSitterClient,
           defaultRender: () => this.createDefaultRenderable(token, blockIndex, hasNextToken)
         };
@@ -10028,7 +9583,7 @@ class MarkdownRenderable extends Renderable {
       }
       if (!renderable) {
         if (token.type === "table") {
-          const tableBlock = this.createTableBlock(token, `${this.id}-block-${blockIndex}`, hasNextToken ? 1 : 0);
+          const tableBlock = this.createTableBlock(token, `${this.id}-block-${blockIndex}`, this.getInterBlockMargin(token, hasNextToken));
           renderable = tableBlock.renderable;
           tableContentCache = tableBlock.tableContentCache;
         } else {
@@ -10065,44 +9620,48 @@ class MarkdownRenderable extends Renderable {
     for (let i = 0;i < this._blockStates.length; i++) {
       const state = this._blockStates[i];
       const hasNextToken = i < this._blockStates.length - 1;
+      const marginBottom = this.getInterBlockMargin(state.token, hasNextToken);
       if (state.token.type === "code") {
-        const codeRenderable = state.renderable;
-        codeRenderable.syntaxStyle = this._syntaxStyle;
-        codeRenderable.conceal = this._conceal;
-      } else if (state.token.type === "table") {
+        this.applyCodeBlockRenderable(state.renderable, state.token, marginBottom);
+        continue;
+      }
+      if (state.token.type === "table") {
         const tableToken = state.token;
-        const marginBottom = hasNextToken ? 1 : 0;
         const { cache } = this.buildTableContentCache(tableToken, state.tableContentCache, true);
         if (!cache) {
-          if (state.renderable instanceof TextRenderable) {
-            state.renderable.content = new StyledText([this.createDefaultChunk(tableToken.raw)]);
-            state.renderable.marginBottom = marginBottom;
+          if (state.renderable instanceof CodeRenderable) {
+            this.applyMarkdownCodeRenderable(state.renderable, tableToken.raw, marginBottom);
           } else {
             state.renderable.destroyRecursively();
-            const fallbackRenderable = this.createTextRenderable([this.createDefaultChunk(tableToken.raw)], `${this.id}-block-${i}`, marginBottom);
+            const fallbackRenderable = this.createMarkdownCodeRenderable(tableToken.raw, `${this.id}-block-${i}`, marginBottom);
             this.add(fallbackRenderable);
             state.renderable = fallbackRenderable;
           }
           state.tableContentCache = undefined;
-        } else if (state.renderable instanceof TextTableRenderable) {
+          continue;
+        }
+        if (state.renderable instanceof TextTableRenderable) {
           state.renderable.content = cache.content;
           this.applyTableRenderableOptions(state.renderable, this.resolveTableRenderableOptions());
           state.renderable.marginBottom = marginBottom;
           state.tableContentCache = cache;
-        } else {
-          state.renderable.destroyRecursively();
-          const tableRenderable = this.createTextTableRenderable(cache.content, `${this.id}-block-${i}`, marginBottom);
-          this.add(tableRenderable);
-          state.renderable = tableRenderable;
-          state.tableContentCache = cache;
-        }
-      } else {
-        const textRenderable = state.renderable;
-        const chunks = this.renderTokenToChunks(state.token);
-        if (chunks.length > 0) {
-          textRenderable.content = new StyledText(chunks);
+          continue;
         }
+        state.renderable.destroyRecursively();
+        const tableRenderable = this.createTextTableRenderable(cache.content, `${this.id}-block-${i}`, marginBottom);
+        this.add(tableRenderable);
+        state.renderable = tableRenderable;
+        state.tableContentCache = cache;
+        continue;
       }
+      if (state.renderable instanceof CodeRenderable) {
+        this.applyMarkdownCodeRenderable(state.renderable, state.token.raw, marginBottom);
+        continue;
+      }
+      state.renderable.destroyRecursively();
+      const markdownRenderable = this.createMarkdownCodeRenderable(state.token.raw, `${this.id}-block-${i}`, marginBottom);
+      this.add(markdownRenderable);
+      state.renderable = markdownRenderable;
     }
   }
   clearCache() {
@@ -10727,6 +10286,34 @@ class ContentRenderable extends BoxRenderable {
     return this.getChildrenSortedByPrimaryAxis().map((child) => child.num);
   }
 }
+var SCROLLBOX_PADDING_KEYS = [
+  "padding",
+  "paddingX",
+  "paddingY",
+  "paddingTop",
+  "paddingRight",
+  "paddingBottom",
+  "paddingLeft"
+];
+function pickScrollBoxPadding(options) {
+  if (!options)
+    return {};
+  const picked = {};
+  for (const key of SCROLLBOX_PADDING_KEYS) {
+    const value = options[key];
+    if (value !== undefined) {
+      picked[key] = value;
+    }
+  }
+  return picked;
+}
+function stripScrollBoxPadding(options) {
+  const sanitized = { ...options };
+  for (const key of SCROLLBOX_PADDING_KEYS) {
+    delete sanitized[key];
+  }
+  return sanitized;
+}
 
 class ScrollBoxRenderable extends BoxRenderable {
   static idCounter = 0;
@@ -10874,27 +10461,38 @@ class ScrollBoxRenderable extends BoxRenderable {
       this._isApplyingStickyScroll = wasApplyingStickyScroll;
     }
   }
-  constructor(ctx, {
-    wrapperOptions,
-    viewportOptions,
-    contentOptions,
-    rootOptions,
-    scrollbarOptions,
-    verticalScrollbarOptions,
-    horizontalScrollbarOptions,
-    stickyScroll = false,
-    stickyStart,
-    scrollX = false,
-    scrollY = true,
-    scrollAcceleration,
-    viewportCulling = true,
-    ...options
-  }) {
+  constructor(ctx, options) {
+    const {
+      wrapperOptions,
+      viewportOptions,
+      contentOptions,
+      rootOptions,
+      scrollbarOptions,
+      verticalScrollbarOptions,
+      horizontalScrollbarOptions,
+      stickyScroll = false,
+      stickyStart,
+      scrollX = false,
+      scrollY = true,
+      scrollAcceleration,
+      viewportCulling = true,
+      ...rootBoxOptions
+    } = options;
+    const forwardedContentPadding = {
+      ...pickScrollBoxPadding(rootBoxOptions),
+      ...pickScrollBoxPadding(rootOptions)
+    };
+    const sanitizedRootBoxOptions = stripScrollBoxPadding(rootBoxOptions);
+    const sanitizedRootOptions = rootOptions ? stripScrollBoxPadding(rootOptions) : undefined;
+    const mergedContentOptions = {
+      ...forwardedContentPadding,
+      ...contentOptions
+    };
     super(ctx, {
       flexDirection: "row",
       alignItems: "stretch",
-      ...options,
-      ...rootOptions
+      ...sanitizedRootBoxOptions,
+      ...sanitizedRootOptions
     });
     this.internalId = ScrollBoxRenderable.idCounter++;
     this._stickyScroll = stickyScroll;
@@ -10926,7 +10524,7 @@ class ScrollBoxRenderable extends BoxRenderable {
       onSizeChange: () => {
         this.recalculateBarProps();
       },
-      ...contentOptions,
+      ...mergedContentOptions,
       id: `scroll-box-content-${this.internalId}`
     });
     this.viewport.add(this.content);
@@ -11242,6 +10840,34 @@ class ScrollBoxRenderable extends BoxRenderable {
       this.requestRender();
     });
   }
+  set padding(value) {
+    this.content.padding = value;
+    this.requestRender();
+  }
+  set paddingX(value) {
+    this.content.paddingX = value;
+    this.requestRender();
+  }
+  set paddingY(value) {
+    this.content.paddingY = value;
+    this.requestRender();
+  }
+  set paddingTop(value) {
+    this.content.paddingTop = value;
+    this.requestRender();
+  }
+  set paddingRight(value) {
+    this.content.paddingRight = value;
+    this.requestRender();
+  }
+  set paddingBottom(value) {
+    this.content.paddingBottom = value;
+    this.requestRender();
+  }
+  set paddingLeft(value) {
+    this.content.paddingLeft = value;
+    this.requestRender();
+  }
   set rootOptions(options) {
     Object.assign(this, options);
     this.requestRender();
@@ -12077,6 +11703,7 @@ export {
   env,
   engine,
   dim,
+  detectLinks,
   delegate,
   cyan,
   createTimeline,
@@ -12206,5 +11833,5 @@ export {
   ASCIIFont
 };
 
-//# debugId=0C8001DA726AC37664756E2164756E21
+//# debugId=D4980C658617B6F964756E2164756E21
 //# sourceMappingURL=index.js.map