@xterm/xterm 5.6.0-beta.98 → 6.0.0

package/package.json

@@ -1,13 +1,16 @@
 {
   "name": "@xterm/xterm",
   "description": "Full xterm terminal, in your browser",
-  "version": "5.6.0-beta.98",
+  "version": "6.0.0",
   "main": "lib/xterm.js",
   "module": "lib/xterm.mjs",
   "style": "css/xterm.css",
   "types": "typings/xterm.d.ts",
   "repository": "https://github.com/xtermjs/xterm.js",
   "license": "MIT",
+  "workspaces": [
+    "addons/*"
+  ],
   "keywords": [
     "cli",
     "command-line",
@@ -25,8 +28,6 @@
   ],
   "scripts": {
     "setup": "npm run build",
-    "presetup": "npm run install-addons",
-    "install-addons": "node ./bin/install-addons.js",
     "start": "node demo/start",
     "build": "npm run tsc",
     "watch": "npm run tsc-watch",
@@ -42,6 +43,7 @@
     "test": "npm run test-unit",
     "posttest": "npm run lint",
     "lint": "eslint -c .eslintrc.json --max-warnings 0 --ext .ts src/ addons/",
+    "lint-fix": "eslint -c .eslintrc.json --fix --ext .ts src/ addons/",
     "lint-api": "eslint --no-eslintrc -c .eslintrc.json.typings --max-warnings 0 --no-ignore --ext .d.ts typings/",
     "test-unit": "node ./bin/test_unit.js",
     "test-unit-coverage": "node ./bin/test_unit.js --coverage",
@@ -73,7 +75,6 @@
     "@types/deep-equal": "^1.0.1",
     "@types/express": "4",
     "@types/express-ws": "^3.0.1",
-    "@types/glob": "^7.2.0",
     "@types/jsdom": "^16.2.13",
     "@types/mocha": "^9.0.0",
     "@types/node": "^18.16.0",
@@ -86,12 +87,11 @@
     "chai": "^4.3.4",
     "cross-env": "^7.0.3",
     "deep-equal": "^2.0.5",
-    "esbuild": "^0.23.0",
+    "esbuild": "~0.25.2",
     "eslint": "^8.56.0",
     "eslint-plugin-jsdoc": "^46.9.1",
     "express": "^4.19.2",
     "express-ws": "^5.0.2",
-    "glob": "^7.2.0",
     "jsdom": "^18.0.1",
     "mocha": "^10.1.0",
     "mustache": "^4.2.0",
@@ -107,5 +107,5 @@
     "ws": "^8.2.3",
     "xterm-benchmark": "^0.3.1"
   },
-  "commit": "2042bb85023714e55c0c2e986b5000e33b17c414"
+  "commit": "f447274f430fd22513f6adbf9862d19524471c04"
 }

package/src/browser/AccessibilityManager.ts

@@ -185,7 +185,7 @@ export class AccessibilityManager extends Disposable {
       const element = this._rowElements[i];
       if (element) {
         if (lineData.length === 0) {
-          element.innerText = '\u00a0';
+          element.textContent = '\u00a0';
           this._rowColumns.set(element, [0, 1]);
         } else {
           element.textContent = lineData;

package/src/browser/CoreBrowserTerminal.ts

@@ -532,7 +532,13 @@ export class CoreBrowserTerminal extends CoreTerminal implements ITerminal {
       this.textarea!.focus();
       this.textarea!.select();
     }));
-    this._register(this._onScroll.event(() => this._selectionService!.refresh()));
+    this._register(Event.any(
+      this._onScroll.event,
+      this._inputHandler.onScroll
+    )(() => {
+      this._selectionService!.refresh();
+      this._viewport?.queueSync();
+    }));
 
     this._register(this._instantiationService.createInstance(BufferDecorationRenderer, this.screenElement));
     this._register(addDisposableListener(this.element, 'mousedown', (e: MouseEvent) => this._selectionService!.handleMouseDown(e)));
@@ -640,6 +646,14 @@ export class CoreBrowserTerminal extends CoreTerminal implements ITerminal {
           if (deltaY === 0) {
             return false;
           }
+          const lines = self.coreMouseService.consumeWheelEvent(
+            ev as WheelEvent,
+            self._renderService?.dimensions?.device?.cell?.height,
+            self._coreBrowserService?.dpr
+          );
+          if (lines === 0) {
+            return false;
+          }
           action = deltaY < 0 ? CoreMouseAction.UP : CoreMouseAction.DOWN;
           but = CoreMouseButton.WHEEL;
           break;
@@ -811,6 +825,15 @@ export class CoreBrowserTerminal extends CoreTerminal implements ITerminal {
           return false;
         }
 
+        const lines = self.coreMouseService.consumeWheelEvent(
+          ev as WheelEvent,
+          self._renderService?.dimensions?.device?.cell?.height,
+          self._coreBrowserService?.dpr
+        );
+        if (lines === 0) {
+          return this.cancel(ev, true);
+        }
+
         // Construct and send sequences
         const sequence = C0.ESC + (this.coreService.decPrivateModes.applicationCursorKeys ? 'O' : '[') + (ev.deltaY < 0 ? 'A' : 'B');
         this.coreService.triggerDataEvent(sequence, true);

package/src/browser/TimeBasedDebouncer.ts

@@ -45,7 +45,7 @@ export class TimeBasedDebouncer implements IRenderDebouncer {
 
     // Only refresh if the time since last refresh is above a threshold, otherwise wait for
     // enough time to pass before refreshing again.
-    const refreshRequestTime: number = Date.now();
+    const refreshRequestTime: number = performance.now();
     if (refreshRequestTime - this._lastRefreshMs >= this._debounceThresholdMS) {
       // Enough time has lapsed since the last refresh; refresh immediately
       this._lastRefreshMs = refreshRequestTime;
@@ -57,7 +57,7 @@ export class TimeBasedDebouncer implements IRenderDebouncer {
       this._additionalRefreshRequested = true;
 
       this._refreshTimeoutID = window.setTimeout(() => {
-        this._lastRefreshMs = Date.now();
+        this._lastRefreshMs = performance.now();
         this._innerRefresh();
         this._additionalRefreshRequested = false;
         this._refreshTimeoutID = undefined; // No longer need to clear the timeout

package/src/browser/Viewport.ts

@@ -93,8 +93,13 @@ export class Viewport extends Disposable {
       ].join('\n');
     }));
 
-    this._register(this._bufferService.onResize(() => this._queueSync()));
-    this._register(this._bufferService.buffers.onBufferActivate(() => this._queueSync()));
+    this._register(this._bufferService.onResize(() => this.queueSync()));
+    this._register(this._bufferService.buffers.onBufferActivate(() => {
+      // Reset _latestYDisp when switching buffers to prevent stale scroll position
+      // from alt buffer contaminating normal buffer scroll position
+      this._latestYDisp = undefined;
+      this.queueSync();
+    }));
     this._register(this._bufferService.onScroll(() => this._sync()));
 
     this._register(this._scrollableElement.onScroll(e => this._handleScroll(e)));
@@ -126,7 +131,7 @@ export class Viewport extends Disposable {
     };
   }
 
-  private _queueSync(ydisp?: number): void {
+  public queueSync(ydisp?: number): void {
     // Update state
     if (ydisp !== undefined) {
       this._latestYDisp = ydisp;
@@ -157,7 +162,7 @@ export class Viewport extends Disposable {
     });
     this._suppressOnScrollHandler = false;
 
-    // If ydisp has been changed by some other copmonent (input/buffer), then stop animating smooth
+    // If ydisp has been changed by some other component (input/buffer), then stop animating smooth
     // scroll and scroll there immediately.
     if (ydisp !== this._latestYDisp) {
       this._scrollableElement.setScrollPosition({

package/src/browser/input/MoveToCell.ts

@@ -199,7 +199,9 @@ function bufferLine(
   let currentRow = startRow;
   let bufferStr = '';
 
-  while (currentCol !== endCol || currentRow !== endRow) {
+  while ((currentCol !== endCol || currentRow !== endRow) &&
+         currentRow >= 0 &&
+         currentRow < bufferService.buffer.lines.length) {
     currentCol += forward ? 1 : -1;
 
     if (forward && currentCol > bufferService.cols - 1) {

package/src/browser/public/Terminal.ts

@@ -123,6 +123,7 @@ export class Terminal extends Disposable implements ITerminalApi {
       originMode: m.origin,
       reverseWraparoundMode: m.reverseWraparound,
       sendFocusMode: m.sendFocus,
+      synchronizedOutputMode: m.synchronizedOutput,
       wraparoundMode: m.wraparound
     };
   }

package/src/browser/services/RenderService.ts

@@ -9,7 +9,7 @@ import { IRenderDimensions, IRenderer } from 'browser/renderer/shared/Types';
 import { ICharSizeService, ICoreBrowserService, IRenderService, IThemeService } from 'browser/services/Services';
 import { Disposable, MutableDisposable, toDisposable } from 'vs/base/common/lifecycle';
 import { DebouncedIdleTask } from 'common/TaskQueue';
-import { IBufferService, IDecorationService, IOptionsService } from 'common/services/Services';
+import { IBufferService, ICoreService, IDecorationService, IOptionsService } from 'common/services/Services';
 import { Emitter } from 'vs/base/common/event';
 
 interface ISelectionState {
@@ -18,6 +18,10 @@ interface ISelectionState {
   columnSelectMode: boolean;
 }
 
+const enum Constants {
+  SYNCHRONIZED_OUTPUT_TIMEOUT_MS = 1000
+}
+
 export class RenderService extends Disposable implements IRenderService {
   public serviceBrand: undefined;
 
@@ -32,6 +36,7 @@ export class RenderService extends Disposable implements IRenderService {
   private _needsSelectionRefresh: boolean = false;
   private _canvasWidth: number = 0;
   private _canvasHeight: number = 0;
+  private _syncOutputHandler: SynchronizedOutputHandler;
   private _selectionState: ISelectionState = {
     start: undefined,
     end: undefined,
@@ -52,23 +57,31 @@ export class RenderService extends Disposable implements IRenderService {
   constructor(
     private _rowCount: number,
     screenElement: HTMLElement,
-    @IOptionsService optionsService: IOptionsService,
+    @IOptionsService private readonly _optionsService: IOptionsService,
     @ICharSizeService private readonly _charSizeService: ICharSizeService,
+    @ICoreService private readonly _coreService: ICoreService,
     @IDecorationService decorationService: IDecorationService,
     @IBufferService bufferService: IBufferService,
-    @ICoreBrowserService coreBrowserService: ICoreBrowserService,
+    @ICoreBrowserService private readonly _coreBrowserService: ICoreBrowserService,
     @IThemeService themeService: IThemeService
   ) {
     super();
 
-    this._renderDebouncer = new RenderDebouncer((start, end) => this._renderRows(start, end), coreBrowserService);
+    this._renderDebouncer = new RenderDebouncer((start, end) => this._renderRows(start, end), this._coreBrowserService);
     this._register(this._renderDebouncer);
 
-    this._register(coreBrowserService.onDprChange(() => this.handleDevicePixelRatioChange()));
+    this._syncOutputHandler = new SynchronizedOutputHandler(
+      this._coreBrowserService,
+      this._coreService,
+      () => this._fullRefresh()
+    );
+    this._register(toDisposable(() => this._syncOutputHandler.dispose()));
+
+    this._register(this._coreBrowserService.onDprChange(() => this.handleDevicePixelRatioChange()));
 
     this._register(bufferService.onResize(() => this._fullRefresh()));
     this._register(bufferService.buffers.onBufferActivate(() => this._renderer.value?.clear()));
-    this._register(optionsService.onOptionChange(() => this._handleOptionsChanged()));
+    this._register(this._optionsService.onOptionChange(() => this._handleOptionsChanged()));
     this._register(this._charSizeService.onCharSizeChange(() => this.handleCharSizeChanged()));
 
     // Do a full refresh whenever any decoration is added or removed. This may not actually result
@@ -78,7 +91,7 @@ export class RenderService extends Disposable implements IRenderService {
     this._register(decorationService.onDecorationRemoved(() => this._fullRefresh()));
 
     // Clear the renderer when the a change that could affect glyphs occurs
-    this._register(optionsService.onMultipleOptionChange([
+    this._register(this._optionsService.onMultipleOptionChange([
       'customGlyphs',
       'drawBoldTextInBrightColors',
       'letterSpacing',
@@ -96,15 +109,15 @@ export class RenderService extends Disposable implements IRenderService {
     }));
 
     // Refresh the cursor line when the cursor changes
-    this._register(optionsService.onMultipleOptionChange([
+    this._register(this._optionsService.onMultipleOptionChange([
       'cursorBlink',
       'cursorStyle'
     ], () => this.refreshRows(bufferService.buffer.y, bufferService.buffer.y, true)));
 
     this._register(themeService.onChangeColors(() => this._fullRefresh()));
 
-    this._registerIntersectionObserver(coreBrowserService.window, screenElement);
-    this._register(coreBrowserService.onWindowChange((w) => this._registerIntersectionObserver(w, screenElement)));
+    this._registerIntersectionObserver(this._coreBrowserService.window, screenElement);
+    this._register(this._coreBrowserService.onWindowChange((w) => this._registerIntersectionObserver(w, screenElement)));
   }
 
   private _registerIntersectionObserver(w: Window & typeof globalThis, screenElement: HTMLElement): void {
@@ -137,6 +150,18 @@ export class RenderService extends Disposable implements IRenderService {
       this._needsFullRefresh = true;
       return;
     }
+
+    if (this._coreService.decPrivateModes.synchronizedOutput) {
+      this._syncOutputHandler.bufferRows(start, end);
+      return;
+    }
+
+    const buffered = this._syncOutputHandler.flush();
+    if (buffered) {
+      start = Math.min(start, buffered.start);
+      end = Math.max(end, buffered.end);
+    }
+
     if (!isRedrawOnly) {
       this._isNextRenderRedrawOnly = false;
     }
@@ -148,6 +173,13 @@ export class RenderService extends Disposable implements IRenderService {
       return;
     }
 
+    // Skip rendering if synchronized output mode is enabled. This check must happen here
+    // (in addition to refreshRows) to handle renders that were queued before the mode was enabled.
+    if (this._coreService.decPrivateModes.synchronizedOutput) {
+      this._syncOutputHandler.bufferRows(start, end);
+      return;
+    }
+
     // Since this is debounced, a resize event could have happened between the time a refresh was
     // requested and when this triggers. Clamp the values of start and end to ensure they're valid
     // given the current viewport state.
@@ -283,3 +315,62 @@ export class RenderService extends Disposable implements IRenderService {
     this._renderer.value?.clear();
   }
 }
+
+/**
+ * Buffers row refresh requests during synchronized output mode (DEC mode 2026).
+ * When the mode is disabled, the accumulated row range is flushed for rendering.
+ * A safety timeout ensures rendering occurs even if the end sequence is not received.
+ */
+class SynchronizedOutputHandler {
+  private _start: number = 0;
+  private _end: number = 0;
+  private _timeout: number | undefined;
+  private _isBuffering: boolean = false;
+
+  constructor(
+    private readonly _coreBrowserService: ICoreBrowserService,
+    private readonly _coreService: ICoreService,
+    private readonly _onTimeout: () => void
+  ) {}
+
+  public bufferRows(start: number, end: number): void {
+    if (!this._isBuffering) {
+      this._start = start;
+      this._end = end;
+      this._isBuffering = true;
+    } else {
+      this._start = Math.min(this._start, start);
+      this._end = Math.max(this._end, end);
+    }
+
+    if (this._timeout === undefined) {
+      this._timeout = this._coreBrowserService.window.setTimeout(() => {
+        this._timeout = undefined;
+        this._coreService.decPrivateModes.synchronizedOutput = false;
+        this._onTimeout();
+      }, Constants.SYNCHRONIZED_OUTPUT_TIMEOUT_MS);
+    }
+  }
+
+  public flush(): { start: number, end: number } | undefined {
+    if (this._timeout !== undefined) {
+      this._coreBrowserService.window.clearTimeout(this._timeout);
+      this._timeout = undefined;
+    }
+
+    if (!this._isBuffering) {
+      return undefined;
+    }
+
+    const result = { start: this._start, end: this._end };
+    this._isBuffering = false;
+    return result;
+  }
+
+  public dispose(): void {
+    if (this._timeout !== undefined) {
+      this._coreBrowserService.window.clearTimeout(this._timeout);
+      this._timeout = undefined;
+    }
+  }
+}

package/src/browser/services/SelectionService.ts

@@ -152,6 +152,14 @@ export class SelectionService extends Disposable implements ISelectionService {
     this._register(toDisposable(() => {
       this._removeMouseDownListeners();
     }));
+
+    // Clear selection when resizing vertically. This experience could be improved, this is the
+    // simple option to fix the buggy behavior. https://github.com/xtermjs/xterm.js/issues/5300
+    this._register(this._bufferService.onResize(e => {
+      if (e.rowsChanged) {
+        this.clearSelection();
+      }
+    }));
   }
 
   public reset(): void {

package/src/common/InputHandler.ts

@@ -445,7 +445,10 @@ export class InputHandler extends Disposable implements IInputHandler {
 
     // Log debug data, the log level gate is to prevent extra work in this hot path
     if (this._logService.logLevel <= LogLevelEnum.DEBUG) {
-      this._logService.debug(`parsing data${typeof data === 'string' ? ` "${data}"` : ` "${Array.prototype.map.call(data, e => String.fromCharCode(e)).join('')}"`}`, typeof data === 'string'
+      this._logService.debug(`parsing data ${typeof data === 'string' ? ` "${data}"` : ` "${Array.prototype.map.call(data, e => String.fromCharCode(e)).join('')}"`}`);
+    }
+    if (this._logService.logLevel === LogLevelEnum.TRACE) {
+      this._logService.trace(`parsing data (codes)`, typeof data === 'string'
         ? data.split('').map(e => e.charCodeAt(0))
         : data
       );
@@ -606,7 +609,7 @@ export class InputHandler extends Disposable implements IInputHandler {
         // since an empty cell is only set by fullwidth chars
         bufferRow.addCodepointToCell(this._activeBuffer.x - offset,
           code, chWidth);
-        for (let delta = chWidth - oldWidth; --delta >= 0; ) {
+        for (let delta = chWidth - oldWidth; --delta >= 0;) {
           bufferRow.setCellFromCodepoint(this._activeBuffer.x++, 0, 0, curAttr);
         }
         continue;
@@ -1220,12 +1223,27 @@ export class InputHandler extends Disposable implements IInputHandler {
         this._dirtyRowTracker.markDirty(0);
         break;
       case 2:
-        j = this._bufferService.rows;
-        this._dirtyRowTracker.markDirty(j - 1);
-        while (j--) {
-          this._resetBufferLine(j, respectProtect);
+        if (this._optionsService.rawOptions.scrollOnEraseInDisplay) {
+          j = this._bufferService.rows;
+          this._dirtyRowTracker.markRangeDirty(0, j - 1);
+          while (j--) {
+            const currentLine = this._activeBuffer.lines.get(this._activeBuffer.ybase + j);
+            if (currentLine?.getTrimmedLength()) {
+              break;
+            }
+          }
+          for (; j >= 0; j--) {
+            this._bufferService.scroll(this._eraseAttrData());
+          }
+        }
+        else {
+          j = this._bufferService.rows;
+          this._dirtyRowTracker.markDirty(j - 1);
+          while (j--) {
+            this._resetBufferLine(j, respectProtect);
+          }
+          this._dirtyRowTracker.markDirty(0);
         }
-        this._dirtyRowTracker.markDirty(0);
         break;
       case 3:
         // Clear scrollback (everything not in viewport)
@@ -1607,7 +1625,7 @@ export class InputHandler extends Disposable implements IInputHandler {
     const text = bufferRow.getString(x);
     const data = new Uint32Array(text.length * length);
     let idata = 0;
-    for (let itext = 0; itext < text.length; ) {
+    for (let itext = 0; itext < text.length;) {
       const ch = text.codePointAt(itext) || 0;
       data[idata++] = ch;
       itext += ch > 0xffff ? 2 : 1;
@@ -1951,6 +1969,9 @@ export class InputHandler extends Disposable implements IInputHandler {
         case 2004: // bracketed paste mode (https://cirw.in/blog/bracketed-paste)
           this._coreService.decPrivateModes.bracketedPasteMode = true;
           break;
+        case 2026: // synchronized output (https://github.com/contour-terminal/vt-extensions/blob/master/synchronized-output.md)
+          this._coreService.decPrivateModes.synchronizedOutput = true;
+          break;
       }
     }
     return true;
@@ -2179,6 +2200,10 @@ export class InputHandler extends Disposable implements IInputHandler {
         case 2004: // bracketed paste mode (https://cirw.in/blog/bracketed-paste)
           this._coreService.decPrivateModes.bracketedPasteMode = false;
           break;
+        case 2026: // synchronized output (https://github.com/contour-terminal/vt-extensions/blob/master/synchronized-output.md)
+          this._coreService.decPrivateModes.synchronizedOutput = false;
+          this._onRequestRefreshRows.fire(undefined);
+          break;
       }
     }
     return true;
@@ -2273,6 +2298,7 @@ export class InputHandler extends Disposable implements IInputHandler {
     if (p === 1048) return f(p, V.SET); // xterm always returns SET here
     if (p === 47 || p === 1047 || p === 1049) return f(p, b2v(active === alt));
     if (p === 2004) return f(p, b2v(dm.bracketedPasteMode));
+    if (p === 2026) return f(p, b2v(dm.synchronizedOutput));
     return f(p, V.NOT_RECOGNIZED);
   }
 

package/src/common/TaskQueue.ts

@@ -74,14 +74,14 @@ abstract class TaskQueue implements ITaskQueue {
     let lastDeadlineRemaining = deadline.timeRemaining();
     let deadlineRemaining = 0;
     while (this._i < this._tasks.length) {
-      taskDuration = Date.now();
+      taskDuration = performance.now();
       if (!this._tasks[this._i]()) {
         this._i++;
       }
-      // other than performance.now, Date.now might not be stable (changes on wall clock changes),
-      // this is not an issue here as a clock change during a short running task is very unlikely
-      // in case it still happened and leads to negative duration, simply assume 1 msec
-      taskDuration = Math.max(1, Date.now() - taskDuration);
+      // other than performance.now, performance.now might not be stable (changes on wall clock
+      // changes), this is not an issue here as a clock change during a short running task is very
+      // unlikely in case it still happened and leads to negative duration, simply assume 1 msec
+      taskDuration = Math.max(1, performance.now() - taskDuration);
       longestTask = Math.max(taskDuration, longestTask);
       // Guess the following task will take a similar time to the longest task in this batch, allow
       // additional room to try avoid exceeding the deadline
@@ -116,9 +116,9 @@ export class PriorityTaskQueue extends TaskQueue {
   }
 
   private _createDeadline(duration: number): ITaskDeadline {
-    const end = Date.now() + duration;
+    const end = performance.now() + duration;
     return {
-      timeRemaining: () => Math.max(0, end - Date.now())
+      timeRemaining: () => Math.max(0, end - performance.now())
     };
   }
 }

package/src/common/Types.ts

@@ -273,6 +273,7 @@ export interface IDecPrivateModes {
   origin: boolean;
   reverseWraparound: boolean;
   sendFocus: boolean;
+  synchronizedOutput: boolean;
   wraparound: boolean; // defaults: xterm - true, vt100 - false
 }
 

package/src/common/input/Keyboard.ts

@@ -117,12 +117,6 @@ export function evaluateKeyboardEvent(
       }
       if (modifiers) {
         result.key = C0.ESC + '[1;' + (modifiers + 1) + 'D';
-        // HACK: Make Alt + left-arrow behave like Ctrl + left-arrow: move one word backwards
-        // http://unix.stackexchange.com/a/108106
-        // macOS uses different escape sequences than linux
-        if (result.key === C0.ESC + '[1;3D') {
-          result.key = C0.ESC + (isMac ? 'b' : '[1;5D');
-        }
       } else if (applicationCursorMode) {
         result.key = C0.ESC + 'OD';
       } else {
@@ -136,12 +130,6 @@ export function evaluateKeyboardEvent(
       }
       if (modifiers) {
         result.key = C0.ESC + '[1;' + (modifiers + 1) + 'C';
-        // HACK: Make Alt + right-arrow behave like Ctrl + right-arrow: move one word forward
-        // http://unix.stackexchange.com/a/108106
-        // macOS uses different escape sequences than linux
-        if (result.key === C0.ESC + '[1;3C') {
-          result.key = C0.ESC + (isMac ? 'f' : '[1;5C');
-        }
       } else if (applicationCursorMode) {
         result.key = C0.ESC + 'OC';
       } else {
@@ -155,12 +143,6 @@ export function evaluateKeyboardEvent(
       }
       if (modifiers) {
         result.key = C0.ESC + '[1;' + (modifiers + 1) + 'A';
-        // HACK: Make Alt + up-arrow behave like Ctrl + up-arrow
-        // http://unix.stackexchange.com/a/108106
-        // macOS uses different escape sequences than linux
-        if (!isMac && result.key === C0.ESC + '[1;3A') {
-          result.key = C0.ESC + '[1;5A';
-        }
       } else if (applicationCursorMode) {
         result.key = C0.ESC + 'OA';
       } else {
@@ -174,12 +156,6 @@ export function evaluateKeyboardEvent(
       }
       if (modifiers) {
         result.key = C0.ESC + '[1;' + (modifiers + 1) + 'B';
-        // HACK: Make Alt + down-arrow behave like Ctrl + down-arrow
-        // http://unix.stackexchange.com/a/108106
-        // macOS uses different escape sequences than linux
-        if (!isMac && result.key === C0.ESC + '[1;3B') {
-          result.key = C0.ESC + '[1;5B';
-        }
       } else if (applicationCursorMode) {
         result.key = C0.ESC + 'OB';
       } else {

package/src/common/input/WriteBuffer.ts

@@ -137,7 +137,7 @@ export class WriteBuffer extends Disposable {
    * effectively lowering the redrawing needs, schematically:
    *
    *   macroTask _innerWrite:
-   *     if (Date.now() - (lastTime | 0) < WRITE_TIMEOUT_MS):
+   *     if (performance.now() - (lastTime | 0) < WRITE_TIMEOUT_MS):
    *        schedule microTask _innerWrite(lastTime)
    *     else:
    *        schedule macroTask _innerWrite(0)
@@ -158,7 +158,7 @@ export class WriteBuffer extends Disposable {
    * Note, for pure sync code `lastTime` and `promiseResult` have no meaning.
    */
   protected _innerWrite(lastTime: number = 0, promiseResult: boolean = true): void {
-    const startTime = lastTime || Date.now();
+    const startTime = lastTime || performance.now();
     while (this._writeBuffer.length > this._bufferOffset) {
       const data = this._writeBuffer[this._bufferOffset];
       const result = this._action(data, promiseResult);
@@ -186,7 +186,7 @@ export class WriteBuffer extends Disposable {
          * responsibility to slice hard work), but we can at least schedule a screen update as we
          * gain control.
          */
-        const continuation: (r: boolean) => void = (r: boolean) => Date.now() - startTime >= WRITE_TIMEOUT_MS
+        const continuation: (r: boolean) => void = (r: boolean) => performance.now() - startTime >= WRITE_TIMEOUT_MS
           ? setTimeout(() => this._innerWrite(0, r))
           : this._innerWrite(startTime, r);
 
@@ -202,7 +202,8 @@ export class WriteBuffer extends Disposable {
          * throughput by eval'ing `startTime` upfront pulling at least one more chunk into the
          * current microtask queue (executed before setTimeout).
          */
-        // const continuation: (r: boolean) => void = Date.now() - startTime >= WRITE_TIMEOUT_MS
+        // const continuation: (r: boolean) => void = performance.now() - startTime >=
+        //     WRITE_TIMEOUT_MS
         //   ? r => setTimeout(() => this._innerWrite(0, r))
         //   : r => this._innerWrite(startTime, r);
 
@@ -222,7 +223,7 @@ export class WriteBuffer extends Disposable {
       this._bufferOffset++;
       this._pendingData -= data.length;
 
-      if (Date.now() - startTime >= WRITE_TIMEOUT_MS) {
+      if (performance.now() - startTime >= WRITE_TIMEOUT_MS) {
         break;
       }
     }

package/src/common/services/BufferService.ts

@@ -7,7 +7,7 @@ import { Disposable } from 'vs/base/common/lifecycle';
 import { IAttributeData, IBufferLine } from 'common/Types';
 import { BufferSet } from 'common/buffer/BufferSet';
 import { IBuffer, IBufferSet } from 'common/buffer/Types';
-import { IBufferService, IOptionsService } from 'common/services/Services';
+import { IBufferService, IOptionsService, type IBufferResizeEvent } from 'common/services/Services';
 import { Emitter } from 'vs/base/common/event';
 
 export const MINIMUM_COLS = 2; // Less than 2 can mess with wide chars
@@ -22,7 +22,7 @@ export class BufferService extends Disposable implements IBufferService {
   /** Whether the user is scrolling (locks the scroll position) */
   public isUserScrolling: boolean = false;
 
-  private readonly _onResize = this._register(new Emitter<{ cols: number, rows: number }>());
+  private readonly _onResize = this._register(new Emitter<IBufferResizeEvent>());
   public readonly onResize = this._onResize.event;
   private readonly _onScroll = this._register(new Emitter<number>());
   public readonly onScroll = this._onScroll.event;
@@ -37,15 +37,18 @@ export class BufferService extends Disposable implements IBufferService {
     this.cols = Math.max(optionsService.rawOptions.cols || 0, MINIMUM_COLS);
     this.rows = Math.max(optionsService.rawOptions.rows || 0, MINIMUM_ROWS);
     this.buffers = this._register(new BufferSet(optionsService, this));
+    this._register(this.buffers.onBufferActivate(e => {
+      this._onScroll.fire(e.activeBuffer.ydisp);
+    }));
   }
 
   public resize(cols: number, rows: number): void {
+    const colsChanged = this.cols !== cols;
+    const rowsChanged = this.rows !== rows;
     this.cols = cols;
     this.rows = rows;
     this.buffers.resize(cols, rows);
-    // TODO: This doesn't fire when scrollback changes - add a resize event to BufferSet and forward
-    //       event
-    this._onResize.fire({ cols, rows });
+    this._onResize.fire({ cols, rows, colsChanged, rowsChanged });
   }
 
   public reset(): void {