term.js

/*
 *  This file is part of CoCalc: Copyright © 2020 Sagemath, Inc.
 *  License: MS-RSL – see LICENSE.md for details
 */

/**
 * tty.js - an xterm emulator
 *
 * Copyright (c) 2012, Christopher Jeffrey (https://github.com/chjj/tty.js)
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in
 * all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 * THE SOFTWARE.
 *
 * Originally forked from (with the author's permission):
 *   Fabrice Bellard's javascript vt100 for jslinux:
 *   http://bellard.org/jslinux/
 *   Copyright (c) 2011 Fabrice Bellard
 *   The original design remains. The terminal itself
 *   has been extended to include xterm CSI codes, among
 *   other features.
 */

(function() {
  /**
   * Terminal Emulation References:
   *   http://vt100.net/
   *   http://invisible-island.net/xterm/ctlseqs/ctlseqs.txt
   *   http://invisible-island.net/xterm/ctlseqs/ctlseqs.html
   *   http://invisible-island.net/vttest/
   *   http://www.inwap.com/pdp10/ansicode.txt
   *   http://linux.die.net/man/4/console_codes
   *   http://linux.die.net/man/7/urxvt
   */

  "use strict";

  /**
   * Shared
   */

  var window = this,
    document = this.document;

  /**
   * EventEmitter
   */

  function EventEmitter() {
    this._events = this._events || {};
  }

  EventEmitter.prototype.addListener = function(type, listener) {
    this._events[type] = this._events[type] || [];
    this._events[type].push(listener);
  };

  EventEmitter.prototype.on = EventEmitter.prototype.addListener;

  EventEmitter.prototype.removeListener = function(type, listener) {
    if (!this._events[type]) return;

    var obj = this._events[type],
      i = obj.length;

    while (i--) {
      if (obj[i] === listener || obj[i].listener === listener) {
        obj.splice(i, 1);
        return;
      }
    }
  };

  EventEmitter.prototype.off = EventEmitter.prototype.removeListener;

  EventEmitter.prototype.removeAllListeners = function(type) {
    if (this._events[type]) delete this._events[type];
  };

  EventEmitter.prototype.once = function(type, listener) {
    function on() {
      var args = Array.prototype.slice.call(arguments);
      this.removeListener(type, on);
      return listener.apply(this, args);
    }
    on.listener = listener;
    return this.on(type, on);
  };

  EventEmitter.prototype.emit = function(type) {
    if (!this._events[type]) return;

    var args = Array.prototype.slice.call(arguments, 1),
      obj = this._events[type],
      l = obj.length,
      i = 0;

    for (; i < l; i++) {
      obj[i].apply(this, args);
    }
  };

  EventEmitter.prototype.listeners = function(type) {
    return (this._events[type] = this._events[type] || []);
  };

  /**
   * States
   */

  var normal = 0,
    escaped = 1,
    csi = 2,
    osc = 3,
    charset = 4,
    dcs = 5,
    ignore = 6;

  /**
   * Terminal
   */

  function Terminal(cols, rows, handler) {
    EventEmitter.call(this);

    var options;
    // Yes, we have to check for null! See https://github.com/sagemathinc/cocalc/issues/5961
    if (cols != null && typeof cols === "object") {
      options = cols;
      cols = options.cols;
      rows = options.rows;
      handler = options.handler;
    }
    this._options = options || {};

    this.cols = cols || Terminal.geometry[0];
    this.rows = rows || Terminal.geometry[1];

    if (handler) {
      this.on("data", handler);
    }

    this.ybase = 0;
    this.ydisp = 0;
    this.x = 0;
    this.y = 0;
    this.cursorState = 0;
    this.cursorHidden = false;
    this.convertEol = false;
    this.state = 0;
    this.queue = "";
    this.scrollTop = 0;
    this.scrollBottom = this.rows - 1;

    // modes
    this.applicationKeypad = false;
    this.originMode = false;
    this.insertMode = false;
    this.wraparoundMode = false;
    this.normal = null;

    // charset
    this.charset = null;
    this.gcharset = null;
    this.glevel = 0;
    this.charsets = [null];

    // mouse properties
    this.decLocator;
    this.x10Mouse;
    this.vt200Mouse;
    this.vt300Mouse;
    this.normalMouse;
    this.mouseEvents;
    this.sendFocus;
    this.utfMouse;
    this.sgrMouse;
    this.urxvtMouse;

    // misc
    this.element;
    this.children;
    this.refreshStart;
    this.refreshEnd;
    this.savedX;
    this.savedY;
    this.savedCols;

    // stream
    this.readable = true;
    this.writable = true;

    this.defAttr = (257 << 9) | 256;
    this.curAttr = this.defAttr;

    this.params = [];
    this.currentParam = 0;
    this.prefix = "";
    this.postfix = "";

    this.lines = [];
    var i = this.rows;
    while (i--) {
      this.lines.push(this.blankLine());
    }

    this.tabs;
    this.setupStops();
  }

  inherits(Terminal, EventEmitter);

  /**
   * Colors
   */

  // Colors 0-15
  Terminal.colors = [
    // dark:
    "#000000", // black
    "#cc0000", // red
    "#4e9a06", // green
    "#c4a000", // yellow
    "#3465a4", // blue
    "#75507b", // magenta
    "#06989a", // cyan
    "#d3d7cf", // white-ish (really light grey)
    // bright versions of the above.
    "#555753", // bright black
    "#ef2929", // bright red
    "#8ae234", // bright green
    "#fce94f", // bright yellow
    "#729fcf", // bright blue
    "#ad7fa8", // bright magenta
    "#34e2e2", // bright cyan
    "#ffffff" // bright white
  ];

  // Colors 16-255
  // Much thanks to TooTallNate for writing this.
  Terminal.colors = (function() {
    var colors = Terminal.colors,
      r = [0x00, 0x5f, 0x87, 0xaf, 0xd7, 0xff],
      i;

    // 16-231
    i = 0;
    for (; i < 216; i++) {
      out(r[((i / 36) % 6) | 0], r[((i / 6) % 6) | 0], r[i % 6]);
    }

    // 232-255 (grey)
    i = 0;
    for (; i < 24; i++) {
      r = 8 + i * 10;
      out(r, r, r);
    }

    function out(r, g, b) {
      colors.push("#" + hex(r) + hex(g) + hex(b));
    }

    function hex(c) {
      c = c.toString(16);
      return c.length < 2 ? "0" + c : c;
    }

    return colors;
  })();

  // Default BG/FG
  Terminal.defaultColors = {
    bg: Terminal.colors[15], // '#ffffff',
    fg: Terminal.colors[0] // '#000000'
  };

  Terminal.colors[256] = Terminal.defaultColors.bg;
  Terminal.colors[257] = Terminal.defaultColors.fg;

  /**
   * Options
   */

  Terminal.termName = "xterm";
  Terminal.geometry = [80, 24];
  Terminal.cursorBlink = false;
  Terminal.visualBell = false;
  Terminal.popOnBell = false;
  Terminal.scrollback = 1000;
  Terminal.screenKeys = false;
  Terminal.programFeatures = false;
  Terminal.debug = false;

  /**
   * Focused Terminal
   */

  Terminal.focus = null;

  Terminal.prototype.blur = function() {
    if (Terminal.focus !== this) return;
    if (Terminal.focus) {
      Terminal.focus.cursorState = 0;
      Terminal.focus.refresh(Terminal.focus.y, Terminal.focus.y);
      if (Terminal.focus.sendFocus) Terminal.focus.send("\x1b[O");
    }
    Terminal.focus = undefined;
  };

  Terminal.prototype.focus = function() {
    if (Terminal.focus === this) return;
    if (Terminal.focus) {
      Terminal.focus.cursorState = 0;
      Terminal.focus.refresh(Terminal.focus.y, Terminal.focus.y);
      if (Terminal.focus.sendFocus) Terminal.focus.send("\x1b[O");
    }
    Terminal.focus = this;
    if (this.sendFocus) this.send("\x1b[I");
    this.showCursor();
  };

  /**
   * Global Events for key handling
   */

  function getSelectionHtml() {
    /* from http://stackoverflow.com/questions/5222814/window-getselection-return-html */
    var html = "";
    if (typeof window.getSelection != "undefined") {
      var sel = window.getSelection();
      if (sel.rangeCount) {
        var container = document.createElement("div");
        for (var i = 0, len = sel.rangeCount; i < len; ++i) {
          container.appendChild(sel.getRangeAt(i).cloneContents());
        }
        html = container.innerHTML;
      }
    } else if (typeof document.selection != "undefined") {
      if (document.selection.type == "Text") {
        html = document.selection.createRange().htmlText;
      }
    }
    return html;
  }

  Terminal.keys_are_bound = false;
  Terminal.bindKeys = function(client_keydown) {
    if (Terminal.focus) return;

    /* It is critical that we only bind to the keyboard once in the whole program.
      If we bind more than once, than multiple terms on the same
      page will result in multiple key data being sent.
    */
    if (Terminal.keys_are_bound) return;
    Terminal.keys_are_bound = true;

    // We handle composite characters, which otherwise
    // would not work with firefox and opera.  This
    // addresses https://github.com/sagemathinc/cocalc/issues/2211
    // Idea/work done by Gonzalo Tornaría.
    on(
      document,
      "compositionend",
      function(ev) {
        Terminal.focus.handler(ev.data);
      },
      true
    );

    on(
      document,
      "keydown",
      function(ev) {
        if (typeof Terminal.focus === "undefined") {
          return;
        }

        //console.log('term.js keydown ', ev);

        if (
          typeof client_keydown != "undefined" &&
          client_keydown(ev) === false
        ) {
          return false;
        }

        if (!isMac) {
          // on OS X ctrl-C does *not* copy, so we don't need to do this.
          if (ev.ctrlKey && ev.keyCode == 67 && getSelectionHtml() != "") {
            // copy
            return false;
          }

          if (ev.ctrlKey && ev.keyCode == 86) {
            // paste
            return false;
          }
        }

        /* term -- handle the keystroke via the xterm . */
        if (typeof Terminal.focus === "object") {
          return Terminal.focus.keyDown(ev);
        }
      },
      true
    );

    on(
      document,
      "keypress",
      function(ev) {
        if (typeof Terminal.focus === "undefined") {
          return;
        }

        if (typeof Terminal.focus === "object") {
          return Terminal.focus.keyPress(ev);
        }
      },
      true
    );
  };

  /*Terminal.bindKeys = function() {
  if (Terminal.focus) return;

  // We could put an "if (Terminal.focus)" check
  // here, but it shouldn't be necessary.
  on(document, 'keydown', function(ev) {
    if (ev.metaKey) { return false ; } // allow copy/paste/etc. on OS X
    return Terminal.focus.keyDown(ev);
  }, true);

  on(document, 'keypress', function(ev) {
    if (ev.metaKey) { return false ; } // allow copy/paste/etc. on OS X
    return Terminal.focus.keyPress(ev);
  }, true);
};
*/

  /**
   * Open Terminal
   */

  Terminal.prototype.open = function() {
    var self = this,
      i = 0,
      div;

    this.set_color_scheme("default");
    this.element = document.createElement("div");
    this.element.setAttribute("spellcheck", "false");
    this.children = [];

    for (; i < this.rows; i++) {
      div = document.createElement("div");
      this.element.appendChild(div);
      this.children.push(div);
    }

    document.body.appendChild(this.element);

    this.refresh(0, this.rows - 1);

    Terminal.bindKeys(this.client_keydown);
    this.focus();

    this.startBlink();

    on(this.element, "mousedown", function() {
      self.focus();
    });

    // This probably shouldn't work,
    // ... but it does. Firefox's paste
    // event seems to only work for textareas?
    on(
      this.element,
      "mousedown",
      function(ev) {
        var button =
          ev.button != null
            ? +ev.button
            : ev.which != null
              ? ev.which - 1
              : null;

        // Does IE9 do this?
        if (~navigator.userAgent.indexOf("MSIE")) {
          button = button === 1 ? 0 : button === 4 ? 1 : button;
        }

        if (button !== 2) return;

        self.element.contentEditable = "true";
        setTimeout(function() {
          self.element.contentEditable = "inherit"; // 'false';
        }, 1);
      },
      true
    );

    on(this.element, "paste", function(ev) {
      if (ev.clipboardData) {
        self.send(ev.clipboardData.getData("text/plain"));
      } else if (window.clipboardData) {
        self.send(window.clipboardData.getData("Text"));
      }
      // Not necessary. Do it anyway for good measure.
      self.element.contentEditable = "inherit";
      return cancel(ev);
    });

    this.bindMouse();

    // XXX - hack, move this somewhere else.
    if (Terminal.brokenBold == null) {
      Terminal.brokenBold = isBoldBroken();
    }

    // sync default bg/fg colors
    this.element.style.backgroundColor = this.defaultColors.bg;
    this.element.style.color = this.defaultColors.fg;

    //this.emit('open');
  };

  Terminal.prototype.set_color_scheme = function(color_scheme) {
    const data = Terminal.color_schemes[color_scheme];
    if (data == null) {
      console.warn(`unknown color scheme "${color_scheme}"`);
      return;
    }
    const colors = data.colors;
    this.colors = [];
    for (let i = 0; i < 16; i++) {
      this.colors[i] = colors[i];
    }

    if (colors.length > 16) {
      this.defaultColors = {
        fg: colors[16],
        bg: colors[17]
      };
    } else {
      this.defaultColors = {
        fg: colors[15],
        bg: colors[0]
      };
    }
    this.colors[256] = this.defaultColors.bg;
    this.colors[257] = this.defaultColors.fg;

    if (this.element != null) {
      this.element.style.backgroundColor = this.defaultColors.bg;
      this.element.style.color = this.defaultColors.fg;
    }
  };

  Terminal.prototype.set_font_size = function(size) {
    $(this.element).css("font-size", `${size}px`);
  };

  Terminal.prototype.set_font_family = function(family) {
    $(this.element).css("font-family", `${family}, Monospace`);
  };

  // XTerm mouse events
  // http://invisible-island.net/xterm/ctlseqs/ctlseqs.html#Mouse%20Tracking
  // To better understand these
  // the xterm code is very helpful:
  // Relevant files:
  //   button.c, charproc.c, misc.c
  // Relevant functions in xterm/button.c:
  //   BtnCode, EmitButtonCode, EditorButton, SendMousePosition
  Terminal.prototype.bindMouse = function() {
    var el = this.element,
      self = this,
      pressed = 32;

    var wheelEvent = "onmousewheel" in window ? "mousewheel" : "DOMMouseScroll";

    // mouseup, mousedown, mousewheel
    // left click: ^[[M 3<^[[M#3<
    // mousewheel up: ^[[M`3>
    function sendButton(ev) {
      var button, pos;

      // get the xterm-style button
      button = getButton(ev);

      // get mouse coordinates
      pos = getCoords(ev);
      if (!pos) return;

      sendEvent(button, pos);

      switch (ev.type) {
        case "mousedown":
          pressed = button;
          break;
        case "mouseup":
          // keep it at the left
          // button, just in case.
          pressed = 32;
          break;
        case wheelEvent:
          // nothing. don't
          // interfere with
          // `pressed`.
          break;
      }
    }

    // motion example of a left click:
    // ^[[M 3<^[[M@4<^[[M@5<^[[M@6<^[[M@7<^[[M#7<
    function sendMove(ev) {
      var button = pressed,
        pos;

      pos = getCoords(ev);
      if (!pos) return;

      // buttons marked as motions
      // are incremented by 32
      button += 32;

      sendEvent(button, pos);
    }

    // encode button and
    // position to characters
    function encode(data, ch) {
      if (!self.utfMouse) {
        if (ch === 255) return data.push(0);
        if (ch > 127) ch = 127;
        data.push(ch);
      } else {
        if (ch === 2047) return data.push(0);
        if (ch < 127) {
          data.push(ch);
        } else {
          if (ch > 2047) ch = 2047;
          data.push(0xc0 | (ch >> 6));
          data.push(0x80 | (ch & 0x3f));
        }
      }
    }

    // send a mouse event:
    // regular/utf8: ^[[M Cb Cx Cy
    // urxvt: ^[[ Cb ; Cx ; Cy M
    // sgr: ^[[ Cb ; Cx ; Cy M/m
    // vt300: ^[[ 24(1/3/5)~ [ Cx , Cy ] \r
    // locator: CSI P e ; P b ; P r ; P c ; P p & w
    function sendEvent(button, pos) {
      // self.emit('mouse', {
      //   x: pos.x - 32,
      //   y: pos.x - 32,
      //   button: button
      // });

      if (self.vt300Mouse) {
        // NOTE: Unstable.
        // http://www.vt100.net/docs/vt3xx-gp/chapter15.html
        button &= 3;
        pos.x -= 32;
        pos.y -= 32;
        var data = "\x1b[24";
        if (button === 0) data += "1";
        else if (button === 1) data += "3";
        else if (button === 2) data += "5";
        else if (button === 3) return;
        else data += "0";
        data += "~[" + pos.x + "," + pos.y + "]\r";
        self.send(data);
        return;
      }

      if (self.decLocator) {
        // NOTE: Unstable.
        button &= 3;
        pos.x -= 32;
        pos.y -= 32;
        if (button === 0) button = 2;
        else if (button === 1) button = 4;
        else if (button === 2) button = 6;
        else if (button === 3) button = 3;
        self.send(
          "\x1b[" +
            button +
            ";" +
            (button === 3 ? 4 : 0) +
            ";" +
            pos.y +
            ";" +
            pos.x +
            ";" +
            (pos.page || 0) +
            "&w"
        );
        return;
      }

      if (self.urxvtMouse) {
        pos.x -= 32;
        pos.y -= 32;
        pos.x++;
        pos.y++;
        self.send("\x1b[" + button + ";" + pos.x + ";" + pos.y + "M");
        return;
      }

      if (self.sgrMouse) {
        pos.x -= 32;
        pos.y -= 32;
        self.send(
          "\x1b[<" +
            ((button & 3) === 3 ? button & ~3 : button) +
            ";" +
            pos.x +
            ";" +
            pos.y +
            ((button & 3) === 3 ? "m" : "M")
        );
        return;
      }

      var data = [];

      encode(data, button);
      encode(data, pos.x);
      encode(data, pos.y);

      self.send("\x1b[M" + String.fromCharCode.apply(String, data));
    }

    function getButton(ev) {
      var button, shift, meta, ctrl, mod;

      // two low bits:
      // 0 = left
      // 1 = middle
      // 2 = right
      // 3 = release
      // wheel up/down:
      // 1, and 2 - with 64 added
      switch (ev.type) {
        case "mousedown":
          button =
            ev.button != null
              ? +ev.button
              : ev.which != null
                ? ev.which - 1
                : null;

          if (~navigator.userAgent.indexOf("MSIE")) {
            button = button === 1 ? 0 : button === 4 ? 1 : button;
          }
          break;
        case "mouseup":
          button = 3;
          break;
        case "DOMMouseScroll":
          button = ev.detail < 0 ? 64 : 65;
          break;
        case "mousewheel":
          button = ev.wheelDeltaY > 0 ? 64 : 65;
          break;
      }

      // next three bits are the modifiers:
      // 4 = shift, 8 = meta, 16 = control
      shift = ev.shiftKey ? 4 : 0;
      meta = ev.metaKey ? 8 : 0;
      ctrl = ev.ctrlKey ? 16 : 0;
      mod = shift | meta | ctrl;

      // no mods
      if (self.vt200Mouse) {
        // ctrl only
        mod &= ctrl;
      } else if (!self.normalMouse) {
        mod = 0;
      }

      // increment to SP
      button = 32 + (mod << 2) + button;

      return button;
    }

    // mouse coordinates measured in cols/rows
    function getCoords(ev) {
      var x, y, w, h, el;

      // ignore browsers without pageX for now
      if (ev.pageX == null) return;

      x = ev.pageX;
      y = ev.pageY;
      el = self.element;

      // should probably check offsetParent but this is more portable
      var offset = $(el).offset();
      x -= offset.left;
      y -= offset.top;

      // convert to cols/rows
      w = self.element.clientWidth;
      h = self.element.clientHeight;
      x = (x / w * self.cols) | 0;
      y = (y / h * self.rows) | 0;
      x += 1;
      y += 1;

      // be sure to avoid sending
      // bad positions to the program
      if (x < 0) x = 0;
      if (x > self.cols) x = self.cols;
      if (y < 0) y = 0;
      if (y > self.rows) y = self.rows;

      // xterm sends raw bytes and
      // starts at 32 (SP) for each.
      x += 32;
      y += 32;

      return {
        x: x,
        y: y,
        down: ev.type === "mousedown",
        up: ev.type === "mouseup",
        wheel: ev.type === wheelEvent,
        move: ev.type === "mousemove"
      };
    }

    on(el, "mousedown", function(ev) {
      if (!self.mouseEvents) return;

      // send the button
      sendButton(ev);

      // ensure focus
      self.focus();

      // fix for odd bug
      if (self.vt200Mouse) {
        sendButton(new ev.constructor("mouseup", ev));
        return cancel(ev);
      }

      // bind events
      if (self.normalMouse) on(document, "mousemove", sendMove);

      // x10 compatibility mode can't send button releases
      if (!self.x10Mouse) {
        on(document, "mouseup", function up(ev) {
          sendButton(ev);
          if (self.normalMouse) off(document, "mousemove", sendMove);
          off(document, "mouseup", up);
          return cancel(ev);
        });
      }

      return cancel(ev);
    });

    on(el, wheelEvent, function(ev) {
      if (!self.mouseEvents) return;
      if (self.x10Mouse || self.vt300Mouse || self.decLocator) return;
      sendButton(ev);
      return cancel(ev);
    });

    // allow mousewheel scrolling in
    // the shell for example
    on(el, wheelEvent, function(ev) {
      if (self.mouseEvents) return;
      if (self.applicationKeypad) return;
      if (ev.type === "DOMMouseScroll") {
        self.scrollDisp(ev.detail < 0 ? -5 : 5);
      } else {
        self.scrollDisp(ev.wheelDeltaY > 0 ? -5 : 5);
      }
      return cancel(ev);
    });
  };

  /**
   * Destroy Terminal
   */

  Terminal.prototype.destroy = function() {
    this.readable = false;
    this.writable = false;
    this._events = {};
    this.handler = function() {};
    this.write = function() {};
    //this.emit('close');
    this.removeAllListeners();
  };

  /**
   * Rendering Engine
   */

  // In the screen buffer, each character
  // is stored as an array with a character
  // and a 32-bit integer.
  // First value: a utf-16 character.
  // Second value:
  // Next 9 bits: background color (0-511).
  // Next 9 bits: foreground color (0-511).
  // Next 14 bits: a mask for misc. flags:
  //   1=bold, 2=underline, 4=inverse

  Terminal.prototype.refresh = function(start, end) {
    if (
      typeof this.custom_renderer !== "undefined" &&
      this.custom_renderer !== null
    ) {
      this.custom_renderer(start, end);
      return;
    }

    var x,
      y,
      i,
      line,
      out,
      ch,
      width,
      data,
      attr,
      fgColor,
      bgColor,
      flags,
      row,
      parent;

    if (end - start >= this.rows / 2) {
      parent = this.element.parentNode;
      if (parent) parent.removeChild(this.element);
    }

    width = this.cols;
    y = start;

    for (; y <= end; y++) {
      row = y + this.ydisp;

      if (row >= this.lines.length) break;
      line = this.lines[row];
      out = "";

      if (
        y === this.y &&
        this.cursorState &&
        this.ydisp === this.ybase &&
        !this.cursorHidden
      ) {
        x = this.x;
      } else {
        x = -1;
      }

      attr = this.defAttr;
      i = 0;

      if (typeof line === "undefined" || line === null) {
        /* I added this since sometimes "line.length" below raises an exception crashing everything. */
        continue;
      }
      var w = Math.min(width, line.length);

      /*
    var ln="", j;
    for(j=0;j<w;j++) {
	ln += line[j][1];
    }
    console.log("line=",ln); */

      for (; i < w; i++) {
        if (!(line[i] != null)) {
          continue;
        }
        data = line[i][0];
        ch = line[i][1];

        if (i === x) data = -1;

        if (data !== attr) {
          if (attr !== this.defAttr) {
            out += "</span>";
          }
          if (data !== this.defAttr) {
            if (data === -1) {
              out += '<span class="webapp-console-cursor-focus">';
            } else {
              out += '<span style="';

              bgColor = data & 0x1ff;
              fgColor = (data >> 9) & 0x1ff;
              flags = data >> 18;

              if (flags & 1) {
                if (!Terminal.brokenBold) {
                  out += "font-weight:bold;";
                }
                // see: XTerm*boldColors
                if (fgColor < 8) fgColor += 8;
              }

              if (flags & 2) {
                out += "text-decoration:underline;";
              }

              if (bgColor !== 256) {
                out += "background-color:" + this.colors[bgColor] + ";";
              }

              if (fgColor !== 257) {
                out += "color:" + this.colors[fgColor] + ";";
              }

              out += '">';
            }
          }
        }

        switch (ch) {
          case "&":
            out += "&amp;";
            break;
          case "<":
            out += "&lt;";
            break;
          case ">":
            out += "&gt;";
            break;
          default:
            if (ch <= " ") {
              out += "&nbsp;";
            } else {
              out += ch;
            }
            break;
        }

        attr = data;
      }

      if (attr !== this.defAttr) {
        out += "</span>";
      }

      var a = this.children[y];
      if (a != null) {
        /* Strip trailing &nbsp;'s, which helps massively with copy/paste. */
        /* TODO: should do this with a regexp, but I couldn't easily think of one... */
        i = out.length;
        while (out.slice(i - 6, i) === "&nbsp;") {
          i -= 6;
        }
        out = out.slice(0, i);
        if (out.length === 0) {
          out = "&nbsp;";
        }

        a.innerHTML = out;
      }
    }

    if (parent) parent.appendChild(this.element);
  };

  Terminal.prototype.cursorBlink = function() {
    return; /* we use css for this */
    if (Terminal.focus !== this) return;
    this.cursorState ^= 1;
    this.refresh(this.y, this.y);
  };

  Terminal.prototype.showCursor = function() {
    if (!this.cursorState) {
      this.cursorState = 1;
      this.refresh(this.y, this.y);
    } else {
      // Temporarily disabled:
      // this.refreshBlink();
    }
  };

  Terminal.prototype.startBlink = function() {
    return; /* we use css for this */
    if (!Terminal.cursorBlink) return;
    var self = this;
    this._blinker = function() {
      self.cursorBlink();
    };
    this._blink = setInterval(this._blinker, 500);
  };

  Terminal.prototype.refreshBlink = function() {
    return; /* we use css for this */
    if (!Terminal.cursorBlink) return;
    clearInterval(this._blink);
    this._blink = setInterval(this._blinker, 500);
  };

  Terminal.prototype.scroll = function() {
    var row;

    if (++this.ybase === Terminal.scrollback) {
      this.ybase = (this.ybase / 2) | 0;
      this.lines = this.lines.slice(-(this.ybase + this.rows) + 1);
    }

    this.ydisp = this.ybase;

    // last line
    row = this.ybase + this.rows - 1;

    // subtract the bottom scroll region
    row -= this.rows - 1 - this.scrollBottom;

    if (row === this.lines.length) {
      // potential optimization:
      // pushing is faster than splicing
      // when they amount to the same
      // behavior.
      this.lines.push(this.blankLine());
    } else {
      // add our new line
      this.lines.splice(row, 0, this.blankLine());
    }

    if (this.scrollTop !== 0) {
      if (this.ybase !== 0) {
        this.ybase--;
        this.ydisp = this.ybase;
      }
      this.lines.splice(this.ybase + this.scrollTop, 1);
    }

    // this.maxRange();
    this.updateRange(this.scrollTop);
    this.updateRange(this.scrollBottom);
  };

  Terminal.prototype.scrollDisp = function(disp) {
    this.ydisp += disp;

    if (this.ydisp > this.ybase) {
      this.ydisp = this.ybase;
    } else if (this.ydisp < 0) {
      this.ydisp = 0;
    }

    this.emit("scroll", this.ydisp, this.ybase);

    this.refresh(0, this.rows - 1);
  };

  Terminal.prototype.setchar = function(x, y, attr, ch) {
    var line = this.lines[y];
    if (line != null) {
      line[x] = [attr, ch];
    }
  };

  Terminal.prototype.write = function(data) {
    var l = data.length,
      i = 0,
      cs,
      ch;

    this.refreshStart = this.y;
    this.refreshEnd = this.y;

    if (this.ybase !== this.ydisp) {
      this.ydisp = this.ybase;
      this.maxRange();
    }

    // this.log(JSON.stringify(data.replace(/\x1b/g, '^[')));

    for (; i < l; i++) {
      ch = data[i];
      switch (this.state) {
        case normal:
          switch (ch) {
            // '\0'
            // case '\0':
            //   break;

            // '\a'
            case "\x07":
              this.bell();
              break;

            // '\n', '\v', '\f'
            case "\n":
            case "\x0b":
            case "\x0c":
              if (this.convertEol) {
                this.x = 0;
              }
              this.y++;
              if (this.y > this.scrollBottom) {
                this.y--;
                this.scroll();
              }
              break;

            // '\r'
            case "\r":
              this.x = 0;
              break;

            // '\b'
            case "\x08":
              if (this.x > 0) {
                this.x--;
              }
              break;

            // '\t'
            case "\t":
              this.x = this.nextStop();
              break;

            // shift out
            case "\x0e":
              this.setgLevel(1);
              break;

            // shift in
            case "\x0f":
              this.setgLevel(0);
              break;

            // '\e'
            case "\x1b":
              this.state = escaped;
              break;

            default:
              // ' '
              if (ch >= " ") {
                if (this.charset && this.charset[ch]) {
                  ch = this.charset[ch];
                }
                if (this.x >= this.cols) {
                  this.x = 0;
                  this.y++;
                  if (this.y > this.scrollBottom) {
                    this.y--;
                    this.scroll();
                  }
                }
                /* this.lines[this.y + this.ybase][this.x] = [this.curAttr, ch]; */
                this.setchar(this.x, this.y + this.ybase, this.curAttr, ch);
                this.x++;
                this.updateRange(this.y);
              }
              break;
          }
          break;
        case escaped:
          switch (ch) {
            // ESC [ Control Sequence Introducer ( CSI is 0x9b).
            case "[":
              this.params = [];
              this.currentParam = 0;
              this.state = csi;
              break;

            // ESC ] Operating System Command ( OSC is 0x9d).
            case "]":
              this.params = [];
              this.currentParam = 0;
              this.state = osc;
              break;

            // ESC P Device Control String ( DCS is 0x90).
            case "P":
              this.params = [];
              this.currentParam = 0;
              this.state = dcs;
              break;

            // ESC _ Application Program Command ( APC is 0x9f).
            case "_":
              this.state = ignore;
              break;

            // ESC ^ Privacy Message ( PM is 0x9e).
            case "^":
              this.state = ignore;
              break;

            // ESC c Full Reset (RIS).
            case "c":
              this.reset();
              break;

            // ESC E Next Line ( NEL is 0x85).
            // ESC D Index ( IND is 0x84).
            case "E":
              this.x = 0;
            case "D":
              this.index();
              break;

            // ESC M Reverse Index ( RI is 0x8d).
            case "M":
              this.reverseIndex();
              break;

            // ESC % Select default/utf-8 character set.
            // @ = default, G = utf-8
            case "%":
              //this.charset = null;
              this.setgLevel(0);
              this.setgCharset(0, Terminal.charsets.US);
              this.state = normal;
              i++;
              break;

            // ESC (,),*,+,-,. Designate G0-G2 Character Set.
            case "(": // <-- this seems to get all the attention
            case ")":
            case "*":
            case "+":
            case "-":
            case ".":
              switch (ch) {
                case "(":
                  this.gcharset = 0;
                  break;
                case ")":
                  this.gcharset = 1;
                  break;
                case "*":
                  this.gcharset = 2;
                  break;
                case "+":
                  this.gcharset = 3;
                  break;
                case "-":
                  this.gcharset = 1;
                  break;
                case ".":
                  this.gcharset = 2;
                  break;
              }
              this.state = charset;
              break;

            // Designate G3 Character Set (VT300).
            // A = ISO Latin-1 Supplemental.
            // Not implemented.
            case "/":
              this.gcharset = 3;
              this.state = charset;
              i--;
              break;

            // ESC N
            // Single Shift Select of G2 Character Set
            // ( SS2 is 0x8e). This affects next character only.
            case "N":
              break;
            // ESC O
            // Single Shift Select of G3 Character Set
            // ( SS3 is 0x8f). This affects next character only.
            case "O":
              break;
            // ESC n
            // Invoke the G2 Character Set as GL (LS2).
            case "n":
              this.setgLevel(2);
              break;
            // ESC o
            // Invoke the G3 Character Set as GL (LS3).
            case "o":
              this.setgLevel(3);
              break;
            // ESC |
            // Invoke the G3 Character Set as GR (LS3R).
            case "|":
              this.setgLevel(3);
              break;
            // ESC }
            // Invoke the G2 Character Set as GR (LS2R).
            case "}":
              this.setgLevel(2);
              break;
            // ESC ~
            // Invoke the G1 Character Set as GR (LS1R).
            case "~":
              this.setgLevel(1);
              break;

            // ESC 7 Save Cursor (DECSC).
            case "7":
              this.saveCursor();
              this.state = normal;
              break;

            // ESC 8 Restore Cursor (DECRC).
            case "8":
              this.restoreCursor();
              this.state = normal;
              break;

            // ESC # 3 DEC line height/width
            case "#":
              this.state = normal;
              i++;
              break;

            // ESC H Tab Set (HTS is 0x88).
            case "H":
              this.tabSet();
              break;

            // ESC = Application Keypad (DECPAM).
            case "=":
              this.log("Serial port requested application keypad.");
              this.applicationKeypad = true;
              this.state = normal;
              break;

            // ESC > Normal Keypad (DECPNM).
            case ">":
              this.log("Switching back to normal keypad.");
              this.applicationKeypad = false;
              this.state = normal;
              break;

            default:
              this.state = normal;
              this.error("Unknown ESC control: %s.", ch);
              break;
          }
          break;

        case charset:
          switch (ch) {
            case "0": // DEC Special Character and Line Drawing Set.
              cs = Terminal.charsets.SCLD;
              break;
            case "A": // UK
              cs = Terminal.charsets.UK;
              break;
            case "B": // United States (USASCII).
              cs = Terminal.charsets.US;
              break;
            case "4": // Dutch
              cs = Terminal.charsets.Dutch;
              break;
            case "C": // Finnish
            case "5":
              cs = Terminal.charsets.Finnish;
              break;
            case "R": // French
              cs = Terminal.charsets.French;
              break;
            case "Q": // FrenchCanadian
              cs = Terminal.charsets.FrenchCanadian;
              break;
            case "K": // German
              cs = Terminal.charsets.German;
              break;
            case "Y": // Italian
              cs = Terminal.charsets.Italian;
              break;
            case "E": // NorwegianDanish
            case "6":
              cs = Terminal.charsets.NorwegianDanish;
              break;
            case "Z": // Spanish
              cs = Terminal.charsets.Spanish;
              break;
            case "H": // Swedish
            case "7":
              cs = Terminal.charsets.Swedish;
              break;
            case "=": // Swiss
              cs = Terminal.charsets.Swiss;
              break;
            case "/": // ISOLatin (actually /A)
              cs = Terminal.charsets.ISOLatin;
              i++;
              break;
            default:
              // Default
              cs = Terminal.charsets.US;
              break;
          }
          this.setgCharset(this.gcharset, cs);
          this.gcharset = null;
          this.state = normal;
          break;

        case osc:
          // OSC Ps ; Pt ST
          // OSC Ps ; Pt BEL
          //   Set Text Parameters.
          if (ch === "\x1b" || ch === "\x07") {
            if (ch === "\x1b") i++;

            this.params.push(this.currentParam);

            // console.log("code=", this.params[0]);

            switch (this.params[0]) {
              case 0:
              case 1:
              case 2:
                if (this.params[1]) {
                  this.title = this.params[1];
                  this.handleTitle(this.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 49:
                // I'm just making this up! -- William -- I couldn't find any use of code 49...
                if (this.params[1]) {
                  this.handleMesg(this.params[1]);
                }
                break;
              case 50:
                // dynamic font
                break;
              case 51:
                // emacs shell
                break;
              case 52:
                // manipulate selection data
                break;
              case 105:
              case 110:
              case 111:
              case 112:
              case 113:
              case 114:
              case 115:
              case 116:
              case 117:
              case 118:
                // reset colors
                break;
            }

            this.params = [];
            this.currentParam = 0;
            this.state = normal;
          } else {
            if (!this.params.length) {
              if (ch >= "0" && ch <= "9") {
                this.currentParam =
                  this.currentParam * 10 + ch.charCodeAt(0) - 48;
              } else if (ch === ";") {
                this.params.push(this.currentParam);
                this.currentParam = "";
              }
            } else {
              this.currentParam += ch;
            }
          }
          break;

        case csi:
          // '?', '>', '!'
          if (ch === "?" || ch === ">" || ch === "!") {
            this.prefix = ch;
            break;
          }

          // 0 - 9
          if (ch >= "0" && ch <= "9") {
            this.currentParam = this.currentParam * 10 + ch.charCodeAt(0) - 48;
            break;
          }

          // '$', '"', ' ', '\''
          if (ch === "$" || ch === '"' || ch === " " || ch === "'") {
            this.postfix = ch;
            break;
          }

          this.params.push(this.currentParam);
          this.currentParam = 0;

          // ';'
          if (ch === ";") break;

          this.state = normal;

          // console.log("ch = ", ch);
          switch (ch) {
            // CSI Ps A
            // Cursor Up Ps Times (default = 1) (CUU).
            case "A":
              this.cursorUp(this.params);
              break;

            // CSI Ps B
            // Cursor Down Ps Times (default = 1) (CUD).
            case "B":
              this.cursorDown(this.params);
              break;

            // CSI Ps C
            // Cursor Forward Ps Times (default = 1) (CUF).
            case "C":
              this.cursorForward(this.params);
              break;

            // CSI Ps D
            // Cursor Backward Ps Times (default = 1) (CUB).
            case "D":
              this.cursorBackward(this.params);
              break;

            // CSI Ps ; Ps H
            // Cursor Position [row;column] (default = [1,1]) (CUP).
            case "H":
              this.cursorPos(this.params);
              break;

            // CSI Ps J  Erase in Display (ED).
            case "J":
              this.eraseInDisplay(this.params);
              break;

            // CSI Ps K  Erase in Line (EL).
            case "K":
              this.eraseInLine(this.params);
              break;

            // CSI Pm m  Character Attributes (SGR).
            case "m":
              this.charAttributes(this.params);
              break;

            // CSI Ps n  Device Status Report (DSR).
            case "n":
              this.deviceStatus(this.params);
              break;

            /**
             * Additions
             */

            // CSI Ps @
            // Insert Ps (Blank) Character(s) (default = 1) (ICH).
            case "@":
              this.insertChars(this.params);
              break;

            // CSI Ps E
            // Cursor Next Line Ps Times (default = 1) (CNL).
            case "E":
              this.cursorNextLine(this.params);
              break;

            // CSI Ps F
            // Cursor Preceding Line Ps Times (default = 1) (CNL).
            case "F":
              this.cursorPrecedingLine(this.params);
              break;

            // CSI Ps G
            // Cursor Character Absolute  [column] (default = [row,1]) (CHA).
            case "G":
              this.cursorCharAbsolute(this.params);
              break;

            // CSI Ps L
            // Insert Ps Line(s) (default = 1) (IL).
            case "L":
              this.insertLines(this.params);
              break;

            // CSI Ps M
            // Delete Ps Line(s) (default = 1) (DL).
            case "M":
              this.deleteLines(this.params);
              break;

            // CSI Ps P
            // Delete Ps Character(s) (default = 1) (DCH).
            case "P":
              this.deleteChars(this.params);
              break;

            // CSI Ps X
            // Erase Ps Character(s) (default = 1) (ECH).
            case "X":
              this.eraseChars(this.params);
              break;

            // CSI Pm `  Character Position Absolute
            //   [column] (default = [row,1]) (HPA).
            case "`":
              this.charPosAbsolute(this.params);
              break;

            // 141 61 a * HPR -
            // Horizontal Position Relative
            case "a":
              this.HPositionRelative(this.params);
              break;

            // CSI P s c
            // Send Device Attributes (Primary DA).
            // CSI > P s c
            // Send Device Attributes (Secondary DA)
            case "c":
              this.sendDeviceAttributes(this.params);
              break;

            // CSI Pm d
            // Line Position Absolute  [row] (default = [1,column]) (VPA).
            case "d":
              this.linePosAbsolute(this.params);
              break;

            // 145 65 e * VPR - Vertical Position Relative
            case "e":
              this.VPositionRelative(this.params);
              break;

            // CSI Ps ; Ps f
            //   Horizontal and Vertical Position [row;column] (default =
            //   [1,1]) (HVP).
            case "f":
              this.HVPosition(this.params);
              break;

            // CSI Pm h  Set Mode (SM).
            // CSI ? Pm h - mouse escape codes, cursor escape codes
            case "h":
              this.setMode(this.params);
              break;

            // CSI Pm l  Reset Mode (RM).
            // CSI ? Pm l
            case "l":
              this.resetMode(this.params);
              break;

            // CSI Ps ; Ps r
            //   Set Scrolling Region [top;bottom] (default = full size of win-
            //   dow) (DECSTBM).
            // CSI ? Pm r
            case "r":
              this.setScrollRegion(this.params);
              break;

            // CSI s
            //   Save cursor (ANSI.SYS).
            case "s":
              this.saveCursor(this.params);
              break;

            // CSI u
            //   Restore cursor (ANSI.SYS).
            case "u":
              this.restoreCursor(this.params);
              break;

            /**
             * Lesser Used
             */

            // CSI Ps I
            // Cursor Forward Tabulation Ps tab stops (default = 1) (CHT).
            case "I":
              this.cursorForwardTab(this.params);
              break;

            // CSI Ps S  Scroll up Ps lines (default = 1) (SU).
            case "S":
              this.scrollUp(this.params);
              break;

            // CSI Ps T  Scroll down Ps lines (default = 1) (SD).
            // CSI Ps ; Ps ; Ps ; Ps ; Ps T
            // CSI > Ps; Ps T
            case "T":
              // if (this.prefix === '>') {
              //   this.resetTitleModes(this.params);
              //   break;
              // }
              // if (this.params.length > 2) {
              //   this.initMouseTracking(this.params);
              //   break;
              // }
              if (this.params.length < 2 && !this.prefix) {
                this.scrollDown(this.params);
              }
              break;

            // CSI Ps Z
            // Cursor Backward Tabulation Ps tab stops (default = 1) (CBT).
            case "Z":
              this.cursorBackwardTab(this.params);
              break;

            // CSI Ps b  Repeat the preceding graphic character Ps times (REP).
            case "b":
              this.repeatPrecedingCharacter(this.params);
              break;

            // CSI Ps g  Tab Clear (TBC).
            case "g":
              this.tabClear(this.params);
              break;

            // CSI Pm i  Media Copy (MC).
            // CSI ? Pm i
            // case 'i':
            //   this.mediaCopy(this.params);
            //   break;

            // CSI Pm m  Character Attributes (SGR).
            // CSI > Ps; Ps m
            // case 'm': // duplicate
            //   if (this.prefix === '>') {
            //     this.setResources(this.params);
            //   } else {
            //     this.charAttributes(this.params);
            //   }
            //   break;

            // CSI Ps n  Device Status Report (DSR).
            // CSI > Ps n
            // case 'n': // duplicate
            //   if (this.prefix === '>') {
            //     this.disableModifiers(this.params);
            //   } else {
            //     this.deviceStatus(this.params);
            //   }
            //   break;

            // CSI > Ps p  Set pointer mode.
            // CSI ! p   Soft terminal reset (DECSTR).
            // CSI Ps$ p
            //   Request ANSI mode (DECRQM).
            // CSI ? Ps$ p
            //   Request DEC private mode (DECRQM).
            // CSI Ps ; Ps " p
            case "p":
              switch (this.prefix) {
                // case '>':
                //   this.setPointerMode(this.params);
                //   break;
                case "!":
                  this.softReset(this.params);
                  break;
                // case '?':
                //   if (this.postfix === '$') {
                //     this.requestPrivateMode(this.params);
                //   }
                //   break;
                // default:
                //   if (this.postfix === '"') {
                //     this.setConformanceLevel(this.params);
                //   } else if (this.postfix === '$') {
                //     this.requestAnsiMode(this.params);
                //   }
                //   break;
              }
              break;

            // CSI Ps q  Load LEDs (DECLL).
            // CSI Ps SP q
            // CSI Ps " q
            // case 'q':
            //   if (this.postfix === ' ') {
            //     this.setCursorStyle(this.params);
            //     break;
            //   }
            //   if (this.postfix === '"') {
            //     this.setCharProtectionAttr(this.params);
            //     break;
            //   }
            //   this.loadLEDs(this.params);
            //   break;

            // CSI Ps ; Ps r
            //   Set Scrolling Region [top;bottom] (default = full size of win-
            //   dow) (DECSTBM).
            // CSI ? Pm r
            // CSI Pt; Pl; Pb; Pr; Ps$ r
            // case 'r': // duplicate
            //   if (this.prefix === '?') {
            //     this.restorePrivateValues(this.params);
            //   } else if (this.postfix === '$') {
            //     this.setAttrInRectangle(this.params);
            //   } else {
            //     this.setScrollRegion(this.params);
            //   }
            //   break;

            // CSI s     Save cursor (ANSI.SYS).
            // CSI ? Pm s
            // case 's': // duplicate
            //   if (this.prefix === '?') {
            //     this.savePrivateValues(this.params);
            //   } else {
            //     this.saveCursor(this.params);
            //   }
            //   break;

            // CSI Ps ; Ps ; Ps t
            // CSI Pt; Pl; Pb; Pr; Ps$ t
            // CSI > Ps; Ps t
            // CSI Ps SP t
            // case 't':
            //   if (this.postfix === '$') {
            //     this.reverseAttrInRectangle(this.params);
            //   } else if (this.postfix === ' ') {
            //     this.setWarningBellVolume(this.params);
            //   } else {
            //     if (this.prefix === '>') {
            //       this.setTitleModeFeature(this.params);
            //     } else {
            //       this.manipulateWindow(this.params);
            //     }
            //   }
            //   break;

            // CSI u     Restore cursor (ANSI.SYS).
            // CSI Ps SP u
            // case 'u': // duplicate
            //   if (this.postfix === ' ') {
            //     this.setMarginBellVolume(this.params);
            //   } else {
            //     this.restoreCursor(this.params);
            //   }
            //   break;

            // CSI Pt; Pl; Pb; Pr; Pp; Pt; Pl; Pp$ v
            // case 'v':
            //   if (this.postfix === '$') {
            //     this.copyRectagle(this.params);
            //   }
            //   break;

            // CSI Pt ; Pl ; Pb ; Pr ' w
            // case 'w':
            //   if (this.postfix === '\'') {
            //     this.enableFilterRectangle(this.params);
            //   }
            //   break;

            // CSI Ps x  Request Terminal Parameters (DECREQTPARM).
            // CSI Ps x  Select Attribute Change Extent (DECSACE).
            // CSI Pc; Pt; Pl; Pb; Pr$ x
            // case 'x':
            //   if (this.postfix === '$') {
            //     this.fillRectangle(this.params);
            //   } else {
            //     this.requestParameters(this.params);
            //     //this.__(this.params);
            //   }
            //   break;

            // CSI Ps ; Pu ' z
            // CSI Pt; Pl; Pb; Pr$ z
            // case 'z':
            //   if (this.postfix === '\'') {
            //     this.enableLocatorReporting(this.params);
            //   } else if (this.postfix === '$') {
            //     this.eraseRectangle(this.params);
            //   }
            //   break;

            // CSI Pm ' {
            // CSI Pt; Pl; Pb; Pr$ {
            // case '{':
            //   if (this.postfix === '\'') {
            //     this.setLocatorEvents(this.params);
            //   } else if (this.postfix === '$') {
            //     this.selectiveEraseRectangle(this.params);
            //   }
            //   break;

            // CSI Ps ' |
            // case '|':
            //   if (this.postfix === '\'') {
            //     this.requestLocatorPosition(this.params);
            //   }
            //   break;

            // CSI P m SP }
            // Insert P s Column(s) (default = 1) (DECIC), VT420 and up.
            // case '}':
            //   if (this.postfix === ' ') {
            //     this.insertColumns(this.params);
            //   }
            //   break;

            // CSI P m SP ~
            // Delete P s Column(s) (default = 1) (DECDC), VT420 and up
            // case '~':
            //   if (this.postfix === ' ') {
            //     this.deleteColumns(this.params);
            //   }
            //   break;

            default:
              this.error("Unknown CSI code: %s.", ch);
              break;
          }

          this.prefix = "";
          this.postfix = "";
          break;

        case dcs:
          if (ch === "\x1b" || ch === "\x07") {
            if (ch === "\x1b") i++;

            switch (this.prefix) {
              // User-Defined Keys (DECUDK).
              case "":
                break;

              // Request Status String (DECRQSS).
              // test: echo -e '\eP$q"p\e\\'
              case "$q":
                var pt = this.currentParam,
                  valid = false;

                switch (pt) {
                  // DECSCA
                  case '"q':
                    pt = '0"q';
                    break;

                  // DECSCL
                  case '"p':
                    pt = '61"p';
                    break;

                  // DECSTBM
                  case "r":
                    pt =
                      "" +
                      (this.scrollTop + 1) +
                      ";" +
                      (this.scrollBottom + 1) +
                      "r";
                    break;

                  // SGR
                  case "m":
                    pt = "0m";
                    break;

                  default:
                    this.error("Unknown DCS Pt: %s.", pt);
                    pt = "";
                    break;
                }

                this.send("\x1bP" + +valid + "$r" + pt + "\x1b\\");
                break;

              // Set Termcap/Terminfo Data (xterm, experimental).
              case "+p":
                break;

              // Request Termcap/Terminfo String (xterm, experimental)
              // Regular xterm does not even respond to this sequence.
              // This can cause a small glitch in vim.
              // test: echo -ne '\eP+q6b64\e\\'
              case "+q":
                var pt = this.currentParam,
                  valid = false;

                this.send("\x1bP" + +valid + "+r" + pt + "\x1b\\");
                break;

              default:
                this.error("Unknown DCS prefix: %s.", this.prefix);
                break;
            }

            this.currentParam = 0;
            this.prefix = "";
            this.state = normal;
          } else if (!this.currentParam) {
            if (!this.prefix && ch !== "$" && ch !== "+") {
              this.currentParam = ch;
            } else if (this.prefix.length === 2) {
              this.currentParam = ch;
            } else {
              this.prefix += ch;
            }
          } else {
            this.currentParam += ch;
          }
          break;

        case ignore:
          // For PM and APC.
          if (ch === "\x1b" || ch === "\x07") {
            if (ch === "\x1b") i++;
            this.state = normal;
          }
          break;
      }
    }

    this.updateRange(this.y);
    this.refresh(this.refreshStart, this.refreshEnd);
  };

  Terminal.prototype.writeln = function(data) {
    this.write(data + "\r\n");
  };

  Terminal.prototype.keyDown = function(ev) {
    var key;
    // console.log("term.js.keyDown: ", ev);
    switch (ev.keyCode) {
      // backspace
      case 8:
        if (ev.shiftKey) {
          key = "\x08"; // ^H
          break;
        }
        key = "\x7f"; // ^?
        break;
      // tab
      case 9:
        if (ev.shiftKey) {
          key = "\x1b[Z";
          break;
        }
        key = "\t";
        break;
      // return/enter
      case 13:
        key = "\r";
        break;
      // escape
      case 27:
        key = "\x1b";
        break;
      // left-arrow
      case 37:
        if (this.applicationKeypad) {
          key = "\x1bOD"; // SS3 as ^[O for 7-bit
          //key = '\x8fD'; // SS3 as 0x8f for 8-bit
          break;
        }
        key = "\x1b[D";
        break;
      // right-arrow
      case 39:
        if (this.applicationKeypad) {
          key = "\x1bOC";
          break;
        }
        key = "\x1b[C";
        break;
      // up-arrow
      case 38:
        if (this.applicationKeypad) {
          key = "\x1bOA";
          break;
        }
        if (ev.ctrlKey) {
          this.scrollDisp(-1);
          return cancel(ev);
        } else {
          key = "\x1b[A";
        }
        break;
      // down-arrow
      case 40:
        if (this.applicationKeypad) {
          key = "\x1bOB";
          break;
        }
        if (ev.ctrlKey) {
          this.scrollDisp(1);
          return cancel(ev);
        } else {
          key = "\x1b[B";
        }
        break;
      // delete
      case 46:
        key = "\x1b[3~";
        break;
      // insert
      case 45:
        key = "\x1b[2~";
        break;
      // home
      case 36:
        if (this.applicationKeypad) {
          key = "\x1bOH";
          break;
        }
        key = "\x1bOH";
        break;
      // end
      case 35:
        if (this.applicationKeypad) {
          key = "\x1bOF";
          break;
        }
        key = "\x1bOF";
        break;
      // page up
      case 33:
        if (ev.shiftKey) {
          this.scrollDisp(-(this.rows - 1));
          return cancel(ev);
        } else {
          key = "\x1b[5~";
        }
        break;
      // page down
      case 34:
        if (ev.shiftKey) {
          this.scrollDisp(this.rows - 1);
          return cancel(ev);
        } else {
          key = "\x1b[6~";
        }
        break;
      // F1
      case 112:
        key = "\x1bOP";
        break;
      // F2
      case 113:
        key = "\x1bOQ";
        break;
      // F3
      case 114:
        key = "\x1bOR";
        break;
      // F4
      case 115:
        key = "\x1bOS";
        break;
      // F5
      case 116:
        key = "\x1b[15~";
        break;
      // F6
      case 117:
        key = "\x1b[17~";
        break;
      // F7
      case 118:
        key = "\x1b[18~";
        break;
      // F8
      case 119:
        key = "\x1b[19~";
        break;
      // F9
      case 120:
        key = "\x1b[20~";
        break;
      // F10
      case 121:
        key = "\x1b[21~";
        break;
      // F11
      case 122:
        key = "\x1b[23~";
        break;
      // F12
      case 123:
        key = "\x1b[24~";
        break;
      default:
        // a-z and space
        if (ev.ctrlKey) {
          if (ev.keyCode >= 65 && ev.keyCode <= 90) {
            key = String.fromCharCode(ev.keyCode - 64);
          } else if (ev.keyCode === 32) {
            // NUL
            key = String.fromCharCode(0);
          } else if (ev.keyCode >= 51 && ev.keyCode <= 55) {
            // escape, file sep, group sep, record sep, unit sep
            key = String.fromCharCode(ev.keyCode - 51 + 27);
          } else if (ev.keyCode === 56) {
            // delete
            key = String.fromCharCode(127);
          } else if (ev.keyCode === 219) {
            // ^[ - escape
            key = String.fromCharCode(27);
          } else if (ev.keyCode === 221) {
            // ^] - group sep
            key = String.fromCharCode(29);
          }
        } else if ((!isMac && ev.altKey) || (isMac && ev.metaKey)) {
          if (ev.keyCode >= 65 && ev.keyCode <= 90) {
            key = "\x1b" + String.fromCharCode(ev.keyCode + 32);
          } else if (ev.keyCode === 192) {
            key = "\x1b`";
          } else if (ev.keyCode >= 48 && ev.keyCode <= 57) {
            key = "\x1b" + (ev.keyCode - 48);
          }
        }
        break;
    }

    if (!key) {
      /* some devices, e.g., the iPad Pro with SmartKeyboard, have keys that do not have
         a keyCode, but do corresponding to something above. */
      switch (ev.key) {
        // left-arrow
        case "UIKeyInputLeftArrow":
          if (this.applicationKeypad) {
            key = "\x1bOD"; // SS3 as ^[O for 7-bit
            //key = '\x8fD'; // SS3 as 0x8f for 8-bit
            break;
          }
          key = "\x1b[D";
          break;
        // right-arrow
        case "UIKeyInputRightArrow":
          if (this.applicationKeypad) {
            key = "\x1bOC";
            break;
          }
          key = "\x1b[C";
          break;
        // up-arrow
        case "UIKeyInputUpArrow":
          if (this.applicationKeypad) {
            key = "\x1bOA";
            break;
          }
          if (ev.ctrlKey) {
            this.scrollDisp(-1);
            return cancel(ev);
          } else {
            key = "\x1b[A";
          }
          break;
        // down-arrow
        case "UIKeyInputDownArrow":
          if (this.applicationKeypad) {
            key = "\x1bOB";
            break;
          }
          if (ev.ctrlKey) {
            this.scrollDisp(1);
            return cancel(ev);
          } else {
            key = "\x1b[B";
          }
          break;
      }
    }

    //console.log("term.js.keyDown: after switch, key=", key);

    this.emit("keydown", ev);

    if (key) {
      this.emit("key", key, ev);

      this.showCursor();
      this.handler(key);

      return cancel(ev);
    } else {
      if (this.IS_TOUCH && ev.keyCode == 32) {
        /* On iPad with external Keyboard,
         the spacebar keyPress fires but with charCode, etc., set to 0.  Ugh.
         We thus simulate the proper code. */
        this.keyPress({ charCode: 32 });
        /* We then cancel the space event, since otherwise the browser
         will scroll the page down.  Also, this will prevent seeing two
         spaces in case this bug is fixed or not present on some touch devices! */
        return cancel(ev);
      }
    }

    return true;
  };

  Terminal.prototype.setgLevel = function(g) {
    this.glevel = g;
    this.charset = this.charsets[g];
  };

  Terminal.prototype.setgCharset = function(g, charset) {
    this.charsets[g] = charset;
    if (this.glevel === g) {
      this.charset = charset;
    }
  };

  Terminal.prototype.keyPress = function(ev) {
    var key;

    /* Doing cancel here seems to server no purpose, *and* completely breaks
     using Ctrl-c to copy on firefox. */
    /* cancel(ev);*/
    //console.log("term.js.keyPress: ", ev);

    if (ev.charCode) {
      key = ev.charCode;
    } else if (ev.which == null) {
      key = ev.keyCode;
    } else if (ev.which !== 0 && ev.charCode !== 0) {
      key = ev.which;
    } else {
      return false;
    }

    //console.log("term.js.keyPress: got key=", key);

    if (!key || ev.ctrlKey || ev.altKey || ev.metaKey) return false;

    key = String.fromCharCode(key);
    //console.log("term.js.keyPress: got string=", key);

    this.emit("keypress", key, ev);
    this.emit("key", key, ev);

    this.showCursor();
    this.handler(key);

    return false;
  };

  Terminal.prototype.send = function(data) {
    var self = this;

    if (!this.queue) {
      setTimeout(function() {
        self.handler(self.queue);
        self.queue = "";
      }, 50); /* this was 1 but it causes trouble in some cases. */
    }

    this.queue += data;
  };

  Terminal.prototype.bell = function() {
    if (!Terminal.visualBell) return;
    var self = this;
    this.element.style.borderColor = "white";
    setTimeout(function() {
      self.element.style.borderColor = "";
    }, 10);
    if (Terminal.popOnBell) this.focus();
  };

  Terminal.prototype.log = function() {
    if (!Terminal.debug) return;
    if (!window.console || !window.console.log) return;
    var args = Array.prototype.slice.call(arguments);
    window.console.log.apply(window.console, args);
  };

  Terminal.prototype.error = function() {
    if (!Terminal.debug) return;
    if (!window.console || !window.console.error) return;
    var args = Array.prototype.slice.call(arguments);
    window.console.error.apply(window.console, args);
  };

  Terminal.prototype.resize = function(x, y) {
    var line, el, i, j, ch;

    if (x < 1) x = 1;
    if (y < 1) y = 1;

    // resize cols
    j = this.cols;
    if (j < x) {
      ch = [this.defAttr, " "];
      i = this.lines.length;
      while (i--) {
        while (this.lines[i].length < x) {
          this.lines[i].push(ch);
        }
      }
    } else if (j > x) {
      i = this.lines.length;
      while (i--) {
        while (this.lines[i].length > x) {
          this.lines[i].pop();
        }
      }
    }
    this.setupStops(j);
    this.cols = x;

    // resize rows
    j = this.rows;
    if (j < y) {
      el = this.element;
      while (j++ < y) {
        if (this.lines.length < y + this.ybase) {
          this.lines.push(this.blankLine());
        }
        if (this.children.length < y) {
          line = document.createElement("div");
          el.appendChild(line);
          this.children.push(line);
        }
      }
    } else if (j > y) {
      while (j-- > y) {
        if (this.lines.length > y + this.ybase) {
          this.lines.pop();
        }
        if (this.children.length > y) {
          el = this.children.pop();
          if (!el) continue;
          el.parentNode.removeChild(el);
        }
      }
    }
    this.rows = y;

    // make sure the cursor stays on screen
    if (this.y >= y) this.y = y - 1;
    if (this.x >= x) this.x = x - 1;

    this.scrollTop = 0;
    this.scrollBottom = y - 1;

    this.refresh(0, this.rows - 1);

    // it's a real nightmare trying
    // to resize the original
    // screen buffer. just set it
    // to null for now.
    this.normal = null;
  };

  Terminal.prototype.updateRange = function(y) {
    if (y < this.refreshStart) this.refreshStart = y;
    if (y > this.refreshEnd) this.refreshEnd = y;
  };

  Terminal.prototype.maxRange = function() {
    this.refreshStart = 0;
    this.refreshEnd = this.rows - 1;
  };

  Terminal.prototype.setupStops = function(i) {
    if (i != null) {
      if (!this.tabs[i]) {
        i = this.prevStop(i);
      }
    } else {
      this.tabs = {};
      i = 0;
    }

    for (; i < this.cols; i += 8) {
      this.tabs[i] = true;
    }
  };

  Terminal.prototype.prevStop = function(x) {
    if (x == null) x = this.x;
    while (!this.tabs[--x] && x > 0);
    return x >= this.cols ? this.cols - 1 : x < 0 ? 0 : x;
  };

  Terminal.prototype.nextStop = function(x) {
    if (x == null) x = this.x;
    while (!this.tabs[++x] && x < this.cols);
    return x >= this.cols ? this.cols - 1 : x < 0 ? 0 : x;
  };

  Terminal.prototype.eraseRight = function(x, y) {
    if (this.ybase + y >= this.lines.length) return;

    var line = this.lines[this.ybase + y],
      ch = [this.curAttr, " "]; // xterm

    if (!(typeof line !== "undefined" && line !== null)) {
      return;
    }

    for (; x < this.cols; x++) {
      line[x] = ch;
    }

    this.updateRange(y);
  };

  Terminal.prototype.eraseLeft = function(x, y) {
    if (this.ybase + y >= this.lines.length) return;

    var line = this.lines[this.ybase + y],
      ch = [this.curAttr, " "]; // xterm

    x++;
    while (x--) line[x] = ch;

    this.updateRange(y);
  };

  Terminal.prototype.eraseLine = function(y) {
    this.eraseRight(0, y);
  };

  Terminal.prototype.blankLine = function(cur) {
    var attr = cur ? this.curAttr : this.defAttr;

    var ch = [attr, " "],
      line = [],
      i = 0;

    for (; i < this.cols; i++) {
      line[i] = ch;
    }

    return line;
  };

  Terminal.prototype.ch = function(cur) {
    return cur ? [this.curAttr, " "] : [this.defAttr, " "];
  };

  Terminal.prototype.is = function(term) {
    var name = this.termName || Terminal.termName;
    return (name + "").indexOf(term) === 0;
  };

  Terminal.prototype.handler = function(data) {
    this.emit("data", data);
  };

  Terminal.prototype.handleTitle = function(title) {
    this.emit("title", title);
  };

  /* Message as (nearly) arbitrary string.  Client sends a message by printing this:

    \x1b]49;any string you want goes here\x07

*/
  Terminal.prototype.handleMesg = function(mesg) {
    this.emit("mesg", mesg);
  };

  /**
   * ESC
   */

  // ESC D Index (IND is 0x84).
  Terminal.prototype.index = function() {
    this.y++;
    if (this.y > this.scrollBottom) {
      this.y--;
      this.scroll();
    }
    this.state = normal;
  };

  // ESC M Reverse Index (RI is 0x8d).
  Terminal.prototype.reverseIndex = function() {
    var j;
    this.y--;
    if (this.y < this.scrollTop) {
      this.y++;
      // possibly move the code below to term.reverseScroll();
      // test: echo -ne '\e[1;1H\e[44m\eM\e[0m'
      // blankLine(true) is xterm/linux behavior
      this.lines.splice(this.y + this.ybase, 0, this.blankLine(true));
      j = this.rows - 1 - this.scrollBottom;
      this.lines.splice(this.rows - 1 + this.ybase - j + 1, 1);
      // this.maxRange();
      this.updateRange(this.scrollTop);
      this.updateRange(this.scrollBottom);
    }
    this.state = normal;
  };

  // ESC c Full Reset (RIS).
  Terminal.prototype.reset = function() {
    Terminal.call(this, this.cols, this.rows);
    this.refresh(0, this.rows - 1);
  };

  // ESC H Tab Set (HTS is 0x88).
  Terminal.prototype.tabSet = function() {
    this.tabs[this.x] = true;
    this.state = normal;
  };

  /**
   * CSI
   */

  // CSI Ps A
  // Cursor Up Ps Times (default = 1) (CUU).
  Terminal.prototype.cursorUp = function(params) {
    var param = params[0];
    if (param < 1) param = 1;
    this.y -= param;
    if (this.y < 0) this.y = 0;
  };

  // CSI Ps B
  // Cursor Down Ps Times (default = 1) (CUD).
  Terminal.prototype.cursorDown = function(params) {
    var param = params[0];
    if (param < 1) param = 1;
    this.y += param;
    if (this.y >= this.rows) {
      this.y = this.rows - 1;
    }
  };

  // CSI Ps C
  // Cursor Forward Ps Times (default = 1) (CUF).
  Terminal.prototype.cursorForward = function(params) {
    var param = params[0];
    if (param < 1) param = 1;
    this.x += param;
    if (this.x >= this.cols) {
      this.x = this.cols - 1;
    }
  };

  // CSI Ps D
  // Cursor Backward Ps Times (default = 1) (CUB).
  Terminal.prototype.cursorBackward = function(params) {
    var param = params[0];
    if (param < 1) param = 1;
    this.x -= param;
    if (this.x < 0) this.x = 0;
  };

  // CSI Ps ; Ps H
  // Cursor Position [row;column] (default = [1,1]) (CUP).
  Terminal.prototype.cursorPos = function(params) {
    var row, col;

    row = params[0] - 1;

    if (params.length >= 2) {
      col = params[1] - 1;
    } else {
      col = 0;
    }

    if (row < 0) {
      row = 0;
    } else if (row >= this.rows) {
      row = this.rows - 1;
    }

    if (col < 0) {
      col = 0;
    } else if (col >= this.cols) {
      col = this.cols - 1;
    }

    this.x = col;
    this.y = row;
  };

  // CSI Ps J  Erase in Display (ED).
  //     Ps = 0  -> Erase Below (default).
  //     Ps = 1  -> Erase Above.
  //     Ps = 2  -> Erase All.
  //     Ps = 3  -> Erase Saved Lines (xterm).
  // CSI ? Ps J
  //   Erase in Display (DECSED).
  //     Ps = 0  -> Selective Erase Below (default).
  //     Ps = 1  -> Selective Erase Above.
  //     Ps = 2  -> Selective Erase All.
  Terminal.prototype.eraseInDisplay = function(params) {
    var j;
    switch (params[0]) {
      case 0:
        this.eraseRight(this.x, this.y);
        j = this.y + 1;
        for (; j < this.rows; j++) {
          this.eraseLine(j);
        }
        break;
      case 1:
        this.eraseLeft(this.x, this.y);
        j = this.y;
        while (j--) {
          this.eraseLine(j);
        }
        break;
      case 2:
        j = this.rows;
        while (j--) this.eraseLine(j);
        break;
      case 3: // no saved lines
        break;
    }
  };

  // CSI Ps K  Erase in Line (EL).
  //     Ps = 0  -> Erase to Right (default).
  //     Ps = 1  -> Erase to Left.
  //     Ps = 2  -> Erase All.
  // CSI ? Ps K
  //   Erase in Line (DECSEL).
  //     Ps = 0  -> Selective Erase to Right (default).
  //     Ps = 1  -> Selective Erase to Left.
  //     Ps = 2  -> Selective Erase All.
  Terminal.prototype.eraseInLine = function(params) {
    switch (params[0]) {
      case 0:
        this.eraseRight(this.x, this.y);
        break;
      case 1:
        this.eraseLeft(this.x, this.y);
        break;
      case 2:
        this.eraseLine(this.y);
        break;
    }
  };

  // CSI Pm m  Character Attributes (SGR).
  //     Ps = 0  -> Normal (default).
  //     Ps = 1  -> Bold.
  //     Ps = 4  -> Underlined.
  //     Ps = 5  -> Blink (appears as Bold).
  //     Ps = 7  -> Inverse.
  //     Ps = 8  -> Invisible, i.e., hidden (VT300).
  //     Ps = 2 2  -> Normal (neither bold nor faint).
  //     Ps = 2 4  -> Not underlined.
  //     Ps = 2 5  -> Steady (not blinking).
  //     Ps = 2 7  -> Positive (not inverse).
  //     Ps = 2 8  -> Visible, i.e., not hidden (VT300).
  //     Ps = 3 0  -> Set foreground color to Black.
  //     Ps = 3 1  -> Set foreground color to Red.
  //     Ps = 3 2  -> Set foreground color to Green.
  //     Ps = 3 3  -> Set foreground color to Yellow.
  //     Ps = 3 4  -> Set foreground color to Blue.
  //     Ps = 3 5  -> Set foreground color to Magenta.
  //     Ps = 3 6  -> Set foreground color to Cyan.
  //     Ps = 3 7  -> Set foreground color to White.
  //     Ps = 3 9  -> Set foreground color to default (original).
  //     Ps = 4 0  -> Set background color to Black.
  //     Ps = 4 1  -> Set background color to Red.
  //     Ps = 4 2  -> Set background color to Green.
  //     Ps = 4 3  -> Set background color to Yellow.
  //     Ps = 4 4  -> Set background color to Blue.
  //     Ps = 4 5  -> Set background color to Magenta.
  //     Ps = 4 6  -> Set background color to Cyan.
  //     Ps = 4 7  -> Set background color to White.
  //     Ps = 4 9  -> Set background color to default (original).

  //   If 16-color support is compiled, the following apply.  Assume
  //   that xterm's resources are set so that the ISO color codes are
  //   the first 8 of a set of 16.  Then the aixterm colors are the
  //   bright versions of the ISO colors:
  //     Ps = 9 0  -> Set foreground color to Black.
  //     Ps = 9 1  -> Set foreground color to Red.
  //     Ps = 9 2  -> Set foreground color to Green.
  //     Ps = 9 3  -> Set foreground color to Yellow.
  //     Ps = 9 4  -> Set foreground color to Blue.
  //     Ps = 9 5  -> Set foreground color to Magenta.
  //     Ps = 9 6  -> Set foreground color to Cyan.
  //     Ps = 9 7  -> Set foreground color to White.
  //     Ps = 1 0 0  -> Set background color to Black.
  //     Ps = 1 0 1  -> Set background color to Red.
  //     Ps = 1 0 2  -> Set background color to Green.
  //     Ps = 1 0 3  -> Set background color to Yellow.
  //     Ps = 1 0 4  -> Set background color to Blue.
  //     Ps = 1 0 5  -> Set background color to Magenta.
  //     Ps = 1 0 6  -> Set background color to Cyan.
  //     Ps = 1 0 7  -> Set background color to White.

  //   If xterm is compiled with the 16-color support disabled, it
  //   supports the following, from rxvt:
  //     Ps = 1 0 0  -> Set foreground and background color to
  //     default.

  //   If 88- or 256-color support is compiled, the following apply.
  //     Ps = 3 8  ; 5  ; Ps -> Set foreground color to the second
  //     Ps.
  //     Ps = 4 8  ; 5  ; Ps -> Set background color to the second
  //     Ps.
  Terminal.prototype.charAttributes = function(params) {
    var l = params.length,
      i = 0,
      bg,
      fg,
      p;

    for (; i < l; i++) {
      p = params[i];
      if (p >= 30 && p <= 37) {
        // fg color 8
        this.curAttr = (this.curAttr & ~(0x1ff << 9)) | ((p - 30) << 9);
      } else if (p >= 40 && p <= 47) {
        // bg color 8
        this.curAttr = (this.curAttr & ~0x1ff) | (p - 40);
      } else if (p >= 90 && p <= 97) {
        // fg color 16
        p += 8;
        this.curAttr = (this.curAttr & ~(0x1ff << 9)) | ((p - 90) << 9);
      } else if (p >= 100 && p <= 107) {
        // bg color 16
        p += 8;
        this.curAttr = (this.curAttr & ~0x1ff) | (p - 100);
      } else if (p === 0) {
        // default
        this.curAttr = this.defAttr;
      } else if (p === 1) {
        // bold text
        this.curAttr = this.curAttr | (1 << 18);
      } else if (p === 4) {
        // underlined text
        if (this.prefix === ">") {
          // > is a mode reset, according to the docs, and this gets triggered on exit from emacs.
          //
          //CSI > Ps; Ps T
          //          Reset one or more features of the title modes to the default
          //          value.  Normally, "reset" disables the feature.
        } else {
          this.curAttr = this.curAttr | (2 << 18);
        }
      } else if (p === 7 || p === 27) {
        // inverse and positive
        // test with: echo -e '\e[31m\e[42mhello\e[7mworld\e[27mhi\e[m'
        if (p === 7) {
          if ((this.curAttr >> 18) & 4) continue;
          this.curAttr = this.curAttr | (4 << 18);
        } else if (p === 27) {
          if (~(this.curAttr >> 18) & 4) continue;
          this.curAttr = this.curAttr & ~(4 << 18);
        }

        bg = this.curAttr & 0x1ff;
        fg = (this.curAttr >> 9) & 0x1ff;

        this.curAttr = (this.curAttr & ~0x3ffff) | ((bg << 9) | fg);
      } else if (p === 22) {
        // not bold
        this.curAttr = this.curAttr & ~(1 << 18);
      } else if (p === 24) {
        // not underlined
        this.curAttr = this.curAttr & ~(2 << 18);
      } else if (p === 39) {
        // reset fg
        this.curAttr = this.curAttr & ~(0x1ff << 9);
        this.curAttr = this.curAttr | (((this.defAttr >> 9) & 0x1ff) << 9);
      } else if (p === 49) {
        // reset bg
        this.curAttr = this.curAttr & ~0x1ff;
        this.curAttr = this.curAttr | (this.defAttr & 0x1ff);
      } else if (p === 38) {
        // fg color 256
        if (params[i + 1] !== 5) continue;
        i += 2;
        p = params[i] & 0xff;
        // convert 88 colors to 256
        // if (this.is('rxvt-unicode') && p < 88) p = p * 2.9090 | 0;
        this.curAttr = (this.curAttr & ~(0x1ff << 9)) | (p << 9);
      } else if (p === 48) {
        1; // bg color 256
        if (params[i + 1] !== 5) continue;
        i += 2;
        p = params[i] & 0xff;
        // convert 88 colors to 256
        // if (this.is('rxvt-unicode') && p < 88) p = p * 2.9090 | 0;
        this.curAttr = (this.curAttr & ~0x1ff) | p;
      }
    }
  };

  // CSI Ps n  Device Status Report (DSR).
  //     Ps = 5  -> Status Report.  Result (``OK'') is
  //   CSI 0 n
  //     Ps = 6  -> Report Cursor Position (CPR) [row;column].
  //   Result is
  //   CSI r ; c R
  // CSI ? Ps n
  //   Device Status Report (DSR, DEC-specific).
  //     Ps = 6  -> Report Cursor Position (CPR) [row;column] as CSI
  //     ? r ; c R (assumes page is zero).
  //     Ps = 1 5  -> Report Printer status as CSI ? 1 0  n  (ready).
  //     or CSI ? 1 1  n  (not ready).
  //     Ps = 2 5  -> Report UDK status as CSI ? 2 0  n  (unlocked)
  //     or CSI ? 2 1  n  (locked).
  //     Ps = 2 6  -> Report Keyboard status as
  //   CSI ? 2 7  ;  1  ;  0  ;  0  n  (North American).
  //   The last two parameters apply to VT400 & up, and denote key-
  //   board ready and LK01 respectively.
  //     Ps = 5 3  -> Report Locator status as
  //   CSI ? 5 3  n  Locator available, if compiled-in, or
  //   CSI ? 5 0  n  No Locator, if not.
  Terminal.prototype.deviceStatus = function(params) {
    if (!this.prefix) {
      switch (params[0]) {
        case 5:
          // status report
          this.send("\x1b[0n");
          break;
        case 6:
          // cursor position
          this.send("\x1b[" + (this.y + 1) + ";" + (this.x + 1) + "R");
          break;
      }
    } else if (this.prefix === "?") {
      // modern xterm doesnt seem to
      // respond to any of these except ?6, 6, and 5
      switch (params[0]) {
        case 6:
          // cursor position
          this.send("\x1b[?" + (this.y + 1) + ";" + (this.x + 1) + "R");
          break;
        case 15:
          // no printer
          // this.send('\x1b[?11n');
          break;
        case 25:
          // dont support user defined keys
          // this.send('\x1b[?21n');
          break;
        case 26:
          // north american keyboard
          // this.send('\x1b[?27;1;0;0n');
          break;
        case 53:
          // no dec locator/mouse
          // this.send('\x1b[?50n');
          break;
      }
    }
  };

  /**
   * Additions
   */

  // CSI Ps @
  // Insert Ps (Blank) Character(s) (default = 1) (ICH).
  Terminal.prototype.insertChars = function(params) {
    var param, row, j, ch;

    param = params[0];
    if (param < 1) param = 1;

    row = this.y + this.ybase;
    j = this.x;
    ch = [this.curAttr, " "]; // xterm

    while (param-- && j < this.cols) {
      // sometimes, row is too large
      if (row >= this.lines.length) {
        continue;
      }
      // Question: How can you possibly have a problem because of running that code? It seems
      // like if you don't have that commented out code, then the next line would
      // cause a traceback? Answer: well, those tracebacks are there right now.
      // With this code there, the output started to do weird things, repeating
      // parts of the text, etc. So, I know this is a problem, but I don't
      // want to fix it by making it worse.
      this.lines[row].splice(j++, 0, ch);
      this.lines[row].pop();
    }
  };

  // CSI Ps E
  // Cursor Next Line Ps Times (default = 1) (CNL).
  // same as CSI Ps B ?
  Terminal.prototype.cursorNextLine = function(params) {
    var param = params[0];
    if (param < 1) param = 1;
    this.y += param;
    if (this.y >= this.rows) {
      this.y = this.rows - 1;
    }
    this.x = 0;
  };

  // CSI Ps F
  // Cursor Preceding Line Ps Times (default = 1) (CNL).
  // reuse CSI Ps A ?
  Terminal.prototype.cursorPrecedingLine = function(params) {
    var param = params[0];
    if (param < 1) param = 1;
    this.y -= param;
    if (this.y < 0) this.y = 0;
    this.x = 0;
  };

  // CSI Ps G
  // Cursor Character Absolute  [column] (default = [row,1]) (CHA).
  Terminal.prototype.cursorCharAbsolute = function(params) {
    var param = params[0];
    if (param < 1) param = 1;
    this.x = param - 1;
  };

  // CSI Ps L
  // Insert Ps Line(s) (default = 1) (IL).
  Terminal.prototype.insertLines = function(params) {
    var param, row, j;

    param = params[0];
    if (param < 1) param = 1;
    row = this.y + this.ybase;

    j = this.rows - 1 - this.scrollBottom;
    j = this.rows - 1 + this.ybase - j + 1;

    while (param--) {
      // test: echo -e '\e[44m\e[1L\e[0m'
      // blankLine(true) - xterm/linux behavior
      this.lines.splice(row, 0, this.blankLine(true));
      this.lines.splice(j, 1);
    }

    // this.maxRange();
    this.updateRange(this.y);
    this.updateRange(this.scrollBottom);
  };

  // CSI Ps M
  // Delete Ps Line(s) (default = 1) (DL).
  Terminal.prototype.deleteLines = function(params) {
    var param, row, j;

    param = params[0];
    if (param < 1) param = 1;
    row = this.y + this.ybase;

    j = this.rows - 1 - this.scrollBottom;
    j = this.rows - 1 + this.ybase - j;

    while (param--) {
      // test: echo -e '\e[44m\e[1M\e[0m'
      // blankLine(true) - xterm/linux behavior
      this.lines.splice(j + 1, 0, this.blankLine(true));
      this.lines.splice(row, 1);
    }

    // this.maxRange();
    this.updateRange(this.y);
    this.updateRange(this.scrollBottom);
  };

  // CSI Ps P
  // Delete Ps Character(s) (default = 1) (DCH).
  Terminal.prototype.deleteChars = function(params) {
    var param, row, ch;

    param = params[0];
    if (param < 1) param = 1;

    row = this.y + this.ybase;
    ch = [this.curAttr, " "]; // xterm

    while (param--) {
      if (row < this.lines.length) {
        this.lines[row].splice(this.x, 1);
        this.lines[row].push(ch);
      }
    }
  };

  // CSI Ps X
  // Erase Ps Character(s) (default = 1) (ECH).
  Terminal.prototype.eraseChars = function(params) {
    var param, row, j, ch;

    param = params[0];
    if (param < 1) param = 1;

    row = this.y + this.ybase;
    j = this.x;
    ch = [this.curAttr, " "]; // xterm

    while (param-- && j < this.cols) {
      this.lines[row][j++] = ch;
    }
  };

  // CSI Pm `  Character Position Absolute
  //   [column] (default = [row,1]) (HPA).
  Terminal.prototype.charPosAbsolute = function(params) {
    var param = params[0];
    if (param < 1) param = 1;
    this.x = param - 1;
    if (this.x >= this.cols) {
      this.x = this.cols - 1;
    }
  };

  // 141 61 a * HPR -
  // Horizontal Position Relative
  // reuse CSI Ps C ?
  Terminal.prototype.HPositionRelative = function(params) {
    var param = params[0];
    if (param < 1) param = 1;
    this.x += param;
    if (this.x >= this.cols) {
      this.x = this.cols - 1;
    }
  };

  // CSI Ps c  Send Device Attributes (Primary DA).
  //     Ps = 0  or omitted -> request attributes from terminal.  The
  //     response depends on the decTerminalID resource setting.
  //     -> CSI ? 1 ; 2 c  (``VT100 with Advanced Video Option'')
  //     -> CSI ? 1 ; 0 c  (``VT101 with No Options'')
  //     -> CSI ? 6 c  (``VT102'')
  //     -> CSI ? 6 0 ; 1 ; 2 ; 6 ; 8 ; 9 ; 1 5 ; c  (``VT220'')
  //   The VT100-style response parameters do not mean anything by
  //   themselves.  VT220 parameters do, telling the host what fea-
  //   tures the terminal supports:
  //     Ps = 1  -> 132-columns.
  //     Ps = 2  -> Printer.
  //     Ps = 6  -> Selective erase.
  //     Ps = 8  -> User-defined keys.
  //     Ps = 9  -> National replacement character sets.
  //     Ps = 1 5  -> Technical characters.
  //     Ps = 2 2  -> ANSI color, e.g., VT525.
  //     Ps = 2 9  -> ANSI text locator (i.e., DEC Locator mode).
  // CSI > Ps c
  //   Send Device Attributes (Secondary DA).
  //     Ps = 0  or omitted -> request the terminal's identification
  //     code.  The response depends on the decTerminalID resource set-
  //     ting.  It should apply only to VT220 and up, but xterm extends
  //     this to VT100.
  //     -> CSI  > Pp ; Pv ; Pc c
  //   where Pp denotes the terminal type
  //     Pp = 0  -> ``VT100''.
  //     Pp = 1  -> ``VT220''.
  //   and Pv is the firmware version (for xterm, this was originally
  //   the XFree86 patch number, starting with 95).  In a DEC termi-
  //   nal, Pc indicates the ROM cartridge registration number and is
  //   always zero.
  // More information:
  //   xterm/charproc.c - line 2012, for more information.
  //   vim responds with ^[[?0c or ^[[?1c after the terminal's response (?)
  Terminal.prototype.sendDeviceAttributes = function(params) {
    if (params[0] > 0) return;

    if (!this.prefix) {
      if (this.is("xterm") || this.is("rxvt-unicode") || this.is("screen")) {
        // This causes enormous pain - I don't understand it.
        // To trigger this pain in CoCalc,
        // type this into a terminal:
        //   printf "\E[c\n" ; sleep 1 ; echo
        // See https://stackoverflow.com/questions/47691348/how-to-determine-graphics-capabilities-of-an-x11-terminal-window
        this.send('\x1b[?1;2c');
      } else if (this.is("linux")) {
        this.send("\x1b[?6c");
      }
    } else if (this.prefix === ">") {
      // xterm and urxvt
      // seem to spit this
      // out around ~370 times (?).
      if (this.is("xterm")) {
        this.send("\x1b[>0;276;0c");
      } else if (this.is("rxvt-unicode")) {
        this.send("\x1b[>85;95;0c");
      } else if (this.is("linux")) {
        // not supported by linux console.
        // linux console echoes parameters.
        this.send(params[0] + "c");
      } else if (this.is("screen")) {
        this.send("\x1b[>83;40003;0c");
      }
    }
  };

  // CSI Pm d
  // Line Position Absolute  [row] (default = [1,column]) (VPA).
  Terminal.prototype.linePosAbsolute = function(params) {
    var param = params[0];
    if (param < 1) param = 1;
    this.y = param - 1;
    if (this.y >= this.rows) {
      this.y = this.rows - 1;
    }
  };

  // 145 65 e * VPR - Vertical Position Relative
  // reuse CSI Ps B ?
  Terminal.prototype.VPositionRelative = function(params) {
    var param = params[0];
    if (param < 1) param = 1;
    this.y += param;
    if (this.y >= this.rows) {
      this.y = this.rows - 1;
    }
  };

  // CSI Ps ; Ps f
  //   Horizontal and Vertical Position [row;column] (default =
  //   [1,1]) (HVP).
  Terminal.prototype.HVPosition = function(params) {
    if (params[0] < 1) params[0] = 1;
    if (params[1] < 1) params[1] = 1;

    this.y = params[0] - 1;
    if (this.y >= this.rows) {
      this.y = this.rows - 1;
    }

    this.x = params[1] - 1;
    if (this.x >= this.cols) {
      this.x = this.cols - 1;
    }
  };

  // CSI Pm h  Set Mode (SM).
  //     Ps = 2  -> Keyboard Action Mode (AM).
  //     Ps = 4  -> Insert Mode (IRM).
  //     Ps = 1 2  -> Send/receive (SRM).
  //     Ps = 2 0  -> Automatic Newline (LNM).
  // CSI ? Pm h
  //   DEC Private Mode Set (DECSET).
  //     Ps = 1  -> Application Cursor Keys (DECCKM).
  //     Ps = 2  -> Designate USASCII for character sets G0-G3
  //     (DECANM), and set VT100 mode.
  //     Ps = 3  -> 132 Column Mode (DECCOLM).
  //     Ps = 4  -> Smooth (Slow) Scroll (DECSCLM).
  //     Ps = 5  -> Reverse Video (DECSCNM).
  //     Ps = 6  -> Origin Mode (DECOM).
  //     Ps = 7  -> Wraparound Mode (DECAWM).
  //     Ps = 8  -> Auto-repeat Keys (DECARM).
  //     Ps = 9  -> Send Mouse X & Y on button press.  See the sec-
  //     tion Mouse Tracking.
  //     Ps = 1 0  -> Show toolbar (rxvt).
  //     Ps = 1 2  -> Start Blinking Cursor (att610).
  //     Ps = 1 8  -> Print form feed (DECPFF).
  //     Ps = 1 9  -> Set print extent to full screen (DECPEX).
  //     Ps = 2 5  -> Show Cursor (DECTCEM).
  //     Ps = 3 0  -> Show scrollbar (rxvt).
  //     Ps = 3 5  -> Enable font-shifting functions (rxvt).
  //     Ps = 3 8  -> Enter Tektronix Mode (DECTEK).
  //     Ps = 4 0  -> Allow 80 -> 132 Mode.
  //     Ps = 4 1  -> more(1) fix (see curses resource).
  //     Ps = 4 2  -> Enable Nation Replacement Character sets (DECN-
  //     RCM).
  //     Ps = 4 4  -> Turn On Margin Bell.
  //     Ps = 4 5  -> Reverse-wraparound Mode.
  //     Ps = 4 6  -> Start Logging.  This is normally disabled by a
  //     compile-time option.
  //     Ps = 4 7  -> Use Alternate Screen Buffer.  (This may be dis-
  //     abled by the titeInhibit resource).
  //     Ps = 6 6  -> Application keypad (DECNKM).
  //     Ps = 6 7  -> Backarrow key sends backspace (DECBKM).
  //     Ps = 1 0 0 0  -> Send Mouse X & Y on button press and
  //     release.  See the section Mouse Tracking.
  //     Ps = 1 0 0 1  -> Use Hilite Mouse Tracking.
  //     Ps = 1 0 0 2  -> Use Cell Motion Mouse Tracking.
  //     Ps = 1 0 0 3  -> Use All Motion Mouse Tracking.
  //     Ps = 1 0 0 4  -> Send FocusIn/FocusOut events.
  //     Ps = 1 0 0 5  -> Enable Extended Mouse Mode.
  //     Ps = 1 0 1 0  -> Scroll to bottom on tty output (rxvt).
  //     Ps = 1 0 1 1  -> Scroll to bottom on key press (rxvt).
  //     Ps = 1 0 3 4  -> Interpret "meta" key, sets eighth bit.
  //     (enables the eightBitInput resource).
  //     Ps = 1 0 3 5  -> Enable special modifiers for Alt and Num-
  //     Lock keys.  (This enables the numLock resource).
  //     Ps = 1 0 3 6  -> Send ESC   when Meta modifies a key.  (This
  //     enables the metaSendsEscape resource).
  //     Ps = 1 0 3 7  -> Send DEL from the editing-keypad Delete
  //     key.
  //     Ps = 1 0 3 9  -> Send ESC  when Alt modifies a key.  (This
  //     enables the altSendsEscape resource).
  //     Ps = 1 0 4 0  -> Keep selection even if not highlighted.
  //     (This enables the keepSelection resource).
  //     Ps = 1 0 4 1  -> Use the CLIPBOARD selection.  (This enables
  //     the selectToClipboard resource).
  //     Ps = 1 0 4 2  -> Enable Urgency window manager hint when
  //     Control-G is received.  (This enables the bellIsUrgent
  //     resource).
  //     Ps = 1 0 4 3  -> Enable raising of the window when Control-G
  //     is received.  (enables the popOnBell resource).
  //     Ps = 1 0 4 7  -> Use Alternate Screen Buffer.  (This may be
  //     disabled by the titeInhibit resource).
  //     Ps = 1 0 4 8  -> Save cursor as in DECSC.  (This may be dis-
  //     abled by the titeInhibit resource).
  //     Ps = 1 0 4 9  -> Save cursor as in DECSC and use Alternate
  //     Screen Buffer, clearing it first.  (This may be disabled by
  //     the titeInhibit resource).  This combines the effects of the 1
  //     0 4 7  and 1 0 4 8  modes.  Use this with terminfo-based
  //     applications rather than the 4 7  mode.
  //     Ps = 1 0 5 0  -> Set terminfo/termcap function-key mode.
  //     Ps = 1 0 5 1  -> Set Sun function-key mode.
  //     Ps = 1 0 5 2  -> Set HP function-key mode.
  //     Ps = 1 0 5 3  -> Set SCO function-key mode.
  //     Ps = 1 0 6 0  -> Set legacy keyboard emulation (X11R6).
  //     Ps = 1 0 6 1  -> Set VT220 keyboard emulation.
  //     Ps = 2 0 0 4  -> Set bracketed paste mode.
  // Modes:
  //   http://vt100.net/docs/vt220-rm/chapter4.html
  Terminal.prototype.setMode = function(params) {
    if (typeof params === "object") {
      var l = params.length,
        i = 0;

      for (; i < l; i++) {
        this.setMode(params[i]);
      }

      return;
    }

    if (!this.prefix) {
      switch (params) {
        case 4:
          this.insertMode = true;
          break;
        case 20:
          //this.convertEol = true;
          break;
      }
    } else if (this.prefix === "?") {
      switch (params) {
        case 1:
          this.applicationKeypad = true;
          break;
        case 2:
          this.setgCharset(0, Terminal.charsets.US);
          this.setgCharset(1, Terminal.charsets.US);
          this.setgCharset(2, Terminal.charsets.US);
          this.setgCharset(3, Terminal.charsets.US);
          // set VT100 mode here
          break;
        case 3: // 132 col mode
          this.savedCols = this.cols;
          this.resize(132, this.rows);
          break;
        case 6:
          this.originMode = true;
          break;
        case 7:
          this.wraparoundMode = true;
          break;
        case 12:
          // this.cursorBlink = true;
          break;
        case 9: // X10 Mouse
        // no release, no motion, no wheel, no modifiers.
        case 1000: // vt200 mouse
        // no motion.
        // no modifiers, except control on the wheel.
        case 1002: // button event mouse
        case 1003: // any event mouse
          // any event - sends motion events,
          // even if there is no button held down.
          this.x10Mouse = params === 9;
          this.vt200Mouse = params === 1000;
          this.normalMouse = params > 1000;
          this.mouseEvents = true;
          this.element.style.cursor = "default";
          this.log("Binding to mouse events.");
          break;
        case 1004: // send focusin/focusout events
          // focusin: ^[[I
          // focusout: ^[[O
          this.sendFocus = true;
          break;
        case 1005: // utf8 ext mode mouse
          this.utfMouse = true;
          // for wide terminals
          // simply encodes large values as utf8 characters
          break;
        case 1006: // sgr ext mode mouse
          this.sgrMouse = true;
          // for wide terminals
          // does not add 32 to fields
          // press: ^[[<b;x;yM
          // release: ^[[<b;x;ym
          break;
        case 1015: // urxvt ext mode mouse
          this.urxvtMouse = true;
          // for wide terminals
          // numbers for fields
          // press: ^[[b;x;yM
          // motion: ^[[b;x;yT
          break;
        case 25: // show cursor
          this.cursorHidden = false;
          break;
        case 1049: // alt screen buffer cursor
        //this.saveCursor(); // FALL-THROUGH
        case 47: // alt screen buffer
        case 1047: // alt screen buffer
          if (!this.normal) {
            var normal = {
              lines: this.lines,
              ybase: this.ybase,
              ydisp: this.ydisp,
              x: this.x,
              y: this.y,
              scrollTop: this.scrollTop,
              scrollBottom: this.scrollBottom,
              tabs: this.tabs
              // XXX save charset(s) here?
              // charset: this.charset,
              // glevel: this.glevel,
              // charsets: this.charsets
            };
            this.reset();
            this.normal = normal;
            this.showCursor();
          }
          break;
      }
    }
  };

  // CSI Pm l  Reset Mode (RM).
  //     Ps = 2  -> Keyboard Action Mode (AM).
  //     Ps = 4  -> Replace Mode (IRM).
  //     Ps = 1 2  -> Send/receive (SRM).
  //     Ps = 2 0  -> Normal Linefeed (LNM).
  // CSI ? Pm l
  //   DEC Private Mode Reset (DECRST).
  //     Ps = 1  -> Normal Cursor Keys (DECCKM).
  //     Ps = 2  -> Designate VT52 mode (DECANM).
  //     Ps = 3  -> 80 Column Mode (DECCOLM).
  //     Ps = 4  -> Jump (Fast) Scroll (DECSCLM).
  //     Ps = 5  -> Normal Video (DECSCNM).
  //     Ps = 6  -> Normal Cursor Mode (DECOM).
  //     Ps = 7  -> No Wraparound Mode (DECAWM).
  //     Ps = 8  -> No Auto-repeat Keys (DECARM).
  //     Ps = 9  -> Don't send Mouse X & Y on button press.
  //     Ps = 1 0  -> Hide toolbar (rxvt).
  //     Ps = 1 2  -> Stop Blinking Cursor (att610).
  //     Ps = 1 8  -> Don't print form feed (DECPFF).
  //     Ps = 1 9  -> Limit print to scrolling region (DECPEX).
  //     Ps = 2 5  -> Hide Cursor (DECTCEM).
  //     Ps = 3 0  -> Don't show scrollbar (rxvt).
  //     Ps = 3 5  -> Disable font-shifting functions (rxvt).
  //     Ps = 4 0  -> Disallow 80 -> 132 Mode.
  //     Ps = 4 1  -> No more(1) fix (see curses resource).
  //     Ps = 4 2  -> Disable Nation Replacement Character sets (DEC-
  //     NRCM).
  //     Ps = 4 4  -> Turn Off Margin Bell.
  //     Ps = 4 5  -> No Reverse-wraparound Mode.
  //     Ps = 4 6  -> Stop Logging.  (This is normally disabled by a
  //     compile-time option).
  //     Ps = 4 7  -> Use Normal Screen Buffer.
  //     Ps = 6 6  -> Numeric keypad (DECNKM).
  //     Ps = 6 7  -> Backarrow key sends delete (DECBKM).
  //     Ps = 1 0 0 0  -> Don't send Mouse X & Y on button press and
  //     release.  See the section Mouse Tracking.
  //     Ps = 1 0 0 1  -> Don't use Hilite Mouse Tracking.
  //     Ps = 1 0 0 2  -> Don't use Cell Motion Mouse Tracking.
  //     Ps = 1 0 0 3  -> Don't use All Motion Mouse Tracking.
  //     Ps = 1 0 0 4  -> Don't send FocusIn/FocusOut events.
  //     Ps = 1 0 0 5  -> Disable Extended Mouse Mode.
  //     Ps = 1 0 1 0  -> Don't scroll to bottom on tty output
  //     (rxvt).
  //     Ps = 1 0 1 1  -> Don't scroll to bottom on key press (rxvt).
  //     Ps = 1 0 3 4  -> Don't interpret "meta" key.  (This disables
  //     the eightBitInput resource).
  //     Ps = 1 0 3 5  -> Disable special modifiers for Alt and Num-
  //     Lock keys.  (This disables the numLock resource).
  //     Ps = 1 0 3 6  -> Don't send ESC  when Meta modifies a key.
  //     (This disables the metaSendsEscape resource).
  //     Ps = 1 0 3 7  -> Send VT220 Remove from the editing-keypad
  //     Delete key.
  //     Ps = 1 0 3 9  -> Don't send ESC  when Alt modifies a key.
  //     (This disables the altSendsEscape resource).
  //     Ps = 1 0 4 0  -> Do not keep selection when not highlighted.
  //     (This disables the keepSelection resource).
  //     Ps = 1 0 4 1  -> Use the PRIMARY selection.  (This disables
  //     the selectToClipboard resource).
  //     Ps = 1 0 4 2  -> Disable Urgency window manager hint when
  //     Control-G is received.  (This disables the bellIsUrgent
  //     resource).
  //     Ps = 1 0 4 3  -> Disable raising of the window when Control-
  //     G is received.  (This disables the popOnBell resource).
  //     Ps = 1 0 4 7  -> Use Normal Screen Buffer, clearing screen
  //     first if in the Alternate Screen.  (This may be disabled by
  //     the titeInhibit resource).
  //     Ps = 1 0 4 8  -> Restore cursor as in DECRC.  (This may be
  //     disabled by the titeInhibit resource).
  //     Ps = 1 0 4 9  -> Use Normal Screen Buffer and restore cursor
  //     as in DECRC.  (This may be disabled by the titeInhibit
  //     resource).  This combines the effects of the 1 0 4 7  and 1 0
  //     4 8  modes.  Use this with terminfo-based applications rather
  //     than the 4 7  mode.
  //     Ps = 1 0 5 0  -> Reset terminfo/termcap function-key mode.
  //     Ps = 1 0 5 1  -> Reset Sun function-key mode.
  //     Ps = 1 0 5 2  -> Reset HP function-key mode.
  //     Ps = 1 0 5 3  -> Reset SCO function-key mode.
  //     Ps = 1 0 6 0  -> Reset legacy keyboard emulation (X11R6).
  //     Ps = 1 0 6 1  -> Reset keyboard emulation to Sun/PC style.
  //     Ps = 2 0 0 4  -> Reset bracketed paste mode.
  Terminal.prototype.resetMode = function(params) {
    if (typeof params === "object") {
      var l = params.length,
        i = 0;

      for (; i < l; i++) {
        this.resetMode(params[i]);
      }

      return;
    }

    if (!this.prefix) {
      switch (params) {
        case 4:
          this.insertMode = false;
          break;
        case 20:
          //this.convertEol = false;
          break;
      }
    } else if (this.prefix === "?") {
      switch (params) {
        case 1:
          this.applicationKeypad = false;
          break;
        case 3:
          if (this.cols === 132 && this.savedCols) {
            this.resize(this.savedCols, this.rows);
          }
          delete this.savedCols;
          break;
        case 6:
          this.originMode = false;
          break;
        case 7:
          this.wraparoundMode = false;
          break;
        case 12:
          // this.cursorBlink = false;
          break;
        case 9: // X10 Mouse
        case 1000: // vt200 mouse
        case 1002: // button event mouse
        case 1003: // any event mouse
          this.x10Mouse = false;
          this.vt200Mouse = false;
          this.normalMouse = false;
          this.mouseEvents = false;
          this.element.style.cursor = "";
          break;
        case 1004: // send focusin/focusout events
          this.sendFocus = false;
          break;
        case 1005: // utf8 ext mode mouse
          this.utfMouse = false;
          break;
        case 1006: // sgr ext mode mouse
          this.sgrMouse = false;
          break;
        case 1015: // urxvt ext mode mouse
          this.urxvtMouse = false;
          break;
        case 25: // hide cursor
          this.cursorHidden = true;
          break;
        case 1049: // alt screen buffer cursor // FALL-THROUGH
        case 47: // normal screen buffer
        case 1047: // normal screen buffer - clearing it first
          if (this.normal) {
            this.lines = this.normal.lines;
            this.ybase = this.normal.ybase;
            this.ydisp = this.normal.ydisp;
            this.x = this.normal.x;
            this.y = this.normal.y;
            this.scrollTop = this.normal.scrollTop;
            this.scrollBottom = this.normal.scrollBottom;
            this.tabs = this.normal.tabs;
            this.normal = null;
            // if (params === 1049) {
            //   this.x = this.savedX;
            //   this.y = this.savedY;
            // }
            this.refresh(0, this.rows - 1);
            this.showCursor();
          }
          break;
      }
    }
  };

  // CSI Ps ; Ps r
  //   Set Scrolling Region [top;bottom] (default = full size of win-
  //   dow) (DECSTBM).
  // CSI ? Pm r
  Terminal.prototype.setScrollRegion = function(params) {
    if (this.prefix) return;
    this.scrollTop = (params[0] || 1) - 1;
    this.scrollBottom = (params[1] || this.rows) - 1;
    this.x = 0;
    this.y = 0;
  };

  // CSI s
  //   Save cursor (ANSI.SYS).
  Terminal.prototype.saveCursor = function(params) {
    this.savedX = this.x;
    this.savedY = this.y;
  };

  // CSI u
  //   Restore cursor (ANSI.SYS).
  Terminal.prototype.restoreCursor = function(params) {
    this.x = this.savedX || 0;
    this.y = this.savedY || 0;
  };

  /**
   * Lesser Used
   */

  // CSI Ps I
  //   Cursor Forward Tabulation Ps tab stops (default = 1) (CHT).
  Terminal.prototype.cursorForwardTab = function(params) {
    var param = params[0] || 1;
    while (param--) {
      this.x = this.nextStop();
    }
  };

  // CSI Ps S  Scroll up Ps lines (default = 1) (SU).
  Terminal.prototype.scrollUp = function(params) {
    var param = params[0] || 1;
    while (param--) {
      this.lines.splice(this.ybase + this.scrollTop, 1);
      this.lines.splice(this.ybase + this.scrollBottom, 0, this.blankLine());
    }
    // this.maxRange();
    this.updateRange(this.scrollTop);
    this.updateRange(this.scrollBottom);
  };

  // CSI Ps T  Scroll down Ps lines (default = 1) (SD).
  Terminal.prototype.scrollDown = function(params) {
    var param = params[0] || 1;
    while (param--) {
      this.lines.splice(this.ybase + this.scrollBottom, 1);
      this.lines.splice(this.ybase + this.scrollTop, 0, this.blankLine());
    }
    // this.maxRange();
    this.updateRange(this.scrollTop);
    this.updateRange(this.scrollBottom);
  };

  // CSI Ps ; Ps ; Ps ; Ps ; Ps T
  //   Initiate highlight mouse tracking.  Parameters are
  //   [func;startx;starty;firstrow;lastrow].  See the section Mouse
  //   Tracking.
  Terminal.prototype.initMouseTracking = function(params) {
    // Relevant: DECSET 1001
  };

  // CSI > Ps; Ps T
  //   Reset one or more features of the title modes to the default
  //   value.  Normally, "reset" disables the feature.  It is possi-
  //   ble to disable the ability to reset features by compiling a
  //   different default for the title modes into xterm.
  //     Ps = 0  -> Do not set window/icon labels using hexadecimal.
  //     Ps = 1  -> Do not query window/icon labels using hexadeci-
  //     mal.
  //     Ps = 2  -> Do not set window/icon labels using UTF-8.
  //     Ps = 3  -> Do not query window/icon labels using UTF-8.
  //   (See discussion of "Title Modes").
  Terminal.prototype.resetTitleModes = function(params) {};

  // CSI Ps Z  Cursor Backward Tabulation Ps tab stops (default = 1) (CBT).
  Terminal.prototype.cursorBackwardTab = function(params) {
    var param = params[0] || 1;
    while (param--) {
      this.x = this.prevStop();
    }
  };

  // CSI Ps b  Repeat the preceding graphic character Ps times (REP).
  Terminal.prototype.repeatPrecedingCharacter = function(params) {
    var param = params[0] || 1,
      line = this.lines[this.ybase + this.y],
      ch = line[this.x - 1] || [this.defAttr, " "];

    while (param--) line[this.x++] = ch;
  };

  // CSI Ps g  Tab Clear (TBC).
  //     Ps = 0  -> Clear Current Column (default).
  //     Ps = 3  -> Clear All.
  // Potentially:
  //   Ps = 2  -> Clear Stops on Line.
  //   http://vt100.net/annarbor/aaa-ug/section6.html
  Terminal.prototype.tabClear = function(params) {
    var param = params[0];
    if (param <= 0) {
      delete this.tabs[this.x];
    } else if (param === 3) {
      this.tabs = {};
    }
  };

  // CSI Pm i  Media Copy (MC).
  //     Ps = 0  -> Print screen (default).
  //     Ps = 4  -> Turn off printer controller mode.
  //     Ps = 5  -> Turn on printer controller mode.
  // CSI ? Pm i
  //   Media Copy (MC, DEC-specific).
  //     Ps = 1  -> Print line containing cursor.
  //     Ps = 4  -> Turn off autoprint mode.
  //     Ps = 5  -> Turn on autoprint mode.
  //     Ps = 1  0  -> Print composed display, ignores DECPEX.
  //     Ps = 1  1  -> Print all pages.
  Terminal.prototype.mediaCopy = function(params) {};

  // CSI > Ps; Ps m
  //   Set or reset resource-values used by xterm to decide whether
  //   to construct escape sequences holding information about the
  //   modifiers pressed with a given key.  The first parameter iden-
  //   tifies the resource to set/reset.  The second parameter is the
  //   value to assign to the resource.  If the second parameter is
  //   omitted, the resource is reset to its initial value.
  //     Ps = 1  -> modifyCursorKeys.
  //     Ps = 2  -> modifyFunctionKeys.
  //     Ps = 4  -> modifyOtherKeys.
  //   If no parameters are given, all resources are reset to their
  //   initial values.
  Terminal.prototype.setResources = function(params) {};

  // CSI > Ps n
  //   Disable modifiers which may be enabled via the CSI > Ps; Ps m
  //   sequence.  This corresponds to a resource value of "-1", which
  //   cannot be set with the other sequence.  The parameter identi-
  //   fies the resource to be disabled:
  //     Ps = 1  -> modifyCursorKeys.
  //     Ps = 2  -> modifyFunctionKeys.
  //     Ps = 4  -> modifyOtherKeys.
  //   If the parameter is omitted, modifyFunctionKeys is disabled.
  //   When modifyFunctionKeys is disabled, xterm uses the modifier
  //   keys to make an extended sequence of functions rather than
  //   adding a parameter to each function key to denote the modi-
  //   fiers.
  Terminal.prototype.disableModifiers = function(params) {};

  // CSI > Ps p
  //   Set resource value pointerMode.  This is used by xterm to
  //   decide whether to hide the pointer cursor as the user types.
  //   Valid values for the parameter:
  //     Ps = 0  -> never hide the pointer.
  //     Ps = 1  -> hide if the mouse tracking mode is not enabled.
  //     Ps = 2  -> always hide the pointer.  If no parameter is
  //     given, xterm uses the default, which is 1 .
  Terminal.prototype.setPointerMode = function(params) {};

  // CSI ! p   Soft terminal reset (DECSTR).
  // http://vt100.net/docs/vt220-rm/table4-10.html
  Terminal.prototype.softReset = function(params) {
    this.cursorHidden = false;
    this.insertMode = false;
    this.originMode = false;
    this.wraparoundMode = false; // autowrap
    this.applicationKeypad = false; // ?
    this.scrollTop = 0;
    this.scrollBottom = this.rows - 1;
    this.curAttr = this.defAttr;
    this.x = this.y = 0; // ?
    this.charset = null;
    this.glevel = 0; // ??
    this.charsets = [null]; // ??
  };

  // CSI Ps$ p
  //   Request ANSI mode (DECRQM).  For VT300 and up, reply is
  //     CSI Ps; Pm$ y
  //   where Ps is the mode number as in RM, and Pm is the mode
  //   value:
  //     0 - not recognized
  //     1 - set
  //     2 - reset
  //     3 - permanently set
  //     4 - permanently reset
  Terminal.prototype.requestAnsiMode = function(params) {};

  // CSI ? Ps$ p
  //   Request DEC private mode (DECRQM).  For VT300 and up, reply is
  //     CSI ? Ps; Pm$ p
  //   where Ps is the mode number as in DECSET, Pm is the mode value
  //   as in the ANSI DECRQM.
  Terminal.prototype.requestPrivateMode = function(params) {};

  // CSI Ps ; Ps " p
  //   Set conformance level (DECSCL).  Valid values for the first
  //   parameter:
  //     Ps = 6 1  -> VT100.
  //     Ps = 6 2  -> VT200.
  //     Ps = 6 3  -> VT300.
  //   Valid values for the second parameter:
  //     Ps = 0  -> 8-bit controls.
  //     Ps = 1  -> 7-bit controls (always set for VT100).
  //     Ps = 2  -> 8-bit controls.
  Terminal.prototype.setConformanceLevel = function(params) {};

  // CSI Ps q  Load LEDs (DECLL).
  //     Ps = 0  -> Clear all LEDS (default).
  //     Ps = 1  -> Light Num Lock.
  //     Ps = 2  -> Light Caps Lock.
  //     Ps = 3  -> Light Scroll Lock.
  //     Ps = 2  1  -> Extinguish Num Lock.
  //     Ps = 2  2  -> Extinguish Caps Lock.
  //     Ps = 2  3  -> Extinguish Scroll Lock.
  Terminal.prototype.loadLEDs = function(params) {};

  // CSI Ps SP q
  //   Set cursor style (DECSCUSR, VT520).
  //     Ps = 0  -> blinking block.
  //     Ps = 1  -> blinking block (default).
  //     Ps = 2  -> steady block.
  //     Ps = 3  -> blinking underline.
  //     Ps = 4  -> steady underline.
  Terminal.prototype.setCursorStyle = function(params) {};

  // CSI Ps " q
  //   Select character protection attribute (DECSCA).  Valid values
  //   for the parameter:
  //     Ps = 0  -> DECSED and DECSEL can erase (default).
  //     Ps = 1  -> DECSED and DECSEL cannot erase.
  //     Ps = 2  -> DECSED and DECSEL can erase.
  Terminal.prototype.setCharProtectionAttr = function(params) {};

  // CSI ? Pm r
  //   Restore DEC Private Mode Values.  The value of Ps previously
  //   saved is restored.  Ps values are the same as for DECSET.
  Terminal.prototype.restorePrivateValues = function(params) {};

  // CSI Pt; Pl; Pb; Pr; Ps$ r
  //   Change Attributes in Rectangular Area (DECCARA), VT400 and up.
  //     Pt; Pl; Pb; Pr denotes the rectangle.
  //     Ps denotes the SGR attributes to change: 0, 1, 4, 5, 7.
  // NOTE: xterm doesn't enable this code by default.
  Terminal.prototype.setAttrInRectangle = function(params) {
    var t = params[0],
      l = params[1],
      b = params[2],
      r = params[3],
      attr = params[4];

    var line, i;

    for (; t < b + 1; t++) {
      line = this.lines[this.ybase + t];
      for (i = l; i < r; i++) {
        line[i] = [attr, line[i][1]];
      }
    }

    // this.maxRange();
    this.updateRange(params[0]);
    this.updateRange(params[2]);
  };

  // CSI ? Pm s
  //   Save DEC Private Mode Values.  Ps values are the same as for
  //   DECSET.
  Terminal.prototype.savePrivateValues = function(params) {};

  // CSI Ps ; Ps ; Ps t
  //   Window manipulation (from dtterm, as well as extensions).
  //   These controls may be disabled using the allowWindowOps
  //   resource.  Valid values for the first (and any additional
  //   parameters) are:
  //     Ps = 1  -> De-iconify window.
  //     Ps = 2  -> Iconify window.
  //     Ps = 3  ;  x ;  y -> Move window to [x, y].
  //     Ps = 4  ;  height ;  width -> Resize the xterm window to
  //     height and width in pixels.
  //     Ps = 5  -> Raise the xterm window to the front of the stack-
  //     ing order.
  //     Ps = 6  -> Lower the xterm window to the bottom of the
  //     stacking order.
  //     Ps = 7  -> Refresh the xterm window.
  //     Ps = 8  ;  height ;  width -> Resize the text area to
  //     [height;width] in characters.
  //     Ps = 9  ;  0  -> Restore maximized window.
  //     Ps = 9  ;  1  -> Maximize window (i.e., resize to screen
  //     size).
  //     Ps = 1 0  ;  0  -> Undo full-screen mode.
  //     Ps = 1 0  ;  1  -> Change to full-screen.
  //     Ps = 1 1  -> Report xterm window state.  If the xterm window
  //     is open (non-iconified), it returns CSI 1 t .  If the xterm
  //     window is iconified, it returns CSI 2 t .
  //     Ps = 1 3  -> Report xterm window position.  Result is CSI 3
  //     ; x ; y t
  //     Ps = 1 4  -> Report xterm window in pixels.  Result is CSI
  //     4  ;  height ;  width t
  //     Ps = 1 8  -> Report the size of the text area in characters.
  //     Result is CSI  8  ;  height ;  width t
  //     Ps = 1 9  -> Report the size of the screen in characters.
  //     Result is CSI  9  ;  height ;  width t
  //     Ps = 2 0  -> Report xterm window's icon label.  Result is
  //     OSC  L  label ST
  //     Ps = 2 1  -> Report xterm window's title.  Result is OSC  l
  //     label ST
  //     Ps = 2 2  ;  0  -> Save xterm icon and window title on
  //     stack.
  //     Ps = 2 2  ;  1  -> Save xterm icon title on stack.
  //     Ps = 2 2  ;  2  -> Save xterm window title on stack.
  //     Ps = 2 3  ;  0  -> Restore xterm icon and window title from
  //     stack.
  //     Ps = 2 3  ;  1  -> Restore xterm icon title from stack.
  //     Ps = 2 3  ;  2  -> Restore xterm window title from stack.
  //     Ps >= 2 4  -> Resize to Ps lines (DECSLPP).
  Terminal.prototype.manipulateWindow = function(params) {};

  // CSI Pt; Pl; Pb; Pr; Ps$ t
  //   Reverse Attributes in Rectangular Area (DECRARA), VT400 and
  //   up.
  //     Pt; Pl; Pb; Pr denotes the rectangle.
  //     Ps denotes the attributes to reverse, i.e.,  1, 4, 5, 7.
  // NOTE: xterm doesn't enable this code by default.
  Terminal.prototype.reverseAttrInRectangle = function(params) {};

  // CSI > Ps; Ps t
  //   Set one or more features of the title modes.  Each parameter
  //   enables a single feature.
  //     Ps = 0  -> Set window/icon labels using hexadecimal.
  //     Ps = 1  -> Query window/icon labels using hexadecimal.
  //     Ps = 2  -> Set window/icon labels using UTF-8.
  //     Ps = 3  -> Query window/icon labels using UTF-8.  (See dis-
  //     cussion of "Title Modes")
  Terminal.prototype.setTitleModeFeature = function(params) {};

  // CSI Ps SP t
  //   Set warning-bell volume (DECSWBV, VT520).
  //     Ps = 0  or 1  -> off.
  //     Ps = 2 , 3  or 4  -> low.
  //     Ps = 5 , 6 , 7 , or 8  -> high.
  Terminal.prototype.setWarningBellVolume = function(params) {};

  // CSI Ps SP u
  //   Set margin-bell volume (DECSMBV, VT520).
  //     Ps = 1  -> off.
  //     Ps = 2 , 3  or 4  -> low.
  //     Ps = 0 , 5 , 6 , 7 , or 8  -> high.
  Terminal.prototype.setMarginBellVolume = function(params) {};

  // CSI Pt; Pl; Pb; Pr; Pp; Pt; Pl; Pp$ v
  //   Copy Rectangular Area (DECCRA, VT400 and up).
  //     Pt; Pl; Pb; Pr denotes the rectangle.
  //     Pp denotes the source page.
  //     Pt; Pl denotes the target location.
  //     Pp denotes the target page.
  // NOTE: xterm doesn't enable this code by default.
  Terminal.prototype.copyRectangle = function(params) {};

  // CSI Pt ; Pl ; Pb ; Pr ' w
  //   Enable Filter Rectangle (DECEFR), VT420 and up.
  //   Parameters are [top;left;bottom;right].
  //   Defines the coordinates of a filter rectangle and activates
  //   it.  Anytime the locator is detected outside of the filter
  //   rectangle, an outside rectangle event is generated and the
  //   rectangle is disabled.  Filter rectangles are always treated
  //   as "one-shot" events.  Any parameters that are omitted default
  //   to the current locator position.  If all parameters are omit-
  //   ted, any locator motion will be reported.  DECELR always can-
  //   cels any previous rectangle definition.
  Terminal.prototype.enableFilterRectangle = function(params) {};

  // CSI Ps x  Request Terminal Parameters (DECREQTPARM).
  //   if Ps is a "0" (default) or "1", and xterm is emulating VT100,
  //   the control sequence elicits a response of the same form whose
  //   parameters describe the terminal:
  //     Ps -> the given Ps incremented by 2.
  //     Pn = 1  <- no parity.
  //     Pn = 1  <- eight bits.
  //     Pn = 1  <- 2  8  transmit 38.4k baud.
  //     Pn = 1  <- 2  8  receive 38.4k baud.
  //     Pn = 1  <- clock multiplier.
  //     Pn = 0  <- STP flags.
  Terminal.prototype.requestParameters = function(params) {};

  // CSI Ps x  Select Attribute Change Extent (DECSACE).
  //     Ps = 0  -> from start to end position, wrapped.
  //     Ps = 1  -> from start to end position, wrapped.
  //     Ps = 2  -> rectangle (exact).
  Terminal.prototype.selectChangeExtent = function(params) {};

  // CSI Pc; Pt; Pl; Pb; Pr$ x
  //   Fill Rectangular Area (DECFRA), VT420 and up.
  //     Pc is the character to use.
  //     Pt; Pl; Pb; Pr denotes the rectangle.
  // NOTE: xterm doesn't enable this code by default.
  Terminal.prototype.fillRectangle = function(params) {
    var ch = params[0],
      t = params[1],
      l = params[2],
      b = params[3],
      r = params[4];

    var line, i;

    for (; t < b + 1; t++) {
      line = this.lines[this.ybase + t];
      for (i = l; i < r; i++) {
        line[i] = [line[i][0], String.fromCharCode(ch)];
      }
    }

    // this.maxRange();
    this.updateRange(params[1]);
    this.updateRange(params[3]);
  };

  // CSI Ps ; Pu ' z
  //   Enable Locator Reporting (DECELR).
  //   Valid values for the first parameter:
  //     Ps = 0  -> Locator disabled (default).
  //     Ps = 1  -> Locator enabled.
  //     Ps = 2  -> Locator enabled for one report, then disabled.
  //   The second parameter specifies the coordinate unit for locator
  //   reports.
  //   Valid values for the second parameter:
  //     Pu = 0  <- or omitted -> default to character cells.
  //     Pu = 1  <- device physical pixels.
  //     Pu = 2  <- character cells.
  Terminal.prototype.enableLocatorReporting = function(params) {
    var val = params[0] > 0;
    //this.mouseEvents = val;
    //this.decLocator = val;
  };

  // CSI Pt; Pl; Pb; Pr$ z
  //   Erase Rectangular Area (DECERA), VT400 and up.
  //     Pt; Pl; Pb; Pr denotes the rectangle.
  // NOTE: xterm doesn't enable this code by default.
  Terminal.prototype.eraseRectangle = function(params) {
    var t = params[0],
      l = params[1],
      b = params[2],
      r = params[3];

    var line, i, ch;

    ch = [this.curAttr, " "]; // xterm?

    for (; t < b + 1; t++) {
      line = this.lines[this.ybase + t];
      for (i = l; i < r; i++) {
        line[i] = ch;
      }
    }

    // this.maxRange();
    this.updateRange(params[0]);
    this.updateRange(params[2]);
  };

  // CSI Pm ' {
  //   Select Locator Events (DECSLE).
  //   Valid values for the first (and any additional parameters)
  //   are:
  //     Ps = 0  -> only respond to explicit host requests (DECRQLP).
  //                (This is default).  It also cancels any filter
  //   rectangle.
  //     Ps = 1  -> report button down transitions.
  //     Ps = 2  -> do not report button down transitions.
  //     Ps = 3  -> report button up transitions.
  //     Ps = 4  -> do not report button up transitions.
  Terminal.prototype.setLocatorEvents = function(params) {};

  // CSI Pt; Pl; Pb; Pr$ {
  //   Selective Erase Rectangular Area (DECSERA), VT400 and up.
  //     Pt; Pl; Pb; Pr denotes the rectangle.
  Terminal.prototype.selectiveEraseRectangle = function(params) {};

  // CSI Ps ' |
  //   Request Locator Position (DECRQLP).
  //   Valid values for the parameter are:
  //     Ps = 0 , 1 or omitted -> transmit a single DECLRP locator
  //     report.

  //   If Locator Reporting has been enabled by a DECELR, xterm will
  //   respond with a DECLRP Locator Report.  This report is also
  //   generated on button up and down events if they have been
  //   enabled with a DECSLE, or when the locator is detected outside
  //   of a filter rectangle, if filter rectangles have been enabled
  //   with a DECEFR.

  //     -> CSI Pe ; Pb ; Pr ; Pc ; Pp &  w

  //   Parameters are [event;button;row;column;page].
  //   Valid values for the event:
  //     Pe = 0  -> locator unavailable - no other parameters sent.
  //     Pe = 1  -> request - xterm received a DECRQLP.
  //     Pe = 2  -> left button down.
  //     Pe = 3  -> left button up.
  //     Pe = 4  -> middle button down.
  //     Pe = 5  -> middle button up.
  //     Pe = 6  -> right button down.
  //     Pe = 7  -> right button up.
  //     Pe = 8  -> M4 button down.
  //     Pe = 9  -> M4 button up.
  //     Pe = 1 0  -> locator outside filter rectangle.
  //   ``button'' parameter is a bitmask indicating which buttons are
  //     pressed:
  //     Pb = 0  <- no buttons down.
  //     Pb & 1  <- right button down.
  //     Pb & 2  <- middle button down.
  //     Pb & 4  <- left button down.
  //     Pb & 8  <- M4 button down.
  //   ``row'' and ``column'' parameters are the coordinates of the
  //     locator position in the xterm window, encoded as ASCII deci-
  //     mal.
  //   The ``page'' parameter is not used by xterm, and will be omit-
  //   ted.
  Terminal.prototype.requestLocatorPosition = function(params) {};

  // CSI P m SP }
  // Insert P s Column(s) (default = 1) (DECIC), VT420 and up.
  // NOTE: xterm doesn't enable this code by default.
  Terminal.prototype.insertColumns = function() {
    var param = params[0],
      l = this.ybase + this.rows,
      ch = [this.curAttr, " "], // xterm?
      i;

    while (param--) {
      for (i = this.ybase; i < l; i++) {
        this.lines[i].splice(this.x + 1, 0, ch);
        this.lines[i].pop();
      }
    }

    this.maxRange();
  };

  // CSI P m SP ~
  // Delete P s Column(s) (default = 1) (DECDC), VT420 and up
  // NOTE: xterm doesn't enable this code by default.
  Terminal.prototype.deleteColumns = function() {
    var param = params[0],
      l = this.ybase + this.rows,
      ch = [this.curAttr, " "], // xterm?
      i;

    while (param--) {
      for (i = this.ybase; i < l; i++) {
        this.lines[i].splice(this.x, 1);
        this.lines[i].push(ch);
      }
    }

    this.maxRange();
  };

  /**
   * Character Sets
   */

  Terminal.charsets = {};

  // DEC Special Character and Line Drawing Set.
  // http://vt100.net/docs/vt102-ug/table5-13.html
  // A lot of curses apps use this if they see TERM=xterm.
  // testing: echo -e '\e(0a\e(B'
  // The xterm output sometimes seems to conflict with the
  // reference above. xterm seems in line with the reference
  // when running vttest however.
  // The table below now uses xterm's output from vttest.
  Terminal.charsets.SCLD = {
    // (0
    "`": "\u25c6", // '◆'
    a: "\u2592", // '▒'
    b: "\u0009", // '\t'
    c: "\u000c", // '\f'
    d: "\u000d", // '\r'
    e: "\u000a", // '\n'
    f: "\u00b0", // '°'
    g: "\u00b1", // '±'
    h: "\u2424", // '\u2424' (NL)
    i: "\u000b", // '\v'
    j: "\u2518", // '┘'
    k: "\u2510", // '┐'
    l: "\u250c", // '┌'
    m: "\u2514", // '└'
    n: "\u253c", // '┼'
    o: "\u23ba", // '⎺'
    p: "\u23bb", // '⎻'
    q: "\u2500", // '─'
    r: "\u23bc", // '⎼'
    s: "\u23bd", // '⎽'
    t: "\u251c", // '├'
    u: "\u2524", // '┤'
    v: "\u2534", // '┴'
    w: "\u252c", // '┬'
    x: "\u2502", // '│'
    y: "\u2264", // '≤'
    z: "\u2265", // '≥'
    "{": "\u03c0", // 'π'
    "|": "\u2260", // '≠'
    "}": "\u00a3", // '£'
    "~": "\u00b7" // '·'
  };

  Terminal.charsets.UK = null; // (A
  Terminal.charsets.US = null; // (B (USASCII)
  Terminal.charsets.Dutch = null; // (4
  Terminal.charsets.Finnish = null; // (C or (5
  Terminal.charsets.French = null; // (R
  Terminal.charsets.FrenchCanadian = null; // (Q
  Terminal.charsets.German = null; // (K
  Terminal.charsets.Italian = null; // (Y
  Terminal.charsets.NorwegianDanish = null; // (E or (6
  Terminal.charsets.Spanish = null; // (Z
  Terminal.charsets.Swedish = null; // (H or (7
  Terminal.charsets.Swiss = null; // (=
  Terminal.charsets.ISOLatin = null; // /A

  /**
   * Helpers
   */

  function on(el, type, handler, capture) {
    el.addEventListener(type, handler, capture || false);
  }

  function off(el, type, handler, capture) {
    el.removeEventListener(type, handler, capture || false);
  }

  function cancel(ev) {
    if (ev.preventDefault) ev.preventDefault();
    ev.returnValue = false;
    if (ev.stopPropagation) ev.stopPropagation();
    ev.cancelBubble = true;
    return false;
  }

  function inherits(child, parent) {
    function f() {
      this.constructor = child;
    }
    f.prototype = parent.prototype;
    child.prototype = new f();
  }

  var isMac = ~navigator.userAgent.indexOf("Mac");

  // if bold is broken, we can't
  // use it in the terminal.
  function isBoldBroken() {
    var el = document.createElement("span");
    el.innerHTML = "hello world";
    document.body.appendChild(el);
    var w1 = el.scrollWidth;
    el.style.fontWeight = "bold";
    var w2 = el.scrollWidth;
    document.body.removeChild(el);
    return w1 !== w2;
  }

  var String = this.String;
  var setTimeout = this.setTimeout;
  var setInterval = this.setInterval;

  /**
   * Expose
   */

  Terminal.EventEmitter = EventEmitter;
  Terminal.isMac = isMac;
  Terminal.inherits = inherits;
  Terminal.on = on;
  Terminal.off = off;
  Terminal.cancel = cancel;

  if (typeof module !== "undefined") {
    module.exports = Terminal;
  } else {
    this.Terminal = Terminal;
  }
}.call(
  (function() {
    return this || (typeof window !== "undefined" ? window : global);
  })()
));