diff --git a/src/EscapeSequenceParser.test.ts b/src/EscapeSequenceParser.test.ts
new file mode 100644
index 00000000..eefa7603
--- /dev/null
+++ b/src/EscapeSequenceParser.test.ts
@@ -0,0 +1,1042 @@
+import { AnsiParser, IParserTerminal } from './EscapeSequenceParser';
+import * as chai from 'chai';
+
+function r(a: number, b: number): string[] {
+    let c = b - a;
+    let arr = new Array(c);
+    while (c--) {
+        arr[c] = String.fromCharCode(--b);
+    }
+    return arr;
+}
+
+interface ITestTerminal extends IParserTerminal {
+    calls: any[];
+    clear: () => void;
+    compare: (value: any) => void;
+}
+
+let testTerminal: ITestTerminal = {
+    calls: [],
+    clear: function (): void {
+        this.calls = [];
+    },
+    compare: function (value: any): void {
+        chai.expect(this.calls.slice()).eql(value); // weird bug w'o slicing here
+    },
+    inst_p: function (s: string, start: number, end: number): void {
+        this.calls.push(['print', s.substring(start, end)]);
+    },
+    inst_o: function (s: string): void {
+        this.calls.push(['osc', s]);
+    },
+    inst_x: function (flag: string): void {
+        this.calls.push(['exe', flag]);
+    },
+    inst_c: function (collected: string, params: number[], flag: string): void {
+        this.calls.push(['csi', collected, params, flag]);
+    },
+    inst_e: function (collected: string, flag: string): void {
+        this.calls.push(['esc', collected, flag]);
+    },
+    inst_H: function (collected: string, params: number[], flag: string): void {
+        this.calls.push(['dcs hook', collected, params, flag]);
+    },
+    inst_P: function (dcs: string): void {
+        this.calls.push(['dcs put', dcs]);
+    },
+    inst_U: function (): void {
+        this.calls.push(['dcs unhook']);
+    }
+};
+
+let parser = new AnsiParser(testTerminal);
+
+describe('Parser init and methods', function(): void {
+    it('parser init', function (): void {
+        let p = new AnsiParser({});
+        chai.expect(p.term).a('object');
+        chai.expect(p.term.inst_p).a('function');
+        chai.expect(p.term.inst_o).a('function');
+        chai.expect(p.term.inst_x).a('function');
+        chai.expect(p.term.inst_c).a('function');
+        chai.expect(p.term.inst_e).a('function');
+        chai.expect(p.term.inst_H).a('function');
+        chai.expect(p.term.inst_P).a('function');
+        chai.expect(p.term.inst_U).a('function');
+        p.parse('\x1b[31mHello World!');
+    });
+    it('terminal callbacks', function (): void {
+        chai.expect(parser.term).equal(testTerminal);
+        chai.expect(parser.term.inst_p).equal(testTerminal.inst_p);
+        chai.expect(parser.term.inst_o).equal(testTerminal.inst_o);
+        chai.expect(parser.term.inst_x).equal(testTerminal.inst_x);
+        chai.expect(parser.term.inst_c).equal(testTerminal.inst_c);
+        chai.expect(parser.term.inst_e).equal(testTerminal.inst_e);
+        chai.expect(parser.term.inst_H).equal(testTerminal.inst_H);
+        chai.expect(parser.term.inst_P).equal(testTerminal.inst_P);
+        chai.expect(parser.term.inst_U).equal(testTerminal.inst_U);
+    });
+    it('inital states', function (): void {
+        chai.expect(parser.initialState).equal(0);
+        chai.expect(parser.currentState).equal(0);
+        chai.expect(parser.osc).equal('');
+        chai.expect(parser.params).eql([0]);
+        chai.expect(parser.collected).equal('');
+    });
+    it('reset states', function (): void {
+        parser.currentState = 124;
+        parser.osc = '#';
+        parser.params = [123];
+        parser.collected = '#';
+
+        parser.reset();
+        chai.expect(parser.currentState).equal(0);
+        chai.expect(parser.osc).equal('');
+        chai.expect(parser.params).eql([0]);
+        chai.expect(parser.collected).equal('');
+    });
+});
+
+describe('state transitions and actions', function(): void {
+    it('state GROUND execute action', function (): void {
+        parser.reset();
+        testTerminal.clear();
+        let exes = r(0x00, 0x18);
+        exes.concat(['\x19']);
+        exes.concat(r(0x1c, 0x20));
+        for (let i = 0; i < exes.length; ++i) {
+            parser.currentState = 0;
+            parser.parse(exes[i]);
+            chai.expect(parser.currentState).equal(0);
+            testTerminal.compare([['exe', exes[i]]]);
+            parser.reset();
+            testTerminal.clear();
+        }
+    });
+    it('state GROUND print action', function (): void {
+        parser.reset();
+        testTerminal.clear();
+        let printables = r(0x20, 0x7f); // NOTE: DEL excluded
+        for (let i = 0; i < printables.length; ++i) {
+            parser.currentState = 0;
+            parser.parse(printables[i]);
+            chai.expect(parser.currentState).equal(0);
+            testTerminal.compare([['print', printables[i]]]);
+            parser.reset();
+            testTerminal.clear();
+        }
+    });
+    it('trans ANYWHERE --> GROUND with actions', function (): void {
+        let exes = [
+            '\x18', '\x1a',
+            '\x80', '\x81', '\x82', '\x83', '\x84', '\x85', '\x86', '\x87', '\x88',
+            '\x89', '\x8a', '\x8b', '\x8c', '\x8d', '\x8e', '\x8f',
+            '\x91', '\x92', '\x93', '\x94', '\x95', '\x96', '\x97', '\x99', '\x9a'
+        ];
+        let exceptions = {
+            8: {'\x18': [], '\x1a': []} // simply abort osc state
+        };
+        parser.reset();
+        testTerminal.clear();
+        for (let state = 0; state < 14; ++state) {
+            for (let i = 0; i < exes.length; ++i) {
+                parser.currentState = state;
+                parser.parse(exes[i]);
+                chai.expect(parser.currentState).equal(0);
+                testTerminal.compare(((exceptions[state]) ? exceptions[state][exes[i]] : 0) || [['exe', exes[i]]]);
+                parser.reset();
+                testTerminal.clear();
+            }
+            parser.parse('\x9c');
+            chai.expect(parser.currentState).equal(0);
+            testTerminal.compare([]);
+            parser.reset();
+            testTerminal.clear();
+        }
+    });
+    it('trans ANYWHERE --> ESCAPE with clear', function (): void {
+        parser.reset();
+        for (let state = 0; state < 14; ++state) {
+            parser.currentState = state;
+            parser.osc = '#';
+            parser.params = [23];
+            parser.collected = '#';
+            parser.parse('\x1b');
+            chai.expect(parser.currentState).equal(1);
+            chai.expect(parser.osc).equal('');
+            chai.expect(parser.params).eql([0]);
+            chai.expect(parser.collected).equal('');
+            parser.reset();
+        }
+    });
+    it('state ESCAPE execute rules', function (): void {
+        parser.reset();
+        testTerminal.clear();
+        let exes = r(0x00, 0x18);
+        exes.concat(['\x19']);
+        exes.concat(r(0x1c, 0x20));
+        for (let i = 0; i < exes.length; ++i) {
+            parser.currentState = 1;
+            parser.parse(exes[i]);
+            chai.expect(parser.currentState).equal(1);
+            testTerminal.compare([['exe', exes[i]]]);
+            parser.reset();
+            testTerminal.clear();
+        }
+    });
+    it('state ESCAPE ignore', function (): void {
+        parser.reset();
+        testTerminal.clear();
+        parser.currentState = 1;
+        parser.parse('\x7f');
+        chai.expect(parser.currentState).equal(1);
+        testTerminal.compare([]);
+        parser.reset();
+        testTerminal.clear();
+    });
+    it('trans ESCAPE --> GROUND with ecs_dispatch action', function (): void {
+        parser.reset();
+        testTerminal.clear();
+        let dispatches = r(0x30, 0x50);
+        dispatches.concat(r(0x51, 0x58));
+        dispatches.concat(['\x59', '\x5a', '\x5c']);
+        dispatches.concat(r(0x60, 0x7f));
+        for (let i = 0; i < dispatches.length; ++i) {
+            parser.currentState = 1;
+            parser.parse(dispatches[i]);
+            chai.expect(parser.currentState).equal(0);
+            testTerminal.compare([['esc', '', dispatches[i]]]);
+            parser.reset();
+            testTerminal.clear();
+        }
+    });
+    it('trans ESCAPE --> ESCAPE_INTERMEDIATE with collect action', function (): void {
+        parser.reset();
+        let collect = r(0x20, 0x30);
+        for (let i = 0; i < collect.length; ++i) {
+            parser.currentState = 1;
+            parser.parse(collect[i]);
+            chai.expect(parser.currentState).equal(2);
+            chai.expect(parser.collected).equal(collect[i]);
+            parser.reset();
+        }
+    });
+    it('state ESCAPE_INTERMEDIATE execute rules', function (): void {
+        parser.reset();
+        testTerminal.clear();
+        let exes = r(0x00, 0x18);
+        exes.concat(['\x19']);
+        exes.concat(r(0x1c, 0x20));
+        for (let i = 0; i < exes.length; ++i) {
+            parser.currentState = 2;
+            parser.parse(exes[i]);
+            chai.expect(parser.currentState).equal(2);
+            testTerminal.compare([['exe', exes[i]]]);
+            parser.reset();
+            testTerminal.clear();
+        }
+    });
+    it('state ESCAPE_INTERMEDIATE ignore', function (): void {
+        parser.reset();
+        testTerminal.clear();
+        parser.currentState = 2;
+        parser.parse('\x7f');
+        chai.expect(parser.currentState).equal(2);
+        testTerminal.compare([]);
+        parser.reset();
+        testTerminal.clear();
+    });
+    it('state ESCAPE_INTERMEDIATE collect action', function (): void {
+        parser.reset();
+        let collect = r(0x20, 0x30);
+        for (let i = 0; i < collect.length; ++i) {
+            parser.currentState = 2;
+            parser.parse(collect[i]);
+            chai.expect(parser.currentState).equal(2);
+            chai.expect(parser.collected).equal(collect[i]);
+            parser.reset();
+        }
+    });
+    it('trans ESCAPE_INTERMEDIATE --> GROUND with esc_dispatch action', function (): void {
+        parser.reset();
+        testTerminal.clear();
+        let collect = r(0x30, 0x7f);
+        for (let i = 0; i < collect.length; ++i) {
+            parser.currentState = 2;
+            parser.parse(collect[i]);
+            chai.expect(parser.currentState).equal(0);
+            testTerminal.compare([['esc', '', collect[i]]]);
+            parser.reset();
+            testTerminal.clear();
+        }
+    });
+    it('trans ANYWHERE/ESCAPE --> CSI_ENTRY with clear', function (): void {
+        parser.reset();
+        // C0
+        parser.currentState = 1;
+        parser.osc = '#';
+        parser.params = [123];
+        parser.collected = '#';
+        parser.parse('[');
+        chai.expect(parser.currentState).equal(3);
+        chai.expect(parser.osc).equal('');
+        chai.expect(parser.params).eql([0]);
+        chai.expect(parser.collected).equal('');
+        parser.reset();
+        // C1
+        for (let state = 0; state < 14; ++state) {
+            parser.currentState = state;
+            parser.osc = '#';
+            parser.params = [123];
+            parser.collected = '#';
+            parser.parse('\x9b');
+            chai.expect(parser.currentState).equal(3);
+            chai.expect(parser.osc).equal('');
+            chai.expect(parser.params).eql([0]);
+            chai.expect(parser.collected).equal('');
+            parser.reset();
+        }
+    });
+    it('state CSI_ENTRY execute rules', function (): void {
+        parser.reset();
+        testTerminal.clear();
+        let exes = r(0x00, 0x18);
+        exes.concat(['\x19']);
+        exes.concat(r(0x1c, 0x20));
+        for (let i = 0; i < exes.length; ++i) {
+            parser.currentState = 3;
+            parser.parse(exes[i]);
+            chai.expect(parser.currentState).equal(3);
+            testTerminal.compare([['exe', exes[i]]]);
+            parser.reset();
+            testTerminal.clear();
+        }
+    });
+    it('state CSI_ENTRY ignore', function (): void {
+        parser.reset();
+        testTerminal.clear();
+        parser.currentState = 3;
+        parser.parse('\x7f');
+        chai.expect(parser.currentState).equal(3);
+        testTerminal.compare([]);
+        parser.reset();
+        testTerminal.clear();
+    });
+    it('trans CSI_ENTRY --> GROUND with csi_dispatch action', function (): void {
+        parser.reset();
+        let dispatches = r(0x40, 0x7f);
+        for (let i = 0; i < dispatches.length; ++i) {
+            parser.currentState = 3;
+            parser.parse(dispatches[i]);
+            chai.expect(parser.currentState).equal(0);
+            testTerminal.compare([['csi', '', [0], dispatches[i]]]);
+            parser.reset();
+            testTerminal.clear();
+        }
+    });
+    it('trans CSI_ENTRY --> CSI_PARAM with param/collect actions', function (): void {
+        parser.reset();
+        let params = ['\x30', '\x31', '\x32', '\x33', '\x34', '\x35', '\x36', '\x37', '\x38', '\x39'];
+        let collect = ['\x3c', '\x3d', '\x3e', '\x3f'];
+        for (let i = 0; i < params.length; ++i) {
+            parser.currentState = 3;
+            parser.parse(params[i]);
+            chai.expect(parser.currentState).equal(4);
+            chai.expect(parser.params).eql([params[i].charCodeAt(0) - 48]);
+            parser.reset();
+        }
+        // ';'
+        parser.currentState = 3;
+        parser.parse('\x3b');
+        chai.expect(parser.currentState).equal(4);
+        chai.expect(parser.params).eql([0, 0]);
+        parser.reset();
+        for (let i = 0; i < collect.length; ++i) {
+            parser.currentState = 3;
+            parser.parse(collect[i]);
+            chai.expect(parser.currentState).equal(4);
+            chai.expect(parser.collected).equal(collect[i]);
+            parser.reset();
+        }
+    });
+    it('state CSI_PARAM execute rules', function (): void {
+        parser.reset();
+        testTerminal.clear();
+        let exes = r(0x00, 0x18);
+        exes.concat(['\x19']);
+        exes.concat(r(0x1c, 0x20));
+        for (let i = 0; i < exes.length; ++i) {
+            parser.currentState = 4;
+            parser.parse(exes[i]);
+            chai.expect(parser.currentState).equal(4);
+            testTerminal.compare([['exe', exes[i]]]);
+            parser.reset();
+            testTerminal.clear();
+        }
+    });
+    it('state CSI_PARAM param action', function (): void {
+        parser.reset();
+        let params = ['\x30', '\x31', '\x32', '\x33', '\x34', '\x35', '\x36', '\x37', '\x38', '\x39'];
+        for (let i = 0; i < params.length; ++i) {
+            parser.currentState = 4;
+            parser.parse(params[i]);
+            chai.expect(parser.currentState).equal(4);
+            chai.expect(parser.params).eql([params[i].charCodeAt(0) - 48]);
+            parser.reset();
+        }
+        parser.currentState = 4;
+        parser.parse('\x3b');
+        chai.expect(parser.currentState).equal(4);
+        chai.expect(parser.params).eql([0, 0]);
+        parser.reset();
+    });
+    it('state CSI_PARAM ignore', function (): void {
+        parser.reset();
+        testTerminal.clear();
+        parser.currentState = 4;
+        parser.parse('\x7f');
+        chai.expect(parser.currentState).equal(4);
+        testTerminal.compare([]);
+        parser.reset();
+        testTerminal.clear();
+    });
+    it('trans CSI_PARAM --> GROUND with csi_dispatch action', function (): void {
+        parser.reset();
+        let dispatches = r(0x40, 0x7f);
+        for (let i = 0; i < dispatches.length; ++i) {
+            parser.currentState = 4;
+            parser.params = [0, 1];
+            parser.parse(dispatches[i]);
+            chai.expect(parser.currentState).equal(0);
+            testTerminal.compare([['csi', '', [0, 1], dispatches[i]]]);
+            parser.reset();
+            testTerminal.clear();
+        }
+    });
+    it('trans CSI_ENTRY --> CSI_INTERMEDIATE with collect action', function (): void {
+        parser.reset();
+        let collect = r(0x20, 0x30);
+        for (let i = 0; i < collect.length; ++i) {
+            parser.currentState = 3;
+            parser.parse(collect[i]);
+            chai.expect(parser.currentState).equal(5);
+            chai.expect(parser.collected).equal(collect[i]);
+            parser.reset();
+        }
+    });
+    it('trans CSI_PARAM --> CSI_INTERMEDIATE with collect action', function (): void {
+        parser.reset();
+        let collect = r(0x20, 0x30);
+        for (let i = 0; i < collect.length; ++i) {
+            parser.currentState = 4;
+            parser.parse(collect[i]);
+            chai.expect(parser.currentState).equal(5);
+            chai.expect(parser.collected).equal(collect[i]);
+            parser.reset();
+        }
+    });
+    it('state CSI_INTERMEDIATE execute rules', function (): void {
+        parser.reset();
+        testTerminal.clear();
+        let exes = r(0x00, 0x18);
+        exes.concat(['\x19']);
+        exes.concat(r(0x1c, 0x20));
+        for (let i = 0; i < exes.length; ++i) {
+            parser.currentState = 5;
+            parser.parse(exes[i]);
+            chai.expect(parser.currentState).equal(5);
+            testTerminal.compare([['exe', exes[i]]]);
+            parser.reset();
+            testTerminal.clear();
+        }
+    });
+    it('state CSI_INTERMEDIATE collect', function (): void {
+        parser.reset();
+        let collect = r(0x20, 0x30);
+        for (let i = 0; i < collect.length; ++i) {
+            parser.currentState = 5;
+            parser.parse(collect[i]);
+            chai.expect(parser.currentState).equal(5);
+            chai.expect(parser.collected).equal(collect[i]);
+            parser.reset();
+        }
+    });
+    it('state CSI_INTERMEDIATE ignore', function (): void {
+        parser.reset();
+        testTerminal.clear();
+        parser.currentState = 5;
+        parser.parse('\x7f');
+        chai.expect(parser.currentState).equal(5);
+        testTerminal.compare([]);
+        parser.reset();
+        testTerminal.clear();
+    });
+    it('trans CSI_INTERMEDIATE --> GROUND with csi_dispatch action', function (): void {
+        parser.reset();
+        let dispatches = r(0x40, 0x7f);
+        for (let i = 0; i < dispatches.length; ++i) {
+            parser.currentState = 5;
+            parser.params = [0, 1];
+            parser.parse(dispatches[i]);
+            chai.expect(parser.currentState).equal(0);
+            testTerminal.compare([['csi', '', [0, 1], dispatches[i]]]);
+            parser.reset();
+            testTerminal.clear();
+        }
+    });
+    it('trans CSI_ENTRY --> CSI_IGNORE', function (): void {
+        parser.reset();
+        parser.currentState = 3;
+        parser.parse('\x3a');
+        chai.expect(parser.currentState).equal(6);
+        parser.reset();
+    });
+    it('trans CSI_PARAM --> CSI_IGNORE', function (): void {
+        parser.reset();
+        let chars = ['\x3a', '\x3c', '\x3d', '\x3e', '\x3f'];
+        for (let i = 0; i < chars.length; ++i) {
+            parser.currentState = 4;
+            parser.parse('\x3b' + chars[i]);
+            chai.expect(parser.currentState).equal(6);
+            chai.expect(parser.params).eql([0, 0]);
+            parser.reset();
+        }
+    });
+    it('trans CSI_INTERMEDIATE --> CSI_IGNORE', function (): void {
+        parser.reset();
+        let chars = r(0x30, 0x40);
+        for (let i = 0; i < chars.length; ++i) {
+            parser.currentState = 5;
+            parser.parse(chars[i]);
+            chai.expect(parser.currentState).equal(6);
+            chai.expect(parser.params).eql([0]);
+            parser.reset();
+        }
+    });
+    it('state CSI_IGNORE execute rules', function (): void {
+        parser.reset();
+        testTerminal.clear();
+        let exes = r(0x00, 0x18);
+        exes.concat(['\x19']);
+        exes.concat(r(0x1c, 0x20));
+        for (let i = 0; i < exes.length; ++i) {
+            parser.currentState = 6;
+            parser.parse(exes[i]);
+            chai.expect(parser.currentState).equal(6);
+            testTerminal.compare([['exe', exes[i]]]);
+            parser.reset();
+            testTerminal.clear();
+        }
+    });
+    it('state CSI_IGNORE ignore', function (): void {
+        parser.reset();
+        testTerminal.clear();
+        let ignored = r(0x20, 0x40);
+        ignored.concat(['\x7f']);
+        for (let i = 0; i < ignored.length; ++i) {
+            parser.currentState = 6;
+            parser.parse(ignored[i]);
+            chai.expect(parser.currentState).equal(6);
+            testTerminal.compare([]);
+            parser.reset();
+            testTerminal.clear();
+        }
+    });
+    it('trans CSI_IGNORE --> GROUND', function (): void {
+        parser.reset();
+        let dispatches = r(0x40, 0x7f);
+        for (let i = 0; i < dispatches.length; ++i) {
+            parser.currentState = 6;
+            parser.params = [0, 1];
+            parser.parse(dispatches[i]);
+            chai.expect(parser.currentState).equal(0);
+            testTerminal.compare([]);
+            parser.reset();
+            testTerminal.clear();
+        }
+    });
+    it('trans ANYWHERE/ESCAPE --> SOS_PM_APC_STRING', function (): void {
+        parser.reset();
+        // C0
+        let initializers = ['\x58', '\x5e', '\x5f'];
+        for (let i = 0; i < initializers.length; ++i) {
+            parser.parse('\x1b' + initializers[i]);
+            chai.expect(parser.currentState).equal(7);
+            parser.reset();
+        }
+        // C1
+        for (let state = 0; state < 14; ++state) {
+            parser.currentState = state;
+            initializers = ['\x98', '\x9e', '\x9f'];
+            for (let i = 0; i < initializers.length; ++i) {
+                parser.parse(initializers[i]);
+                chai.expect(parser.currentState).equal(7);
+                parser.reset();
+            }
+        }
+    });
+    it('state SOS_PM_APC_STRING ignore rules', function (): void {
+        parser.reset();
+        let ignored = r(0x00, 0x18);
+        ignored.concat(['\x19']);
+        ignored.concat(r(0x1c, 0x20));
+        ignored.concat(r(0x20, 0x80));
+        for (let i = 0; i < ignored.length; ++i) {
+            parser.currentState = 7;
+            parser.parse(ignored[i]);
+            chai.expect(parser.currentState).equal(7);
+            parser.reset();
+        }
+    });
+    it('trans ANYWHERE/ESCAPE --> OSC_STRING', function (): void {
+        parser.reset();
+        // C0
+        parser.parse('\x1b]');
+        chai.expect(parser.currentState).equal(8);
+        parser.reset();
+        // C1
+        for (let state = 0; state < 14; ++state) {
+            parser.currentState = state;
+            parser.parse('\x9d');
+            chai.expect(parser.currentState).equal(8);
+            parser.reset();
+        }
+    });
+    it('state OSC_STRING ignore rules', function (): void {
+        parser.reset();
+        let ignored = [
+            '\x00', '\x01', '\x02', '\x03', '\x04', '\x05', '\x06', /*'\x07',*/ '\x08',
+            '\x09', '\x0a', '\x0b', '\x0c', '\x0d', '\x0e', '\x0f', '\x10', '\x11',
+            '\x12', '\x13', '\x14', '\x15', '\x16', '\x17', '\x19', '\x1c', '\x1d', '\x1e', '\x1f'];
+        for (let i = 0; i < ignored.length; ++i) {
+            parser.currentState = 8;
+            parser.parse(ignored[i]);
+            chai.expect(parser.currentState).equal(8);
+            chai.expect(parser.osc).equal('');
+            parser.reset();
+        }
+    });
+    it('state OSC_STRING put action', function (): void {
+        parser.reset();
+        let puts = r(0x20, 0x80);
+        for (let i = 0; i < puts.length; ++i) {
+            parser.currentState = 8;
+            parser.parse(puts[i]);
+            chai.expect(parser.currentState).equal(8);
+            chai.expect(parser.osc).equal(puts[i]);
+            parser.reset();
+        }
+    });
+    it('state DCS_ENTRY', function (): void {
+        parser.reset();
+        // C0
+        parser.parse('\x1bP');
+        chai.expect(parser.currentState).equal(9);
+        parser.reset();
+        // C1
+        for (let state = 0; state < 14; ++state) {
+            parser.currentState = state;
+            parser.parse('\x90');
+            chai.expect(parser.currentState).equal(9);
+            parser.reset();
+        }
+    });
+    it('state DCS_ENTRY ignore rules', function (): void {
+        parser.reset();
+        let ignored = [
+            '\x00', '\x01', '\x02', '\x03', '\x04', '\x05', '\x06', '\x07', '\x08',
+            '\x09', '\x0a', '\x0b', '\x0c', '\x0d', '\x0e', '\x0f', '\x10', '\x11',
+            '\x12', '\x13', '\x14', '\x15', '\x16', '\x17', '\x19', '\x1c', '\x1d', '\x1e', '\x1f', '\x7f'];
+        for (let i = 0; i < ignored.length; ++i) {
+            parser.currentState = 9;
+            parser.parse(ignored[i]);
+            chai.expect(parser.currentState).equal(9);
+            parser.reset();
+        }
+    });
+    it('state DCS_ENTRY --> DCS_PARAM with param/collect actions', function (): void {
+        parser.reset();
+        let params = ['\x30', '\x31', '\x32', '\x33', '\x34', '\x35', '\x36', '\x37', '\x38', '\x39'];
+        let collect = ['\x3c', '\x3d', '\x3e', '\x3f'];
+        for (let i = 0; i < params.length; ++i) {
+            parser.currentState = 9;
+            parser.parse(params[i]);
+            chai.expect(parser.currentState).equal(10);
+            chai.expect(parser.params).eql([params[i].charCodeAt(0) - 48]);
+            parser.reset();
+        }
+        parser.currentState = 9;
+        parser.parse('\x3b');
+        chai.expect(parser.currentState).equal(10);
+        chai.expect(parser.params).eql([0, 0]);
+        parser.reset();
+        for (let i = 0; i < collect.length; ++i) {
+            parser.currentState = 9;
+            parser.parse(collect[i]);
+            chai.expect(parser.currentState).equal(10);
+            chai.expect(parser.collected).equal(collect[i]);
+            parser.reset();
+        }
+    });
+    it('state DCS_PARAM ignore rules', function (): void {
+        parser.reset();
+        let ignored = [
+            '\x00', '\x01', '\x02', '\x03', '\x04', '\x05', '\x06', '\x07', '\x08',
+            '\x09', '\x0a', '\x0b', '\x0c', '\x0d', '\x0e', '\x0f', '\x10', '\x11',
+            '\x12', '\x13', '\x14', '\x15', '\x16', '\x17', '\x19', '\x1c', '\x1d', '\x1e', '\x1f', '\x7f'];
+        for (let i = 0; i < ignored.length; ++i) {
+            parser.currentState = 10;
+            parser.parse(ignored[i]);
+            chai.expect(parser.currentState).equal(10);
+            parser.reset();
+        }
+    });
+    it('state DCS_PARAM param action', function (): void {
+        parser.reset();
+        let params = ['\x30', '\x31', '\x32', '\x33', '\x34', '\x35', '\x36', '\x37', '\x38', '\x39'];
+        for (let i = 0; i < params.length; ++i) {
+            parser.currentState = 10;
+            parser.parse(params[i]);
+            chai.expect(parser.currentState).equal(10);
+            chai.expect(parser.params).eql([params[i].charCodeAt(0) - 48]);
+            parser.reset();
+        }
+        parser.currentState = 10;
+        parser.parse('\x3b');
+        chai.expect(parser.currentState).equal(10);
+        chai.expect(parser.params).eql([0, 0]);
+        parser.reset();
+    });
+    it('trans DCS_ENTRY --> DCS_IGNORE', function (): void {
+        parser.reset();
+        parser.currentState = 9;
+        parser.parse('\x3a');
+        chai.expect(parser.currentState).equal(11);
+        parser.reset();
+    });
+    it('trans DCS_PARAM --> DCS_IGNORE', function (): void {
+        parser.reset();
+        let chars = ['\x3a', '\x3c', '\x3d', '\x3e', '\x3f'];
+        for (let i = 0; i < chars.length; ++i) {
+            parser.currentState = 10;
+            parser.parse('\x3b' + chars[i]);
+            chai.expect(parser.currentState).equal(11);
+            chai.expect(parser.params).eql([0, 0]);
+            parser.reset();
+        }
+    });
+    it('trans DCS_INTERMEDIATE --> DCS_IGNORE', function (): void {
+        parser.reset();
+        let chars = r(0x30, 0x40);
+        for (let i = 0; i < chars.length; ++i) {
+            parser.currentState = 12;
+            parser.parse(chars[i]);
+            chai.expect(parser.currentState).equal(11);
+            parser.reset();
+        }
+    });
+    it('state DCS_IGNORE ignore rules', function (): void {
+        parser.reset();
+        let ignored = [
+            '\x00', '\x01', '\x02', '\x03', '\x04', '\x05', '\x06', '\x07', '\x08',
+            '\x09', '\x0a', '\x0b', '\x0c', '\x0d', '\x0e', '\x0f', '\x10', '\x11',
+            '\x12', '\x13', '\x14', '\x15', '\x16', '\x17', '\x19', '\x1c', '\x1d', '\x1e', '\x1f', '\x7f'];
+        ignored.concat(r(0x20, 0x80));
+        for (let i = 0; i < ignored.length; ++i) {
+            parser.currentState = 11;
+            parser.parse(ignored[i]);
+            chai.expect(parser.currentState).equal(11);
+            parser.reset();
+        }
+    });
+    it('trans DCS_ENTRY --> DCS_INTERMEDIATE with collect action', function (): void {
+        parser.reset();
+        let collect = r(0x20, 0x30);
+        for (let i = 0; i < collect.length; ++i) {
+            parser.currentState = 9;
+            parser.parse(collect[i]);
+            chai.expect(parser.currentState).equal(12);
+            chai.expect(parser.collected).equal(collect[i]);
+            parser.reset();
+        }
+    });
+    it('trans DCS_PARAM --> DCS_INTERMEDIATE with collect action', function (): void {
+        parser.reset();
+        let collect = r(0x20, 0x30);
+        for (let i = 0; i < collect.length; ++i) {
+            parser.currentState = 10;
+            parser.parse(collect[i]);
+            chai.expect(parser.currentState).equal(12);
+            chai.expect(parser.collected).equal(collect[i]);
+            parser.reset();
+        }
+    });
+    it('state DCS_INTERMEDIATE ignore rules', function (): void {
+        parser.reset();
+        let ignored = [
+            '\x00', '\x01', '\x02', '\x03', '\x04', '\x05', '\x06', '\x07', '\x08',
+            '\x09', '\x0a', '\x0b', '\x0c', '\x0d', '\x0e', '\x0f', '\x10', '\x11',
+            '\x12', '\x13', '\x14', '\x15', '\x16', '\x17', '\x19', '\x1c', '\x1d', '\x1e', '\x1f', '\x7f'];
+        for (let i = 0; i < ignored.length; ++i) {
+            parser.currentState = 12;
+            parser.parse(ignored[i]);
+            chai.expect(parser.currentState).equal(12);
+            parser.reset();
+        }
+    });
+    it('state DCS_INTERMEDIATE collect action', function (): void {
+        parser.reset();
+        let collect = r(0x20, 0x30);
+        for (let i = 0; i < collect.length; ++i) {
+            parser.currentState = 12;
+            parser.parse(collect[i]);
+            chai.expect(parser.currentState).equal(12);
+            chai.expect(parser.collected).equal(collect[i]);
+            parser.reset();
+        }
+    });
+    it('trans DCS_INTERMEDIATE --> DCS_IGNORE', function (): void {
+        parser.reset();
+        let chars = r(0x30, 0x40);
+        for (let i = 0; i < chars.length; ++i) {
+            parser.currentState = 12;
+            parser.parse('\x20' + chars[i]);
+            chai.expect(parser.currentState).equal(11);
+            chai.expect(parser.collected).equal('\x20');
+            parser.reset();
+        }
+    });
+    it('trans DCS_ENTRY --> DCS_PASSTHROUGH with hook', function (): void {
+        parser.reset();
+        testTerminal.clear();
+        let collect = r(0x40, 0x7f);
+        for (let i = 0; i < collect.length; ++i) {
+            parser.currentState = 9;
+            parser.parse(collect[i]);
+            chai.expect(parser.currentState).equal(13);
+            testTerminal.compare([['dcs hook', '', [0], collect[i]]]);
+            parser.reset();
+            testTerminal.clear();
+        }
+    });
+    it('trans DCS_PARAM --> DCS_PASSTHROUGH with hook', function (): void {
+        parser.reset();
+        testTerminal.clear();
+        let collect = r(0x40, 0x7f);
+        for (let i = 0; i < collect.length; ++i) {
+            parser.currentState = 10;
+            parser.parse(collect[i]);
+            chai.expect(parser.currentState).equal(13);
+            testTerminal.compare([['dcs hook', '', [0], collect[i]]]);
+            parser.reset();
+            testTerminal.clear();
+        }
+    });
+    it('trans DCS_INTERMEDIATE --> DCS_PASSTHROUGH with hook', function (): void {
+        parser.reset();
+        testTerminal.clear();
+        let collect = r(0x40, 0x7f);
+        for (let i = 0; i < collect.length; ++i) {
+            parser.currentState = 12;
+            parser.parse(collect[i]);
+            chai.expect(parser.currentState).equal(13);
+            testTerminal.compare([['dcs hook', '', [0], collect[i]]]);
+            parser.reset();
+            testTerminal.clear();
+        }
+    });
+    it('state DCS_PASSTHROUGH put action', function (): void {
+        parser.reset();
+        testTerminal.clear();
+        let puts = r(0x00, 0x18);
+        puts.concat(['\x19']);
+        puts.concat(r(0x1c, 0x20));
+        puts.concat(r(0x20, 0x7f));
+        for (let i = 0; i < puts.length; ++i) {
+            parser.currentState = 13;
+            parser.parse(puts[i]);
+            chai.expect(parser.currentState).equal(13);
+            testTerminal.compare([['dcs put', puts[i]]]);
+            parser.reset();
+            testTerminal.clear();
+        }
+    });
+    it('state DCS_PASSTHROUGH ignore', function (): void {
+        parser.reset();
+        testTerminal.clear();
+        parser.currentState = 13;
+        parser.parse('\x7f');
+        chai.expect(parser.currentState).equal(13);
+        testTerminal.compare([]);
+        parser.reset();
+        testTerminal.clear();
+    });
+});
+
+function test(s: string, value: any, noReset: any): void {
+    if (!noReset) {
+        parser.reset();
+        testTerminal.clear();
+    }
+    parser.parse(s);
+    testTerminal.compare(value);
+}
+
+describe('escape sequence examples', function(): void {
+    it('CSI with print and execute', function (): void {
+        test('\x1b[<31;5mHello World! öäü€\nabc',
+            [
+                ['csi', '<', [31, 5], 'm'],
+                ['print', 'Hello World! öäü€'],
+                ['exe', '\n'],
+                ['print', 'abc']
+            ], null);
+    });
+    it('OSC', function (): void {
+        test('\x1b]0;abc123€öäü\x07', [
+            ['osc', '0;abc123€öäü']
+        ], null);
+    });
+    it('single DCS', function (): void {
+        test('\x1bP1;2;3+$abc;de\x9c', [
+            ['dcs hook', '+$', [1, 2, 3], 'a'],
+            ['dcs put', 'bc;de'],
+            ['dcs unhook']
+        ], null);
+    });
+    it('multi DCS', function (): void {
+        test('\x1bP1;2;3+$abc;de', [
+            ['dcs hook', '+$', [1, 2, 3], 'a'],
+            ['dcs put', 'bc;de']
+        ], null);
+        testTerminal.clear();
+        test('abc\x9c', [
+            ['dcs put', 'abc'],
+            ['dcs unhook']
+        ], true);
+    });
+    it('print + DCS(C1)', function (): void {
+        test('abc\x901;2;3+$abc;de\x9c', [
+            ['print', 'abc'],
+            ['dcs hook', '+$', [1, 2, 3], 'a'],
+            ['dcs put', 'bc;de'],
+            ['dcs unhook']
+        ], null);
+    });
+    it('print + PM(C1) + print', function (): void {
+        test('abc\x98123tzf\x9cdefg', [
+            ['print', 'abc'],
+            ['print', 'defg']
+        ], null);
+    });
+    it('print + OSC(C1) + print', function (): void {
+        test('abc\x9d123tzf\x9cdefg', [
+            ['print', 'abc'],
+            ['osc', '123tzf'],
+            ['print', 'defg']
+        ], null);
+    });
+    it('error recovery', function (): void {
+        test('\x1b[1€abcdefg\x9b<;c', [
+            ['print', 'abcdefg'],
+            ['csi', '<', [0, 0], 'c']
+        ], null);
+    });
+});
+
+describe('coverage tests', function(): void {
+    it('CSI_IGNORE error', function (): void {
+        parser.reset();
+        testTerminal.clear();
+        parser.currentState = 6;
+        parser.parse('€öäü');
+        chai.expect(parser.currentState).equal(6);
+        testTerminal.compare([]);
+        parser.reset();
+        testTerminal.clear();
+    });
+    it('DCS_IGNORE error', function (): void {
+        parser.reset();
+        testTerminal.clear();
+        parser.currentState = 11;
+        parser.parse('€öäü');
+        chai.expect(parser.currentState).equal(11);
+        testTerminal.compare([]);
+        parser.reset();
+        testTerminal.clear();
+    });
+    it('DCS_PASSTHROUGH error', function (): void {
+        parser.reset();
+        testTerminal.clear();
+        parser.currentState = 13;
+        parser.parse('€öäü');
+        chai.expect(parser.currentState).equal(13);
+        testTerminal.compare([['dcs put', '€öäü']]);
+        parser.reset();
+        testTerminal.clear();
+    });
+    it('error else of if (code > 159)', function (): void {
+        parser.reset();
+        testTerminal.clear();
+        parser.currentState = 0;
+        parser.parse('\x1e');
+        chai.expect(parser.currentState).equal(0);
+        testTerminal.compare([]);
+        parser.reset();
+        testTerminal.clear();
+    });
+});
+
+let errorTerminal1 = function(): void {};
+errorTerminal1.prototype = testTerminal;
+let errTerminal1 = new errorTerminal1();
+errTerminal1.inst_E = function(e: any): void {
+    this.calls.push(['error', e]);
+};
+let errParser1 = new AnsiParser(errTerminal1);
+
+let errorTerminal2 = function(): void {};
+errorTerminal2.prototype = testTerminal;
+let errTerminal2 = new errorTerminal2();
+errTerminal2.inst_E = function(e: any): any {
+    this.calls.push(['error', e]);
+    return true;  // --> abort parsing
+};
+let errParser2 = new AnsiParser(errTerminal2);
+
+describe('error tests', function(): void {
+    it('CSI_PARAM unicode error - inst_E output w/o abort', function (): void {
+        errParser1.parse('\x1b[<31;5€normal print');
+        errTerminal1.compare([
+            ['error', {
+                pos: 7,
+                character: '€',
+                state: 4,
+                print: -1,
+                dcs: -1,
+                osc: '',
+                collect: '<',
+                params: [31, 5]}],
+            ['print', 'normal print']
+        ]);
+        parser.reset();
+        testTerminal.clear();
+    });
+    it('CSI_PARAM unicode error - inst_E output with abort', function (): void {
+        errParser2.parse('\x1b[<31;5€no print');
+        errTerminal2.compare([
+            ['error', {
+                pos: 7,
+                character: '€',
+                state: 4,
+                print: -1,
+                dcs: -1,
+                osc: '',
+                collect: '<',
+                params: [31, 5]}]
+        ]);
+        parser.reset();
+        testTerminal.clear();
+    });
+});
diff --git a/src/EscapeSequenceParser.ts b/src/EscapeSequenceParser.ts
new file mode 100644
index 00000000..6facddea
--- /dev/null
+++ b/src/EscapeSequenceParser.ts
@@ -0,0 +1,718 @@
+export interface IParserTerminal {
+    inst_p?: (s: string, start: number, end: number) => void;
+    inst_o?: (s: string) => void;
+    inst_x?: (flag: string) => void;
+    inst_c?: (collected: string, params: number[], flag: string) => void;
+    inst_e?: (collected: string, flag: string) => void;
+    inst_H?: (collected: string, params: number[], flag: string) => void;
+    inst_P?: (dcs: string) => void;
+    inst_U?: () => void;
+    inst_E?: () => void; // TODO: real signature
+}
+
+
+export function r(a: number, b: number): number[] {
+    let c = b - a;
+    let arr = new Array(c);
+    while (c--) {
+        arr[c] = --b;
+    }
+    return arr;
+}
+
+
+export class TransitionTable {
+    public table: Uint8Array;
+    constructor(length: number) {
+        this.table = new Uint8Array(length);
+    }
+    add(inp: number, state: number, action: number | null, next: number | null): void {
+        this.table[state << 8 | inp] = ((action | 0) << 4) | ((next === undefined) ? state : next);
+    }
+    add_list(inps: number[], state: number, action: number | null, next: number | null): void {
+        for (let i = 0; i < inps.length; i++) {
+            this.add(inps[i], state, action, next);
+        }
+    }
+}
+
+
+let PRINTABLES = r(0x20, 0x7f);
+let EXECUTABLES = r(0x00, 0x18);
+EXECUTABLES.push(0x19);
+EXECUTABLES.concat(r(0x1c, 0x20));
+
+
+export const TRANSITION_TABLE = (function (): TransitionTable {
+    let t: TransitionTable = new TransitionTable(4095);
+
+    // table with default transition [any] --> [error, GROUND]
+    for (let state = 0; state < 14; ++state) {
+        for (let code = 0; code < 160; ++code) {
+            t[state << 8 | code] = 16;
+        }
+    }
+
+    // apply transitions
+    // printables
+    t.add_list(PRINTABLES, 0, 2, 0);
+    // global anywhere rules
+    for (let state = 0; state < 14; ++state) {
+        t.add_list([0x18, 0x1a, 0x99, 0x9a], state, 3, 0);
+        t.add_list(r(0x80, 0x90), state, 3, 0);
+        t.add_list(r(0x90, 0x98), state, 3, 0);
+        t.add(0x9c, state, 0, 0);   // ST as terminator
+        t.add(0x1b, state, 11, 1);  // ESC
+        t.add(0x9d, state, 4, 8);   // OSC
+        t.add_list([0x98, 0x9e, 0x9f], state, 0, 7);
+        t.add(0x9b, state, 11, 3);  // CSI
+        t.add(0x90, state, 11, 9);  // DCS
+    }
+    // rules for executables and 7f
+    t.add_list(EXECUTABLES, 0, 3, 0);
+    t.add_list(EXECUTABLES, 1, 3, 1);
+    t.add(0x7f, 1, null, 1);
+    t.add_list(EXECUTABLES, 8, null, 8);
+    t.add_list(EXECUTABLES, 3, 3, 3);
+    t.add(0x7f, 3, null, 3);
+    t.add_list(EXECUTABLES, 4, 3, 4);
+    t.add(0x7f, 4, null, 4);
+    t.add_list(EXECUTABLES, 6, 3, 6);
+    t.add_list(EXECUTABLES, 5, 3, 5);
+    t.add(0x7f, 5, null, 5);
+    t.add_list(EXECUTABLES, 2, 3, 2);
+    t.add(0x7f, 2, null, 2);
+    // osc
+    t.add(0x5d, 1, 4, 8);
+    t.add_list(PRINTABLES, 8, 5, 8);
+    t.add(0x7f, 8, 5, 8);
+    t.add_list([0x9c, 0x1b, 0x18, 0x1a, 0x07], 8, 6, 0);
+    t.add_list(r(0x1c, 0x20), 8, 0, 8);
+    // sos/pm/apc does nothing
+    t.add_list([0x58, 0x5e, 0x5f], 1, 0, 7);
+    t.add_list(PRINTABLES, 7, null, 7);
+    t.add_list(EXECUTABLES, 7, null, 7);
+    t.add(0x9c, 7, 0, 0);
+    // csi entries
+    t.add(0x5b, 1, 11, 3);
+    t.add_list(r(0x40, 0x7f), 3, 7, 0);
+    t.add_list(r(0x30, 0x3a), 3, 8, 4);
+    t.add(0x3b, 3, 8, 4);
+    t.add_list([0x3c, 0x3d, 0x3e, 0x3f], 3, 9, 4);
+    t.add_list(r(0x30, 0x3a), 4, 8, 4);
+    t.add(0x3b, 4, 8, 4);
+    t.add_list(r(0x40, 0x7f), 4, 7, 0);
+    t.add_list([0x3a, 0x3c, 0x3d, 0x3e, 0x3f], 4, 0, 6);
+    t.add_list(r(0x20, 0x40), 6, null, 6);
+    t.add(0x7f, 6, null, 6);
+    t.add_list(r(0x40, 0x7f), 6, 0, 0);
+    t.add(0x3a, 3, 0, 6);
+    t.add_list(r(0x20, 0x30), 3, 9, 5);
+    t.add_list(r(0x20, 0x30), 5, 9, 5);
+    t.add_list(r(0x30, 0x40), 5, 0, 6);
+    t.add_list(r(0x40, 0x7f), 5, 7, 0);
+    t.add_list(r(0x20, 0x30), 4, 9, 5);
+    // esc_intermediate
+    t.add_list(r(0x20, 0x30), 1, 9, 2);
+    t.add_list(r(0x20, 0x30), 2, 9, 2);
+    t.add_list(r(0x30, 0x7f), 2, 10, 0);
+    t.add_list(r(0x30, 0x50), 1, 10, 0);
+    t.add_list([0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x59, 0x5a, 0x5c], 1, 10, 0);
+    t.add_list(r(0x60, 0x7f), 1, 10, 0);
+    // dcs entry
+    t.add(0x50, 1, 11, 9);
+    t.add_list(EXECUTABLES, 9, null, 9);
+    t.add(0x7f, 9, null, 9);
+    t.add_list(r(0x1c, 0x20), 9, null, 9);
+    t.add_list(r(0x20, 0x30), 9, 9, 12);
+    t.add(0x3a, 9, 0, 11);
+    t.add_list(r(0x30, 0x3a), 9, 8, 10);
+    t.add(0x3b, 9, 8, 10);
+    t.add_list([0x3c, 0x3d, 0x3e, 0x3f], 9, 9, 10);
+    t.add_list(EXECUTABLES, 11, null, 11);
+    t.add_list(r(0x20, 0x80), 11, null, 11);
+    t.add_list(r(0x1c, 0x20), 11, null, 11);
+    t.add_list(EXECUTABLES, 10, null, 10);
+    t.add(0x7f, 10, null, 10);
+    t.add_list(r(0x1c, 0x20), 10, null, 10);
+    t.add_list(r(0x30, 0x3a), 10, 8, 10);
+    t.add(0x3b, 10, 8, 10);
+    t.add_list([0x3a, 0x3c, 0x3d, 0x3e, 0x3f], 10, 0, 11);
+    t.add_list(r(0x20, 0x30), 10, 9, 12);
+    t.add_list(EXECUTABLES, 12, null, 12);
+    t.add(0x7f, 12, null, 12);
+    t.add_list(r(0x1c, 0x20), 12, null, 12);
+    t.add_list(r(0x20, 0x30), 12, 9, 12);
+    t.add_list(r(0x30, 0x40), 12, 0, 11);
+    t.add_list(r(0x40, 0x7f), 12, 12, 13);
+    t.add_list(r(0x40, 0x7f), 10, 12, 13);
+    t.add_list(r(0x40, 0x7f), 9, 12, 13);
+    t.add_list(EXECUTABLES, 13, 13, 13);
+    t.add_list(PRINTABLES, 13, 13, 13);
+    t.add(0x7f, 13, null, 13);
+    t.add_list([0x1b, 0x9c], 13, 14, 0);
+
+    return t;
+})();
+
+export class AnsiParser {
+    public initialState: number;
+    public currentState: number;
+    public transitions: TransitionTable;
+    public osc: string;
+    public params: number[];
+    public collected: string;
+    public term: any;
+    constructor(terminal: IParserTerminal) {
+        this.initialState = 0;
+        this.currentState = this.initialState | 0;
+        this.transitions = new TransitionTable(4095);
+        this.transitions.table.set(TRANSITION_TABLE.table);
+        this.osc = '';
+        this.params = [0];
+        this.collected = '';
+        this.term = terminal || {};
+        let instructions = ['inst_p', 'inst_o', 'inst_x', 'inst_c',
+            'inst_e', 'inst_H', 'inst_P', 'inst_U', 'inst_E'];
+        for (let i = 0; i < instructions.length; ++i) {
+            if (!(instructions[i] in this.term)) {
+                this.term[instructions[i]] = function(): void {};
+            }
+        }
+    }
+    reset(): void {
+        this.currentState = this.initialState;
+        this.osc = '';
+        this.params = [0];
+        this.collected = '';
+    }
+    parse(s: string): void {
+        let code = 0;
+        let transition = 0;
+        let error = false;
+        let currentState = this.currentState;
+
+        // local buffers
+        let printed = -1;
+        let dcs = -1;
+        let osc = this.osc;
+        let collected = this.collected;
+        let params = this.params;
+        let table: Uint8Array = this.transitions.table;
+
+        // process input string
+        let l = s.length;
+        for (let i = 0; i < l; ++i) {
+            code = s.charCodeAt(i);
+            // shortcut for most chars (print action)
+            if (currentState === 0 && (code > 0x1f && code < 0x80)) {
+                printed = (~printed) ? printed : i;
+                continue;
+            }
+            if (currentState === 4) {
+                if (code === 0x3b) {
+                    params.push(0);
+                    continue;
+                }
+                if (code > 0x2f && code < 0x39) {
+                    params[params.length - 1] = params[params.length - 1] * 10 + code - 48;
+                    continue;
+                }
+            }
+            transition = ((code < 0xa0) ? (table[currentState << 8 | code]) : 16);
+            switch (transition >> 4) {
+                case 2: // print
+                    printed = (~printed) ? printed : i;
+                    break;
+                case 3: // execute
+                    if (printed + 1) {
+                        this.term.inst_p(s, printed, i);
+                        printed = -1;
+                    }
+                    this.term.inst_x(String.fromCharCode(code));
+                    break;
+                case 0: // ignore
+                    // handle leftover print and dcs chars
+                    if (printed + 1) {
+                        this.term.inst_p(s, printed, i);
+                        printed = -1;
+                    } else if (dcs + 1) {
+                        this.term.inst_P(s.substring(dcs, i));
+                        dcs = -1;
+                    }
+                    break;
+                case 1: // error
+                    // handle unicode chars in write buffers w'o state change
+                    if (code > 0x9f) {
+                        switch (currentState) {
+                            case 0: // GROUND -> add char to print string
+                                printed = (~printed) ? printed : i;
+                                break;
+                            case 8: // OSC_STRING -> add char to osc string
+                                osc += String.fromCharCode(code);
+                                transition |= 8;
+                                break;
+                            case 6: // CSI_IGNORE -> ignore char
+                                transition |= 6;
+                                break;
+                            case 11: // DCS_IGNORE -> ignore char
+                                transition |= 11;
+                                break;
+                            case 13: // DCS_PASSTHROUGH -> add char to dcs
+                                if (!(~dcs)) dcs = i | 0;
+                                transition |= 13;
+                                break;
+                            default: // real error
+                                error = true;
+                        }
+                    } else { // real error
+                        error = true;
+                    }
+                    if (error) {
+                        if (this.term.inst_E(
+                                {
+                                    pos: i,                 // position in parse string
+                                    character: String.fromCharCode(code), // wrong character
+                                    state: currentState,   // in state
+                                    print: printed,         // print buffer
+                                    dcs: dcs,               // dcs buffer
+                                    osc: osc,               // osc buffer
+                                    collect: collected,     // collect buffer
+                                    params: params          // params buffer
+                                })) {
+                            return;
+                        }
+                        error = false;
+                    }
+                    break;
+                case 7: // csi_dispatch
+                    this.term.inst_c(collected, params, String.fromCharCode(code));
+                    break;
+                case 8: // param
+                    if (code === 0x3b) params.push(0);
+                    else params[params.length - 1] = params[params.length - 1] * 10 + code - 48;
+                    break;
+                case 9: // collect
+                    collected += String.fromCharCode(code);
+                    break;
+                case 10: // esc_dispatch
+                    this.term.inst_e(collected, String.fromCharCode(code));
+                    break;
+                case 11: // clear
+                    if (~printed) {
+                        this.term.inst_p(s, printed, i);
+                        printed = -1;
+                    }
+                    osc = '';
+                    params = [0];
+                    collected = '';
+                    dcs = -1;
+                    break;
+                case 12: // dcs_hook
+                    this.term.inst_H(collected, params, String.fromCharCode(code));
+                    break;
+                case 13: // dcs_put
+                    if (!(~dcs)) dcs = i;
+                    break;
+                case 14: // dcs_unhook
+                    if (~dcs) this.term.inst_P(s.substring(dcs, i));
+                    this.term.inst_U();
+                    if (code === 0x1b) transition |= 1;
+                    osc = '';
+                    params = [0];
+                    collected = '';
+                    dcs = -1;
+                    break;
+                case 4: // osc_start
+                    if (~printed) {
+                        this.term.inst_p(s, printed, i);
+                        printed = -1;
+                    }
+                    osc = '';
+                    break;
+                case 5: // osc_put
+                    osc += s.charAt(i);
+                    break;
+                case 6: // osc_end
+                    if (osc && code !== 0x18 && code !== 0x1a) this.term.inst_o(osc);
+                    if (code === 0x1b) transition |= 1;
+                    osc = '';
+                    params = [0];
+                    collected = '';
+                    dcs = -1;
+                    break;
+            }
+            currentState = transition & 15;
+        }
+
+        // push leftover pushable buffers to terminal
+        if (!currentState && (printed + 1)) {
+            this.term.inst_p(s, printed, s.length);
+        } else if (currentState === 13 && (dcs + 1)) {
+            this.term.inst_P(s.substring(dcs));
+        }
+
+        // save non pushable buffers
+        this.osc = osc;
+        this.collected = collected;
+        this.params = params;
+
+        // save state
+        this.currentState = currentState;
+    }
+}
+
+
+
+
+
+import { IInputHandler, IInputHandlingTerminal } from './Types';
+import { CHARSETS, DEFAULT_CHARSET } from './Charsets';
+import { C0 } from './EscapeSequences';
+
+// glue code between AnsiParser and Terminal
+export class ParserTerminal implements IParserTerminal {
+    private _parser: AnsiParser;
+    private _terminal: any;
+    private _inputHandler: IInputHandler;
+
+    constructor(_terminal: any, _inputHandler: IInputHandler) {
+        this._parser = new AnsiParser(this);
+        this._terminal = _terminal;
+        this._inputHandler = _inputHandler;
+    }
+
+    write(data: string): void {
+        const cursorStartX = this._terminal.buffer.x;
+        const cursorStartY = this._terminal.buffer.y;
+        if (this._terminal.debug) {
+          this._terminal.log('data: ' + data);
+        }
+        // apply leftover surrogate high from last write
+        if (this._terminal.surrogate_high) {
+          data = this._terminal.surrogate_high + data;
+          this._terminal.surrogate_high = '';
+        }
+
+        this._parser.parse(data);
+
+        if (this._terminal.buffer.x !== cursorStartX || this._terminal.buffer.y !== cursorStartY) {
+            this._terminal.emit('cursormove');
+        }
+    }
+
+    inst_p(data: string, start: number, end: number): void {
+        // const l = data.length;
+        let ch;
+        let code;
+        let low;
+        for (let i = start; i < end; ++i) {
+            ch = data.charAt(i);
+            code = data.charCodeAt(i);
+            if (0xD800 <= code && code <= 0xDBFF) {
+              // we got a surrogate high
+              // get surrogate low (next 2 bytes)
+              low = data.charCodeAt(i + 1);
+              if (isNaN(low)) {
+                // end of data stream, save surrogate high
+                this._terminal.surrogate_high = ch;
+                continue;
+              }
+              code = ((code - 0xD800) * 0x400) + (low - 0xDC00) + 0x10000;
+              ch += data.charAt(i + 1);
+            }
+            // surrogate low - already handled above
+            if (0xDC00 <= code && code <= 0xDFFF) {
+              continue;
+            }
+            this._inputHandler.addChar(ch, code);
+        }
+    }
+
+    inst_o(data: string): void {
+        let params = data.split(';');
+        switch (parseInt(params[0])) {
+            case 0:
+            case 1:
+            case 2:
+                if (params[1]) {
+                    this._terminal.title = params[1];
+                    this._terminal.handleTitle(this._terminal.title);
+                }
+                break;
+            case 3:
+                // set X property
+                break;
+            case 4:
+            case 5:
+                // change dynamic colors
+                break;
+            case 10:
+            case 11:
+            case 12:
+            case 13:
+            case 14:
+            case 15:
+            case 16:
+            case 17:
+            case 18:
+            case 19:
+                // change dynamic ui colors
+                break;
+            case 46:
+                // change log file
+                break;
+            case 50:
+                // dynamic font
+                break;
+            case 51:
+                // emacs shell
+                break;
+            case 52:
+                // manipulate selection data
+                break;
+            case 104:
+            case 105:
+            case 110:
+            case 111:
+            case 112:
+            case 113:
+            case 114:
+            case 115:
+            case 116:
+            case 117:
+            case 118:
+                // reset colors
+                break;
+        }
+    }
+
+    inst_x(flag: string): void {
+        switch (flag) {
+            case C0.BEL: return this._inputHandler.bell();
+            case C0.LF: return this._inputHandler.lineFeed();
+            case C0.VT: return this._inputHandler.lineFeed();
+            case C0.FF: return this._inputHandler.lineFeed();
+            case C0.CR: return this._inputHandler.carriageReturn();
+            case C0.BS: return this._inputHandler.backspace();
+            case C0.HT: return this._inputHandler.tab();
+            case C0.SO: return this._inputHandler.shiftOut();
+            case C0.SI: return this._inputHandler.shiftIn();
+            default:
+                this._inputHandler.addChar(flag, flag.charCodeAt(0));
+        }
+        this._terminal.error('Unknown EXEC flag: %s.', flag);
+    }
+
+    inst_c(collected: string, params: number[], flag: string): void {
+        this._terminal.prefix = collected;
+        switch (flag) {
+            case '@': return this._inputHandler.insertChars(params);
+            case 'A': return this._inputHandler.cursorUp(params);
+            case 'B': return this._inputHandler.cursorDown(params);
+            case 'C': return this._inputHandler.cursorForward(params);
+            case 'D': return this._inputHandler.cursorBackward(params);
+            case 'E': return this._inputHandler.cursorNextLine(params);
+            case 'F': return this._inputHandler.cursorPrecedingLine(params);
+            case 'G': return this._inputHandler.cursorCharAbsolute(params);
+            case 'H': return this._inputHandler.cursorPosition(params);
+            case 'I': return this._inputHandler.cursorForwardTab(params);
+            case 'J': return this._inputHandler.eraseInDisplay(params);
+            case 'K': return this._inputHandler.eraseInLine(params);
+            case 'L': return this._inputHandler.insertLines(params);
+            case 'M': return this._inputHandler.deleteLines(params);
+            case 'P': return this._inputHandler.deleteChars(params);
+            case 'S': return this._inputHandler.scrollUp(params);
+            case 'T':
+                if (params.length < 2 && !collected) {
+                    return this._inputHandler.scrollDown(params);
+                }
+                break;
+            case 'X': return this._inputHandler.eraseChars(params);
+            case 'Z': return this._inputHandler.cursorBackwardTab(params);
+            case '`': return this._inputHandler.charPosAbsolute(params);
+            case 'a': return this._inputHandler.HPositionRelative(params);
+            case 'b': return this._inputHandler.repeatPrecedingCharacter(params);
+            case 'c': return this._inputHandler.sendDeviceAttributes(params);
+            case 'd': return this._inputHandler.linePosAbsolute(params);
+            case 'e': return this._inputHandler.VPositionRelative(params);
+            case 'f': return this._inputHandler.HVPosition(params);
+            case 'g': return this._inputHandler.tabClear(params);
+            case 'h': return this._inputHandler.setMode(params);
+            case 'l': return this._inputHandler.resetMode(params);
+            case 'm': return this._inputHandler.charAttributes(params);
+            case 'n': return this._inputHandler.deviceStatus(params);
+            case 'p':
+                if (collected === '!') {
+                    return this._inputHandler.softReset(params);
+                }
+                break;
+            case 'q':
+                if (collected === ' ') {
+                    return this._inputHandler.setCursorStyle(params);
+                }
+                break;
+            case 'r': return this._inputHandler.setScrollRegion(params);
+            case 's': return this._inputHandler.saveCursor(params);
+            case 'u': return this._inputHandler.restoreCursor(params);
+        }
+        this._terminal.error('Unknown CSI code: %s %s %s.', collected, params, flag);
+    }
+
+    inst_e(collected: string, flag: string): void {
+        let cs;
+
+        switch (collected) {
+            case '':
+                switch (flag) {
+                    // case '6':  // Back Index (DECBI), VT420 and up - not supported
+                    case '7':  // Save Cursor (DECSC)
+                        this._inputHandler.saveCursor();
+                        return;
+                    case '8':  // Restore Cursor (DECRC)
+                        this._inputHandler.restoreCursor();
+                        return;
+                    // case '9':  // Forward Index (DECFI), VT420 and up - not supported
+                    case 'D':  // Index (IND is 0x84)
+                        this._terminal.index();
+                        return;
+                    case 'E':  // Next Line (NEL is 0x85)
+                        this._terminal.buffer.x = 0;
+                        this._terminal.index();
+                        return;
+                    case 'H':  //    ESC H   Tab Set (HTS is 0x88)
+                        (<IInputHandlingTerminal>this._terminal).tabSet();
+                        return;
+                    case 'M':  // Reverse Index (RI is 0x8d)
+                        this._terminal.reverseIndex();
+                        return;
+                    case 'N':  // Single Shift Select of G2 Character Set ( SS2 is 0x8e) - Is this supported?
+                    case 'O':  // Single Shift Select of G3 Character Set ( SS3 is 0x8f)
+                        return;
+                    // case 'P':  // Device Control String (DCS is 0x90) - covered by parser
+                    // case 'V':  // Start of Guarded Area (SPA is 0x96) - not supported
+                    // case 'W':  // End of Guarded Area (EPA is 0x97) - not supported
+                    // case 'X':  // Start of String (SOS is 0x98) - covered by parser (unsupported)
+                    // case 'Z':  // Return Terminal ID (DECID is 0x9a). Obsolete form of CSI c (DA).  - not supported
+                    // case '[':  // Control Sequence Introducer (CSI is 0x9b) - covered by parser
+                    // case '\':  // String Terminator (ST is 0x9c) - covered by parser
+                    // case ']':  //	Operating System Command (OSC is 0x9d) - covered by parser
+                    // case '^':  //	Privacy Message (PM is 0x9e) - covered by parser (unsupported)
+                    // case '_':  //	Application Program Command (APC is 0x9f) - covered by parser (unsupported)
+                    case '=':  // Application Keypad (DECKPAM)
+                        this._terminal.log('Serial port requested application keypad.');
+                        this._terminal.applicationKeypad = true;
+                        if (this._terminal.viewport) {
+                            this._terminal.viewport.syncScrollArea();
+                        }
+                        return;
+                    case '>':  // Normal Keypad (DECKPNM)
+                        this._terminal.log('Switching back to normal keypad.');
+                        this._terminal.applicationKeypad = false;
+                        if (this._terminal.viewport) {
+                            this._terminal.viewport.syncScrollArea();
+                        }
+                        return;
+                    // case 'F':  // Cursor to lower left corner of screen
+                    case 'c':  // Full Reset (RIS) http://vt100.net/docs/vt220-rm/chapter4.html
+                        this._terminal.reset();
+                        return;
+                    // case 'l':  // Memory Lock (per HP terminals). Locks memory above the cursor.
+                    // case 'm':  // Memory Unlock (per HP terminals).
+                    case 'n':  // Invoke the G2 Character Set as GL (LS2).
+                        this._terminal.setgLevel(2);
+                        return;
+                    case 'o':  // Invoke the G3 Character Set as GL (LS3).
+                        this._terminal.setgLevel(3);
+                        return;
+                    case '|':  // Invoke the G3 Character Set as GR (LS3R).
+                        this._terminal.setgLevel(3);
+                        return;
+                    case '}':  // Invoke the G2 Character Set as GR (LS2R).
+                        this._terminal.setgLevel(2);
+                        return;
+                    case '~':  // Invoke the G1 Character Set as GR (LS1R).
+                        this._terminal.setgLevel(1);
+                        return;
+                }
+            // case ' ':
+                // switch (flag) {
+                    // case 'F':  // (SP) 7-bit controls (S7C1T)
+                    // case 'G':  // (SP) 8-bit controls (S8C1T)
+                    // case 'L':  // (SP) Set ANSI conformance level 1 (dpANS X3.134.1)
+                    // case 'M':  // (SP) Set ANSI conformance level 2 (dpANS X3.134.1)
+                    // case 'N':  // (SP) Set ANSI conformance level 3 (dpANS X3.134.1)
+                // }
+
+            // case '#':
+                // switch (flag) {
+                    // case '3':  // DEC double-height line, top half (DECDHL)
+                    // case '4':  // DEC double-height line, bottom half (DECDHL)
+                    // case '5':  // DEC single-width line (DECSWL)
+                    // case '6':  // DEC double-width line (DECDWL)
+                    // case '8':  // DEC Screen Alignment Test (DECALN)
+                // }
+
+            case '%':
+                // switch (flag) {
+                    // case '@':  // (%) Select default character set. That is ISO 8859-1 (ISO 2022)
+                    // case 'G':  // (%) Select UTF-8 character set (ISO 2022)
+                // }
+                this._terminal.setgLevel(0);
+                this._terminal.setgCharset(0, DEFAULT_CHARSET); // US (default)
+                return;
+
+            // load character sets
+            case '(': // G0 (VT100)
+                cs = CHARSETS[flag];
+                if (!cs) cs = DEFAULT_CHARSET;
+                this._terminal.setgCharset(0, cs);
+                return;
+            case ')': // G1 (VT100)
+                cs = CHARSETS[flag];
+                if (!cs) cs = DEFAULT_CHARSET;
+                this._terminal.setgCharset(1, cs);
+                return;
+            case '*': // G2 (VT220)
+                cs = CHARSETS[flag];
+                if (!cs) cs = DEFAULT_CHARSET;
+                this._terminal.setgCharset(2, cs);
+                return;
+            case '+': // G3 (VT220)
+                cs = CHARSETS[flag];
+                if (!cs) cs = DEFAULT_CHARSET;
+                this._terminal.setgCharset(3, cs);
+                return;
+            case '-': // G1 (VT300)
+            cs = CHARSETS[flag];
+                if (!cs) cs = DEFAULT_CHARSET;
+                this._terminal.setgCharset(1, cs);
+                return;
+            case '.': // G2 (VT300)
+                if (!cs) cs = DEFAULT_CHARSET;
+                this._terminal.setgCharset(2, cs);
+                return;
+            case '/': // G3 (VT300)
+                // not supported - how to deal with this? (original code is not reachable)
+                return;
+            default:
+                this._terminal.error('Unknown ESC control: %s %s.', collected, flag);
+        }
+    }
+
+    inst_H(collected: string, params: number[], flag: string): void {
+        // TODO
+    }
+
+    inst_P(dcs: string): void {
+        // TODO
+    }
+
+    inst_U(): void {
+        // TODO
+    }
+
+    inst_E(): void {
+        // TODO
+    }
+}
diff --git a/src/InputHandler.ts b/src/InputHandler.ts
index 4df3e695..9e7ad3a5 100644
--- a/src/InputHandler.ts
+++ b/src/InputHandler.ts
@@ -22,7 +22,7 @@ export class InputHandler implements IInputHandler {
   constructor(private _terminal: IInputHandlingTerminal) { }
 
   public addChar(char: string, code: number): void {
-    if (char >= ' ') {
+    // if (char >= ' ') {
 
       // make buffer local for faster access
       const buffer = this._terminal.buffer;
@@ -111,7 +111,7 @@ export class InputHandler implements IInputHandler {
         buffer.lines.get(row)[buffer.x] = [this._terminal.curAttr, '', 0, undefined];
         buffer.x++;
       }
-    }
+    // }
   }
 
   /**
diff --git a/src/Terminal.ts b/src/Terminal.ts
index ba1fff3d..44c90643 100644
--- a/src/Terminal.ts
+++ b/src/Terminal.ts
@@ -32,7 +32,7 @@ import { Viewport } from './Viewport';
 import { rightClickHandler, moveTextAreaUnderMouseCursor, pasteHandler, copyHandler } from './handlers/Clipboard';
 import { C0 } from './EscapeSequences';
 import { InputHandler } from './InputHandler';
-import { Parser } from './Parser';
+// import { Parser } from './Parser';
 import { Renderer } from './renderer/Renderer';
 import { Linkifier } from './Linkifier';
 import { SelectionManager } from './SelectionManager';
@@ -49,6 +49,7 @@ import { AccessibilityManager } from './AccessibilityManager';
 import { ScreenDprMonitor } from './utils/ScreenDprMonitor';
 import { ITheme, ILocalizableStrings, IMarker, IDisposable } from 'xterm';
 import { removeTerminalFromCache } from './renderer/atlas/CharAtlas';
+import { ParserTerminal } from './EscapeSequenceParser';
 
 // reg + shift key mappings for digits and special chars
 const KEYCODE_KEY_MAPPINGS = {
@@ -216,7 +217,8 @@ export class Terminal extends EventEmitter implements ITerminal, IDisposable, II
 
   private _inputHandler: InputHandler;
   public soundManager: SoundManager;
-  private _parser: Parser;
+  // private _parser: Parser;
+  private _newParser: ParserTerminal;
   public renderer: IRenderer;
   public selectionManager: SelectionManager;
   public linkifier: ILinkifier;
@@ -331,7 +333,8 @@ export class Terminal extends EventEmitter implements ITerminal, IDisposable, II
     this._userScrolling = false;
 
     this._inputHandler = new InputHandler(this);
-    this._parser = new Parser(this._inputHandler, this);
+    // this._parser = new Parser(this._inputHandler, this);
+    this._newParser = new ParserTerminal(this, this._inputHandler);
     // Reuse renderer if the Terminal is being recreated via a reset call.
     this.renderer = this.renderer || null;
     this.selectionManager = this.selectionManager || null;
@@ -1315,8 +1318,10 @@ export class Terminal extends EventEmitter implements ITerminal, IDisposable, II
       // middle of parsing escape sequence in two chunks. For some reason the
       // state of the parser resets to 0 after exiting parser.parse. This change
       // just sets the state back based on the correct return statement.
-      const state = this._parser.parse(data);
-      this._parser.setState(state);
+
+      // const state = this._parser.parse(data);
+      this._newParser.write(data);
+      // this._parser.setState(state);
 
       this.updateRange(this.buffer.y);
       this.refresh(this._refreshStart, this._refreshEnd);