text: "use strict";
  Object.defineProperty(exports, "__esModule", { value: true });
  var EscapeSequences_1 = require("./EscapeSequences");
  var Charsets_1 = require("./Charsets");
  var normalStateHandler = {};
  normalStateHandler[EscapeSequences_1.C0.BEL] = function (parser, handler) { return handler.bell(); };
  normalStateHandler[EscapeSequences_1.C0.LF] = function (parser, handler) { return handler.lineFeed(); };
  normalStateHandler[EscapeSequences_1.C0.VT] = normalStateHandler[EscapeSequences_1.C0.LF];
  normalStateHandler[EscapeSequences_1.C0.FF] = normalStateHandler[EscapeSequences_1.C0.LF];
  normalStateHandler[EscapeSequences_1.C0.CR] = function (parser, handler) { return handler.carriageReturn(); };
  normalStateHandler[EscapeSequences_1.C0.BS] = function (parser, handler) { return handler.backspace(); };
  normalStateHandler[EscapeSequences_1.C0.HT] = function (parser, handler) { return handler.tab(); };
  normalStateHandler[EscapeSequences_1.C0.SO] = function (parser, handler) { return handler.shiftOut(); };
  normalStateHandler[EscapeSequences_1.C0.SI] = function (parser, handler) { return handler.shiftIn(); };
  normalStateHandler[EscapeSequences_1.C0.ESC] = function (parser, handler) { return parser.setState(ParserState.ESCAPED); };
  var escapedStateHandler = {};
  escapedStateHandler['['] = function (parser, terminal) {
      terminal.params = [];
      terminal.currentParam = 0;
      parser.setState(ParserState.CSI_PARAM);
  };
  escapedStateHandler[']'] = function (parser, terminal) {
      terminal.params = [];
      terminal.currentParam = 0;
      parser.setState(ParserState.OSC);
  };
  escapedStateHandler['P'] = function (parser, terminal) {
      terminal.params = [];
      terminal.currentParam = 0;
      parser.setState(ParserState.DCS);
  };
  escapedStateHandler['_'] = function (parser, terminal) {
      parser.setState(ParserState.IGNORE);
  };
  escapedStateHandler['^'] = function (parser, terminal) {
      parser.setState(ParserState.IGNORE);
  };
  escapedStateHandler['c'] = function (parser, terminal) {
      terminal.reset();
  };
  escapedStateHandler['E'] = function (parser, terminal) {
      terminal.buffer.x = 0;
      terminal.index();
      parser.setState(ParserState.NORMAL);
  };
  escapedStateHandler['D'] = function (parser, terminal) {
      terminal.index();
      parser.setState(ParserState.NORMAL);
  };
  escapedStateHandler['M'] = function (parser, terminal) {
      terminal.reverseIndex();
      parser.setState(ParserState.NORMAL);
  };
  escapedStateHandler['%'] = function (parser, terminal) {
      terminal.setgLevel(0);
      terminal.setgCharset(0, Charsets_1.DEFAULT_CHARSET);
      parser.setState(ParserState.NORMAL);
      parser.skipNextChar();
  };
  escapedStateHandler[EscapeSequences_1.C0.CAN] = function (parser) { return parser.setState(ParserState.NORMAL); };
  var csiParamStateHandler = {};
  csiParamStateHandler['?'] = function (parser) { return parser.setPrefix('?'); };
  csiParamStateHandler['>'] = function (parser) { return parser.setPrefix('>'); };
  csiParamStateHandler['!'] = function (parser) { return parser.setPrefix('!'); };
  csiParamStateHandler['0'] = function (parser) { return parser.setParam(parser.getParam() * 10); };
  csiParamStateHandler['1'] = function (parser) { return parser.setParam(parser.getParam() * 10 + 1); };
  csiParamStateHandler['2'] = function (parser) { return parser.setParam(parser.getParam() * 10 + 2); };
  csiParamStateHandler['3'] = function (parser) { return parser.setParam(parser.getParam() * 10 + 3); };
  csiParamStateHandler['4'] = function (parser) { return parser.setParam(parser.getParam() * 10 + 4); };
  csiParamStateHandler['5'] = function (parser) { return parser.setParam(parser.getParam() * 10 + 5); };
  csiParamStateHandler['6'] = function (parser) { return parser.setParam(parser.getParam() * 10 + 6); };
  csiParamStateHandler['7'] = function (parser) { return parser.setParam(parser.getParam() * 10 + 7); };
  csiParamStateHandler['8'] = function (parser) { return parser.setParam(parser.getParam() * 10 + 8); };
  csiParamStateHandler['9'] = function (parser) { return parser.setParam(parser.getParam() * 10 + 9); };
  csiParamStateHandler['$'] = function (parser) { return parser.setPostfix('$'); };
  csiParamStateHandler['"'] = function (parser) { return parser.setPostfix('"'); };
  csiParamStateHandler[' '] = function (parser) { return parser.setPostfix(' '); };
  csiParamStateHandler['\''] = function (parser) { return parser.setPostfix('\''); };
  csiParamStateHandler[';'] = function (parser) { return parser.finalizeParam(); };
  csiParamStateHandler[EscapeSequences_1.C0.CAN] = function (parser) { return parser.setState(ParserState.NORMAL); };
  var csiStateHandler = {};
  csiStateHandler['@'] = function (handler, params, prefix) { return handler.insertChars(params); };
  csiStateHandler['A'] = function (handler, params, prefix) { return handler.cursorUp(params); };
  csiStateHandler['B'] = function (handler, params, prefix) { return handler.cursorDown(params); };
  csiStateHandler['C'] = function (handler, params, prefix) { return handler.cursorForward(params); };
  csiStateHandler['D'] = function (handler, params, prefix) { return handler.cursorBackward(params); };
  csiStateHandler['E'] = function (handler, params, prefix) { return handler.cursorNextLine(params); };
  csiStateHandler['F'] = function (handler, params, prefix) { return handler.cursorPrecedingLine(params); };
  csiStateHandler['G'] = function (handler, params, prefix) { return handler.cursorCharAbsolute(params); };
  csiStateHandler['H'] = function (handler, params, prefix) { return handler.cursorPosition(params); };
  csiStateHandler['I'] = function (handler, params, prefix) { return handler.cursorForwardTab(params); };
  csiStateHandler['J'] = function (handler, params, prefix) { return handler.eraseInDisplay(params); };
  csiStateHandler['K'] = function (handler, params, prefix) { return handler.eraseInLine(params); };
  csiStateHandler['L'] = function (handler, params, prefix) { return handler.insertLines(params); };
  csiStateHandler['M'] = function (handler, params, prefix) { return handler.deleteLines(params); };
  csiStateHandler['P'] = function (handler, params, prefix) { return handler.deleteChars(params); };
  csiStateHandler['S'] = function (handler, params, prefix) { return handler.scrollUp(params); };
  csiStateHandler['T'] = function (handler, params, prefix) {
      if (params.length < 2 && !prefix) {
          handler.scrollDown(params);
      }
  };
  csiStateHandler['X'] = function (handler, params, prefix) { return handler.eraseChars(params); };
  csiStateHandler['Z'] = function (handler, params, prefix) { return handler.cursorBackwardTab(params); };
  csiStateHandler['`'] = function (handler, params, prefix) { return handler.charPosAbsolute(params); };
  csiStateHandler['a'] = function (handler, params, prefix) { return handler.HPositionRelative(params); };
  csiStateHandler['b'] = function (handler, params, prefix) { return handler.repeatPrecedingCharacter(params); };
  csiStateHandler['c'] = function (handler, params, prefix) { return handler.sendDeviceAttributes(params); };
  csiStateHandler['d'] = function (handler, params, prefix) { return handler.linePosAbsolute(params); };
  csiStateHandler['e'] = function (handler, params, prefix) { return handler.VPositionRelative(params); };
  csiStateHandler['f'] = function (handler, params, prefix) { return handler.HVPosition(params); };
  csiStateHandler['g'] = function (handler, params, prefix) { return handler.tabClear(params); };
  csiStateHandler['h'] = function (handler, params, prefix) { return handler.setMode(params); };
  csiStateHandler['l'] = function (handler, params, prefix) { return handler.resetMode(params); };
  csiStateHandler['m'] = function (handler, params, prefix) { return handler.charAttributes(params); };
  csiStateHandler['n'] = function (handler, params, prefix) { return handler.deviceStatus(params); };
  csiStateHandler['p'] = function (handler, params, prefix) {
      switch (prefix) {
          case '!':
              handler.softReset(params);
              break;
      }
  };
  csiStateHandler['q'] = function (handler, params, prefix, postfix) {
      if (postfix === ' ') {
          handler.setCursorStyle(params);
      }
  };
  csiStateHandler['r'] = function (handler, params) { return handler.setScrollRegion(params); };
  csiStateHandler['s'] = function (handler, params) { return handler.saveCursor(params); };
  csiStateHandler['u'] = function (handler, params) { return handler.restoreCursor(params); };
  csiStateHandler[EscapeSequences_1.C0.CAN] = function (handler, params, prefix, postfix, parser) { return parser.setState(ParserState.NORMAL); };
  var ParserState;
  (function (ParserState) {
      ParserState[ParserState["NORMAL"] = 0] = "NORMAL";
      ParserState[ParserState["ESCAPED"] = 1] = "ESCAPED";
      ParserState[ParserState["CSI_PARAM"] = 2] = "CSI_PARAM";
      ParserState[ParserState["CSI"] = 3] = "CSI";
      ParserState[ParserState["OSC"] = 4] = "OSC";
      ParserState[ParserState["CHARSET"] = 5] = "CHARSET";
      ParserState[ParserState["DCS"] = 6] = "DCS";
      ParserState[ParserState["IGNORE"] = 7] = "IGNORE";
  })(ParserState = exports.ParserState || (exports.ParserState = {}));
  var Parser = (function () {
      function Parser(_inputHandler, _terminal) {
          this._inputHandler = _inputHandler;
          this._terminal = _terminal;
          this._state = ParserState.NORMAL;
      }
      Parser.prototype.parse = function (data) {
          var l = data.length;
          var cs;
          var ch;
          var code;
          var low;
          var cursorStartX = this._terminal.buffer.x;
          var cursorStartY = this._terminal.buffer.y;
          if (this._terminal.debug) {
              this._terminal.log('data: ' + data);
          }
          this._position = 0;
          if (this._terminal.surrogate_high) {
              data = this._terminal.surrogate_high + data;
              this._terminal.surrogate_high = '';
          }
          for (; this._position < l; this._position++) {
              ch = data[this._position];
              code = data.charCodeAt(this._position);
              if (0xD800 <= code && code <= 0xDBFF) {
                  low = data.charCodeAt(this._position + 1);
                  if (isNaN(low)) {
                      this._terminal.surrogate_high = ch;
                      continue;
                  }
                  code = ((code - 0xD800) * 0x400) + (low - 0xDC00) + 0x10000;
                  ch += data.charAt(this._position + 1);
              }
              if (0xDC00 <= code && code <= 0xDFFF) {
                  continue;
              }
              switch (this._state) {
                  case ParserState.NORMAL:
                      if (ch in normalStateHandler) {
                          normalStateHandler[ch](this, this._inputHandler);
                      }
                      else {
                          this._inputHandler.addChar(ch, code);
                      }
                      break;
                  case ParserState.ESCAPED:
                      if (ch in escapedStateHandler) {
                          escapedStateHandler[ch](this, this._terminal);
                          break;
                      }
                      switch (ch) {
                          case '(':
                          case ')':
                          case '*':
                          case '+':
                          case '-':
                          case '.':
                              switch (ch) {
                                  case '(':
                                      this._terminal.gcharset = 0;
                                      break;
                                  case ')':
                                      this._terminal.gcharset = 1;
                                      break;
                                  case '*':
                                      this._terminal.gcharset = 2;
                                      break;
                                  case '+':
                                      this._terminal.gcharset = 3;
                                      break;
                                  case '-':
                                      this._terminal.gcharset = 1;
                                      break;
                                  case '.':
                                      this._terminal.gcharset = 2;
                                      break;
                              }
                              this._state = ParserState.CHARSET;
                              break;
                          case '/':
                              this._terminal.gcharset = 3;
                              this._state = ParserState.CHARSET;
                              this._position--;
                              break;
                          case 'N':
                              this._state = ParserState.NORMAL;
                              break;
                          case 'O':
                              this._state = ParserState.NORMAL;
                              break;
                          case 'n':
                              this._terminal.setgLevel(2);
                              this._state = ParserState.NORMAL;
                              break;
                          case 'o':
                              this._terminal.setgLevel(3);
                              this._state = ParserState.NORMAL;
                              break;
                          case '|':
                              this._terminal.setgLevel(3);
                              this._state = ParserState.NORMAL;
                              break;
                          case '}':
                              this._terminal.setgLevel(2);
                              this._state = ParserState.NORMAL;
                              break;
                          case '~':
                              this._terminal.setgLevel(1);
                              this._state = ParserState.NORMAL;
                              break;
                          case '7':
                              this._inputHandler.saveCursor();
                              this._state = ParserState.NORMAL;
                              break;
                          case '8':
                              this._inputHandler.restoreCursor();
                              this._state = ParserState.NORMAL;
                              break;
                          case '#':
                              this._state = ParserState.NORMAL;
                              this._position++;
                              break;
                          case 'H':
                              this._terminal.tabSet();
                              this._state = ParserState.NORMAL;
                              break;
                          case '=':
                              this._terminal.log('Serial port requested application keypad.');
                              this._terminal.applicationKeypad = true;
                              if (this._terminal.viewport) {
                                  this._terminal.viewport.syncScrollArea();
                              }
                              this._state = ParserState.NORMAL;
                              break;
                          case '>':
                              this._terminal.log('Switching back to normal keypad.');
                              this._terminal.applicationKeypad = false;
                              if (this._terminal.viewport) {
                                  this._terminal.viewport.syncScrollArea();
                              }
                              this._state = ParserState.NORMAL;
                              break;
                          default:
                              this._state = ParserState.NORMAL;
                              this._terminal.error('Unknown ESC control: %s.', ch);
                              break;
                      }
                      break;
                  case ParserState.CHARSET:
                      if (ch in Charsets_1.CHARSETS) {
                          cs = Charsets_1.CHARSETS[ch];
                          if (ch === '/') {
                              this.skipNextChar();
                          }
                      }
                      else {
                          cs = Charsets_1.DEFAULT_CHARSET;
                      }
                      this._terminal.setgCharset(this._terminal.gcharset, cs);
                      this._terminal.gcharset = null;
                      this._state = ParserState.NORMAL;
                      break;
                  case ParserState.OSC:
                      if (ch === EscapeSequences_1.C0.ESC || ch === EscapeSequences_1.C0.BEL) {
                          if (ch === EscapeSequences_1.C0.ESC)
                              this._position++;
                          this._terminal.params.push(this._terminal.currentParam);
                          switch (this._terminal.params[0]) {
                              case 0:
                              case 1:
                              case 2:
                                  if (this._terminal.params[1]) {
                                      this._terminal.title = this._terminal.params[1];
                                      this._terminal.handleTitle(this._terminal.title);
                                  }
                                  break;
                              case 3:
                                  break;
                              case 4:
                              case 5:
                                  break;
                              case 10:
                              case 11:
                              case 12:
                              case 13:
                              case 14:
                              case 15:
                              case 16:
                              case 17:
                              case 18:
                              case 19:
                                  break;
                              case 46:
                                  break;
                              case 50:
                                  break;
                              case 51:
                                  break;
                              case 52:
                                  break;
                              case 104:
                              case 105:
                              case 110:
                              case 111:
                              case 112:
                              case 113:
                              case 114:
                              case 115:
                              case 116:
                              case 117:
                              case 118:
                                  break;
                          }
                          this._terminal.params = [];
                          this._terminal.currentParam = 0;
                          this._state = ParserState.NORMAL;
                      }
                      else {
                          if (!this._terminal.params.length) {
                              if (ch >= '0' && ch <= '9') {
                                  this._terminal.currentParam =
                                      this._terminal.currentParam * 10 + ch.charCodeAt(0) - 48;
                              }
                              else if (ch === ';') {
                                  this._terminal.params.push(this._terminal.currentParam);
                                  this._terminal.currentParam = '';
                              }
                          }
                          else {
                              this._terminal.currentParam += ch;
                          }
                      }
                      break;
                  case ParserState.CSI_PARAM:
                      if (ch in csiParamStateHandler) {
                          csiParamStateHandler[ch](this);
                          break;
                      }
                      this.finalizeParam();
                      this._state = ParserState.CSI;
                  case ParserState.CSI:
                      if (ch in csiStateHandler) {
                          if (this._terminal.debug) {
                              this._terminal.log("CSI " + (this._terminal.prefix ? this._terminal.prefix : '') + " " + (this._terminal.params ? this._terminal.params.join(';') : '') + " " + (this._terminal.postfix ? this._terminal.postfix : '') + " " + ch);
                          }
                          csiStateHandler[ch](this._inputHandler, this._terminal.params, this._terminal.prefix, this._terminal.postfix, this);
                      }
                      else {
                          this._terminal.error('Unknown CSI code: %s.', ch);
                      }
                      this._state = ParserState.NORMAL;
                      this._terminal.prefix = '';
                      this._terminal.postfix = '';
                      break;
                  case ParserState.DCS:
                      if (ch === EscapeSequences_1.C0.ESC || ch === EscapeSequences_1.C0.BEL) {
                          if (ch === EscapeSequences_1.C0.ESC)
                              this._position++;
                          var pt = void 0;
                          var valid = void 0;
                          switch (this._terminal.prefix) {
                              case '':
                                  break;
                              case '$q':
                                  pt = this._terminal.currentParam;
                                  valid = false;
                                  switch (pt) {
                                      case '"q':
                                          pt = '0"q';
                                          break;
                                      case '"p':
                                          pt = '61"p';
                                          break;
                                      case 'r':
                                          pt = ''
                                              + (this._terminal.buffer.scrollTop + 1)
                                              + ';'
                                              + (this._terminal.buffer.scrollBottom + 1)
                                              + 'r';
                                          break;
                                      case 'm':
                                          pt = '0m';
                                          break;
                                      default:
                                          this._terminal.error('Unknown DCS Pt: %s.', pt);
                                          pt = '';
                                          break;
                                  }
                                  this._terminal.send(EscapeSequences_1.C0.ESC + 'P' + +valid + '$r' + pt + EscapeSequences_1.C0.ESC + '\\');
                                  break;
                              case '+p':
                                  break;
                              case '+q':
                                  pt = this._terminal.currentParam;
                                  valid = false;
                                  this._terminal.send(EscapeSequences_1.C0.ESC + 'P' + +valid + '+r' + pt + EscapeSequences_1.C0.ESC + '\\');
                                  break;
                              default:
                                  this._terminal.error('Unknown DCS prefix: %s.', this._terminal.prefix);
                                  break;
                          }
                          this._terminal.currentParam = 0;
                          this._terminal.prefix = '';
                          this._state = ParserState.NORMAL;
                      }
                      else if (!this._terminal.currentParam) {
                          if (!this._terminal.prefix && ch !== '$' && ch !== '+') {
                              this._terminal.currentParam = ch;
                          }
                          else if (this._terminal.prefix.length === 2) {
                              this._terminal.currentParam = ch;
                          }
                          else {
                              this._terminal.prefix += ch;
                          }
                      }
                      else {
                          this._terminal.currentParam += ch;
                      }
                      break;
                  case ParserState.IGNORE:
                      if (ch === EscapeSequences_1.C0.ESC || ch === EscapeSequences_1.C0.BEL) {
                          if (ch === EscapeSequences_1.C0.ESC)
                              this._position++;
                          this._state = ParserState.NORMAL;
                      }
                      break;
              }
          }
          if (this._terminal.buffer.x !== cursorStartX || this._terminal.buffer.y !== cursorStartY) {
              this._terminal.emit('cursormove');
          }
          return this._state;
      };
      Parser.prototype.setState = function (state) {
          this._state = state;
      };
      Parser.prototype.setPrefix = function (prefix) {
          this._terminal.prefix = prefix;
      };
      Parser.prototype.setPostfix = function (postfix) {
          this._terminal.postfix = postfix;
      };
      Parser.prototype.setParam = function (param) {
          this._terminal.currentParam = param;
      };
      Parser.prototype.getParam = function () {
          return this._terminal.currentParam;
      };
      Parser.prototype.finalizeParam = function () {
          this._terminal.params.push(this._terminal.currentParam);
          this._terminal.currentParam = 0;
      };
      Parser.prototype.skipNextChar = function () {
          this._position++;
      };
      return Parser;
  }());
  exports.Parser = Parser;
  
  //# sourceMappingURL=Parser.js.map
  