better interfaces, cleanup

src/InputHandler.ts

@@ -1576,7 +1576,6 @@ export class InputHandler extends Disposable implements IInputHandler {
     }
   }
 
-
   /**
    * Helper to extract and apply color params/subparams.
    * Returns advance for params index.
@@ -1849,6 +1848,7 @@ export class InputHandler extends Disposable implements IInputHandler {
         break;
     }
   }
+
   public deviceStatusPrivate(params: IParams): void {
     // modern xterm doesnt seem to
     // respond to any of these except ?6, 6, and 5

src/Types.d.ts

@@ -114,7 +114,7 @@ export interface IInputHandler {
   /** CSI a */ hPositionRelative(params: IParams): void;
   /** CSI b */ repeatPrecedingCharacter(params: IParams): void;
   /** CSI c */ sendDeviceAttributesPrimary(params: IParams): void;
-               sendDeviceAttributesSecondary(params: IParams): void;
+  /** CSI > c */ sendDeviceAttributesSecondary(params: IParams): void;
   /** CSI d */ linePosAbsolute(params: IParams): void;
   /** CSI e */ vPositionRelative(params: IParams): void;
   /** CSI f */ hVPosition(params: IParams): void;

src/common/parser/DcsParser.test.ts

@@ -75,7 +75,7 @@ describe('DcsParser', () => {
   beforeEach(() => {
     reports = [];
     parser = new DcsParser();
-    parser.setDcsHandlerFallback((id, action, data) => {
+    parser.setHandlerFallback((id, action, data) => {
       if (action === 'HOOK') {
         data = data.toArray();
       }
@@ -84,7 +84,7 @@ describe('DcsParser', () => {
   });
   describe('handler registration', () => {
     it('setDcsHandler', () => {
-      parser.setDcsHandler(identifier({intermediates: '+', final: 'p'}), new TestHandler(reports, 'th'));
+      parser.setHandler(identifier({intermediates: '+', final: 'p'}), new TestHandler(reports, 'th'));
       parser.hook(identifier({intermediates: '+', final: 'p'}), Params.fromArray([1, 2, 3]));
       let data = toUtf32('Here comes');
       parser.put(data, 0, data.length);
@@ -100,8 +100,8 @@ describe('DcsParser', () => {
       ]);
     });
     it('clearDcsHandler', () => {
-      parser.setDcsHandler(identifier({intermediates: '+', final: 'p'}), new TestHandler(reports, 'th'));
-      parser.clearDcsHandler(identifier({intermediates: '+', final: 'p'}));
+      parser.setHandler(identifier({intermediates: '+', final: 'p'}), new TestHandler(reports, 'th'));
+      parser.clearHandler(identifier({intermediates: '+', final: 'p'}));
       parser.hook(identifier({intermediates: '+', final: 'p'}), Params.fromArray([1, 2, 3]));
       let data = toUtf32('Here comes');
       parser.put(data, 0, data.length);
@@ -117,8 +117,8 @@ describe('DcsParser', () => {
       ]);
     });
     it('addDcsHandler', () => {
-      parser.setDcsHandler(identifier({intermediates: '+', final: 'p'}), new TestHandler(reports, 'th1'));
-      parser.addDcsHandler(identifier({intermediates: '+', final: 'p'}), new TestHandler(reports, 'th2'));
+      parser.setHandler(identifier({intermediates: '+', final: 'p'}), new TestHandler(reports, 'th1'));
+      parser.addHandler(identifier({intermediates: '+', final: 'p'}), new TestHandler(reports, 'th2'));
       parser.hook(identifier({intermediates: '+', final: 'p'}), Params.fromArray([1, 2, 3]));
       let data = toUtf32('Here comes');
       parser.put(data, 0, data.length);
@@ -137,8 +137,8 @@ describe('DcsParser', () => {
       ]);
     });
     it('addDcsHandler with return false', () => {
-      parser.setDcsHandler(identifier({intermediates: '+', final: 'p'}), new TestHandler(reports, 'th1'));
-      parser.addDcsHandler(identifier({intermediates: '+', final: 'p'}), new TestHandler(reports, 'th2', true));
+      parser.setHandler(identifier({intermediates: '+', final: 'p'}), new TestHandler(reports, 'th1'));
+      parser.addHandler(identifier({intermediates: '+', final: 'p'}), new TestHandler(reports, 'th2', true));
       parser.hook(identifier({intermediates: '+', final: 'p'}), Params.fromArray([1, 2, 3]));
       let data = toUtf32('Here comes');
       parser.put(data, 0, data.length);
@@ -157,8 +157,8 @@ describe('DcsParser', () => {
       ]);
     });
     it('dispose handlers', () => {
-      parser.setDcsHandler(identifier({intermediates: '+', final: 'p'}), new TestHandler(reports, 'th1'));
-      const dispo = parser.addDcsHandler(identifier({intermediates: '+', final: 'p'}), new TestHandler(reports, 'th2', true));
+      parser.setHandler(identifier({intermediates: '+', final: 'p'}), new TestHandler(reports, 'th1'));
+      const dispo = parser.addHandler(identifier({intermediates: '+', final: 'p'}), new TestHandler(reports, 'th2', true));
       dispo.dispose();
       parser.hook(identifier({intermediates: '+', final: 'p'}), Params.fromArray([1, 2, 3]));
       let data = toUtf32('Here comes');
@@ -176,7 +176,7 @@ describe('DcsParser', () => {
   });
   describe('DcsHandlerFactory', () => {
     it('should be called once on end(true)', () => {
-      parser.setDcsHandler(identifier({intermediates: '+', final: 'p'}), new DcsHandler((data, params) => reports.push([params.toArray(), data])));
+      parser.setHandler(identifier({intermediates: '+', final: 'p'}), new DcsHandler((data, params) => reports.push([params.toArray(), data])));
       parser.hook(identifier({intermediates: '+', final: 'p'}), Params.fromArray([1, 2, 3]));
       let data = toUtf32('Here comes');
       parser.put(data, 0, data.length);
@@ -186,7 +186,7 @@ describe('DcsParser', () => {
       assert.deepEqual(reports, [[[1, 2, 3], 'Here comes the mouse!']]);
     });
     it('should not be called on end(false)', () => {
-      parser.setDcsHandler(identifier({intermediates: '+', final: 'p'}), new DcsHandler((data, params) => reports.push([params.toArray(), data])));
+      parser.setHandler(identifier({intermediates: '+', final: 'p'}), new DcsHandler((data, params) => reports.push([params.toArray(), data])));
       parser.hook(identifier({intermediates: '+', final: 'p'}), Params.fromArray([1, 2, 3]));
       let data = toUtf32('Here comes');
       parser.put(data, 0, data.length);
@@ -196,8 +196,8 @@ describe('DcsParser', () => {
       assert.deepEqual(reports, []);
     });
     it('should be disposable', () => {
-      parser.setDcsHandler(identifier({intermediates: '+', final: 'p'}), new DcsHandler((data, params) => reports.push(['one', params.toArray(), data])));
-      const dispo = parser.addDcsHandler(identifier({intermediates: '+', final: 'p'}), new DcsHandler((data, params) => reports.push(['two', params.toArray(), data])));
+      parser.setHandler(identifier({intermediates: '+', final: 'p'}), new DcsHandler((data, params) => reports.push(['one', params.toArray(), data])));
+      const dispo = parser.addHandler(identifier({intermediates: '+', final: 'p'}), new DcsHandler((data, params) => reports.push(['two', params.toArray(), data])));
       parser.hook(identifier({intermediates: '+', final: 'p'}), Params.fromArray([1, 2, 3]));
       let data = toUtf32('Here comes');
       parser.put(data, 0, data.length);
@@ -215,8 +215,8 @@ describe('DcsParser', () => {
       assert.deepEqual(reports, [['two', [1, 2, 3], 'Here comes the mouse!'], ['one', [1, 2, 3], 'some other data']]);
     });
     it('should respect return false', () => {
-      parser.setDcsHandler(identifier({intermediates: '+', final: 'p'}), new DcsHandler((data, params) => reports.push(['one', params.toArray(), data])));
-      parser.addDcsHandler(identifier({intermediates: '+', final: 'p'}), new DcsHandler((data, params) => { reports.push(['two', params.toArray(), data]); return false; }));
+      parser.setHandler(identifier({intermediates: '+', final: 'p'}), new DcsHandler((data, params) => reports.push(['one', params.toArray(), data])));
+      parser.addHandler(identifier({intermediates: '+', final: 'p'}), new DcsHandler((data, params) => { reports.push(['two', params.toArray(), data]); return false; }));
       parser.hook(identifier({intermediates: '+', final: 'p'}), Params.fromArray([1, 2, 3]));
       let data = toUtf32('Here comes');
       parser.put(data, 0, data.length);
@@ -227,7 +227,7 @@ describe('DcsParser', () => {
     });
     it('should work up to payload limit', function(): void {
       this.timeout(10000);
-      parser.setDcsHandler(identifier({intermediates: '+', final: 'p'}), new DcsHandler((data, params) => reports.push([params.toArray(), data])));
+      parser.setHandler(identifier({intermediates: '+', final: 'p'}), new DcsHandler((data, params) => reports.push([params.toArray(), data])));
       parser.hook(identifier({intermediates: '+', final: 'p'}), Params.fromArray([1, 2, 3]));
       const data = toUtf32('A'.repeat(1000));
       for (let i = 0; i < PAYLOAD_LIMIT; i += 1000) {
@@ -238,7 +238,7 @@ describe('DcsParser', () => {
     });
     it('should abort for payload limit +1', function(): void {
       this.timeout(10000);
-      parser.setDcsHandler(identifier({intermediates: '+', final: 'p'}), new DcsHandler((data, params) => reports.push([params.toArray(), data])));
+      parser.setHandler(identifier({intermediates: '+', final: 'p'}), new DcsHandler((data, params) => reports.push([params.toArray(), data])));
       parser.hook(identifier({intermediates: '+', final: 'p'}), Params.fromArray([1, 2, 3]));
       let data = toUtf32('A'.repeat(1000));
       for (let i = 0; i < PAYLOAD_LIMIT; i += 1000) {

src/common/parser/DcsParser.ts

@@ -9,11 +9,11 @@ import { utf32ToString } from 'common/input/TextDecoder';
 import { Params } from 'common/parser/Params';
 import { PAYLOAD_LIMIT } from 'common/parser/Constants';
 
+const EMPTY_HANDLERS: IDcsHandler[] = [];
 
 export class DcsParser implements IDcsParser {
   private _handlers: IHandlerCollection<IDcsHandler> = Object.create(null);
-  private _empty: IDcsHandler[] = [];
-  private _active: IDcsHandler[] = this._empty;
+  private _active: IDcsHandler[] = EMPTY_HANDLERS;
   private _ident: number = 0;
   private _handlerFb: DcsFallbackHandler = () => {};
 
@@ -22,7 +22,7 @@ export class DcsParser implements IDcsParser {
     this._handlerFb = () => {};
   }
 
-  public addDcsHandler(ident: number, handler: IDcsHandler): IDisposable {
+  public addHandler(ident: number, handler: IDcsHandler): IDisposable {
     if (this._handlers[ident] === undefined) {
       this._handlers[ident] = [];
     }
@@ -38,15 +38,15 @@ export class DcsParser implements IDcsParser {
     };
   }
 
-  public setDcsHandler(ident: number, handler: IDcsHandler): void {
+  public setHandler(ident: number, handler: IDcsHandler): void {
     this._handlers[ident] = [handler];
   }
 
-  public clearDcsHandler(ident: number): void {
+  public clearHandler(ident: number): void {
     if (this._handlers[ident]) delete this._handlers[ident];
   }
 
-  public setDcsHandlerFallback(handler: DcsFallbackHandler): void {
+  public setHandlerFallback(handler: DcsFallbackHandler): void {
     this._handlerFb = handler;
   }
 
@@ -54,7 +54,7 @@ export class DcsParser implements IDcsParser {
     if (this._active.length) {
       this.unhook(false);
     }
-    this._active = this._empty;
+    this._active = EMPTY_HANDLERS;
     this._ident = 0;
   }
 
@@ -62,7 +62,7 @@ export class DcsParser implements IDcsParser {
     // always reset leftover handlers
     this.reset();
     this._ident = ident;
-    this._active = this._handlers[ident] || this._empty;
+    this._active = this._handlers[ident] || EMPTY_HANDLERS;
     if (!this._active.length) {
       this._handlerFb(this._ident, 'HOOK', params);
     } else {
@@ -98,7 +98,7 @@ export class DcsParser implements IDcsParser {
         this._active[j].unhook(false);
       }
     }
-    this._active = this._empty;
+    this._active = EMPTY_HANDLERS;
     this._ident = 0;
   }
 }

src/common/parser/EscapeSequenceParser.test.ts

@@ -41,16 +41,16 @@ class MockOscPutParser implements IOscParser {
       this._fallback(id, 'END', this.data.slice(this.data.indexOf(';') + 1));
     }
   }
-  addOscHandler(ident: number, handler: IOscHandler): IDisposable {
+  addHandler(ident: number, handler: IOscHandler): IDisposable {
     throw new Error('not implemented');
   }
-  setOscHandler(ident: number, handler: IOscHandler): void {
+  setHandler(ident: number, handler: IOscHandler): void {
     throw new Error('not implemented');
   }
-  clearOscHandler(ident: number): void {
+  clearHandler(ident: number): void {
     throw new Error('not implemented');
   }
-  setOscHandlerFallback(handler: OscFallbackHandler): void {
+  setHandlerFallback(handler: OscFallbackHandler): void {
     this._fallback = handler;
   }
 }

src/common/parser/EscapeSequenceParser.ts

@@ -404,29 +404,29 @@ export class EscapeSequenceParser extends Disposable implements IEscapeSequenceP
   }
 
   public addOscHandler(ident: number, handler: IOscHandler): IDisposable {
-    return this._oscParser.addOscHandler(ident, handler);
+    return this._oscParser.addHandler(ident, handler);
   }
   public setOscHandler(ident: number, handler: IOscHandler): void {
-    this._oscParser.setOscHandler(ident, handler);
+    this._oscParser.setHandler(ident, handler);
   }
   public clearOscHandler(ident: number): void {
-    this._oscParser.clearOscHandler(ident);
+    this._oscParser.clearHandler(ident);
   }
   public setOscHandlerFallback(handler: OscFallbackHandler): void {
-    this._oscParser.setOscHandlerFallback(handler);
+    this._oscParser.setHandlerFallback(handler);
   }
 
   public addDcsHandler(id: IFunctionIdentifier, handler: IDcsHandler): IDisposable {
-    return this._dcsParser.addDcsHandler(this._identifier(id), handler);
+    return this._dcsParser.addHandler(this._identifier(id), handler);
   }
   public setDcsHandler(id: IFunctionIdentifier, handler: IDcsHandler): void {
-    this._dcsParser.setDcsHandler(this._identifier(id), handler);
+    this._dcsParser.setHandler(this._identifier(id), handler);
   }
   public clearDcsHandler(id: IFunctionIdentifier): void {
-    this._dcsParser.clearDcsHandler(this._identifier(id));
+    this._dcsParser.clearHandler(this._identifier(id));
   }
   public setDcsHandlerFallback(handler: DcsFallbackHandler): void {
-    this._dcsParser.setDcsHandlerFallback(handler);
+    this._dcsParser.setHandlerFallback(handler);
   }
 
   public setErrorHandler(callback: (state: IParsingState) => IParsingState): void {
@@ -443,7 +443,6 @@ export class EscapeSequenceParser extends Disposable implements IEscapeSequenceP
     this._params.reset();
     this._params.addParam(0); // ZDM
     this._collect = 0;
-    // this._activeDcsHandler = this._dcsHandlerFb;
     this.precedingCodepoint = 0;
   }
 

src/common/parser/OscParser.test.ts

@@ -37,7 +37,7 @@ describe('OscParser', () => {
   beforeEach(() => {
     reports = [];
     parser = new OscParser();
-    parser.setOscHandlerFallback((id, action, data) => {
+    parser.setHandlerFallback((id, action, data) => {
       reports.push([id, action, data]);
     });
   });
@@ -78,7 +78,7 @@ describe('OscParser', () => {
   });
   describe('handler registration', () => {
     it('setOscHandler', () => {
-      parser.setOscHandler(1234, new TestHandler(1234, reports, 'th'));
+      parser.setHandler(1234, new TestHandler(1234, reports, 'th'));
       parser.start();
       let data = toUtf32('1234;Here comes');
       parser.put(data, 0, data.length);
@@ -94,8 +94,8 @@ describe('OscParser', () => {
       ]);
     });
     it('clearOscHandler', () => {
-      parser.setOscHandler(1234, new TestHandler(1234, reports, 'th'));
-      parser.clearOscHandler(1234);
+      parser.setHandler(1234, new TestHandler(1234, reports, 'th'));
+      parser.clearHandler(1234);
       parser.start();
       let data = toUtf32('1234;Here comes');
       parser.put(data, 0, data.length);
@@ -111,8 +111,8 @@ describe('OscParser', () => {
       ]);
     });
     it('addOscHandler', () => {
-      parser.setOscHandler(1234, new TestHandler(1234, reports, 'th1'));
-      parser.addOscHandler(1234, new TestHandler(1234, reports, 'th2'));
+      parser.setHandler(1234, new TestHandler(1234, reports, 'th1'));
+      parser.addHandler(1234, new TestHandler(1234, reports, 'th2'));
       parser.start();
       let data = toUtf32('1234;Here comes');
       parser.put(data, 0, data.length);
@@ -131,8 +131,8 @@ describe('OscParser', () => {
       ]);
     });
     it('addOscHandler with return false', () => {
-      parser.setOscHandler(1234, new TestHandler(1234, reports, 'th1'));
-      parser.addOscHandler(1234, new TestHandler(1234, reports, 'th2', true));
+      parser.setHandler(1234, new TestHandler(1234, reports, 'th1'));
+      parser.addHandler(1234, new TestHandler(1234, reports, 'th2', true));
       parser.start();
       let data = toUtf32('1234;Here comes');
       parser.put(data, 0, data.length);
@@ -151,8 +151,8 @@ describe('OscParser', () => {
       ]);
     });
     it('dispose handlers', () => {
-      parser.setOscHandler(1234, new TestHandler(1234, reports, 'th1'));
-      const dispo = parser.addOscHandler(1234, new TestHandler(1234, reports, 'th2', true));
+      parser.setHandler(1234, new TestHandler(1234, reports, 'th1'));
+      const dispo = parser.addHandler(1234, new TestHandler(1234, reports, 'th2', true));
       dispo.dispose();
       parser.start();
       let data = toUtf32('1234;Here comes');
@@ -170,7 +170,7 @@ describe('OscParser', () => {
   });
   describe('OscHandlerFactory', () => {
     it('should be called once on end(true)', () => {
-      parser.setOscHandler(1234, new OscHandler(data => reports.push([1234, data])));
+      parser.setHandler(1234, new OscHandler(data => reports.push([1234, data])));
       parser.start();
       let data = toUtf32('1234;Here comes');
       parser.put(data, 0, data.length);
@@ -180,7 +180,7 @@ describe('OscParser', () => {
       assert.deepEqual(reports, [[1234, 'Here comes the mouse!']]);
     });
     it('should not be called on end(false)', () => {
-      parser.setOscHandler(1234, new OscHandler(data => reports.push([1234, data])));
+      parser.setHandler(1234, new OscHandler(data => reports.push([1234, data])));
       parser.start();
       let data = toUtf32('1234;Here comes');
       parser.put(data, 0, data.length);
@@ -190,8 +190,8 @@ describe('OscParser', () => {
       assert.deepEqual(reports, []);
     });
     it('should be disposable', () => {
-      parser.setOscHandler(1234, new OscHandler(data => reports.push(['one', data])));
-      const dispo = parser.addOscHandler(1234, new OscHandler(data => reports.push(['two', data])));
+      parser.setHandler(1234, new OscHandler(data => reports.push(['one', data])));
+      const dispo = parser.addHandler(1234, new OscHandler(data => reports.push(['two', data])));
       parser.start();
       let data = toUtf32('1234;Here comes');
       parser.put(data, 0, data.length);
@@ -209,8 +209,8 @@ describe('OscParser', () => {
       assert.deepEqual(reports, [['two', 'Here comes the mouse!'], ['one', 'some other data']]);
     });
     it('should respect return false', () => {
-      parser.setOscHandler(1234, new OscHandler(data => reports.push(['one', data])));
-      parser.addOscHandler(1234, new OscHandler(data => { reports.push(['two', data]); return false; }));
+      parser.setHandler(1234, new OscHandler(data => reports.push(['one', data])));
+      parser.addHandler(1234, new OscHandler(data => { reports.push(['two', data]); return false; }));
       parser.start();
       let data = toUtf32('1234;Here comes');
       parser.put(data, 0, data.length);
@@ -221,7 +221,7 @@ describe('OscParser', () => {
     });
     it('should work up to payload limit', function(): void {
       this.timeout(10000);
-      parser.setOscHandler(1234, new OscHandler(data => reports.push([1234, data])));
+      parser.setHandler(1234, new OscHandler(data => reports.push([1234, data])));
       parser.start();
       let data = toUtf32('1234;');
       parser.put(data, 0, data.length);
@@ -234,7 +234,7 @@ describe('OscParser', () => {
     });
     it('should abort for payload limit +1', function(): void {
       this.timeout(10000);
-      parser.setOscHandler(1234, new OscHandler(data => reports.push([1234, data])));
+      parser.setHandler(1234, new OscHandler(data => reports.push([1234, data])));
       parser.start();
       let data = toUtf32('1234;');
       parser.put(data, 0, data.length);

src/common/parser/OscParser.ts

@@ -3,20 +3,19 @@
  * @license MIT
  */
 
-import { IOscHandler, IHandlerCollection, OscFallbackHandler } from 'common/parser/Types';
+import { IOscHandler, IHandlerCollection, OscFallbackHandler, IOscParser } from 'common/parser/Types';
 import { OscState, PAYLOAD_LIMIT } from 'common/parser/Constants';
-import { Disposable } from 'common/Lifecycle';
 import { utf32ToString } from 'common/input/TextDecoder';
 import { IDisposable } from 'common/Types';
 
 
-export class OscParser extends Disposable {
+export class OscParser implements IOscParser {
   private _state = OscState.START;
   private _id = -1;
   private _handlers: IHandlerCollection<IOscHandler> = Object.create(null);
   private _handlerFb: OscFallbackHandler = () => { };
 
-  public addOscHandler(ident: number, handler: IOscHandler): IDisposable {
+  public addHandler(ident: number, handler: IOscHandler): IDisposable {
     if (this._handlers[ident] === undefined) {
       this._handlers[ident] = [];
     }
@@ -31,13 +30,13 @@ export class OscParser extends Disposable {
       }
     };
   }
-  public setOscHandler(ident: number, handler: IOscHandler): void {
+  public setHandler(ident: number, handler: IOscHandler): void {
     this._handlers[ident] = [handler];
   }
-  public clearOscHandler(ident: number): void {
+  public clearHandler(ident: number): void {
     if (this._handlers[ident]) delete this._handlers[ident];
   }
-  public setOscHandlerFallback(handler: OscFallbackHandler): void {
+  public setHandlerFallback(handler: OscFallbackHandler): void {
     this._handlerFb = handler;
   }
 

src/common/parser/Types.d.ts

@@ -179,28 +179,37 @@ export interface IEscapeSequenceParser extends IDisposable {
   clearErrorHandler(): void;
 }
 
-export interface IOscParser extends IDisposable {
-  addOscHandler(ident: number, handler: IOscHandler): IDisposable;
-  setOscHandler(ident: number, handler: IOscHandler): void;
-  clearOscHandler(ident: number): void;
-  setOscHandlerFallback(handler: OscFallbackHandler): void;
+/**
+ * Subparser interfaces.
+ * The subparsers are instantiated in `EscapeSequenceParser` and
+ * called during `EscapeSequenceParser.parse`.
+ */
+export interface ISubParser<T, U> extends IDisposable {
   reset(): void;
-  start(): void;
+  addHandler(ident: number, handler: T): IDisposable;
+  setHandler(ident: number, handler: T): void;
+  clearHandler(ident: number): void;
+  setHandlerFallback(handler: U): void;
   put(data: Uint32Array, start: number, end: number): void;
+}
+
+export interface IOscParser extends ISubParser<IOscHandler, OscFallbackHandler> {
+  start(): void;
   end(success: boolean): void;
 }
 
-export interface IDcsParser extends IDisposable {
-  addDcsHandler(ident: number, handler: IDcsHandler): IDisposable;
-  setDcsHandler(ident: number, handler: IDcsHandler): void;
-  clearDcsHandler(ident: number): void;
-  setDcsHandlerFallback(handler: DcsFallbackHandler): void;
-  reset(): void;
+export interface IDcsParser extends ISubParser<IDcsHandler, DcsFallbackHandler> {
   hook(ident: number, params: IParams): void;
-  put(data: Uint32Array, start: number, end: number): void;
   unhook(success: boolean): void;
 }
 
+/**
+ * Interface to denote a specific ESC, CSI or DCS handler slot.
+ * The values are used to create an integer respresentation during handler
+ * regristation before passed to the subparsers as `ident`.
+ * The integer translation is made to allow faster key-value access
+ * in `EscapeSequenceParser.parse`.
+ */
 export interface IFunctionIdentifier {
   prefix?: string;
   intermediates?: string;

src/public/Terminal.ts

@@ -21,7 +21,6 @@ export class Terminal implements ITerminalApi {
   constructor(options?: ITerminalOptions) {
     this._core = new TerminalCore(options);
     this._addonManager = new AddonManager();
-    this._parser = new ParserApi(this._core);
   }
 
   public get onCursorMove(): IEvent<void> { return this._core.onCursorMove; }
@@ -35,7 +34,12 @@ export class Terminal implements ITerminalApi {
   public get onResize(): IEvent<{ cols: number, rows: number }> { return this._core.onResize; }
 
   public get element(): HTMLElement { return this._core.element; }
-  public get parser(): IParser { return this._parser; }
+  public get parser(): IParser {
+    if (!this._parser) {
+      this._parser = new ParserApi(this._core);
+    }
+    return this._parser;
+  }
   public get textarea(): HTMLTextAreaElement { return this._core.textarea; }
   public get rows(): number { return this._core.rows; }
   public get cols(): number { return this._core.cols; }

typings/xterm.d.ts

@@ -970,7 +970,7 @@ declare module 'xterm' {
   }
 
   /**
-   * Parser interface.
+   * (EXPERIMENTAL) Parser interface.
    */
   export interface IParser {
     /**