@opentui/core 0.1.82 → 0.1.84

package/index.js

@@ -153,7 +153,7 @@ import {
   white,
   wrapWithDelegates,
   yellow
-} from "./index-fv58mb45.js";
+} from "./index-qr7b6cvh.js";
 // src/text-buffer-view.ts
 class TextBufferView {
   lib;
@@ -4140,617 +4140,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 +4244,6 @@ function parsePatch(uniDiff) {
   }
   return list;
 }
-
 // src/renderables/Text.ts
 class TextRenderable extends TextBufferRenderable {
   _text;
@@ -7171,6 +6559,7 @@ class TextTableRenderable extends Renderable {
   _content;
   _wrapMode;
   _columnWidthMode;
+  _columnFitter;
   _cellPadding;
   _showBorders;
   _border;
@@ -7186,6 +6575,7 @@ class TextTableRenderable extends Renderable {
   _selectionBg;
   _selectionFg;
   _lastLocalSelection = null;
+  _lastSelectionMode = null;
   _cells = [];
   _prevCellContent = [];
   _rowCount = 0;
@@ -7197,8 +6587,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,
@@ -7215,10 +6606,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;
@@ -7267,6 +6659,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;
   }
@@ -7344,6 +6746,7 @@ class TextTableRenderable extends Renderable {
     const dirtyRows = this.getDirtySelectionRowRange(previousLocalSelection, localSelection);
     if (!localSelection?.isActive) {
       this.resetCellSelections();
+      this._lastSelectionMode = null;
     } else {
       this.applySelectionToCells(localSelection, selection?.isStart ?? false);
     }
@@ -7419,7 +6822,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);
@@ -7431,9 +6834,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
@@ -7605,6 +7005,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);
@@ -7627,7 +7030,7 @@ class TextTableRenderable extends Renderable {
       return intrinsicWidths;
     }
     if (currentWidth < maxContentWidth) {
-      if (this._columnWidthMode === "fill") {
+      if (this.isFullWidthMode()) {
         return this.expandColumnWidths(intrinsicWidths, maxContentWidth);
       }
       return intrinsicWidths;
@@ -7657,6 +7060,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)));
@@ -7707,6 +7116,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();
@@ -7876,6 +7359,10 @@ class TextTableRenderable extends Renderable {
     const maxSelY = Math.max(localSelection.anchorY, localSelection.focusY);
     const firstRow = this.findRowForLocalY(minSelY);
     const lastRow = this.findRowForLocalY(maxSelY);
+    const selection = this.resolveSelectionResolution(localSelection);
+    const modeChanged = this._lastSelectionMode !== selection.mode;
+    this._lastSelectionMode = selection.mode;
+    const lockToAnchorColumn = selection.mode === "column-locked" && selection.anchorColumn !== null;
     for (let rowIdx = 0;rowIdx < this._rowCount; rowIdx++) {
       if (rowIdx < firstRow || rowIdx > lastRow) {
         this.resetRowSelection(rowIdx);
@@ -7886,19 +7373,82 @@ class TextTableRenderable extends Renderable {
         const cell = this._cells[rowIdx]?.[colIdx];
         if (!cell)
           continue;
+        if (lockToAnchorColumn && colIdx !== selection.anchorColumn) {
+          cell.textBufferView.resetLocalSelection();
+          continue;
+        }
         const cellLeft = (this._layout.columnOffsets[colIdx] ?? 0) + 1 + this._cellPadding;
-        const anchorX = localSelection.anchorX - cellLeft;
-        const anchorY = localSelection.anchorY - cellTop;
-        const focusX = localSelection.focusX - cellLeft;
-        const focusY = localSelection.focusY - cellTop;
-        if (isStart) {
-          cell.textBufferView.setLocalSelection(anchorX, anchorY, focusX, focusY, this._selectionBg, this._selectionFg);
+        let coords = {
+          anchorX: localSelection.anchorX - cellLeft,
+          anchorY: localSelection.anchorY - cellTop,
+          focusX: localSelection.focusX - cellLeft,
+          focusY: localSelection.focusY - cellTop
+        };
+        const isAnchorCell = selection.anchorCell !== null && selection.anchorCell.rowIdx === rowIdx && selection.anchorCell.colIdx === colIdx;
+        const forceSet = isAnchorCell && selection.mode !== "single-cell";
+        if (forceSet) {
+          coords = this.getFullCellSelectionCoords(rowIdx, colIdx);
+        }
+        const shouldUseSet = isStart || modeChanged || forceSet;
+        if (shouldUseSet) {
+          cell.textBufferView.setLocalSelection(coords.anchorX, coords.anchorY, coords.focusX, coords.focusY, this._selectionBg, this._selectionFg);
         } else {
-          cell.textBufferView.updateLocalSelection(anchorX, anchorY, focusX, focusY, this._selectionBg, this._selectionFg);
+          cell.textBufferView.updateLocalSelection(coords.anchorX, coords.anchorY, coords.focusX, coords.focusY, this._selectionBg, this._selectionFg);
         }
       }
     }
   }
+  resolveSelectionResolution(localSelection) {
+    const anchorCell = this.getCellAtLocalPosition(localSelection.anchorX, localSelection.anchorY);
+    const focusCell = this.getCellAtLocalPosition(localSelection.focusX, localSelection.focusY);
+    const anchorColumn = anchorCell?.colIdx ?? this.getColumnAtLocalX(localSelection.anchorX);
+    if (anchorCell !== null && focusCell !== null && anchorCell.rowIdx === focusCell.rowIdx && anchorCell.colIdx === focusCell.colIdx) {
+      return {
+        mode: "single-cell",
+        anchorCell,
+        anchorColumn
+      };
+    }
+    const focusColumn = this.getColumnAtLocalX(localSelection.focusX);
+    if (anchorColumn !== null && focusColumn === anchorColumn) {
+      return {
+        mode: "column-locked",
+        anchorCell,
+        anchorColumn
+      };
+    }
+    return {
+      mode: "grid",
+      anchorCell,
+      anchorColumn
+    };
+  }
+  getColumnAtLocalX(localX) {
+    if (this._columnCount === 0)
+      return null;
+    if (localX < 0 || localX >= this._layout.tableWidth)
+      return null;
+    for (let colIdx = 0;colIdx < this._columnCount; colIdx++) {
+      const colStart = (this._layout.columnOffsets[colIdx] ?? 0) + 1;
+      const colEnd = colStart + (this._layout.columnWidths[colIdx] ?? 1) - 1;
+      if (localX >= colStart && localX <= colEnd) {
+        return colIdx;
+      }
+    }
+    return null;
+  }
+  getFullCellSelectionCoords(rowIdx, colIdx) {
+    const colWidth = this._layout.columnWidths[colIdx] ?? 1;
+    const rowHeight = this._layout.rowHeights[rowIdx] ?? 1;
+    const contentWidth = Math.max(1, colWidth - this.getHorizontalCellPadding());
+    const contentHeight = Math.max(1, rowHeight - this.getVerticalCellPadding());
+    return {
+      anchorX: -1,
+      anchorY: 0,
+      focusX: contentWidth,
+      focusY: contentHeight
+    };
+  }
   findRowForLocalY(localY) {
     if (this._rowCount === 0)
       return 0;
@@ -7939,8 +7489,6 @@ class TextTableRenderable extends Renderable {
     if (!row)
       return;
     for (const cell of row) {
-      if (!cell.textBufferView.hasSelection())
-        continue;
       cell.textBufferView.resetLocalSelection();
     }
   }
@@ -7965,7 +7513,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;
@@ -7976,6 +7524,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;
@@ -9308,6 +8862,7 @@ class MarkdownRenderable extends Renderable {
   _syntaxStyle;
   _conceal;
   _treeSitterClient;
+  _tableOptions;
   _renderNode;
   _parseState = null;
   _streaming = false;
@@ -9328,6 +8883,7 @@ class MarkdownRenderable extends Renderable {
     this._conceal = options.conceal ?? this._contentDefaultOptions.conceal;
     this._content = options.content ?? this._contentDefaultOptions.content;
     this._treeSitterClient = options.treeSitterClient;
+    this._tableOptions = options.tableOptions;
     this._renderNode = options.renderNode;
     this._streaming = options.streaming ?? this._contentDefaultOptions.streaming;
     this.updateBlocks();
@@ -9369,6 +8925,13 @@ class MarkdownRenderable extends Renderable {
       this.clearCache();
     }
   }
+  get tableOptions() {
+    return this._tableOptions;
+  }
+  set tableOptions(value) {
+    this._tableOptions = value;
+    this.applyTableOptionsToBlocks();
+  }
   getStyle(group) {
     if (!this._syntaxStyle)
       return;
@@ -9744,18 +9307,63 @@ class MarkdownRenderable extends Renderable {
       changed
     };
   }
+  resolveTableRenderableOptions() {
+    const borders = this._tableOptions?.borders ?? true;
+    return {
+      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,
+      showBorders: borders,
+      borderStyle: this._tableOptions?.borderStyle ?? "single",
+      borderColor: this._tableOptions?.borderColor ?? this.getStyle("conceal")?.fg ?? "#888888",
+      selectable: this._tableOptions?.selectable ?? true
+    };
+  }
+  applyTableRenderableOptions(tableRenderable, options) {
+    tableRenderable.columnWidthMode = options.columnWidthMode;
+    tableRenderable.columnFitter = options.columnFitter;
+    tableRenderable.wrapMode = options.wrapMode;
+    tableRenderable.cellPadding = options.cellPadding;
+    tableRenderable.border = options.border;
+    tableRenderable.outerBorder = options.outerBorder;
+    tableRenderable.showBorders = options.showBorders;
+    tableRenderable.borderStyle = options.borderStyle;
+    tableRenderable.borderColor = options.borderColor;
+    tableRenderable.selectable = options.selectable;
+  }
+  applyTableOptionsToBlocks() {
+    const options = this.resolveTableRenderableOptions();
+    let updated = false;
+    for (const state of this._blockStates) {
+      if (state.renderable instanceof TextTableRenderable) {
+        this.applyTableRenderableOptions(state.renderable, options);
+        updated = true;
+      }
+    }
+    if (updated) {
+      this.requestRender();
+    }
+  }
   createTextTableRenderable(content, id, marginBottom = 0) {
+    const options = this.resolveTableRenderableOptions();
     return new TextTableRenderable(this.ctx, {
       id,
       content,
       width: "100%",
       marginBottom,
-      border: true,
-      outerBorder: true,
-      showBorders: true,
-      borderStyle: "single",
-      borderColor: this.getStyle("conceal")?.fg ?? "#888888",
-      selectable: false
+      columnWidthMode: options.columnWidthMode,
+      columnFitter: options.columnFitter,
+      wrapMode: options.wrapMode,
+      cellPadding: options.cellPadding,
+      border: options.border,
+      outerBorder: options.outerBorder,
+      showBorders: options.showBorders,
+      borderStyle: options.borderStyle,
+      borderColor: options.borderColor,
+      selectable: options.selectable
     });
   }
   createTableBlock(table, id, marginBottom = 0, previousCache, forceRegenerate = false) {
@@ -9824,7 +9432,7 @@ class MarkdownRenderable extends Renderable {
         if (changed) {
           state.renderable.content = cache.content;
         }
-        state.renderable.borderColor = this.getStyle("conceal")?.fg ?? "#888888";
+        this.applyTableRenderableOptions(state.renderable, this.resolveTableRenderableOptions());
         state.renderable.marginBottom = marginBottom;
         state.tableContentCache = cache;
         return;
@@ -9968,7 +9576,7 @@ class MarkdownRenderable extends Renderable {
           state.tableContentCache = undefined;
         } else if (state.renderable instanceof TextTableRenderable) {
           state.renderable.content = cache.content;
-          state.renderable.borderColor = this.getStyle("conceal")?.fg ?? "#888888";
+          this.applyTableRenderableOptions(state.renderable, this.resolveTableRenderableOptions());
           state.renderable.marginBottom = marginBottom;
           state.tableContentCache = cache;
         } else {
@@ -10609,6 +10217,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;
@@ -10756,27 +10392,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;
@@ -10808,7 +10455,7 @@ class ScrollBoxRenderable extends BoxRenderable {
       onSizeChange: () => {
         this.recalculateBarProps();
       },
-      ...contentOptions,
+      ...mergedContentOptions,
       id: `scroll-box-content-${this.internalId}`
     });
     this.viewport.add(this.content);
@@ -11124,6 +10771,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();
@@ -12088,5 +11763,5 @@ export {
   ASCIIFont
 };
 
-//# debugId=115C19DFB6D5E10364756E2164756E21
+//# debugId=3C6B494E292F6AEE64756E2164756E21
 //# sourceMappingURL=index.js.map