@xterm/xterm 6.1.0-beta.26 → 6.1.0-beta.260

package/src/common/parser/EscapeSequenceParser.ts

@@ -3,13 +3,32 @@
  * @license MIT
  */
 
-import { IParsingState, IDcsHandler, IEscapeSequenceParser, IParams, IOscHandler, IHandlerCollection, CsiHandlerType, OscFallbackHandlerType, IOscParser, EscHandlerType, IDcsParser, DcsFallbackHandlerType, IFunctionIdentifier, ExecuteFallbackHandlerType, CsiFallbackHandlerType, EscFallbackHandlerType, PrintHandlerType, PrintFallbackHandlerType, ExecuteHandlerType, IParserStackState, ParserStackType, ResumableHandlersType } from 'common/parser/Types';
-import { ParserState, ParserAction } from 'common/parser/Constants';
-import { Disposable, toDisposable } from 'vs/base/common/lifecycle';
-import { IDisposable } from 'common/Types';
-import { Params } from 'common/parser/Params';
-import { OscParser } from 'common/parser/OscParser';
-import { DcsParser } from 'common/parser/DcsParser';
+import { IParsingState, IDcsHandler, IEscapeSequenceParser, IParams, IOscHandler, IHandlerCollection, CsiHandlerType, OscFallbackHandlerType, IOscParser, EscHandlerType, IDcsParser, DcsFallbackHandlerType, IFunctionIdentifier, ExecuteFallbackHandlerType, CsiFallbackHandlerType, EscFallbackHandlerType, PrintHandlerType, PrintFallbackHandlerType, ExecuteHandlerType, IParserStackState, ParserStackType, ResumableHandlersType, IApcHandler, IApcParser, ApcFallbackHandlerType } from './Types';
+import { ParserState, ParserAction } from './Constants';
+import { Disposable, toDisposable } from '../Lifecycle';
+import { IDisposable } from '../Types';
+import { Params } from './Params';
+import { OscParser } from './OscParser';
+import { DcsParser } from './DcsParser';
+import { ApcParser } from './ApcParser';
+
+/**
+ * VT commands done by the parser
+ */
+// @vt: #Y   ESC   CSI   "Control Sequence Introducer"   "ESC ["   "Start of a CSI sequence."
+// @vt: #Y   ESC   OSC   "Operating System Command"      "ESC ]"   "Start of an OSC sequence."
+// @vt: #Y   ESC   DCS   "Device Control String"         "ESC P"   "Start of a DCS sequence."
+// @vt: #Y   ESC   ST    "String Terminator"             "ESC \"   "Terminator used for string type sequences."
+// @vt: #Y   ESC   PM    "Privacy Message"               "ESC ^"   "Start of a privacy message."
+// @vt: #Y   ESC   APC   "Application Program Command"   "ESC _"   "Start of an APC sequence."
+// @vt: #Y   C1    CSI   "Control Sequence Introducer"   "\x9B"    "Start of a CSI sequence."
+// @vt: #Y   C1    OSC   "Operating System Command"      "\x9D"    "Start of an OSC sequence."
+// @vt: #Y   C1    DCS   "Device Control String"         "\x90"    "Start of a DCS sequence."
+// @vt: #Y   C1    ST    "String Terminator"             "\x9C"    "Terminator used for string type sequences."
+// @vt: #Y   C1    PM    "Privacy Message"               "\x9E"    "Start of a privacy message."
+// @vt: #Y   C1    APC   "Application Program Command"   "\x9F"    "Start of an APC sequence."
+// @vt: #Y   C0    NUL   "Null"                          "\0, \x00"  "NUL is ignored."
+// @vt: #Y   C0    ESC   "Escape"                        "\e, \x1B"  "Start of a sequence. Cancels any other sequence."
 
 /**
  * Table values are generated like this:
@@ -17,8 +36,8 @@ import { DcsParser } from 'common/parser/DcsParser';
  *    value:  action << TableValue.TRANSITION_ACTION_SHIFT | nextState
  */
 const enum TableAccess {
-  TRANSITION_ACTION_SHIFT = 4,
-  TRANSITION_STATE_MASK = 15,
+  TRANSITION_ACTION_SHIFT = 8,
+  TRANSITION_STATE_MASK = 255,
   INDEX_STATE_SHIFT = 8
 }
 
@@ -26,10 +45,10 @@ const enum TableAccess {
  * Transition table for EscapeSequenceParser.
  */
 export class TransitionTable {
-  public table: Uint8Array;
+  public table: Uint16Array;
 
   constructor(length: number) {
-    this.table = new Uint8Array(length);
+    this.table = new Uint16Array(length);
   }
 
   /**
@@ -76,7 +95,9 @@ const NON_ASCII_PRINTABLE = 0xA0;
  * Taken from https://vt100.net/emu/dec_ansi_parser.
  */
 export const VT500_TRANSITION_TABLE = (function (): TransitionTable {
-  const table: TransitionTable = new TransitionTable(4095);
+  // table size:
+  // (ParserState.STATE_LENGTH - 1) << TableAccess.INDEX_STATE_SHIFT | NON_ASCII_PRINTABLE + 1
+  const table: TransitionTable = new TransitionTable(4257);
 
   // range macro for byte
   const BYTE_VALUES = 256;
@@ -89,22 +110,22 @@ export const VT500_TRANSITION_TABLE = (function (): TransitionTable {
   EXECUTABLES.push(0x19);
   EXECUTABLES.push.apply(EXECUTABLES, r(0x1c, 0x20));
 
-  const states: number[] = r(ParserState.GROUND, ParserState.DCS_PASSTHROUGH + 1);
-  let state: any;
+  const states: number[] = r(ParserState.GROUND, ParserState.STATE_LENGTH);
 
   // set default transition
   table.setDefault(ParserAction.ERROR, ParserState.GROUND);
   // printables
   table.addMany(PRINTABLES, ParserState.GROUND, ParserAction.PRINT, ParserState.GROUND);
   // global anywhere rules
-  for (state in states) {
+  for (const state of states) {
     table.addMany([0x18, 0x1a, 0x99, 0x9a], state, ParserAction.EXECUTE, ParserState.GROUND);
     table.addMany(r(0x80, 0x90), state, ParserAction.EXECUTE, ParserState.GROUND);
     table.addMany(r(0x90, 0x98), state, ParserAction.EXECUTE, ParserState.GROUND);
     table.add(0x9c, state, ParserAction.IGNORE, ParserState.GROUND); // ST as terminator
     table.add(0x1b, state, ParserAction.CLEAR, ParserState.ESCAPE);  // ESC
     table.add(0x9d, state, ParserAction.OSC_START, ParserState.OSC_STRING);  // OSC
-    table.addMany([0x98, 0x9e, 0x9f], state, ParserAction.IGNORE, ParserState.SOS_PM_APC_STRING);
+    table.addMany([0x98, 0x9e], state, ParserAction.IGNORE, ParserState.SOS_PM_STRING);  // SOS, PM
+    table.add(0x9f, state, ParserAction.CLEAR, ParserState.APC_ENTRY);  // APC
     table.add(0x9b, state, ParserAction.CLEAR, ParserState.CSI_ENTRY);  // CSI
     table.add(0x90, state, ParserAction.CLEAR, ParserState.DCS_ENTRY);  // DCS
   }
@@ -128,12 +149,27 @@ export const VT500_TRANSITION_TABLE = (function (): TransitionTable {
   table.add(0x7f, ParserState.OSC_STRING, ParserAction.OSC_PUT, ParserState.OSC_STRING);
   table.addMany([0x9c, 0x1b, 0x18, 0x1a, 0x07], ParserState.OSC_STRING, ParserAction.OSC_END, ParserState.GROUND);
   table.addMany(r(0x1c, 0x20), ParserState.OSC_STRING, ParserAction.IGNORE, ParserState.OSC_STRING);
-  // sos/pm/apc does nothing
-  table.addMany([0x58, 0x5e, 0x5f], ParserState.ESCAPE, ParserAction.IGNORE, ParserState.SOS_PM_APC_STRING);
-  table.addMany(PRINTABLES, ParserState.SOS_PM_APC_STRING, ParserAction.IGNORE, ParserState.SOS_PM_APC_STRING);
-  table.addMany(EXECUTABLES, ParserState.SOS_PM_APC_STRING, ParserAction.IGNORE, ParserState.SOS_PM_APC_STRING);
-  table.add(0x9c, ParserState.SOS_PM_APC_STRING, ParserAction.IGNORE, ParserState.GROUND);
-  table.add(0x7f, ParserState.SOS_PM_APC_STRING, ParserAction.IGNORE, ParserState.SOS_PM_APC_STRING);
+  // sos/pm
+  table.addMany([0x58, 0x5e], ParserState.ESCAPE, ParserAction.IGNORE, ParserState.SOS_PM_STRING);
+  table.addMany(PRINTABLES, ParserState.SOS_PM_STRING, ParserAction.IGNORE, ParserState.SOS_PM_STRING);
+  table.addMany(EXECUTABLES, ParserState.SOS_PM_STRING, ParserAction.IGNORE, ParserState.SOS_PM_STRING);
+  table.add(0x9c, ParserState.SOS_PM_STRING, ParserAction.IGNORE, ParserState.GROUND);
+  table.add(0x7f, ParserState.SOS_PM_STRING, ParserAction.IGNORE, ParserState.SOS_PM_STRING);
+  // apc
+  table.add(0x5f, ParserState.ESCAPE, ParserAction.CLEAR, ParserState.APC_ENTRY);
+  table.addMany(EXECUTABLES, ParserState.APC_ENTRY, ParserAction.IGNORE, ParserState.APC_ENTRY);
+  table.add(0x7f, ParserState.APC_ENTRY, ParserAction.IGNORE, ParserState.APC_ENTRY);
+  table.addMany(r(0x20, 0x30), ParserState.APC_ENTRY, ParserAction.COLLECT, ParserState.APC_INTERMEDIATE);
+  table.addMany(r(0x30, 0x7f), ParserState.APC_ENTRY, ParserAction.APC_START, ParserState.APC_PASSTHROUGH);
+  table.addMany(r(0x30, 0x7f), ParserState.APC_INTERMEDIATE, ParserAction.APC_START, ParserState.APC_PASSTHROUGH);
+  table.addMany(EXECUTABLES, ParserState.APC_INTERMEDIATE, ParserAction.IGNORE, ParserState.APC_INTERMEDIATE);
+  table.addMany(r(0x20, 0x30), ParserState.APC_INTERMEDIATE, ParserAction.COLLECT, ParserState.APC_INTERMEDIATE);
+  table.add(0x7f, ParserState.APC_INTERMEDIATE, ParserAction.IGNORE, ParserState.APC_INTERMEDIATE);
+  table.addMany(PRINTABLES, ParserState.APC_PASSTHROUGH, ParserAction.APC_PUT, ParserState.APC_PASSTHROUGH);
+  table.addMany(EXECUTABLES, ParserState.APC_PASSTHROUGH, ParserAction.IGNORE, ParserState.APC_PASSTHROUGH);
+  table.addMany(r(0x08, 0x0e), ParserState.APC_PASSTHROUGH, ParserAction.APC_PUT, ParserState.APC_PASSTHROUGH);
+  table.add(0x7f, ParserState.APC_PASSTHROUGH, ParserAction.IGNORE, ParserState.APC_PASSTHROUGH);
+  table.addMany([0x1b, 0x9c, 0x18, 0x1a], ParserState.APC_PASSTHROUGH, ParserAction.APC_END, ParserState.GROUND);
   // csi entries
   table.add(0x5b, ParserState.ESCAPE, ParserAction.CLEAR, ParserState.CSI_ENTRY);
   table.addMany(r(0x40, 0x7f), ParserState.CSI_ENTRY, ParserAction.CSI_DISPATCH, ParserState.GROUND);
@@ -162,22 +198,18 @@ export const VT500_TRANSITION_TABLE = (function (): TransitionTable {
   table.add(0x50, ParserState.ESCAPE, ParserAction.CLEAR, ParserState.DCS_ENTRY);
   table.addMany(EXECUTABLES, ParserState.DCS_ENTRY, ParserAction.IGNORE, ParserState.DCS_ENTRY);
   table.add(0x7f, ParserState.DCS_ENTRY, ParserAction.IGNORE, ParserState.DCS_ENTRY);
-  table.addMany(r(0x1c, 0x20), ParserState.DCS_ENTRY, ParserAction.IGNORE, ParserState.DCS_ENTRY);
   table.addMany(r(0x20, 0x30), ParserState.DCS_ENTRY, ParserAction.COLLECT, ParserState.DCS_INTERMEDIATE);
   table.addMany(r(0x30, 0x3c), ParserState.DCS_ENTRY, ParserAction.PARAM, ParserState.DCS_PARAM);
   table.addMany([0x3c, 0x3d, 0x3e, 0x3f], ParserState.DCS_ENTRY, ParserAction.COLLECT, ParserState.DCS_PARAM);
   table.addMany(EXECUTABLES, ParserState.DCS_IGNORE, ParserAction.IGNORE, ParserState.DCS_IGNORE);
   table.addMany(r(0x20, 0x80), ParserState.DCS_IGNORE, ParserAction.IGNORE, ParserState.DCS_IGNORE);
-  table.addMany(r(0x1c, 0x20), ParserState.DCS_IGNORE, ParserAction.IGNORE, ParserState.DCS_IGNORE);
   table.addMany(EXECUTABLES, ParserState.DCS_PARAM, ParserAction.IGNORE, ParserState.DCS_PARAM);
   table.add(0x7f, ParserState.DCS_PARAM, ParserAction.IGNORE, ParserState.DCS_PARAM);
-  table.addMany(r(0x1c, 0x20), ParserState.DCS_PARAM, ParserAction.IGNORE, ParserState.DCS_PARAM);
   table.addMany(r(0x30, 0x3c), ParserState.DCS_PARAM, ParserAction.PARAM, ParserState.DCS_PARAM);
   table.addMany([0x3c, 0x3d, 0x3e, 0x3f], ParserState.DCS_PARAM, ParserAction.IGNORE, ParserState.DCS_IGNORE);
   table.addMany(r(0x20, 0x30), ParserState.DCS_PARAM, ParserAction.COLLECT, ParserState.DCS_INTERMEDIATE);
   table.addMany(EXECUTABLES, ParserState.DCS_INTERMEDIATE, ParserAction.IGNORE, ParserState.DCS_INTERMEDIATE);
   table.add(0x7f, ParserState.DCS_INTERMEDIATE, ParserAction.IGNORE, ParserState.DCS_INTERMEDIATE);
-  table.addMany(r(0x1c, 0x20), ParserState.DCS_INTERMEDIATE, ParserAction.IGNORE, ParserState.DCS_INTERMEDIATE);
   table.addMany(r(0x20, 0x30), ParserState.DCS_INTERMEDIATE, ParserAction.COLLECT, ParserState.DCS_INTERMEDIATE);
   table.addMany(r(0x30, 0x40), ParserState.DCS_INTERMEDIATE, ParserAction.IGNORE, ParserState.DCS_IGNORE);
   table.addMany(r(0x40, 0x7f), ParserState.DCS_INTERMEDIATE, ParserAction.DCS_HOOK, ParserState.DCS_PASSTHROUGH);
@@ -193,6 +225,7 @@ export const VT500_TRANSITION_TABLE = (function (): TransitionTable {
   table.add(NON_ASCII_PRINTABLE, ParserState.CSI_IGNORE, ParserAction.IGNORE, ParserState.CSI_IGNORE);
   table.add(NON_ASCII_PRINTABLE, ParserState.DCS_IGNORE, ParserAction.IGNORE, ParserState.DCS_IGNORE);
   table.add(NON_ASCII_PRINTABLE, ParserState.DCS_PASSTHROUGH, ParserAction.DCS_PUT, ParserState.DCS_PASSTHROUGH);
+  table.add(NON_ASCII_PRINTABLE, ParserState.APC_PASSTHROUGH, ParserAction.APC_PUT, ParserState.APC_PASSTHROUGH);
   return table;
 })();
 
@@ -239,10 +272,13 @@ export class EscapeSequenceParser extends Disposable implements IEscapeSequenceP
   // handler lookup containers
   protected _printHandler: PrintHandlerType;
   protected _executeHandlers: { [flag: number]: ExecuteHandlerType };
+  // fast path for EXE bytes < 0x18
+  protected _executeHandlersArr: (ExecuteHandlerType | undefined)[];
   protected _csiHandlers: IHandlerCollection<CsiHandlerType>;
   protected _escHandlers: IHandlerCollection<EscHandlerType>;
   protected readonly _oscParser: IOscParser;
   protected readonly _dcsParser: IDcsParser;
+  protected readonly _apcParser: IApcParser;
   protected _errorHandler: (state: IParsingState) => IParsingState;
 
   // fallback handlers
@@ -281,15 +317,18 @@ export class EscapeSequenceParser extends Disposable implements IEscapeSequenceP
     this._errorHandlerFb = (state: IParsingState): IParsingState => state;
     this._printHandler = this._printHandlerFb;
     this._executeHandlers = Object.create(null);
+    this._executeHandlersArr = new Array(0x18).fill(undefined);
     this._csiHandlers = Object.create(null);
     this._escHandlers = Object.create(null);
     this._register(toDisposable(() => {
       this._csiHandlers = Object.create(null);
       this._executeHandlers = Object.create(null);
+      this._executeHandlersArr = new Array(0x18).fill(undefined);
       this._escHandlers = Object.create(null);
     }));
     this._oscParser = this._register(new OscParser());
     this._dcsParser = this._register(new DcsParser());
+    this._apcParser = this._register(new ApcParser());
     this._errorHandler = this._errorHandlerFb;
 
     // swallow 7bit ST (ESC+\)
@@ -351,9 +390,7 @@ export class EscapeSequenceParser extends Disposable implements IEscapeSequenceP
 
   public registerEscHandler(id: IFunctionIdentifier, handler: EscHandlerType): IDisposable {
     const ident = this._identifier(id, [0x30, 0x7e]);
-    if (this._escHandlers[ident] === undefined) {
-      this._escHandlers[ident] = [];
-    }
+    this._escHandlers[ident] ??= [];
     const handlerList = this._escHandlers[ident];
     handlerList.push(handler);
     return {
@@ -373,10 +410,14 @@ export class EscapeSequenceParser extends Disposable implements IEscapeSequenceP
   }
 
   public setExecuteHandler(flag: string, handler: ExecuteHandlerType): void {
-    this._executeHandlers[flag.charCodeAt(0)] = handler;
+    const code = flag.charCodeAt(0);
+    this._executeHandlers[code] = handler;
+    if (code < 0x18) this._executeHandlersArr[code] = handler;
   }
   public clearExecuteHandler(flag: string): void {
-    if (this._executeHandlers[flag.charCodeAt(0)]) delete this._executeHandlers[flag.charCodeAt(0)];
+    const code = flag.charCodeAt(0);
+    if (this._executeHandlers[code]) delete this._executeHandlers[code];
+    if (code < 0x18) this._executeHandlersArr[code] = undefined;
   }
   public setExecuteHandlerFallback(handler: ExecuteFallbackHandlerType): void {
     this._executeHandlerFb = handler;
@@ -384,9 +425,7 @@ export class EscapeSequenceParser extends Disposable implements IEscapeSequenceP
 
   public registerCsiHandler(id: IFunctionIdentifier, handler: CsiHandlerType): IDisposable {
     const ident = this._identifier(id);
-    if (this._csiHandlers[ident] === undefined) {
-      this._csiHandlers[ident] = [];
-    }
+    this._csiHandlers[ident] ??= [];
     const handlerList = this._csiHandlers[ident];
     handlerList.push(handler);
     return {
@@ -425,6 +464,18 @@ export class EscapeSequenceParser extends Disposable implements IEscapeSequenceP
     this._oscParser.setHandlerFallback(handler);
   }
 
+  public registerApcHandler(id: IFunctionIdentifier, handler: IApcHandler): IDisposable {
+    id.prefix = undefined;  // APC does not support prefix byte
+    return this._apcParser.registerHandler(this._identifier(id, [0x30, 0x7e]), handler);
+  }
+  public clearApcHandler(id: IFunctionIdentifier): void {
+    id.prefix = undefined;  // APC does not support prefix byte
+    this._apcParser.clearHandler(this._identifier(id, [0x30, 0x7e]));
+  }
+  public setApcHandlerFallback(handler: ApcFallbackHandlerType): void {
+    this._apcParser.setHandlerFallback(handler);
+  }
+
   public setErrorHandler(callback: (state: IParsingState) => IParsingState): void {
     this._errorHandler = callback;
   }
@@ -445,8 +496,8 @@ export class EscapeSequenceParser extends Disposable implements IEscapeSequenceP
     this.currentState = this.initialState;
     this._oscParser.reset();
     this._dcsParser.reset();
-    this._params.reset();
-    this._params.addParam(0); // ZDM
+    this._apcParser.reset();
+    this._params.resetZdm();
     this._collect = 0;
     this.precedingJoinState = 0;
     // abort pending continuation from async handler
@@ -489,6 +540,10 @@ export class EscapeSequenceParser extends Disposable implements IEscapeSequenceP
    * - OSC_STRING:OSC_PUT
    * - DCS_PASSTHROUGH:DCS_PUT
    *
+   * Additionally the following fast paths exist before the table lookup:
+   * - EXE bytes < 0x18 in non-payload states (avoids table lookup entirely)
+   * - 7-bit CSI sequences without intermediates (ESC [ params final)
+   *
    * Note on asynchronous handler support:
    * Any handler returning a promise will be treated as asynchronous.
    * To keep the in-band blocking working for async handlers, `parse` pauses execution,
@@ -517,8 +572,8 @@ export class EscapeSequenceParser extends Disposable implements IEscapeSequenceP
    * ```
    */
   public parse(data: Uint32Array, length: number, promiseResult?: boolean): void | Promise<boolean> {
-    let code = 0;
-    let transition = 0;
+    let code: number;
+    let transition: number;
     let start = 0;
     let handlerResult: void | boolean | Promise<boolean>;
 
@@ -591,8 +646,7 @@ export class EscapeSequenceParser extends Disposable implements IEscapeSequenceP
               return handlerResult;
             }
             if (code === 0x1b) this._parseStack.transition |= ParserState.ESCAPE;
-            this._params.reset();
-            this._params.addParam(0); // ZDM
+            this._params.resetZdm();
             this._collect = 0;
             break;
           case ParserStackType.OSC:
@@ -602,8 +656,17 @@ export class EscapeSequenceParser extends Disposable implements IEscapeSequenceP
               return handlerResult;
             }
             if (code === 0x1b) this._parseStack.transition |= ParserState.ESCAPE;
-            this._params.reset();
-            this._params.addParam(0); // ZDM
+            this._params.resetZdm();
+            this._collect = 0;
+            break;
+          case ParserStackType.APC:
+            code = data[this._parseStack.chunkPos];
+            handlerResult = this._apcParser.end(code !== 0x18 && code !== 0x1a, promiseResult);
+            if (handlerResult) {
+              return handlerResult;
+            }
+            if (code === 0x1b) this._parseStack.transition |= ParserState.ESCAPE;
+            this._params.resetZdm();
             this._collect = 0;
             break;
         }
@@ -621,34 +684,90 @@ export class EscapeSequenceParser extends Disposable implements IEscapeSequenceP
     for (let i = start; i < length; ++i) {
       code = data[i];
 
+      // EXE fast-path: common control bytes (0x00-0x17) in non-payload states
+      if (code < 0x18 && this.currentState <= ParserState.CSI_IGNORE) {
+        (this._executeHandlersArr[code] ?? this._executeHandlerFb)(code);
+        this.precedingJoinState = 0;
+        continue;
+      }
+
+      // CSI fast-path: collapse ESC [ into a single entry, parse params+final in a tight loop
+      if (code === 0x1b
+        && this.currentState < ParserState.OSC_STRING
+        && i + 2 < length && data[i + 1] === 0x5b
+      ) {
+        this._params.resetZdm();
+        this._collect = 0;
+        let k = i + 2;
+        let ch = data[k];
+        if (ch >= 0x3c && ch <= 0x3f) {
+          this._collect = ch;
+          k++;
+        }
+        let csiDone = false;
+        for (; k < length; k++) {
+          ch = data[k];
+          if (ch >= 0x30 && ch <= 0x39) {
+            this._params.addDigit(ch - 48);
+          } else if (ch === 0x3b) {
+            this._params.addParam(0);
+          } else if (ch === 0x3a) {
+            this._params.addSubParam(-1);
+          } else if (ch >= 0x40 && ch <= 0x7e) {
+            const handlers = this._csiHandlers[this._collect << 8 | ch];
+            let j = handlers ? handlers.length - 1 : -1;
+            for (; j >= 0; j--) {
+              handlerResult = handlers[j](this._params);
+              if (handlerResult === true) {
+                break;
+              } else if (handlerResult instanceof Promise) {
+                transition = ParserAction.CSI_DISPATCH << TableAccess.TRANSITION_ACTION_SHIFT | ParserState.GROUND;
+                this._preserveStack(ParserStackType.CSI, handlers, j, transition, k);
+                return handlerResult;
+              }
+            }
+            if (j < 0) {
+              this._csiHandlerFb(this._collect << 8 | ch, this._params);
+            }
+            this.precedingJoinState = 0;
+            i = k;
+            this.currentState = ParserState.GROUND;
+            csiDone = true;
+            break;
+          } else {
+            break;
+          }
+        }
+        if (!csiDone) {
+          i = k - 1;
+          this.currentState = ParserState.CSI_PARAM;
+        }
+        continue;
+      }
+
       // normal transition & action lookup
-      transition = this._transitions.table[this.currentState << TableAccess.INDEX_STATE_SHIFT | (code < 0xa0 ? code : NON_ASCII_PRINTABLE)];
+      transition = this._transitions.table[
+        this.currentState << TableAccess.INDEX_STATE_SHIFT |
+        (code < NON_ASCII_PRINTABLE ? code : NON_ASCII_PRINTABLE)
+      ];
       switch (transition >> TableAccess.TRANSITION_ACTION_SHIFT) {
         case ParserAction.PRINT:
-          // read ahead with loop unrolling
           // Note: 0x20 (SP) is included, 0x7F (DEL) is excluded
-          for (let j = i + 1; ; ++j) {
-            if (j >= length || (code = data[j]) < 0x20 || (code > 0x7e && code < NON_ASCII_PRINTABLE)) {
-              this._printHandler(data, i, j);
-              i = j - 1;
-              break;
-            }
-            if (++j >= length || (code = data[j]) < 0x20 || (code > 0x7e && code < NON_ASCII_PRINTABLE)) {
-              this._printHandler(data, i, j);
-              i = j - 1;
-              break;
-            }
-            if (++j >= length || (code = data[j]) < 0x20 || (code > 0x7e && code < NON_ASCII_PRINTABLE)) {
-              this._printHandler(data, i, j);
-              i = j - 1;
-              break;
-            }
-            if (++j >= length || (code = data[j]) < 0x20 || (code > 0x7e && code < NON_ASCII_PRINTABLE)) {
-              this._printHandler(data, i, j);
-              i = j - 1;
-              break;
+          let c = i;
+          const l4 = length - 4;
+          while (c < l4
+            && data[++c] >= 0x20 && (data[c] <= 0x7e || data[c] >= NON_ASCII_PRINTABLE)
+            && data[++c] >= 0x20 && (data[c] <= 0x7e || data[c] >= NON_ASCII_PRINTABLE)
+            && data[++c] >= 0x20 && (data[c] <= 0x7e || data[c] >= NON_ASCII_PRINTABLE)
+            && data[++c] >= 0x20 && (data[c] <= 0x7e || data[c] >= NON_ASCII_PRINTABLE)
+          ) {}
+          if (c >= l4) {
+            while (c < length && data[c] >= 0x20 && (data[c] <= 0x7e || data[c] >= NON_ASCII_PRINTABLE)) {
+              c++;
             }
           }
+          this._printHandler(data, i, c);
+          i = c - 1;
           break;
         case ParserAction.EXECUTE:
           if (this._executeHandlers[code]) this._executeHandlers[code]();
@@ -730,8 +849,7 @@ export class EscapeSequenceParser extends Disposable implements IEscapeSequenceP
           this.precedingJoinState = 0;
           break;
         case ParserAction.CLEAR:
-          this._params.reset();
-          this._params.addParam(0); // ZDM
+          this._params.resetZdm();
           this._collect = 0;
           break;
         case ParserAction.DCS_HOOK:
@@ -755,8 +873,7 @@ export class EscapeSequenceParser extends Disposable implements IEscapeSequenceP
             return handlerResult;
           }
           if (code === 0x1b) transition |= ParserState.ESCAPE;
-          this._params.reset();
-          this._params.addParam(0); // ZDM
+          this._params.resetZdm();
           this._collect = 0;
           this.precedingJoinState = 0;
           break;
@@ -780,8 +897,33 @@ export class EscapeSequenceParser extends Disposable implements IEscapeSequenceP
             return handlerResult;
           }
           if (code === 0x1b) transition |= ParserState.ESCAPE;
-          this._params.reset();
-          this._params.addParam(0); // ZDM
+          this._params.resetZdm();
+          this._collect = 0;
+          this.precedingJoinState = 0;
+          break;
+        case ParserAction.APC_START:
+          this._apcParser.start(this._collect << 8 | code);
+          break;
+        case ParserAction.APC_PUT:
+          // inner loop - exit APC_PUT: 0x18, 0x1a, 0x1b, 0x9c
+          // allowed: 00/08 .. 00/13, 02/00 .. 07/14 + NON_ASCII_PRINTABLE
+          for (let j = i + 1; ; ++j) {
+            if (j < length && (
+              (data[j] >= 0x20 && data[j] < 0x7f) || (data[j] >= 0x08 && data[j] < 0x0e) || data[j] >= NON_ASCII_PRINTABLE
+            )) continue;
+            this._apcParser.put(data, i, j);
+            i = j - 1;
+            break;
+          }
+          break;
+        case ParserAction.APC_END:
+          handlerResult = this._apcParser.end(code !== 0x18 && code !== 0x1a);
+          if (handlerResult) {
+            this._preserveStack(ParserStackType.APC, [], 0, transition, i);
+            return handlerResult;
+          }
+          if (code === 0x1b) transition |= ParserState.ESCAPE;
+          this._params.resetZdm();
           this._collect = 0;
           this.precedingJoinState = 0;
           break;

package/src/common/parser/OscParser.ts

@@ -3,10 +3,11 @@
  * @license MIT
  */
 
-import { IOscHandler, IHandlerCollection, OscFallbackHandlerType, IOscParser, ISubParserStackState } from 'common/parser/Types';
-import { OscState, PAYLOAD_LIMIT } from 'common/parser/Constants';
-import { utf32ToString } from 'common/input/TextDecoder';
-import { IDisposable } from 'common/Types';
+import { IOscHandler, IHandlerCollection, OscFallbackHandlerType, IOscParser, ISubParserStackState } from './Types';
+import { OscState, ParserConstants } from './Constants';
+import { utf32ToString } from '../input/TextDecoder';
+import { IDisposable } from '../Types';
+import { LimitedStringBuilder } from '../StringBuilder';
 
 const EMPTY_HANDLERS: IOscHandler[] = [];
 
@@ -23,9 +24,7 @@ export class OscParser implements IOscParser {
   };
 
   public registerHandler(ident: number, handler: IOscHandler): IDisposable {
-    if (this._handlers[ident] === undefined) {
-      this._handlers[ident] = [];
-    }
+    this._handlers[ident] ??= [];
     const handlerList = this._handlers[ident];
     handlerList.push(handler);
     return {
@@ -194,13 +193,15 @@ export class OscParser implements IOscParser {
  * as OSC handlers.
  */
 export class OscHandler implements IOscHandler {
-  private _data = '';
+  private static _payloadLimit = ParserConstants.PAYLOAD_LIMIT;
+
+  private _data = new LimitedStringBuilder(OscHandler._payloadLimit);
   private _hitLimit: boolean = false;
 
   constructor(private _handler: (data: string) => boolean | Promise<boolean>) { }
 
   public start(): void {
-    this._data = '';
+    this._data.reset();
     this._hitLimit = false;
   }
 
@@ -208,9 +209,7 @@ export class OscHandler implements IOscHandler {
     if (this._hitLimit) {
       return;
     }
-    this._data += utf32ToString(data, start, end);
-    if (this._data.length > PAYLOAD_LIMIT) {
-      this._data = '';
+    if (this._data.append(utf32ToString(data, start, end))) {
       this._hitLimit = true;
     }
   }
@@ -220,18 +219,18 @@ export class OscHandler implements IOscHandler {
     if (this._hitLimit) {
       ret = false;
     } else if (success) {
-      ret = this._handler(this._data);
+      ret = this._handler(this._data.toString());
       if (ret instanceof Promise) {
         // need to hold data until `ret` got resolved
         // dont care for errors, data will be freed anyway on next start
         return ret.then(res => {
-          this._data = '';
+          this._data.reset();
           this._hitLimit = false;
           return res;
         });
       }
     }
-    this._data = '';
+    this._data.reset();
     this._hitLimit = false;
     return ret;
   }

package/src/common/parser/Params.ts

@@ -2,12 +2,18 @@
  * Copyright (c) 2019 The xterm.js authors. All rights reserved.
  * @license MIT
  */
-import { IParams, ParamsArray } from 'common/parser/Types';
+import { IParams, ParamsArray } from './Types';
 
-// max value supported for a single param/subparam (clamped to positive int32 range)
-const MAX_VALUE = 0x7FFFFFFF;
-// max allowed subparams for a single sequence (hardcoded limitation)
-const MAX_SUBPARAMS = 256;
+const enum Constants {
+  /**
+   * Max value supported for a single param/subparam (clamped to positive int32 range)
+   */
+  MAX_VALUE = 0x7FFFFFFF,
+  /**
+   * Max allowed subparams for a single sequence (hardcoded limitation)
+   */
+  MAX_SUBPARAMS = 256
+}
 
 /**
  * Params storage class.
@@ -70,7 +76,7 @@ export class Params implements IParams {
    * @param maxSubParamsLength max length of storable sub parameters
    */
   constructor(public maxLength: number = 32, public maxSubParamsLength: number = 32) {
-    if (maxSubParamsLength > MAX_SUBPARAMS) {
+    if (maxSubParamsLength > Constants.MAX_SUBPARAMS) {
       throw new Error('maxSubParamsLength must not be greater than 256');
     }
     this.params = new Int32Array(maxLength);
@@ -129,6 +135,19 @@ export class Params implements IParams {
     this._digitIsSub = false;
   }
 
+  /**
+   * Reset and add 0 as first param (ZDM).
+   */
+  public resetZdm(): void {
+    this.length = 1;
+    this._subParamsLength = 0;
+    this._rejectDigits = false;
+    this._rejectSubDigits = false;
+    this._digitIsSub = false;
+    this._subParamsIdx[0] = 0;
+    this.params[0] = 0;
+  }
+
   /**
    * Add a parameter value.
    * `Params` only stores up to `maxLength` parameters, any later
@@ -146,7 +165,7 @@ export class Params implements IParams {
       throw new Error('values lesser than -1 are not allowed');
     }
     this._subParamsIdx[this.length] = this._subParamsLength << 8 | this._subParamsLength;
-    this.params[this.length++] = value > MAX_VALUE ? MAX_VALUE : value;
+    this.params[this.length++] = value > Constants.MAX_VALUE ? Constants.MAX_VALUE : value;
   }
 
   /**
@@ -168,7 +187,7 @@ export class Params implements IParams {
     if (value < -1) {
       throw new Error('values lesser than -1 are not allowed');
     }
-    this._subParams[this._subParamsLength++] = value > MAX_VALUE ? MAX_VALUE : value;
+    this._subParams[this._subParamsLength++] = value > Constants.MAX_VALUE ? Constants.MAX_VALUE : value;
     this._subParamsIdx[this.length - 1]++;
   }
 
@@ -224,6 +243,6 @@ export class Params implements IParams {
 
     const store = this._digitIsSub ? this._subParams : this.params;
     const cur = store[length - 1];
-    store[length - 1] = ~cur ? Math.min(cur * 10 + value, MAX_VALUE) : value;
+    store[length - 1] = ~cur ? Math.min(cur * 10 + value, Constants.MAX_VALUE) : value;
   }
 }