@opentui/core 0.2.5 → 0.2.7

package/{index-3hyr3wkd.js → index-tx8a4862.js}

@@ -184,7 +184,7 @@ import {
   white,
   wrapWithDelegates,
   yellow
-} from "./index-s460mpf9.js";
+} from "./index-t4yn324k.js";
 
 // src/index.ts
 var exports_src2 = {};
@@ -203,6 +203,7 @@ __export(exports_src2, {
   stripAnsiSequences: () => stripAnsiSequences,
   stringToStyledText: () => stringToStyledText,
   strikethrough: () => strikethrough,
+  setupAudio: () => setupAudio,
   setRenderLibPath: () => setRenderLibPath,
   rgbToHex: () => rgbToHex,
   reverse: () => reverse,
@@ -425,6 +426,7 @@ __export(exports_src2, {
   BorderCharArrays: () => BorderCharArrays,
   BloomEffect: () => BloomEffect,
   BaseRenderable: () => BaseRenderable,
+  Audio: () => Audio,
   ArrowRenderable: () => ArrowRenderable,
   ATTRIBUTE_BASE_MASK: () => ATTRIBUTE_BASE_MASK,
   ATTRIBUTE_BASE_BITS: () => ATTRIBUTE_BASE_BITS,
@@ -3020,6 +3022,362 @@ class NativeSpanFeed {
     }
   }
 }
+// src/audio.ts
+import { EventEmitter } from "events";
+import { readFile } from "fs/promises";
+function statusToError(action, status) {
+  return new Error(`Audio ${action} failed: ${status}`);
+}
+function toBytes(data) {
+  return data instanceof Uint8Array ? data : new Uint8Array(data);
+}
+
+class Audio extends EventEmitter {
+  static create(options = {}) {
+    return new Audio(resolveRenderLib(), options);
+  }
+  lib;
+  defaultStartOptions;
+  engine = null;
+  groups = new Map;
+  playbackStarted = false;
+  mixerStarted = false;
+  constructor(lib, options) {
+    super();
+    this.lib = lib;
+    this.defaultStartOptions = options.startOptions;
+    const createOptions = options.sampleRate == null && options.playbackChannels == null ? undefined : {
+      sampleRate: options.sampleRate == null ? undefined : Math.max(0, Math.trunc(options.sampleRate)),
+      playbackChannels: options.playbackChannels == null ? undefined : Math.max(0, Math.trunc(options.playbackChannels))
+    };
+    this.engine = this.lib.createAudioEngine(createOptions);
+    if (!this.engine) {
+      this.emitError("createAudioEngine", undefined, "Audio createAudioEngine returned null");
+      return;
+    }
+    if (options.autoStart ?? false) {
+      this.start(this.defaultStartOptions);
+    }
+  }
+  emitError(action, status, message, cause) {
+    const error = message ? new Error(message) : statusToError(action, status ?? -1);
+    if (cause)
+      error.cause = cause;
+    this.emit("error", error, { action, status });
+  }
+  start(options) {
+    if (this.playbackStarted)
+      return true;
+    const engine2 = this.engine;
+    if (!engine2) {
+      this.emitError("start", undefined, "Audio engine unavailable during start");
+      return false;
+    }
+    const startOptions = options ?? this.defaultStartOptions;
+    const status = this.lib.audioStart(engine2, startOptions);
+    if (status !== 0) {
+      this.emitError("start", status);
+      return false;
+    }
+    this.playbackStarted = true;
+    this.mixerStarted = true;
+    this.emit("started");
+    return true;
+  }
+  startMixer() {
+    if (this.mixerStarted)
+      return true;
+    const engine2 = this.engine;
+    if (!engine2) {
+      this.emitError("startMixer", undefined, "Audio engine unavailable during startMixer");
+      return false;
+    }
+    const status = this.lib.audioStartMixer(engine2);
+    if (status !== 0) {
+      this.emitError("startMixer", status);
+      return false;
+    }
+    this.mixerStarted = true;
+    this.emit("mixerStarted");
+    return true;
+  }
+  stop() {
+    if (!this.mixerStarted)
+      return true;
+    const engine2 = this.engine;
+    if (!engine2) {
+      this.emitError("stop", undefined, "Audio engine unavailable during stop");
+      return false;
+    }
+    const status = this.lib.audioStop(engine2);
+    if (status !== 0) {
+      this.emitError("stop", status);
+      return false;
+    }
+    this.playbackStarted = false;
+    this.mixerStarted = false;
+    this.emit("stopped");
+    return true;
+  }
+  isStarted() {
+    return this.playbackStarted;
+  }
+  isMixerStarted() {
+    return this.mixerStarted;
+  }
+  loadSound(data) {
+    const engine2 = this.engine;
+    if (!engine2) {
+      this.emitError("loadSound", undefined, "Audio engine unavailable during loadSound");
+      return null;
+    }
+    const result = this.lib.audioLoad(engine2, toBytes(data));
+    if (result.status !== 0 || result.soundId == null) {
+      this.emitError("loadSound", result.status);
+      return null;
+    }
+    return result.soundId;
+  }
+  async loadSoundFile(filePath) {
+    const bytes = await readFile(filePath).catch((err) => {
+      this.emitError("loadSoundFile", undefined, `Failed to read file '${filePath}': ${err.message}`, err);
+      return null;
+    });
+    if (bytes == null)
+      return null;
+    return this.loadSound(bytes);
+  }
+  unloadSound(sound) {
+    const engine2 = this.engine;
+    if (!engine2) {
+      this.emitError("unloadSound", undefined, "Audio engine unavailable during unloadSound");
+      return false;
+    }
+    const status = this.lib.audioUnload(engine2, sound);
+    if (status !== 0) {
+      this.emitError("unloadSound", status);
+      return false;
+    }
+    return true;
+  }
+  group(name) {
+    const existing = this.groups.get(name);
+    if (existing != null) {
+      return existing;
+    }
+    const engine2 = this.engine;
+    if (!engine2) {
+      this.emitError("group", undefined, "Audio engine unavailable during group");
+      return null;
+    }
+    const result = this.lib.audioCreateGroup(engine2, name);
+    if (result.status !== 0 || result.groupId == null) {
+      this.emitError("group", result.status);
+      return null;
+    }
+    this.groups.set(name, result.groupId);
+    return result.groupId;
+  }
+  play(sound, options) {
+    const rawOptions = options ? {
+      volume: options.volume,
+      pan: options.pan,
+      loop: options.loop,
+      groupId: options.groupId ?? 0
+    } : undefined;
+    const engine2 = this.engine;
+    if (!engine2) {
+      this.emitError("play", undefined, "Audio engine unavailable during play");
+      return null;
+    }
+    const result = this.lib.audioPlay(engine2, sound, rawOptions);
+    if (result.status !== 0 || result.voiceId == null) {
+      this.emitError("play", result.status);
+      return null;
+    }
+    return result.voiceId;
+  }
+  stopVoice(voice) {
+    const engine2 = this.engine;
+    if (!engine2) {
+      this.emitError("stopVoice", undefined, "Audio engine unavailable during stopVoice");
+      return false;
+    }
+    const status = this.lib.audioStopVoice(engine2, voice);
+    if (status !== 0) {
+      this.emitError("stopVoice", status);
+      return false;
+    }
+    return true;
+  }
+  setVoiceGroup(voice, group) {
+    const engine2 = this.engine;
+    if (!engine2) {
+      this.emitError("setVoiceGroup", undefined, "Audio engine unavailable during setVoiceGroup");
+      return false;
+    }
+    const status = this.lib.audioSetVoiceGroup(engine2, voice, group);
+    if (status !== 0) {
+      this.emitError("setVoiceGroup", status);
+      return false;
+    }
+    return true;
+  }
+  setGroupVolume(group, volume) {
+    const engine2 = this.engine;
+    if (!engine2) {
+      this.emitError("setGroupVolume", undefined, "Audio engine unavailable during setGroupVolume");
+      return false;
+    }
+    const status = this.lib.audioSetGroupVolume(engine2, group, volume);
+    if (status !== 0) {
+      this.emitError("setGroupVolume", status);
+      return false;
+    }
+    return true;
+  }
+  setMasterVolume(volume) {
+    const engine2 = this.engine;
+    if (!engine2) {
+      this.emitError("setMasterVolume", undefined, "Audio engine unavailable during setMasterVolume");
+      return false;
+    }
+    const status = this.lib.audioSetMasterVolume(engine2, volume);
+    if (status !== 0) {
+      this.emitError("setMasterVolume", status);
+      return false;
+    }
+    return true;
+  }
+  mixFrames(frameCount, channels = 2) {
+    const engine2 = this.engine;
+    if (!engine2) {
+      this.emitError("mixFrames", undefined, "Audio engine unavailable during mixFrames");
+      return null;
+    }
+    const output = new Float32Array(frameCount * channels);
+    const status = this.lib.audioMixToBuffer(engine2, output, frameCount, channels);
+    if (status !== 0) {
+      this.emitError("mixFrames", status);
+      return null;
+    }
+    return output;
+  }
+  enableTap(capacityFrames = 8192) {
+    const engine2 = this.engine;
+    if (!engine2) {
+      this.emitError("enableTap", undefined, "Audio engine unavailable during enableTap");
+      return false;
+    }
+    const status = this.lib.audioEnableTap(engine2, true, capacityFrames);
+    if (status !== 0) {
+      this.emitError("enableTap", status);
+      return false;
+    }
+    return true;
+  }
+  disableTap() {
+    const engine2 = this.engine;
+    if (!engine2) {
+      this.emitError("enableTap", undefined, "Audio engine unavailable during disableTap");
+      return false;
+    }
+    const status = this.lib.audioEnableTap(engine2, false, 0);
+    if (status !== 0) {
+      this.emitError("enableTap", status);
+      return false;
+    }
+    return true;
+  }
+  readTapFrames(frameCount, channels = 2) {
+    const engine2 = this.engine;
+    if (!engine2) {
+      this.emitError("readTapFrames", undefined, "Audio engine unavailable during readTapFrames");
+      return null;
+    }
+    const output = new Float32Array(frameCount * channels);
+    const result = this.lib.audioReadTap(engine2, output, frameCount, channels);
+    if (result.status !== 0) {
+      this.emitError("readTapFrames", result.status);
+      return null;
+    }
+    return { frames: output, framesRead: result.framesRead };
+  }
+  listPlaybackDevices() {
+    const engine2 = this.engine;
+    if (!engine2) {
+      this.emitError("listPlaybackDevices", undefined, "Audio engine unavailable during listPlaybackDevices");
+      return null;
+    }
+    const refreshStatus = this.lib.audioRefreshPlaybackDevices(engine2);
+    if (refreshStatus !== 0) {
+      this.emitError("listPlaybackDevices", refreshStatus);
+      return null;
+    }
+    const count = this.lib.audioGetPlaybackDeviceCount(engine2);
+    const devices = [];
+    for (let index = 0;index < count; index += 1) {
+      devices.push({
+        index,
+        name: this.lib.audioGetPlaybackDeviceName(engine2, index),
+        isDefault: this.lib.audioIsPlaybackDeviceDefault(engine2, index)
+      });
+    }
+    return devices;
+  }
+  selectPlaybackDevice(index) {
+    const engine2 = this.engine;
+    if (!engine2) {
+      this.emitError("selectPlaybackDevice", undefined, "Audio engine unavailable during selectPlaybackDevice");
+      return false;
+    }
+    const refreshStatus = this.lib.audioRefreshPlaybackDevices(engine2);
+    if (refreshStatus !== 0) {
+      this.emitError("selectPlaybackDevice", refreshStatus);
+      return false;
+    }
+    const status = this.lib.audioSelectPlaybackDevice(engine2, index);
+    if (status !== 0) {
+      this.emitError("selectPlaybackDevice", status);
+      return false;
+    }
+    return true;
+  }
+  clearPlaybackDeviceSelection() {
+    const engine2 = this.engine;
+    if (!engine2) {
+      this.emitError("clearPlaybackDeviceSelection", undefined, "Audio engine unavailable during clearPlaybackDeviceSelection");
+      return;
+    }
+    this.lib.audioClearPlaybackDeviceSelection(engine2);
+  }
+  getStats() {
+    const engine2 = this.engine;
+    if (!engine2) {
+      this.emitError("getStats", undefined, "Audio engine unavailable during getStats");
+      return null;
+    }
+    const stats = this.lib.audioGetStats(engine2);
+    if (stats == null) {
+      this.emitError("getStats", undefined, "Failed to retrieve audio stats");
+    }
+    return stats;
+  }
+  dispose() {
+    if (!this.engine)
+      return;
+    if (this.mixerStarted) {
+      this.stop();
+    }
+    this.groups.clear();
+    this.lib.destroyAudioEngine(this.engine);
+    this.engine = null;
+    this.emit("disposed");
+  }
+}
+function setupAudio(options = {}) {
+  return Audio.create(options);
+}
 // src/renderables/FrameBuffer.ts
 class FrameBufferRenderable extends Renderable {
   frameBuffer;
@@ -5588,7 +5946,8 @@ class TextTableRenderable extends Renderable {
   _wrapMode;
   _columnWidthMode;
   _columnFitter;
-  _cellPadding;
+  _cellPaddingX;
+  _cellPaddingY;
   _columnGap;
   _showBorders;
   _border;
@@ -5620,6 +5979,8 @@ class TextTableRenderable extends Renderable {
     columnWidthMode: "full",
     columnFitter: "proportional",
     cellPadding: 0,
+    cellPaddingX: undefined,
+    cellPaddingY: undefined,
     columnGap: 0,
     showBorders: true,
     border: true,
@@ -5641,7 +6002,8 @@ class TextTableRenderable extends Renderable {
     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._cellPaddingX = this.resolveCellPadding(options.cellPaddingX ?? options.cellPadding);
+    this._cellPaddingY = this.resolveCellPadding(options.cellPaddingY ?? options.cellPadding);
     this._columnGap = this.resolveColumnGap(options.columnGap);
     this._showBorders = options.showBorders ?? this._defaultOptions.showBorders;
     this._border = options.border ?? this._defaultOptions.border;
@@ -5701,13 +6063,34 @@ class TextTableRenderable extends Renderable {
     this.invalidateLayoutAndRaster();
   }
   get cellPadding() {
-    return this._cellPadding;
+    return this._cellPaddingX === this._cellPaddingY ? this._cellPaddingX : 0;
   }
   set cellPadding(value) {
     const next = this.resolveCellPadding(value);
-    if (this._cellPadding === next)
+    if (this._cellPaddingX === next && this._cellPaddingY === next)
+      return;
+    this._cellPaddingX = next;
+    this._cellPaddingY = next;
+    this.invalidateLayoutAndRaster();
+  }
+  get cellPaddingX() {
+    return this._cellPaddingX;
+  }
+  set cellPaddingX(value) {
+    const next = this.resolveCellPadding(value);
+    if (this._cellPaddingX === next)
       return;
-    this._cellPadding = next;
+    this._cellPaddingX = next;
+    this.invalidateLayoutAndRaster();
+  }
+  get cellPaddingY() {
+    return this._cellPaddingY;
+  }
+  set cellPaddingY(value) {
+    const next = this.resolveCellPadding(value);
+    if (this._cellPaddingY === next)
+      return;
+    this._cellPaddingY = next;
     this.invalidateLayoutAndRaster();
   }
   get columnGap() {
@@ -6329,14 +6712,15 @@ class TextTableRenderable extends Renderable {
   drawCellRange(buffer, firstRow, lastRow) {
     const colOffsets = this._layout.columnOffsets;
     const rowOffsets = this._layout.rowOffsets;
-    const cellPadding = this._cellPadding;
+    const cellPaddingX = this._cellPaddingX;
+    const cellPaddingY = this._cellPaddingY;
     for (let rowIdx = firstRow;rowIdx <= lastRow; rowIdx++) {
-      const cellY = (rowOffsets[rowIdx] ?? 0) + 1 + cellPadding;
+      const cellY = (rowOffsets[rowIdx] ?? 0) + 1 + cellPaddingY;
       for (let colIdx = 0;colIdx < this._columnCount; colIdx++) {
         const cell = this._cells[rowIdx]?.[colIdx];
         if (!cell)
           continue;
-        buffer.drawTextBuffer(cell.textBufferView, (colOffsets[colIdx] ?? 0) + 1 + cellPadding, cellY);
+        buffer.drawTextBuffer(cell.textBufferView, (colOffsets[colIdx] ?? 0) + 1 + cellPaddingX, cellY);
       }
     }
   }
@@ -6431,7 +6815,7 @@ class TextTableRenderable extends Renderable {
         this.resetRowSelection(rowIdx);
         continue;
       }
-      const cellTop = (this._layout.rowOffsets[rowIdx] ?? 0) + 1 + this._cellPadding;
+      const cellTop = (this._layout.rowOffsets[rowIdx] ?? 0) + 1 + this._cellPaddingY;
       for (let colIdx = 0;colIdx < this._columnCount; colIdx++) {
         const cell = this._cells[rowIdx]?.[colIdx];
         if (!cell)
@@ -6440,7 +6824,7 @@ class TextTableRenderable extends Renderable {
           cell.textBufferView.resetLocalSelection();
           continue;
         }
-        const cellLeft = (this._layout.columnOffsets[colIdx] ?? 0) + 1 + this._cellPadding;
+        const cellLeft = (this._layout.columnOffsets[colIdx] ?? 0) + 1 + this._cellPaddingX;
         let coords = {
           anchorX: localSelection.anchorX - cellLeft,
           anchorY: localSelection.anchorY - cellTop,
@@ -6586,10 +6970,10 @@ class TextTableRenderable extends Renderable {
     return;
   }
   getHorizontalCellPadding() {
-    return this._cellPadding * 2;
+    return this._cellPaddingX * 2;
   }
   getVerticalCellPadding() {
-    return this._cellPadding * 2;
+    return this._cellPaddingY * 2;
   }
   resolveColumnFitter(value) {
     if (value === undefined) {
@@ -8078,6 +8462,28 @@ class MarkdownRenderable extends Renderable {
     this._tableOptions = value;
     this.applyTableOptionsToBlocks();
   }
+  get renderNode() {
+    return this._renderNode;
+  }
+  set renderNode(value) {
+    if (this._renderNode === value)
+      return;
+    this._renderNode = value;
+    this.clearBlockStates();
+    this._parseState = null;
+    this.updateBlocks(true);
+    this.requestRender();
+  }
+  get internalBlockMode() {
+    return this._internalBlockMode;
+  }
+  set internalBlockMode(value) {
+    if (this._internalBlockMode === value)
+      return;
+    this._internalBlockMode = value;
+    this.updateBlocks(true);
+    this.requestRender();
+  }
   getStyle(group) {
     if (!this._syntaxStyle)
       return;
@@ -8234,7 +8640,7 @@ class MarkdownRenderable extends Renderable {
     renderable.marginTop = marginTop;
     renderable.marginBottom = marginBottom;
   }
-  createMarkdownCodeRenderable(content, id, marginBottom = 0) {
+  createMarkdownCodeRenderable(content, id, marginBottom = 0, onChunks = this._linkifyMarkdownChunks, baseHighlight) {
     return new CodeRenderable(this.ctx, {
       id,
       content,
@@ -8245,12 +8651,43 @@ class MarkdownRenderable extends Renderable {
       conceal: this._conceal,
       drawUnstyledText: false,
       streaming: true,
-      onChunks: this._linkifyMarkdownChunks,
+      baseHighlight,
+      onChunks,
       treeSitterClient: this._treeSitterClient,
       width: "100%",
       marginBottom
     });
   }
+  getBlockquoteContent(token) {
+    return "text" in token && typeof token.text === "string" && token.text ? token.text : " ";
+  }
+  getBlockquoteBorderColor() {
+    return this.getStyle("conceal")?.fg ?? this.getStyle("default")?.fg ?? this._fg ?? "#FFFFFF";
+  }
+  createBlockquoteRenderable(token, id, marginBottom = 0) {
+    const renderable = new BoxRenderable(this.ctx, {
+      id,
+      width: "100%",
+      border: ["left"],
+      borderColor: this.getBlockquoteBorderColor(),
+      paddingLeft: 1,
+      flexShrink: 0,
+      marginBottom
+    });
+    renderable.add(this.createMarkdownCodeRenderable(this.getBlockquoteContent(token), `${id}-content`, 0, this._linkifyMarkdownChunks, "markup.quote"));
+    return renderable;
+  }
+  createHorizontalRuleRenderable(id, marginBottom = 0) {
+    return new BoxRenderable(this.ctx, {
+      id,
+      width: "100%",
+      height: 1,
+      border: ["top"],
+      borderColor: this.getStyle("conceal")?.fg ?? this._fg ?? "#888888",
+      flexShrink: 0,
+      marginBottom
+    });
+  }
   createCodeRenderable(token, id, marginBottom = 0) {
     return new CodeRenderable(this.ctx, {
       id,
@@ -8267,7 +8704,7 @@ class MarkdownRenderable extends Renderable {
       marginBottom
     });
   }
-  applyMarkdownCodeRenderable(renderable, content, marginBottom) {
+  applyMarkdownCodeRenderable(renderable, content, marginBottom, baseHighlight) {
     renderable.content = content;
     renderable.filetype = "markdown";
     renderable.syntaxStyle = this._syntaxStyle;
@@ -8276,9 +8713,27 @@ class MarkdownRenderable extends Renderable {
     renderable.conceal = this._conceal;
     renderable.drawUnstyledText = false;
     renderable.streaming = true;
+    renderable.baseHighlight = baseHighlight;
     renderable.marginBottom = marginBottom;
   }
+  applyBlockquoteRenderable(renderable, token, marginBottom) {
+    if (!(renderable instanceof BoxRenderable))
+      return;
+    renderable.borderColor = this.getBlockquoteBorderColor();
+    renderable.marginBottom = marginBottom;
+    const child = renderable.getChildren()[0];
+    if (child instanceof CodeRenderable) {
+      this.applyMarkdownCodeRenderable(child, this.getBlockquoteContent(token), 0, "markup.quote");
+      return;
+    }
+    for (const existing of renderable.getChildren()) {
+      existing.destroyRecursively();
+    }
+    renderable.add(this.createMarkdownCodeRenderable(this.getBlockquoteContent(token), `${renderable.id}-content`, 0, this._linkifyMarkdownChunks, "markup.quote"));
+  }
   applyCodeBlockRenderable(renderable, token, marginBottom) {
+    if (!(renderable instanceof CodeRenderable))
+      return;
     renderable.content = token.text;
     renderable.filetype = infoStringToFiletype(token.lang ?? "");
     renderable.syntaxStyle = this._syntaxStyle;
@@ -8290,7 +8745,7 @@ class MarkdownRenderable extends Renderable {
     renderable.marginBottom = marginBottom;
   }
   shouldRenderSeparately(token) {
-    return token.type === "code" || token.type === "table" || token.type === "blockquote";
+    return token.type === "code" || token.type === "table" || token.type === "blockquote" || token.type === "hr";
   }
   getInterBlockMargin(token, hasNextToken) {
     if (!hasNextToken)
@@ -8363,7 +8818,8 @@ class MarkdownRenderable extends Renderable {
         continue;
       }
       const prev = blocks[blocks.length - 1];
-      const marginTop = prev && (this.shouldRenderSeparately(prev.token) || TRAILING_MARKDOWN_BLOCK_BREAKS_RE.test(prev.token.raw + gapBefore)) ? 1 : 0;
+      const separated = prev ? TRAILING_MARKDOWN_BLOCK_BREAKS_RE.test(prev.token.raw + gapBefore) : false;
+      const marginTop = prev && this.shouldAddTopLevelMargin(prev.token, token, separated) ? 1 : 0;
       blocks.push({
         token,
         sourceTokenEnd: i + 1,
@@ -8373,6 +8829,15 @@ class MarkdownRenderable extends Renderable {
     }
     return blocks;
   }
+  shouldAddTopLevelMargin(prev, current, separated) {
+    if (current.type === "heading" || prev.type === "heading")
+      return true;
+    if (current.type === "list")
+      return separated;
+    if (this.shouldRenderSeparately(prev) || this.shouldRenderSeparately(current))
+      return true;
+    return separated && prev.type === "paragraph" && current.type === "paragraph";
+  }
   getTableRowsToRender(table) {
     return table.rows;
   }
@@ -8516,6 +8981,8 @@ class MarkdownRenderable extends Renderable {
       columnFitter: this._tableOptions?.columnFitter ?? "proportional",
       wrapMode: this._tableOptions?.wrapMode ?? "word",
       cellPadding: this._tableOptions?.cellPadding ?? 0,
+      cellPaddingX: this._tableOptions?.cellPaddingX ?? this._tableOptions?.cellPadding ?? 0,
+      cellPaddingY: this._tableOptions?.cellPaddingY ?? this._tableOptions?.cellPadding ?? 0,
       columnGap: this.usesBorderlessColumnSpacing() ? 2 : 0,
       border: borders,
       outerBorder: this._tableOptions?.outerBorder ?? borders,
@@ -8529,7 +8996,8 @@ class MarkdownRenderable extends Renderable {
     tableRenderable.columnWidthMode = options.columnWidthMode;
     tableRenderable.columnFitter = options.columnFitter;
     tableRenderable.wrapMode = options.wrapMode;
-    tableRenderable.cellPadding = options.cellPadding;
+    tableRenderable.cellPaddingX = options.cellPaddingX;
+    tableRenderable.cellPaddingY = options.cellPaddingY;
     tableRenderable.columnGap = options.columnGap;
     tableRenderable.border = options.border;
     tableRenderable.outerBorder = options.outerBorder;
@@ -8562,6 +9030,8 @@ class MarkdownRenderable extends Renderable {
       columnFitter: options.columnFitter,
       wrapMode: options.wrapMode,
       cellPadding: options.cellPadding,
+      cellPaddingX: options.cellPaddingX,
+      cellPaddingY: options.cellPaddingY,
       columnGap: options.columnGap,
       border: options.border,
       outerBorder: options.outerBorder,
@@ -8622,6 +9092,16 @@ class MarkdownRenderable extends Renderable {
       next.renderable.marginTop = marginTop;
       return next;
     }
+    if (token.type === "blockquote") {
+      const renderable2 = this.createBlockquoteRenderable(token, id);
+      renderable2.marginTop = marginTop;
+      return { renderable: renderable2 };
+    }
+    if (token.type === "hr") {
+      const renderable2 = this.createHorizontalRuleRenderable(id);
+      renderable2.marginTop = marginTop;
+      return { renderable: renderable2 };
+    }
     const markdownRaw = this.getTopLevelBlockRaw(token);
     if (!markdownRaw) {
       return { renderable: undefined };
@@ -8647,7 +9127,8 @@ class MarkdownRenderable extends Renderable {
     };
     const custom = this._renderNode(block.token, context);
     if (custom) {
-      this.applyMargins(custom, block.marginTop, 0);
+      const marginTop = typeof custom.marginTop === "number" ? Math.max(custom.marginTop, block.marginTop) : block.marginTop;
+      this.applyMargins(custom, marginTop, 0);
       return { renderable: custom };
     }
     return next ?? this.createTopLevelDefaultRenderable(block, index);
@@ -8658,6 +9139,12 @@ class MarkdownRenderable extends Renderable {
     if (token.type === "code") {
       return this.createCodeRenderable(token, id, marginBottom);
     }
+    if (token.type === "blockquote") {
+      return this.createBlockquoteRenderable(token, id, marginBottom);
+    }
+    if (token.type === "hr") {
+      return this.createHorizontalRuleRenderable(id, marginBottom);
+    }
     if (token.type === "table") {
       return this.createTableBlock(token, id, marginBottom).renderable;
     }
@@ -8675,6 +9162,14 @@ class MarkdownRenderable extends Renderable {
       this.applyCodeBlockRenderable(state.renderable, token, marginBottom);
       return;
     }
+    if (token.type === "blockquote") {
+      this.applyBlockquoteRenderable(state.renderable, token, marginBottom);
+      return;
+    }
+    if (token.type === "hr") {
+      state.renderable.marginBottom = marginBottom;
+      return;
+    }
     if (token.type === "table") {
       const tableToken = token;
       const { cache, changed } = this.buildTableContentCache(tableToken, state.tableContentCache);
@@ -8708,11 +9203,11 @@ class MarkdownRenderable extends Renderable {
       return;
     }
     if (state.renderable instanceof CodeRenderable) {
-      this.applyMarkdownCodeRenderable(state.renderable, token.raw, marginBottom);
+      this.applyMarkdownCodeRenderable(state.renderable, this.getTopLevelBlockRaw(token) ?? token.raw, marginBottom);
       return;
     }
     state.renderable.destroyRecursively();
-    const markdownRenderable = this.createMarkdownCodeRenderable(token.raw, `${this.id}-block-${index}`, marginBottom);
+    const markdownRenderable = this.createMarkdownCodeRenderable(this.getTopLevelBlockRaw(token) ?? token.raw, `${this.id}-block-${index}`, marginBottom);
     this.add(markdownRenderable);
     state.renderable = markdownRenderable;
   }
@@ -8739,6 +9234,16 @@ class MarkdownRenderable extends Renderable {
         blockIndex++;
         continue;
       }
+      if (existing && !forceTableRefresh && !this._renderNode && existing.token.type === block.token.type && this.canUpdateBlockRenderable(existing.renderable, block.token)) {
+        this.updateBlockRenderable(existing, block.token, blockIndex, blockIndex < blocks.length - 1);
+        existing.renderable.marginBottom = 0;
+        if (existing.marginTop !== block.marginTop) {
+          this.applyMargins(existing.renderable, block.marginTop, 0);
+        }
+        this.syncTopLevelBlockState(existing, block);
+        blockIndex++;
+        continue;
+      }
       if (existing) {
         existing.renderable.destroyRecursively();
       }
@@ -8760,6 +9265,17 @@ class MarkdownRenderable extends Renderable {
       removed.renderable.destroyRecursively();
     }
   }
+  canUpdateBlockRenderable(renderable, token) {
+    if (token.type === "code")
+      return renderable instanceof CodeRenderable;
+    if (token.type === "table")
+      return renderable instanceof TextTableRenderable;
+    if (token.type === "blockquote")
+      return renderable instanceof BoxRenderable;
+    if (token.type === "hr")
+      return renderable instanceof BoxRenderable;
+    return renderable instanceof CodeRenderable;
+  }
   updateBlocks(forceTableRefresh = false) {
     if (this.isDestroyed)
       return;
@@ -8891,6 +9407,14 @@ class MarkdownRenderable extends Renderable {
         this.applyCodeBlockRenderable(state.renderable, state.token, marginBottom);
         continue;
       }
+      if (state.token.type === "blockquote") {
+        this.applyBlockquoteRenderable(state.renderable, state.token, marginBottom);
+        continue;
+      }
+      if (state.token.type === "hr") {
+        state.renderable.marginBottom = marginBottom;
+        continue;
+      }
       if (state.token.type === "table") {
         const tableToken = state.token;
         const { cache } = this.buildTableContentCache(tableToken, state.tableContentCache, true);
@@ -8921,11 +9445,11 @@ class MarkdownRenderable extends Renderable {
         continue;
       }
       if (state.renderable instanceof CodeRenderable) {
-        this.applyMarkdownCodeRenderable(state.renderable, state.token.raw, marginBottom);
+        this.applyMarkdownCodeRenderable(state.renderable, this.getTopLevelBlockRaw(state.token) ?? state.token.raw, marginBottom);
         continue;
       }
       state.renderable.destroyRecursively();
-      const markdownRenderable = this.createMarkdownCodeRenderable(state.token.raw, `${this.id}-block-${i}`, marginBottom);
+      const markdownRenderable = this.createMarkdownCodeRenderable(this.getTopLevelBlockRaw(state.token) ?? state.token.raw, `${this.id}-block-${i}`, marginBottom);
       this.add(markdownRenderable);
       state.renderable = markdownRenderable;
     }
@@ -10988,7 +11512,7 @@ class TimeToFirstDrawRenderable extends Renderable {
     return Math.max(0, Math.floor(value));
   }
 }
-export { DistortionEffect, VignetteEffect, CloudsEffect, FlamesEffect, CRTRollingBarEffect, RainbowTextEffect, applyScanlines, applyInvert, applyNoise, applyChromaticAberration, applyAsciiArt, applyBrightness, applyGain, applySaturation, BloomEffect, SEPIA_MATRIX, PROTANOPIA_SIM_MATRIX, DEUTERANOPIA_SIM_MATRIX, TRITANOPIA_SIM_MATRIX, ACHROMATOPSIA_MATRIX, PROTANOPIA_COMP_MATRIX, DEUTERANOPIA_COMP_MATRIX, TRITANOPIA_COMP_MATRIX, TECHNICOLOR_MATRIX, SOLARIZATION_MATRIX, SYNTHWAVE_MATRIX, GREENSCALE_MATRIX, GRAYSCALE_MATRIX, INVERT_MATRIX, Timeline, engine, createTimeline, SlotRegistry, createSlotRegistry, createCoreSlotRegistry, registerCorePlugin, resolveCoreSlot, SlotRenderable, NativeSpanFeed, FrameBufferRenderable, ASCIIFontRenderable, Generic, Box, Text, ASCIIFont, Input, Select, TabSelect, FrameBuffer, Code, ScrollBox, vstyles, VRenderable, LineNumberRenderable, DiffRenderable, defaultTextareaKeyBindings, TextareaRenderable, InputRenderableEvents, InputRenderable, TextTableRenderable, MarkdownRenderable, SliderRenderable, ScrollBarRenderable, ArrowRenderable, ScrollBoxRenderable, SelectRenderableEvents, SelectRenderable, TabSelectRenderableEvents, TabSelectRenderable, TimeToFirstDrawRenderable, exports_src2 as exports_src };
+export { DistortionEffect, VignetteEffect, CloudsEffect, FlamesEffect, CRTRollingBarEffect, RainbowTextEffect, applyScanlines, applyInvert, applyNoise, applyChromaticAberration, applyAsciiArt, applyBrightness, applyGain, applySaturation, BloomEffect, SEPIA_MATRIX, PROTANOPIA_SIM_MATRIX, DEUTERANOPIA_SIM_MATRIX, TRITANOPIA_SIM_MATRIX, ACHROMATOPSIA_MATRIX, PROTANOPIA_COMP_MATRIX, DEUTERANOPIA_COMP_MATRIX, TRITANOPIA_COMP_MATRIX, TECHNICOLOR_MATRIX, SOLARIZATION_MATRIX, SYNTHWAVE_MATRIX, GREENSCALE_MATRIX, GRAYSCALE_MATRIX, INVERT_MATRIX, Timeline, engine, createTimeline, SlotRegistry, createSlotRegistry, createCoreSlotRegistry, registerCorePlugin, resolveCoreSlot, SlotRenderable, NativeSpanFeed, Audio, setupAudio, FrameBufferRenderable, ASCIIFontRenderable, Generic, Box, Text, ASCIIFont, Input, Select, TabSelect, FrameBuffer, Code, ScrollBox, vstyles, VRenderable, LineNumberRenderable, DiffRenderable, defaultTextareaKeyBindings, TextareaRenderable, InputRenderableEvents, InputRenderable, TextTableRenderable, MarkdownRenderable, SliderRenderable, ScrollBarRenderable, ArrowRenderable, ScrollBoxRenderable, SelectRenderableEvents, SelectRenderable, TabSelectRenderableEvents, TabSelectRenderable, TimeToFirstDrawRenderable, exports_src2 as exports_src };
 
-//# debugId=4A8BA0B5BE8B6F0464756E2164756E21
-//# sourceMappingURL=index-3hyr3wkd.js.map
+//# debugId=38C52BEFC4FA5FFE64756E2164756E21
+//# sourceMappingURL=index-tx8a4862.js.map