@opentui/core 0.0.0-20251205-41c885f6 → 0.0.0-20251209-015faccd

package/index.js

@@ -9,7 +9,9 @@ import {
   ConsolePosition,
   DataPathsManager,
   DebugOverlayCorner,
+  Edge,
   ExtmarksController,
+  Gutter,
   InternalKeyHandler,
   KeyEvent,
   KeyHandler,
@@ -17,6 +19,7 @@ import {
   LinearScrollAccel,
   LogLevel,
   MacOSScrollAccel,
+  MeasureMode,
   MouseButton,
   MouseEvent,
   MouseParser,
@@ -58,6 +61,7 @@ import {
   brightRed,
   brightWhite,
   brightYellow,
+  buildKittyKeyboardFlags,
   capture,
   clearEnvCache,
   convertGlobalToLocalSelection,
@@ -71,6 +75,7 @@ import {
   dim,
   env,
   envRegistry,
+  exports_src,
   extToFiletype,
   fg,
   fonts,
@@ -133,7 +138,7 @@ import {
   white,
   wrapWithDelegates,
   yellow
-} from "./index-x5bb5xvn.js";
+} from "./index-4s3xr47p.js";
 // src/text-buffer-view.ts
 class TextBufferView {
   lib;
@@ -2197,7 +2202,6 @@ class ASCIIFontRenderable extends FrameBufferRenderable {
   }
 }
 // src/renderables/Box.ts
-import { Edge, Gutter } from "bun-yoga";
 function isGapType(value) {
   if (value === undefined) {
     return true;
@@ -2414,7 +2418,6 @@ class BoxRenderable extends Renderable {
   }
 }
 // src/renderables/TextBufferRenderable.ts
-import { MeasureMode } from "bun-yoga";
 class TextBufferRenderable extends Renderable {
   selectable = true;
   _defaultFg;
@@ -3754,8 +3757,720 @@ class LineNumberRenderable extends Renderable {
   }
 }
 
-// src/renderables/Diff.ts
-import { parsePatch } from "diff";
+// ../../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/diff/libesm/diff/character.js
+class CharacterDiff extends Diff {
+}
+var characterDiff = new CharacterDiff;
+
+// ../../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/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/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/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/diff/libesm/diff/css.js
+class CssDiff extends Diff {
+  tokenize(value) {
+    return value.split(/([{}:;,]|\s+)/);
+  }
+}
+var cssDiff = new CssDiff;
+
+// ../../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/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/diff/libesm/patch/parse.js
+function parsePatch(uniDiff) {
+  const diffstr = uniDiff.split(/\n/), list = [];
+  let i = 0;
+  function parseIndex() {
+    const index = {};
+    list.push(index);
+    while (i < diffstr.length) {
+      const line = diffstr[i];
+      if (/^(---|\+\+\+|@@)\s/.test(line)) {
+        break;
+      }
+      const header = /^(?:Index:|diff(?: -r \w+)+)\s+(.+?)\s*$/.exec(line);
+      if (header) {
+        index.index = header[1];
+      }
+      i++;
+    }
+    parseFileHeader(index);
+    parseFileHeader(index);
+    index.hunks = [];
+    while (i < diffstr.length) {
+      const line = diffstr[i];
+      if (/^(Index:\s|diff\s|---\s|\+\+\+\s|===================================================================)/.test(line)) {
+        break;
+      } else if (/^@@/.test(line)) {
+        index.hunks.push(parseHunk());
+      } else if (line) {
+        throw new Error("Unknown line " + (i + 1) + " " + JSON.stringify(line));
+      } else {
+        i++;
+      }
+    }
+  }
+  function parseFileHeader(index) {
+    const fileHeader = /^(---|\+\+\+)\s+(.*)\r?$/.exec(diffstr[i]);
+    if (fileHeader) {
+      const data = fileHeader[2].split("\t", 2), header = (data[1] || "").trim();
+      let fileName = data[0].replace(/\\\\/g, "\\");
+      if (/^".*"$/.test(fileName)) {
+        fileName = fileName.substr(1, fileName.length - 2);
+      }
+      if (fileHeader[1] === "---") {
+        index.oldFileName = fileName;
+        index.oldHeader = header;
+      } else {
+        index.newFileName = fileName;
+        index.newHeader = header;
+      }
+      i++;
+    }
+  }
+  function parseHunk() {
+    var _a;
+    const chunkHeaderIndex = i, chunkHeaderLine = diffstr[i++], chunkHeader = chunkHeaderLine.split(/@@ -(\d+)(?:,(\d+))? \+(\d+)(?:,(\d+))? @@/);
+    const hunk = {
+      oldStart: +chunkHeader[1],
+      oldLines: typeof chunkHeader[2] === "undefined" ? 1 : +chunkHeader[2],
+      newStart: +chunkHeader[3],
+      newLines: typeof chunkHeader[4] === "undefined" ? 1 : +chunkHeader[4],
+      lines: []
+    };
+    if (hunk.oldLines === 0) {
+      hunk.oldStart += 1;
+    }
+    if (hunk.newLines === 0) {
+      hunk.newStart += 1;
+    }
+    let addCount = 0, removeCount = 0;
+    for (;i < diffstr.length && (removeCount < hunk.oldLines || addCount < hunk.newLines || ((_a = diffstr[i]) === null || _a === undefined ? undefined : _a.startsWith("\\"))); i++) {
+      const operation = diffstr[i].length == 0 && i != diffstr.length - 1 ? " " : diffstr[i][0];
+      if (operation === "+" || operation === "-" || operation === " " || operation === "\\") {
+        hunk.lines.push(diffstr[i]);
+        if (operation === "+") {
+          addCount++;
+        } else if (operation === "-") {
+          removeCount++;
+        } else if (operation === " ") {
+          addCount++;
+          removeCount++;
+        }
+      } else {
+        throw new Error(`Hunk at line ${chunkHeaderIndex + 1} contained invalid line ${diffstr[i]}`);
+      }
+    }
+    if (!addCount && hunk.newLines === 1) {
+      hunk.newLines = 0;
+    }
+    if (!removeCount && hunk.oldLines === 1) {
+      hunk.oldLines = 0;
+    }
+    if (addCount !== hunk.newLines) {
+      throw new Error("Added line count did not match for hunk at line " + (chunkHeaderIndex + 1));
+    }
+    if (removeCount !== hunk.oldLines) {
+      throw new Error("Removed line count did not match for hunk at line " + (chunkHeaderIndex + 1));
+    }
+    return hunk;
+  }
+  while (i < diffstr.length) {
+    parseIndex();
+  }
+  return list;
+}
 
 // src/renderables/Text.ts
 class TextRenderable extends TextBufferRenderable {
@@ -3859,6 +4574,7 @@ class DiffRenderable extends Renderable {
   _view;
   _parsedDiff = null;
   _parseError = null;
+  _fg;
   _filetype;
   _syntaxStyle;
   _wrapMode;
@@ -3896,6 +4612,7 @@ class DiffRenderable extends Renderable {
     });
     this._diff = options.diff ?? "";
     this._view = options.view ?? "unified";
+    this._fg = options.fg ? parseColor(options.fg) : undefined;
     this._filetype = options.filetype;
     this._syntaxStyle = options.syntaxStyle;
     this._wrapMode = options.wrapMode;
@@ -4056,6 +4773,7 @@ class DiffRenderable extends Renderable {
         syntaxStyle: this._syntaxStyle ?? SyntaxStyle.create(),
         width: "100%",
         height: "100%",
+        ...this._fg !== undefined && { fg: this._fg },
         ...drawUnstyledText !== undefined && { drawUnstyledText },
         ...this._selectionBg !== undefined && { selectionBg: this._selectionBg },
         ...this._selectionFg !== undefined && { selectionFg: this._selectionFg },
@@ -4087,6 +4805,9 @@ class DiffRenderable extends Renderable {
       if (this._selectionFg !== undefined) {
         existingRenderable.selectionFg = this._selectionFg;
       }
+      if (this._fg !== undefined) {
+        existingRenderable.fg = this._fg;
+      }
       return existingRenderable;
     }
   }
@@ -4698,8 +5419,78 @@ class DiffRenderable extends Renderable {
       this.rebuildView();
     }
   }
+  get fg() {
+    return this._fg;
+  }
+  set fg(value) {
+    const parsed = value ? parseColor(value) : undefined;
+    if (this._fg !== parsed) {
+      this._fg = parsed;
+      if (this.leftCodeRenderable) {
+        this.leftCodeRenderable.fg = parsed;
+      }
+      if (this.rightCodeRenderable) {
+        this.rightCodeRenderable.fg = parsed;
+      }
+    }
+  }
+}
+// src/lib/keymapping.ts
+var defaultKeyAliases = {
+  enter: "return",
+  esc: "escape"
+};
+function mergeKeyAliases(defaults, custom) {
+  return { ...defaults, ...custom };
+}
+function mergeKeyBindings(defaults, custom) {
+  const map = new Map;
+  for (const binding of defaults) {
+    const key = getKeyBindingKey(binding);
+    map.set(key, binding);
+  }
+  for (const binding of custom) {
+    const key = getKeyBindingKey(binding);
+    map.set(key, binding);
+  }
+  return Array.from(map.values());
+}
+function getKeyBindingKey(binding) {
+  return `${binding.name}:${binding.ctrl ? 1 : 0}:${binding.shift ? 1 : 0}:${binding.meta ? 1 : 0}:${binding.super ? 1 : 0}`;
+}
+function buildKeyBindingsMap(bindings, aliasMap) {
+  const map = new Map;
+  const aliases = aliasMap || {};
+  for (const binding of bindings) {
+    const key = getKeyBindingKey(binding);
+    map.set(key, binding.action);
+  }
+  for (const binding of bindings) {
+    const normalizedName = aliases[binding.name] || binding.name;
+    if (normalizedName !== binding.name) {
+      const aliasedKey = getKeyBindingKey({ ...binding, name: normalizedName });
+      map.set(aliasedKey, binding.action);
+    }
+  }
+  return map;
 }
+
 // src/renderables/Input.ts
+var defaultInputKeybindings = [
+  { name: "left", action: "move-left" },
+  { name: "right", action: "move-right" },
+  { name: "home", action: "move-home" },
+  { name: "end", action: "move-end" },
+  { name: "backspace", action: "delete-backward" },
+  { name: "delete", action: "delete-forward" },
+  { name: "return", action: "submit" },
+  { name: "linefeed", action: "submit" },
+  { name: "a", ctrl: true, action: "move-home" },
+  { name: "e", ctrl: true, action: "move-end" },
+  { name: "f", ctrl: true, action: "move-right" },
+  { name: "b", ctrl: true, action: "move-left" },
+  { name: "d", ctrl: true, action: "delete-forward" }
+];
 var InputRenderableEvents;
 ((InputRenderableEvents2) => {
   InputRenderableEvents2["INPUT"] = "input";
@@ -4721,6 +5512,9 @@ class InputRenderable extends Renderable {
   _cursorStyle;
   _maxLength;
   _lastCommittedValue = "";
+  _keyBindingsMap;
+  _keyAliasMap;
+  _keyBindings;
   _defaultOptions = {
     backgroundColor: "transparent",
     textColor: "#FFFFFF",
@@ -4750,6 +5544,10 @@ class InputRenderable extends Renderable {
     this._placeholderColor = parseColor(options.placeholderColor || this._defaultOptions.placeholderColor);
     this._cursorColor = parseColor(options.cursorColor || this._defaultOptions.cursorColor);
     this._cursorStyle = options.cursorStyle || this._defaultOptions.cursorStyle;
+    this._keyAliasMap = mergeKeyAliases(defaultKeyAliases, options.keyAliasMap || {});
+    this._keyBindings = options.keyBindings || [];
+    const mergedBindings = mergeKeyBindings(defaultInputKeybindings, this._keyBindings);
+    this._keyBindingsMap = buildKeyBindingsMap(mergedBindings, this._keyAliasMap);
   }
   updateCursorPosition() {
     if (!this._focused)
@@ -4880,39 +5678,58 @@ class InputRenderable extends Renderable {
   handleKeyPress(key) {
     const keyName = typeof key === "string" ? key : key.name;
     const keySequence = typeof key === "string" ? key : key.sequence;
-    switch (keyName) {
-      case "left":
-        this.cursorPosition = this._cursorPosition - 1;
-        return true;
-      case "right":
-        this.cursorPosition = this._cursorPosition + 1;
-        return true;
-      case "home":
-        this.cursorPosition = 0;
-        return true;
-      case "end":
-        this.cursorPosition = this._value.length;
-        return true;
-      case "backspace":
-        this.deleteCharacter("backward");
-        return true;
-      case "delete":
-        this.deleteCharacter("forward");
+    const keyCtrl = typeof key === "string" ? false : key.ctrl;
+    const keyShift = typeof key === "string" ? false : key.shift;
+    const keyMeta = typeof key === "string" ? false : key.meta;
+    const keySuper = typeof key === "string" ? false : key.super;
+    const keyHyper = typeof key === "string" ? false : key.hyper;
+    const bindingKey = getKeyBindingKey({
+      name: keyName,
+      ctrl: keyCtrl,
+      shift: keyShift,
+      meta: keyMeta,
+      super: keySuper,
+      action: "move-left"
+    });
+    const action = this._keyBindingsMap.get(bindingKey);
+    if (action) {
+      switch (action) {
+        case "move-left":
+          this.cursorPosition = this._cursorPosition - 1;
+          return true;
+        case "move-right":
+          this.cursorPosition = this._cursorPosition + 1;
+          return true;
+        case "move-home":
+          this.cursorPosition = 0;
+          return true;
+        case "move-end":
+          this.cursorPosition = this._value.length;
+          return true;
+        case "delete-backward":
+          this.deleteCharacter("backward");
+          return true;
+        case "delete-forward":
+          this.deleteCharacter("forward");
+          return true;
+        case "submit":
+          if (this._value !== this._lastCommittedValue) {
+            this._lastCommittedValue = this._value;
+            this.emit("change" /* CHANGE */, this._value);
+          }
+          this.emit("enter" /* ENTER */, this._value);
+          return true;
+      }
+    }
+    if (!keyCtrl && !keyMeta && !keySuper && !keyHyper) {
+      if (keyName === "space") {
+        this.insertText(" ");
         return true;
-      case "return":
-      case "linefeed":
-        if (this._value !== this._lastCommittedValue) {
-          this._lastCommittedValue = this._value;
-          this.emit("change" /* CHANGE */, this._value);
-        }
-        this.emit("enter" /* ENTER */, this._value);
+      }
+      if (keySequence && keySequence.length === 1 && keySequence.charCodeAt(0) >= 32 && keySequence.charCodeAt(0) <= 126) {
+        this.insertText(keySequence);
         return true;
-      default:
-        if (keySequence && keySequence.length === 1 && keySequence.charCodeAt(0) >= 32 && keySequence.charCodeAt(0) <= 126) {
-          this.insertText(keySequence);
-          return true;
-        }
-        break;
+      }
     }
     return false;
   }
@@ -4992,6 +5809,16 @@ class InputRenderable extends Renderable {
       this._ctx.setCursorPosition(0, 0, false);
     }
   }
+  set keyBindings(bindings) {
+    this._keyBindings = bindings;
+    const mergedBindings = mergeKeyBindings(defaultInputKeybindings, bindings);
+    this._keyBindingsMap = buildKeyBindingsMap(mergedBindings, this._keyAliasMap);
+  }
+  set keyAliasMap(aliases) {
+    this._keyAliasMap = mergeKeyAliases(defaultKeyAliases, aliases);
+    const mergedBindings = mergeKeyBindings(defaultInputKeybindings, this._keyBindings);
+    this._keyBindingsMap = buildKeyBindingsMap(mergedBindings, this._keyAliasMap);
+  }
 }
 // src/renderables/Slider.ts
 var defaultThumbBackgroundColor = RGBA.fromHex("#9a9ea3");
@@ -5592,7 +6419,7 @@ class ContentRenderable extends BoxRenderable {
   }
   _getVisibleChildren() {
     if (this._viewportCulling) {
-      return getObjectsInViewport(this.viewport, this.getChildrenSortedByPrimaryAxis(), this.primaryAxis).map((child) => child.num);
+      return getObjectsInViewport(this.viewport, this.getChildrenSortedByPrimaryAxis(), this.primaryAxis, 0).map((child) => child.num);
     }
     return this.getChildrenSortedByPrimaryAxis().map((child) => child.num);
   }
@@ -6144,6 +6971,16 @@ class ScrollBoxRenderable extends BoxRenderable {
   }
 }
 // src/renderables/Select.ts
+var defaultSelectKeybindings = [
+  { name: "up", action: "move-up" },
+  { name: "k", action: "move-up" },
+  { name: "down", action: "move-down" },
+  { name: "j", action: "move-down" },
+  { name: "up", shift: true, action: "move-up-fast" },
+  { name: "down", shift: true, action: "move-down-fast" },
+  { name: "return", action: "select-current" },
+  { name: "linefeed", action: "select-current" }
+];
 var SelectRenderableEvents;
 ((SelectRenderableEvents2) => {
   SelectRenderableEvents2["SELECTION_CHANGED"] = "selectionChanged";
@@ -6172,6 +7009,9 @@ class SelectRenderable extends Renderable {
   linesPerItem;
   fontHeight;
   _fastScrollStep;
+  _keyBindingsMap;
+  _keyAliasMap;
+  _keyBindings;
   _defaultOptions = {
     backgroundColor: "transparent",
     textColor: "#FFFFFF",
@@ -6211,6 +7051,10 @@ class SelectRenderable extends Renderable {
     this._descriptionColor = parseColor(options.descriptionColor || this._defaultOptions.descriptionColor);
     this._selectedDescriptionColor = parseColor(options.selectedDescriptionColor || this._defaultOptions.selectedDescriptionColor);
     this._fastScrollStep = options.fastScrollStep || this._defaultOptions.fastScrollStep;
+    this._keyAliasMap = mergeKeyAliases(defaultKeyAliases, options.keyAliasMap || {});
+    this._keyBindings = options.keyBindings || [];
+    const mergedBindings = mergeKeyBindings(defaultSelectKeybindings, this._keyBindings);
+    this._keyBindingsMap = buildKeyBindingsMap(mergedBindings, this._keyAliasMap);
     this.requestRender();
   }
   renderSelf(buffer, deltaTime) {
@@ -6351,20 +7195,37 @@ class SelectRenderable extends Renderable {
   }
   handleKeyPress(key) {
     const keyName = typeof key === "string" ? key : key.name;
-    const isShift = typeof key !== "string" && key.shift;
-    switch (keyName) {
-      case "up":
-      case "k":
-        this.moveUp(isShift ? this._fastScrollStep : 1);
-        return true;
-      case "down":
-      case "j":
-        this.moveDown(isShift ? this._fastScrollStep : 1);
-        return true;
-      case "return":
-      case "linefeed":
-        this.selectCurrent();
-        return true;
+    const keyCtrl = typeof key === "string" ? false : key.ctrl;
+    const keyShift = typeof key === "string" ? false : key.shift;
+    const keyMeta = typeof key === "string" ? false : key.meta;
+    const keySuper = typeof key === "string" ? false : key.super;
+    const bindingKey = getKeyBindingKey({
+      name: keyName,
+      ctrl: keyCtrl,
+      shift: keyShift,
+      meta: keyMeta,
+      super: keySuper,
+      action: "move-up"
+    });
+    const action = this._keyBindingsMap.get(bindingKey);
+    if (action) {
+      switch (action) {
+        case "move-up":
+          this.moveUp(1);
+          return true;
+        case "move-down":
+          this.moveDown(1);
+          return true;
+        case "move-up-fast":
+          this.moveUp(this._fastScrollStep);
+          return true;
+        case "move-down-fast":
+          this.moveDown(this._fastScrollStep);
+          return true;
+        case "select-current":
+          this.selectCurrent();
+          return true;
+      }
     }
     return false;
   }
@@ -6470,6 +7331,16 @@ class SelectRenderable extends Renderable {
   set fastScrollStep(step) {
     this._fastScrollStep = step;
   }
+  set keyBindings(bindings) {
+    this._keyBindings = bindings;
+    const mergedBindings = mergeKeyBindings(defaultSelectKeybindings, bindings);
+    this._keyBindingsMap = buildKeyBindingsMap(mergedBindings, this._keyAliasMap);
+  }
+  set keyAliasMap(aliases) {
+    this._keyAliasMap = mergeKeyAliases(defaultKeyAliases, aliases);
+    const mergedBindings = mergeKeyBindings(defaultSelectKeybindings, this._keyBindings);
+    this._keyBindingsMap = buildKeyBindingsMap(mergedBindings, this._keyAliasMap);
+  }
   set selectedIndex(value) {
     const newIndex = value ?? this._defaultOptions.selectedIndex;
     const clampedIndex = this._options.length > 0 ? Math.min(Math.max(0, newIndex), this._options.length - 1) : 0;
@@ -6481,6 +7352,14 @@ class SelectRenderable extends Renderable {
   }
 }
 // src/renderables/TabSelect.ts
+var defaultTabSelectKeybindings = [
+  { name: "left", action: "move-left" },
+  { name: "[", action: "move-left" },
+  { name: "right", action: "move-right" },
+  { name: "]", action: "move-right" },
+  { name: "return", action: "select-current" },
+  { name: "linefeed", action: "select-current" }
+];
 var TabSelectRenderableEvents;
 ((TabSelectRenderableEvents2) => {
   TabSelectRenderableEvents2["SELECTION_CHANGED"] = "selectionChanged";
@@ -6515,6 +7394,9 @@ class TabSelectRenderable extends Renderable {
   _showDescription;
   _showUnderline;
   _wrapSelection;
+  _keyBindingsMap;
+  _keyAliasMap;
+  _keyBindings;
   constructor(ctx, options) {
     const calculatedHeight = calculateDynamicHeight(options.showUnderline ?? true, options.showDescription ?? true);
     super(ctx, { ...options, height: calculatedHeight, buffered: true });
@@ -6532,6 +7414,10 @@ class TabSelectRenderable extends Renderable {
     this._selectedBackgroundColor = parseColor(options.selectedBackgroundColor || "#334455");
     this._selectedTextColor = parseColor(options.selectedTextColor || "#FFFF00");
     this._selectedDescriptionColor = parseColor(options.selectedDescriptionColor || "#CCCCCC");
+    this._keyAliasMap = mergeKeyAliases(defaultKeyAliases, options.keyAliasMap || {});
+    this._keyBindings = options.keyBindings || [];
+    const mergedBindings = mergeKeyBindings(defaultTabSelectKeybindings, this._keyBindings);
+    this._keyBindingsMap = buildKeyBindingsMap(mergedBindings, this._keyAliasMap);
   }
   calculateDynamicHeight() {
     return calculateDynamicHeight(this._showUnderline, this._showDescription);
@@ -6682,19 +7568,31 @@ class TabSelectRenderable extends Renderable {
   }
   handleKeyPress(key) {
     const keyName = typeof key === "string" ? key : key.name;
-    switch (keyName) {
-      case "left":
-      case "[":
-        this.moveLeft();
-        return true;
-      case "right":
-      case "]":
-        this.moveRight();
-        return true;
-      case "return":
-      case "linefeed":
-        this.selectCurrent();
-        return true;
+    const keyCtrl = typeof key === "string" ? false : key.ctrl;
+    const keyShift = typeof key === "string" ? false : key.shift;
+    const keyMeta = typeof key === "string" ? false : key.meta;
+    const keySuper = typeof key === "string" ? false : key.super;
+    const bindingKey = getKeyBindingKey({
+      name: keyName,
+      ctrl: keyCtrl,
+      shift: keyShift,
+      meta: keyMeta,
+      super: keySuper,
+      action: "move-left"
+    });
+    const action = this._keyBindingsMap.get(bindingKey);
+    if (action) {
+      switch (action) {
+        case "move-left":
+          this.moveLeft();
+          return true;
+        case "move-right":
+          this.moveRight();
+          return true;
+        case "select-current":
+          this.selectCurrent();
+          return true;
+      }
     }
     return false;
   }
@@ -6783,10 +7681,18 @@ class TabSelectRenderable extends Renderable {
     this.updateScrollOffset();
     this.requestRender();
   }
+  set keyBindings(bindings) {
+    this._keyBindings = bindings;
+    const mergedBindings = mergeKeyBindings(defaultTabSelectKeybindings, bindings);
+    this._keyBindingsMap = buildKeyBindingsMap(mergedBindings, this._keyAliasMap);
+  }
+  set keyAliasMap(aliases) {
+    this._keyAliasMap = mergeKeyAliases(defaultKeyAliases, aliases);
+    const mergedBindings = mergeKeyBindings(defaultTabSelectKeybindings, this._keyBindings);
+    this._keyBindingsMap = buildKeyBindingsMap(mergedBindings, this._keyAliasMap);
+  }
 }
 // src/renderables/EditBufferRenderable.ts
-import { MeasureMode as MeasureMode2 } from "bun-yoga";
-
 class EditBufferRenderable extends Renderable {
   _focusable = true;
   selectable = true;
@@ -7086,7 +7992,7 @@ class EditBufferRenderable extends Renderable {
   setupMeasureFunc() {
     const measureFunc = (width, widthMode, height, heightMode) => {
       let effectiveWidth;
-      if (widthMode === MeasureMode2.Undefined || isNaN(width)) {
+      if (widthMode === MeasureMode.Undefined || isNaN(width)) {
         effectiveWidth = 0;
       } else {
         effectiveWidth = width;
@@ -7095,7 +8001,7 @@ class EditBufferRenderable extends Renderable {
       const measureResult = this.editorView.measureForDimensions(Math.floor(effectiveWidth), Math.floor(effectiveHeight));
       const measuredWidth = measureResult ? Math.max(1, measureResult.maxWidth) : 1;
       const measuredHeight = measureResult ? Math.max(1, measureResult.lineCount) : 1;
-      if (widthMode === MeasureMode2.AtMost && this._positionType !== "absolute") {
+      if (widthMode === MeasureMode.AtMost && this._positionType !== "absolute") {
         return {
           width: Math.min(effectiveWidth, measuredWidth),
           height: Math.min(effectiveHeight, measuredHeight)
@@ -7278,31 +8184,6 @@ class EditBufferRenderable extends Renderable {
   }
 }
 
-// src/lib/keymapping.ts
-function mergeKeyBindings(defaults, custom) {
-  const map = new Map;
-  for (const binding of defaults) {
-    const key = getKeyBindingKey(binding);
-    map.set(key, binding);
-  }
-  for (const binding of custom) {
-    const key = getKeyBindingKey(binding);
-    map.set(key, binding);
-  }
-  return Array.from(map.values());
-}
-function getKeyBindingKey(binding) {
-  return `${binding.name}:${binding.ctrl ? 1 : 0}:${binding.shift ? 1 : 0}:${binding.meta ? 1 : 0}:${binding.super ? 1 : 0}`;
-}
-function buildKeyBindingsMap(bindings) {
-  const map = new Map;
-  for (const binding of bindings) {
-    const key = getKeyBindingKey(binding);
-    map.set(key, binding.action);
-  }
-  return map;
-}
-
 // src/renderables/Textarea.ts
 var defaultTextareaKeybindings = [
   { name: "left", action: "move-left" },
@@ -7355,6 +8236,8 @@ class TextareaRenderable extends EditBufferRenderable {
   _focusedBackgroundColor;
   _focusedTextColor;
   _keyBindingsMap;
+  _keyAliasMap;
+  _keyBindings;
   _actionHandlers;
   _initialValueSet = false;
   _submitListener = undefined;
@@ -7378,8 +8261,10 @@ class TextareaRenderable extends EditBufferRenderable {
     this._focusedBackgroundColor = parseColor(options.focusedBackgroundColor || options.backgroundColor || defaults.focusedBackgroundColor);
     this._focusedTextColor = parseColor(options.focusedTextColor || options.textColor || defaults.focusedTextColor);
     this._placeholder = options.placeholder ?? defaults.placeholder;
-    const mergedBindings = mergeKeyBindings(defaultTextareaKeybindings, options.keyBindings || []);
-    this._keyBindingsMap = buildKeyBindingsMap(mergedBindings);
+    this._keyAliasMap = mergeKeyAliases(defaultKeyAliases, options.keyAliasMap || {});
+    this._keyBindings = options.keyBindings || [];
+    const mergedBindings = mergeKeyBindings(defaultTextareaKeybindings, this._keyBindings);
+    this._keyBindingsMap = buildKeyBindingsMap(mergedBindings, this._keyAliasMap);
     this._actionHandlers = this.buildActionHandlers();
     this._submitListener = options.onSubmit;
     if (options.initialValue) {
@@ -7447,6 +8332,7 @@ class TextareaRenderable extends EditBufferRenderable {
     const keyShift = typeof key === "string" ? false : key.shift;
     const keyMeta = typeof key === "string" ? false : key.meta;
     const keySuper = typeof key === "string" ? false : key.super;
+    const keyHyper = typeof key === "string" ? false : key.hyper;
     const bindingKey = getKeyBindingKey({
       name: keyName,
       ctrl: keyCtrl,
@@ -7462,16 +8348,22 @@ class TextareaRenderable extends EditBufferRenderable {
         return handler();
       }
     }
-    if (keySequence && !keyCtrl && !keyMeta) {
-      const firstCharCode = keySequence.charCodeAt(0);
-      if (firstCharCode < 32) {
-        return false;
+    if (!keyCtrl && !keyMeta && !keySuper && !keyHyper) {
+      if (keyName === "space") {
+        this.insertText(" ");
+        return true;
       }
-      if (firstCharCode === 127) {
-        return false;
+      if (keySequence) {
+        const firstCharCode = keySequence.charCodeAt(0);
+        if (firstCharCode < 32) {
+          return false;
+        }
+        if (firstCharCode === 127) {
+          return false;
+        }
+        this.insertText(keySequence);
+        return true;
       }
-      this.insertText(keySequence);
-      return true;
     }
     return false;
   }
@@ -7572,7 +8464,13 @@ class TextareaRenderable extends EditBufferRenderable {
     const select = options?.select ?? false;
     this.updateSelectionForMovement(select, true);
     const cursor = this.editorView.getCursor();
-    this.editBuffer.setCursor(cursor.row, 0);
+    if (cursor.col === 0 && cursor.row > 0) {
+      this.editBuffer.setCursor(cursor.row - 1, 0);
+      const prevLineEol = this.editBuffer.getEOL();
+      this.editBuffer.setCursor(prevLineEol.row, prevLineEol.col);
+    } else {
+      this.editBuffer.setCursor(cursor.row, 0);
+    }
     this.updateSelectionForMovement(select, false);
     this.requestRender();
     return true;
@@ -7580,8 +8478,14 @@ class TextareaRenderable extends EditBufferRenderable {
   gotoLineEnd(options) {
     const select = options?.select ?? false;
     this.updateSelectionForMovement(select, true);
+    const cursor = this.editorView.getCursor();
     const eol = this.editBuffer.getEOL();
-    this.editBuffer.setCursor(eol.row, eol.col);
+    const lineCount = this.editBuffer.getLineCount();
+    if (cursor.col === eol.col && cursor.row < lineCount - 1) {
+      this.editBuffer.setCursor(cursor.row + 1, 0);
+    } else {
+      this.editBuffer.setCursor(eol.row, eol.col);
+    }
     this.updateSelectionForMovement(select, false);
     this.requestRender();
     return true;
@@ -7750,15 +8654,19 @@ class TextareaRenderable extends EditBufferRenderable {
     return this._submitListener;
   }
   set keyBindings(bindings) {
+    this._keyBindings = bindings;
     const mergedBindings = mergeKeyBindings(defaultTextareaKeybindings, bindings);
-    this._keyBindingsMap = buildKeyBindingsMap(mergedBindings);
+    this._keyBindingsMap = buildKeyBindingsMap(mergedBindings, this._keyAliasMap);
+  }
+  set keyAliasMap(aliases) {
+    this._keyAliasMap = mergeKeyAliases(defaultKeyAliases, aliases);
+    const mergedBindings = mergeKeyBindings(defaultTextareaKeybindings, this._keyBindings);
+    this._keyBindingsMap = buildKeyBindingsMap(mergedBindings, this._keyAliasMap);
   }
   get extmarks() {
     return this.editorView.extmarks;
   }
 }
-// src/index.ts
-import * as Yoga from "bun-yoga";
 export {
   yellow,
   wrapWithDelegates,
@@ -7838,6 +8746,7 @@ export {
   convertGlobalToLocalSelection,
   clearEnvCache,
   capture,
+  buildKittyKeyboardFlags,
   brightYellow,
   brightWhite,
   brightRed,
@@ -7868,7 +8777,7 @@ export {
   applyChromaticAberration,
   applyAsciiArt,
   addDefaultParsers,
-  Yoga,
+  exports_src as Yoga,
   VignetteEffect,
   VRenderable,
   TreeSitterClient,
@@ -7946,5 +8855,5 @@ export {
   ASCIIFont
 };
 
-//# debugId=8B540B053341534264756E2164756E21
+//# debugId=23F67606D23EDCE364756E2164756E21
 //# sourceMappingURL=index.js.map